Context.java

/*
 * SoapUI, Copyright (C) 2004-2016 SmartBear Software 
 *
 * Licensed under the EUPL, Version 1.1 or - as soon as they will be approved by the European Commission - subsequent 
 * versions of the EUPL (the "Licence"); 
 * You may not use this work except in compliance with the Licence. 
 * You may obtain a copy of the Licence at: 
 * 
 * http://ec.europa.eu/idabc/eupl 
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the Licence is 
 * distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 
 * express or implied. See the Licence for the specific language governing permissions and limitations 
 * under the Licence. 
 */

package com.eviware.soapui.impl.wadl.inference.schema;

import com.eviware.soapui.impl.wadl.inference.ConflictHandler;
import org.apache.xmlbeans.XmlCursor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * An object that holds information about a validation in-progress, such as the
 * cursor of the content to be validated., etc.
 *
 * @author Dain Nilsson
 */
public class Context {
    private ConflictHandler handler;
    private XmlCursor cursor;
    private SchemaSystem system;
    private List<String> path;
    private List<List<String>> stack;
    private Map<String, String> attributes;

    /**
     * Creates a new Context object.
     *
     * @param system  The SchemaSystem holding the namespaces to be used for
     *                validation.
     * @param handler The ConflictHandler to use whenever a validation error occurs to
     *                decide upon which action to take.
     * @param cursor  An XmlCursor pointing to the beginning of the XML content to
     *                validate.
     */
    public Context(SchemaSystem system, ConflictHandler handler, XmlCursor cursor) {
        this.system = system;
        this.handler = handler;
        this.cursor = cursor;
        path = new ArrayList<String>();
        stack = new ArrayList<List<String>>();
        attributes = new HashMap<String, String>();
    }

    /**
     * Getter for the contained ConflictHandler.
     *
     * @return Returns the ConflictHandler used for validation.
     */
    public ConflictHandler getHandler() {
        return handler;
    }

    /**
     * Get a name to use for a Complex Type at the current path. Names are
     * derived from paths, using the locality from the Settings class.
     *
     * @return A name to be used for the Complex Type at the current location.
     */
    public String getName() {
        String path = getPath().replace("/", "_");
        int parts = Settings.locality;
        int i = path.length();
        while (parts > 0 && i > 0) {
            i--;
            if (path.charAt(i) == '_') {
                parts--;
            }
        }
        if (parts > 0) {
            return path;
        }
        return path.substring(i + 1);
    }

    /**
     * Get a stored attribute.
     *
     * @param key The key of the attribute to get.
     * @return Returns the value of the attribute, if it exists. An empty string
     *         is returned if not.
     */
    public String getAttribute(String key) {
        if (attributes.containsKey(key)) {
            return attributes.get(key);
        }
        return "";
    }

    /**
     * Store an attribute.
     *
     * @param key   The name of the attribute to store.
     * @param value The value to store.
     */
    public void putAttribute(String key, String value) {
        attributes.put(key, value);
    }

    /**
     * Delete a stored attribute.
     *
     * @param key The name of the attribute to delete.
     */
    public void clearAttribute(String key) {
        attributes.remove(key);
    }

    /**
     * Get the path currently at.
     *
     * @return Returns the current path, elements are separated by slash.
     */
    public String getPath() {
        StringBuilder s = new StringBuilder();
        for (String item : path) {
            s.append("/" + item);
        }
        return s.toString();
    }

    /**
     * Push the current path to an internal stack, and start with an empty path.
     */
    public void pushPath() {
        stack.add(path);
        path = new ArrayList<String>();
    }

    /**
     * Pop a previously pushed path from the internal stack, overwriting whatever
     * is currently in the path.
     */
    public void popPath() {
        int last = stack.size() - 1;
        if (last >= 0) {
            path = stack.get(last);
            stack.remove(last);
        }
    }

    /**
     * Append an element to the end of the current path.
     *
     * @param item The name of the element to trascend into.
     */
    public void cd(String item) {
        path.add(item);
    }

    /**
     * Move up one level, removing the last element from the path.
     */
    public void up() {
        if (path.size() > 0) {
            path.remove(path.size() - 1);
        }
    }

    /**
     * Get the internal cursor pointing to the current position of the XML
     * content to be validated.
     *
     * @return Returns an XmlCursor.
     */
    public XmlCursor getCursor() {
        return cursor;
    }

    /**
     * Get the SchemaSystem currently used for validation.
     *
     * @return Returns a SchemaSystem.
     */
    public SchemaSystem getSchemaSystem() {
        return system;
    }
}