Open Source Repository

Home /commons-configuration/commons-configuration-1.7 | Repository Home


org/apache/commons/configuration/tree/NodeAddData.java
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.commons.configuration.tree;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 <p>
 * A simple data class used by <code>{@link ExpressionEngine}</code> to store
 * the results of the <code>prepareAdd()</code> operation.
 </p>
 <p>
 * If a new property is to be added to a configuration, the affected
 <code>Configuration</code> object must know, where in its hierarchy of
 * configuration nodes new elements have to be added. This information is
 * obtained by an <code>ExpressionEngine</code> object that interprets the key
 * of the new property. This expression engine will pack all information
 * necessary for the configuration to perform the add operation in an instance
 * of this class.
 </p>
 <p>
 * Information managed by this class contains:
 <ul>
 <li>the configuration node, to which new elements must be added</li>
 <li>the name of the new node</li>
 <li>whether the new node is a child node or an attribute node</li>
 <li>if a whole branch is to be added at once, the names of all nodes between
 * the parent node (the target of the add operation) and the new node</li>
 </ul>
 </p>
 *
 @since 1.3
 @author Oliver Heger
 */
public class NodeAddData
{
    /** Stores the parent node of the add operation. */
    private ConfigurationNode parent;

    /**
     * Stores a list with nodes that are on the path between the parent node and
     * the new node.
     */
    private List pathNodes;

    /** Stores the name of the new node. */
    private String newNodeName;

    /** Stores the attribute flag. */
    private boolean attribute;

    /**
     * Creates a new, uninitialized instance of <code>NodeAddData</code>.
     */
    public NodeAddData()
    {
        this(null, null);
    }

    /**
     * Creates a new instance of <code>NodeAddData</code> and sets the most
     * important data fields.
     *
     @param parent the parent node
     @param nodeName the name of the new node
     */
    public NodeAddData(ConfigurationNode parent, String nodeName)
    {
        setParent(parent);
        setNewNodeName(nodeName);
    }

    /**
     * Returns a flag if the new node to be added is an attribute.
     *
     @return <b>true</b> for an attribute node, <b>false</b> for a child
     * node
     */
    public boolean isAttribute()
    {
        return attribute;
    }

    /**
     * Sets the attribute flag. This flag determines whether an attribute or a
     * child node will be added.
     *
     @param attribute the attribute flag
     */
    public void setAttribute(boolean attribute)
    {
        this.attribute = attribute;
    }

    /**
     * Returns the name of the new node.
     *
     @return the new node's name
     */
    public String getNewNodeName()
    {
        return newNodeName;
    }

    /**
     * Sets the name of the new node. A node with this name will be added to the
     * configuration's node hierarchy.
     *
     @param newNodeName the name of the new node
     */
    public void setNewNodeName(String newNodeName)
    {
        this.newNodeName = newNodeName;
    }

    /**
     * Returns the parent node.
     *
     @return the parent node
     */
    public ConfigurationNode getParent()
    {
        return parent;
    }

    /**
     * Sets the parent node. New nodes will be added to this node.
     *
     @param parent the parent node
     */
    public void setParent(ConfigurationNode parent)
    {
        this.parent = parent;
    }

    /**
     * Returns a list with further nodes that must be added. This is needed if a
     * complete branch is to be added at once. For instance imagine that there
     * exists only a node <code>database</code>. Now the key
     <code>database.connection.settings.username</code> (assuming the syntax
     * of the default expression engine) is to be added. Then
     <code>username</code> is the name of the new node, but the nodes
     <code>connection</code> and <code>settings</code> must be added to
     * the parent node first. In this example these names would be returned by
     * this method.
     *
     @return a list with the names of nodes that must be added as parents of
     * the new node (never <b>null</b>)
     */
    public List getPathNodes()
    {
        return (pathNodes != null? Collections.unmodifiableList(pathNodes)
                : Collections.EMPTY_LIST;
    }

    /**
     * Adds the name of a path node. With this method an additional node to be
     * added can be defined.
     *
     @param nodeName the name of the node
     @see #getPathNodes()
     */
    public void addPathNode(String nodeName)
    {
        if (pathNodes == null)
        {
            pathNodes = new LinkedList();
        }
        pathNodes.add(nodeName);
    }
}