src/plugins/android.codeutils/src/com/motorola/studio/android/model/resources/types/AbstractResourceNode.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.motorola.studio.android.model.resources.types;

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

/**
 * Abstract class used to describe a node of a resource file
 */
public abstract class AbstractResourceNode
{
    /**
     * Enumeration used to describe the resource node types 
     */
    public static enum NodeType
    {
        Resources, String, Color, Dimen, Drawable, Unknown
    }

    /**
     * The known attributes of a resource node
     */
    protected final Map<String, String> attributes;

    /**
     * The unknown attributes of a resource node
     */
    protected final Map<String, String> unknownAttributes;

    /**
     * The known child nodes of a resource
     */
    protected final List<AbstractResourceNode> children;

    /**
     * The unknown child nodes of a resource
     */
    protected final List<AbstractResourceNode> unknownChildren;

    /**
     * Checks if an attribute name is valid for a resource node
     * 
     * @param attributeName The attribute name
     * 
     * @return true if the attribute is acceptable for the node and false otherwise
     */
    protected abstract boolean isAttributeValid(String attributeName);

    /**
     * Retrieves the resource node type
     * 
     * @return the resource node type
     */
    public abstract NodeType getNodeType();

    /**
     * Checks if a node can be accepted as child node
     * 
     * @param node The node to be checked
     * 
     * @return true if the node can be a child node or false otherwise
     */
    protected abstract boolean canAddChildNode(AbstractResourceNode node);

    /**
     * Retrieves the node type based on a node name
     * 
     * @param nodeName the node name
     * 
     * @return the node type related to the node name. If the name cannot be associated 
     *         to any node type, the unknown type will be returned.
     */
    public static NodeType getNodeType(String nodeName)
    {
        NodeType nodeType = NodeType.Unknown;

        for (NodeType type : NodeType.values())
        {
            if (nodeName.trim().equalsIgnoreCase(getNodeTypeName(type)))
            {
                nodeType = type;
                break;
            }
        }

        return nodeType;
    }

    /**
     * Retrieves the node name based on the node type
     * 
     * @param nodeType The node type
     * 
     * @return The node name
     */
    public static String getNodeTypeName(NodeType nodeType)
    {
        String nodeName;

        switch (nodeType)
        {
            case Resources:
                nodeName = "resources";
                break;
            case String:
                nodeName = "string";
                break;
            case Color:
                nodeName = "color";
                break;
            case Dimen:
                nodeName = "dimen";
                break;
            case Drawable:
                nodeName = "drawable";
                break;
            default:
                nodeName = "unknown";
        }

        return nodeName;
    }

    /**
     * Default constructor
     */
    public AbstractResourceNode()
    {
        attributes = new HashMap<String, String>();
        unknownAttributes = new HashMap<String, String>();
        children = new LinkedList<AbstractResourceNode>();
        unknownChildren = new LinkedList<AbstractResourceNode>();
    }

    /**
     * Retrieves an attribute value from a resource node. The attribute must be valid.
     * 
     * @param attributeName The attribute name
     * @return The attribute value
     */
    public String getAttributeValue(String attributeName)
    {
        String attrValue = null;

        if (attributeName != null)
        {
            attrValue = attributes.get(attributeName);
        }

        return attrValue;
    }

    /**
     * Retrieves an array containing all known attributes of a resource node
     * 
     * @return an array containing all known attributes of a resource node
     */
    public String[] getAttributes()
    {
        String[] attrs = new String[attributes.size()];

        attrs = attributes.keySet().toArray(attrs);

        return attrs;
    }

    /**
     * Adds an unknown attribute to a resource node
     * 
     * @param attributeName The attribute name
     * @param attributeValue The attribute value
     * @return true if the attribute has been added or false otherwise. An attribute is not
     *         added if it exists.
     */
    public boolean addUnknownAttribute(String attributeName, String attributeValue)
    {
        boolean added = false;

        if (attributeName != null)
        {
            if (!isAttributeValid(attributeName))
            {
                if (!unknownAttributes.containsKey(attributeName))
                {
                    unknownAttributes.put(attributeName, attributeValue);
                    added = true;
                }
            }
        }

        return added;
    }

    /**
     * Removes an unknown attribute value from a resource node
     * 
     * @param attributeName The attribute name
     * @return true if the attribute has been removed or false otherwise.
     */
    public boolean removeUnknownAttribute(String attributeName)
    {
        boolean removed = false;

        if (attributeName != null)
        {
            if (unknownAttributes.containsKey(attributeName))
            {
                unknownAttributes.remove(attributeName);
                removed = true;
            }
        }

        return removed;
    }

    /**
     * Retrieves the value of an unknown attribute of a resource node
     * 
     * @param attributeName The attribute name
     * @return The attribute value
     */
    public String getUnknownAttributeValue(String attributeName)
    {
        String value = null;

        if (attributeName != null)
        {
            if (unknownAttributes.containsKey(attributeName))
            {
                value = unknownAttributes.get(attributeName);
            }
        }

        return value;
    }

    /**
     * Retrieves an array containing all unknown attribute names
     * 
     * @return an array containing all unknown attribute names
     */
    public String[] getUnknownAttributes()
    {
        String attributes[] = new String[this.unknownAttributes.size()];

        attributes = this.unknownAttributes.keySet().toArray(attributes);

        return attributes;
    }

    /**
     * Removes all unknown attributes
     */
    public void clearUnknownAttributes()
    {
        unknownAttributes.clear();
    }

    /**
     * Adds a child resource node to this node
     * 
     * @param node The node to be added
     * @return true if the node has been added or false otherwise
     */
    public boolean addChildNode(AbstractResourceNode node)
    {
        boolean added = false;

        if (node != null)
        {
            if (canAddChildNode(node))
            {
                if (!children.contains(node))
                {
                    children.add(node);
                    added = true;
                }
            }
            else
            {
                if (!unknownChildren.contains(node))
                {
                    unknownChildren.add(node);
                    added = true;
                }
            }
        }

        return added;
    }

    /**
     * Removes a child node from this node
     * 
     * @param node the node to be removed
     * @return true if the node has been removed or false otherwise
     */
    public boolean removeChildNode(AbstractResourceNode node)
    {
        boolean removed = false;

        if (node != null)
        {
            if (children.contains(node))
            {
                children.remove(node);
                removed = true;
            }
            else if (unknownChildren.contains(node))
            {
                unknownChildren.remove(node);
                removed = true;
            }
        }

        return removed;
    }

    /**
     * Retrieves an array containing all child nodes of this node
     * 
     * @return an array containing all child nodes of this node
     */
    public AbstractResourceNode[] getChildNodes()
    {
        AbstractResourceNode[] childNodes = new AbstractResourceNode[children.size()];

        childNodes = children.toArray(childNodes);

        return childNodes;
    }

    /**
     * Retrieves an array containing all unknown child nodes of this node
     * 
     * @return an array containing all unknown child nodes of this node
     */
    public AbstractResourceNode[] getUnknownChildNodes()
    {
        AbstractResourceNode[] childNodes = new AbstractResourceNode[unknownChildren.size()];

        childNodes = unknownChildren.toArray(childNodes);

        return childNodes;
    }

    /**
     * Removes all child nodes of this node
     */
    public void clearChildNodes()
    {
        children.clear();
    }

    /**
     * Removes all unknown child nodes of this node
     */
    public void clearUnknownChildNodes()
    {
        unknownChildren.clear();
    }

    /**
     * Retrieves the name of this node
     * 
     * @return the name of this node
     */
    public String getNodeName()
    {
        return getNodeTypeName(getNodeType());
    }
}