Coverage Report

Coverage Report - org.apache.commons.configuration.tree.DefaultConfigurationNode

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultConfigurationNode

99%

72/73

100%

4/4

1,583

DefaultConfigurationNode$SubNodes

100%

58/58

100%

18/18

1,583

 /*
  * 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.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
 /**
  * <p>
  * A default implementation of the <code>ConfigurationNode</code> interface.
  * </p>
  *
  * @since 1.3
  * @author Oliver Heger
  */
 public class DefaultConfigurationNode implements ConfigurationNode, Cloneable
 {
     /** Stores the children of this node. */
     private SubNodes children;
 
     /** Stores the attributes of this node. */
     private SubNodes attributes;
 
     /** Stores a reference to this node's parent. */
     private ConfigurationNode parent;
 
     /** Stores the value of this node. */
     private Object value;
 
     /** Stores the reference. */
     private Object reference;
 
     /** Stores the name of this node. */
     private String name;
 
     /** Stores a flag if this is an attribute. */
     private boolean attribute;
 
     /**
      * Creates a new uninitialized instance of
      * <code>DefaultConfigurationNode</code>.
      */
     public DefaultConfigurationNode()
     {
         this(null);
     }
 
     /**
      * Creates a new instance of <code>DefaultConfigurationNode</code> and
      * initializes it with the node name.
      *
      * @param name the name of this node
      */
     public DefaultConfigurationNode(String name)
     {
         this(name, null);
     }
 
     /**
      * Creates a new instance of <code>DefaultConfigurationNode</code> and
      * initializes it with the name and a value.
      *
      * @param name the node's name
      * @param value the node's value
      */
     public DefaultConfigurationNode(String name, Object value)
     {
         setName(name);
         setValue(value);
         initSubNodes();
     }
 
     /**
      * Returns the name of this node.
      *
      * @return the name of this node
      */
     public String getName()
     {
         return name;
     }
 
     /**
      * Sets the name of this node.
      *
      * @param name the new name
      */
     public void setName(String name)
     {
         checkState();
         this.name = name;
     }
 
     /**
      * Returns the value of this node.
      *
      * @return the value of this node
      */
     public Object getValue()
     {
         return value;
     }
 
     /**
      * Sets the value of this node.
      *
      * @param val the value of this node
      */
     public void setValue(Object val)
     {
         value = val;
     }
 
     /**
      * Returns the reference.
      *
      * @return the reference
      */
     public Object getReference()
     {
         return reference;
     }
 
     /**
      * Sets the reference.
      *
      * @param reference the reference object
      */
     public void setReference(Object reference)
     {
         this.reference = reference;
     }
 
     /**
      * Returns a reference to this node's parent.
      *
      * @return the parent node or <b>null </b> if this is the root
      */
     public ConfigurationNode getParentNode()
     {
         return parent;
     }
 
     /**
      * Sets the parent of this node.
      *
      * @param parent the parent of this node
      */
     public void setParentNode(ConfigurationNode parent)
     {
         this.parent = parent;
     }
 
     /**
      * Adds a new child to this node.
      *
      * @param child the new child
      */
     public void addChild(ConfigurationNode child)
     {
         children.addNode(child);
         child.setAttribute(false);
         child.setParentNode(this);
     }
 
     /**
      * Returns a list with all children of this node.
      *
      * @return a list with all child nodes
      */
     public List getChildren()
     {
         return children.getSubNodes();
     }
 
     /**
      * Returns the number of all children of this node.
      *
      * @return the number of all children
      */
     public int getChildrenCount()
     {
         return children.getSubNodes().size();
     }
 
     /**
      * Returns a list of all children with the given name.
      *
      * @param name the name; can be <b>null </b>, then all children are returned
      * @return a list of all children with the given name
      */
     public List getChildren(String name)
     {
         return children.getSubNodes(name);
     }
 
     /**
      * Returns the number of children with the given name.
      *
      * @param name the name; can be <b>null </b>, then the number of all
      * children is returned
      * @return the number of child nodes with this name
      */
     public int getChildrenCount(String name)
     {
         return children.getSubNodes(name).size();
     }
 
     /**
      * Returns the child node with the given index.
      *
      * @param index the index (0-based)
      * @return the child with this index
      */
     public ConfigurationNode getChild(int index)
     {
         return children.getNode(index);
     }
 
     /**
      * Removes the specified child node from this node.
      *
      * @param child the node to be removed
      * @return a flag if a node was removed
      */
     public boolean removeChild(ConfigurationNode child)
     {
         return children.removeNode(child);
     }
 
     /**
      * Removes all children with the given name.
      *
      * @param childName the name of the children to be removed
      * @return a flag if at least one child node was removed
      */
     public boolean removeChild(String childName)
     {
         return children.removeNodes(childName);
     }
 
     /**
      * Removes all child nodes of this node.
      */
     public void removeChildren()
     {
         children.clear();
     }
 
     /**
      * Checks if this node is an attribute node.
      *
      * @return a flag if this is an attribute node
      */
     public boolean isAttribute()
     {
         return attribute;
     }
 
     /**
      * Sets the attribute flag. Note: this method can only be called if the node
      * is not already part of a node hierarchy.
      *
      * @param f the attribute flag
      */
     public void setAttribute(boolean f)
     {
         checkState();
         attribute = f;
     }
 
     /**
      * Adds the specified attribute to this node.
      *
      * @param attr the attribute to be added
      */
     public void addAttribute(ConfigurationNode attr)
     {
         attributes.addNode(attr);
         attr.setAttribute(true);
         attr.setParentNode(this);
     }
 
     /**
      * Returns a list with the attributes of this node. This list contains
      * <code>ConfigurationNode</code> objects, too.
      *
      * @return the attribute list, never <b>null </b>
      */
     public List getAttributes()
     {
         return attributes.getSubNodes();
     }
 
     /**
      * Returns the number of attributes contained in this node.
      *
      * @return the number of attributes
      */
     public int getAttributeCount()
     {
         return attributes.getSubNodes().size();
     }
 
     /**
      * Returns a list with all attributes of this node with the given name.
      *
      * @param name the attribute's name
      * @return all attributes with this name
      */
     public List getAttributes(String name)
     {
         return attributes.getSubNodes(name);
     }
 
     /**
      * Returns the number of attributes of this node with the given name.
      *
      * @param name the name
      * @return the number of attributes with this name
      */
     public int getAttributeCount(String name)
     {
         return getAttributes(name).size();
     }
 
     /**
      * Removes the specified attribute.
      *
      * @param node the attribute node to be removed
      * @return a flag if the attribute could be removed
      */
     public boolean removeAttribute(ConfigurationNode node)
     {
         return attributes.removeNode(node);
     }
 
     /**
      * Removes all attributes with the specified name.
      *
      * @param name the name
      * @return a flag if at least one attribute was removed
      */
     public boolean removeAttribute(String name)
     {
         return attributes.removeNodes(name);
     }
 
     /**
      * Returns the attribute with the given index.
      *
      * @param index the index (0-based)
      * @return the attribute with this index
      */
     public ConfigurationNode getAttribute(int index)
     {
         return attributes.getNode(index);
     }
 
     /**
      * Removes all attributes of this node.
      */
     public void removeAttributes()
     {
         attributes.clear();
     }
 
     /**
      * Returns a flag if this node is defined. This means that the node contains
      * some data.
      *
      * @return a flag whether this node is defined
      */
     public boolean isDefined()
     {
         return getValue() != null || getChildrenCount() > 0
                 || getAttributeCount() > 0;
     }
 
     /**
      * Visits this node and all its sub nodes.
      *
      * @param visitor the visitor
      */
     public void visit(ConfigurationNodeVisitor visitor)
     {
         if (visitor == null)
         {
             throw new IllegalArgumentException("Visitor must not be null!");
         }
 
         if (!visitor.terminate())
         {
             visitor.visitBeforeChildren(this);
             children.visit(visitor);
             attributes.visit(visitor);
             visitor.visitAfterChildren(this);
         } /* if */
     }
 
     /**
      * Creates a copy of this object. This is not a deep copy, the children are
      * not cloned.
      *
      * @return a copy of this object
      */
     public Object clone()
     {
         try
         {
             DefaultConfigurationNode copy = (DefaultConfigurationNode) super
                     .clone();
             copy.initSubNodes();
             return copy;
         }
         catch (CloneNotSupportedException cex)
         {
             return null; // should not happen
         }
     }
 
     /**
      * Checks if a modification of this node is allowed. Some properties of a
      * node must not be changed when the node has a parent. This method checks
      * this and throws a runtime exception if necessary.
      */
     protected void checkState()
     {
         if (getParentNode() != null)
         {
             throw new IllegalStateException(
                     "Node cannot be modified when added to a parent!");
         } /* if */
     }
 
     /**
      * Creates a <code>SubNodes</code> instance that is used for storing
      * either this node's children or attributes.
      *
      * @param attributes <b>true</b> if the returned instance is used for
      * storing attributes, <b>false</b> for storing child nodes
      * @return the <code>SubNodes</code> object to use
      */
     protected SubNodes createSubNodes(boolean attributes)
     {
         return new SubNodes();
     }
 
     /**
      * Deals with the reference when a node is removed. This method is called
      * for each removed child node or attribute. It can be overloaded in sub
      * classes, for which the reference has a concrete meaning and remove
      * operations need some update actions. This default implementation is
      * empty.
      */
     protected void removeReference()
     {
     }
 
     /**
      * Helper method for initializing the sub nodes objects.
      */
     private void initSubNodes()
     {
         children = createSubNodes(false);
         attributes = createSubNodes(true);
     }
 
     /**
      * An internally used helper class for managing a collection of sub nodes.
      */
     protected static class SubNodes
     {
         /** Stores a list for the sub nodes. */
         private List nodes;
 
         /** Stores a map for accessing subnodes by name. */
         private Map namedNodes;
 
         /**
          * Adds a new sub node.
          *
          * @param node the node to add
          */
         public void addNode(ConfigurationNode node)
         {
             if (node == null || node.getName() == null)
             {
                 throw new IllegalArgumentException(
                         "Node to add must have a defined name!");
             }
             node.setParentNode(null);  // reset, will later be set
 
             if (nodes == null)
             {
                 nodes = new ArrayList();
                 namedNodes = new HashMap();
             }
 
             nodes.add(node);
             List lst = (List) namedNodes.get(node.getName());
             if (lst == null)
             {
                 lst = new LinkedList();
                 namedNodes.put(node.getName(), lst);
             }
             lst.add(node);
         }
 
         /**
          * Removes a sub node.
          *
          * @param node the node to remove
          * @return a flag if the node could be removed
          */
         public boolean removeNode(ConfigurationNode node)
         {
             if (nodes != null && node != null && nodes.contains(node))
             {
                 detachNode(node);
                 nodes.remove(node);
 
                 List lst = (List) namedNodes.get(node.getName());
                 if (lst != null)
                 {
                     lst.remove(node);
                     if (lst.isEmpty())
                     {
                         namedNodes.remove(node.getName());
                     }
                 }
                 return true;
             }
 
             else
             {
                 return false;
             }
         }
 
         /**
          * Removes all sub nodes with the given name.
          *
          * @param name the name
          * @return a flag if at least on sub node was removed
          */
         public boolean removeNodes(String name)
         {
             if (nodes != null && name != null)
             {
                 List lst = (List) namedNodes.remove(name);
                 if (lst != null)
                 {
                     detachNodes(lst);
                     nodes.removeAll(lst);
                     return true;
                 }
             }
             return false;
         }
 
         /**
          * Removes all sub nodes.
          */
         public void clear()
         {
             if (nodes != null)
             {
                 detachNodes(nodes);
                 nodes = null;
                 namedNodes = null;
             }
         }
 
         /**
          * Returns the node with the given index. If this index cannot be found,
          * an <code>IndexOutOfBoundException</code> exception will be thrown.
          *
          * @param index the index (0-based)
          * @return the sub node at the specified index
          */
         public ConfigurationNode getNode(int index)
         {
             if (nodes == null)
             {
                 throw new IndexOutOfBoundsException("No sub nodes available!");
             }
             return (ConfigurationNode) nodes.get(index);
         }
 
         /**
          * Returns a list with all stored sub nodes. The return value is never
          * <b>null</b>.
          *
          * @return a list with the sub nodes
          */
         public List getSubNodes()
         {
             return (nodes == null) ? Collections.EMPTY_LIST : Collections
                     .unmodifiableList(nodes);
         }
 
         /**
          * Returns a list of the sub nodes with the given name. The return value
          * is never <b>null</b>.
          *
          * @param name the name; if <b>null</b> is passed, all sub nodes will
          * be returned
          * @return all sub nodes with this name
          */
         public List getSubNodes(String name)
         {
             if (name == null)
             {
                 return getSubNodes();
             }
 
             List result;
             if (nodes == null)
             {
                 result = null;
             }
             else
             {
                 result = (List) namedNodes.get(name);
             }
 
             return (result == null) ? Collections.EMPTY_LIST : Collections
                     .unmodifiableList(result);
         }
 
         /**
          * Let the passed in visitor visit all sub nodes.
          *
          * @param visitor the visitor
          */
         public void visit(ConfigurationNodeVisitor visitor)
         {
             if (nodes != null)
             {
                 for (Iterator it = nodes.iterator(); it.hasNext()
                         && !visitor.terminate();)
                 {
                     ((ConfigurationNode) it.next()).visit(visitor);
                 }
             }
         }
 
         /**
          * This method is called whenever a sub node is removed from this
          * object. It ensures that the removed node's parent is reset and its
          * <code>removeReference()</code> method gets called.
          *
          * @param subNode the node to be removed
          */
         protected void detachNode(ConfigurationNode subNode)
         {
             subNode.setParentNode(null);
             if (subNode instanceof DefaultConfigurationNode)
             {
                 ((DefaultConfigurationNode) subNode).removeReference();
             }
         }
 
         /**
          * Detaches a list of sub nodes. This method calls
          * <code>detachNode()</code> for each node contained in the list.
          *
          * @param subNodes the list with nodes to be detached
          */
         protected void detachNodes(Collection subNodes)
         {
             for (Iterator it = subNodes.iterator(); it.hasNext();)
             {
                 detachNode((ConfigurationNode) it.next());
             }
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.configuration.tree;
18
19		import java.util.ArrayList;
20		import java.util.Collection;
21		import java.util.Collections;
22		import java.util.HashMap;
23		import java.util.Iterator;
24		import java.util.LinkedList;
25		import java.util.List;
26		import java.util.Map;
27
28		/**
29		* <p>
30		* A default implementation of the <code>ConfigurationNode</code> interface.
31		* </p>
32		*
33		* @since 1.3
34		* @author Oliver Heger
35		*/
36		public class DefaultConfigurationNode implements ConfigurationNode, Cloneable
37		{
38		/** Stores the children of this node. */
39		private SubNodes children;
40
41		/** Stores the attributes of this node. */
42		private SubNodes attributes;
43
44		/** Stores a reference to this node's parent. */
45		private ConfigurationNode parent;
46
47		/** Stores the value of this node. */
48		private Object value;
49
50		/** Stores the reference. */
51		private Object reference;
52
53		/** Stores the name of this node. */
54		private String name;
55
56		/** Stores a flag if this is an attribute. */
57		private boolean attribute;
58
59		/**
60		* Creates a new uninitialized instance of
61		* <code>DefaultConfigurationNode</code>.
62		*/
63		public DefaultConfigurationNode()
64		{
65	1829	this(null);
66	1829	}
67
68		/**
69		* Creates a new instance of <code>DefaultConfigurationNode</code> and
70		* initializes it with the node name.
71		*
72		* @param name the name of this node
73		*/
74		public DefaultConfigurationNode(String name)
75		{
76	16566	this(name, null);
77	16566	}
78
79		/**
80		* Creates a new instance of <code>DefaultConfigurationNode</code> and
81		* initializes it with the name and a value.
82		*
83		* @param name the node's name
84		* @param value the node's value
85		*/
86		public DefaultConfigurationNode(String name, Object value)
87	243733	{
88	243733	setName(name);
89	243733	setValue(value);
90	243733	initSubNodes();
91	243733	}
92
93		/**
94		* Returns the name of this node.
95		*
96		* @return the name of this node
97		*/
98		public String getName()
99		{
100	679346	return name;
101		}
102
103		/**
104		* Sets the name of this node.
105		*
106		* @param name the new name
107		*/
108		public void setName(String name)
109		{
110	244596	checkState();
111	244596	this.name = name;
112	244596	}
113
114		/**
115		* Returns the value of this node.
116		*
117		* @return the value of this node
118		*/
119		public Object getValue()
120		{
121	70095	return value;
122		}
123
124		/**
125		* Sets the value of this node.
126		*
127		* @param val the value of this node
128		*/
129		public void setValue(Object val)
130		{
131	260969	value = val;
132	260969	}
133
134		/**
135		* Returns the reference.
136		*
137		* @return the reference
138		*/
139		public Object getReference()
140		{
141	28213	return reference;
142		}
143
144		/**
145		* Sets the reference.
146		*
147		* @param reference the reference object
148		*/
149		public void setReference(Object reference)
150		{
151	11452	this.reference = reference;
152	11452	}
153
154		/**
155		* Returns a reference to this node's parent.
156		*
157		* @return the parent node or <b>null </b> if this is the root
158		*/
159		public ConfigurationNode getParentNode()
160		{
161	491129	return parent;
162		}
163
164		/**
165		* Sets the parent of this node.
166		*
167		* @param parent the parent of this node
168		*/
169		public void setParentNode(ConfigurationNode parent)
170		{
171	490985	this.parent = parent;
172	490985	}
173
174		/**
175		* Adds a new child to this node.
176		*
177		* @param child the new child
178		*/
179		public void addChild(ConfigurationNode child)
180		{
181	128479	children.addNode(child);
182	128477	child.setAttribute(false);
183	128477	child.setParentNode(this);
184	128477	}
185
186		/**
187		* Returns a list with all children of this node.
188		*
189		* @return a list with all child nodes
190		*/
191		public List getChildren()
192		{
193	29037	return children.getSubNodes();
194		}
195
196		/**
197		* Returns the number of all children of this node.
198		*
199		* @return the number of all children
200		*/
201		public int getChildrenCount()
202		{
203	23119	return children.getSubNodes().size();
204		}
205
206		/**
207		* Returns a list of all children with the given name.
208		*
209		* @param name the name; can be <b>null </b>, then all children are returned
210		* @return a list of all children with the given name
211		*/
212		public List getChildren(String name)
213		{
214	8711	return children.getSubNodes(name);
215		}
216
217		/**
218		* Returns the number of children with the given name.
219		*
220		* @param name the name; can be <b>null </b>, then the number of all
221		* children is returned
222		* @return the number of child nodes with this name
223		*/
224		public int getChildrenCount(String name)
225		{
226	6122	return children.getSubNodes(name).size();
227		}
228
229		/**
230		* Returns the child node with the given index.
231		*
232		* @param index the index (0-based)
233		* @return the child with this index
234		*/
235		public ConfigurationNode getChild(int index)
236		{
237	3987	return children.getNode(index);
238		}
239
240		/**
241		* Removes the specified child node from this node.
242		*
243		* @param child the node to be removed
244		* @return a flag if a node was removed
245		*/
246		public boolean removeChild(ConfigurationNode child)
247		{
248	623	return children.removeNode(child);
249		}
250
251		/**
252		* Removes all children with the given name.
253		*
254		* @param childName the name of the children to be removed
255		* @return a flag if at least one child node was removed
256		*/
257		public boolean removeChild(String childName)
258		{
259	9	return children.removeNodes(childName);
260		}
261
262		/**
263		* Removes all child nodes of this node.
264		*/
265		public void removeChildren()
266		{
267	3	children.clear();
268	3	}
269
270		/**
271		* Checks if this node is an attribute node.
272		*
273		* @return a flag if this is an attribute node
274		*/
275		public boolean isAttribute()
276		{
277	12025	return attribute;
278		}
279
280		/**
281		* Sets the attribute flag. Note: this method can only be called if the node
282		* is not already part of a node hierarchy.
283		*
284		* @param f the attribute flag
285		*/
286		public void setAttribute(boolean f)
287		{
288	244311	checkState();
289	244310	attribute = f;
290	244310	}
291
292		/**
293		* Adds the specified attribute to this node.
294		*
295		* @param attr the attribute to be added
296		*/
297		public void addAttribute(ConfigurationNode attr)
298		{
299	115829	attributes.addNode(attr);
300	115829	attr.setAttribute(true);
301	115829	attr.setParentNode(this);
302	115829	}
303
304		/**
305		* Returns a list with the attributes of this node. This list contains
306		* <code>ConfigurationNode</code> objects, too.
307		*
308		* @return the attribute list, never <b>null </b>
309		*/
310		public List getAttributes()
311		{
312	10498	return attributes.getSubNodes();
313		}
314
315		/**
316		* Returns the number of attributes contained in this node.
317		*
318		* @return the number of attributes
319		*/
320		public int getAttributeCount()
321		{
322	8644	return attributes.getSubNodes().size();
323		}
324
325		/**
326		* Returns a list with all attributes of this node with the given name.
327		*
328		* @param name the attribute's name
329		* @return all attributes with this name
330		*/
331		public List getAttributes(String name)
332		{
333	5651	return attributes.getSubNodes(name);
334		}
335
336		/**
337		* Returns the number of attributes of this node with the given name.
338		*
339		* @param name the name
340		* @return the number of attributes with this name
341		*/
342		public int getAttributeCount(String name)
343		{
344	39	return getAttributes(name).size();
345		}
346
347		/**
348		* Removes the specified attribute.
349		*
350		* @param node the attribute node to be removed
351		* @return a flag if the attribute could be removed
352		*/
353		public boolean removeAttribute(ConfigurationNode node)
354		{
355	1	return attributes.removeNode(node);
356		}
357
358		/**
359		* Removes all attributes with the specified name.
360		*
361		* @param name the name
362		* @return a flag if at least one attribute was removed
363		*/
364		public boolean removeAttribute(String name)
365		{
366	7	return attributes.removeNodes(name);
367		}
368
369		/**
370		* Returns the attribute with the given index.
371		*
372		* @param index the index (0-based)
373		* @return the attribute with this index
374		*/
375		public ConfigurationNode getAttribute(int index)
376		{
377	3916	return attributes.getNode(index);
378		}
379
380		/**
381		* Removes all attributes of this node.
382		*/
383		public void removeAttributes()
384		{
385	1	attributes.clear();
386	1	}
387
388		/**
389		* Returns a flag if this node is defined. This means that the node contains
390		* some data.
391		*
392		* @return a flag whether this node is defined
393		*/
394		public boolean isDefined()
395		{
396	1	return getValue() != null \|\| getChildrenCount() > 0
397		\|\| getAttributeCount() > 0;
398		}
399
400		/**
401		* Visits this node and all its sub nodes.
402		*
403		* @param visitor the visitor
404		*/
405		public void visit(ConfigurationNodeVisitor visitor)
406		{
407	2840	if (visitor == null)
408		{
409	1	throw new IllegalArgumentException("Visitor must not be null!");
410		}
411
412	2839	if (!visitor.terminate())
413		{
414	2839	visitor.visitBeforeChildren(this);
415	2839	children.visit(visitor);
416	2839	attributes.visit(visitor);
417	2839	visitor.visitAfterChildren(this);
418		} /* if */
419	2839	}
420
421		/**
422		* Creates a copy of this object. This is not a deep copy, the children are
423		* not cloned.
424		*
425		* @return a copy of this object
426		*/
427		public Object clone()
428		{
429		try
430		{
431	229	DefaultConfigurationNode copy = (DefaultConfigurationNode) super
432		.clone();
433	229	copy.initSubNodes();
434	229	return copy;
435		}
436		catch (CloneNotSupportedException cex)
437		{
438	0	return null; // should not happen
439		}
440		}
441
442		/**
443		* Checks if a modification of this node is allowed. Some properties of a
444		* node must not be changed when the node has a parent. This method checks
445		* this and throws a runtime exception if necessary.
446		*/
447		protected void checkState()
448		{
449	488907	if (getParentNode() != null)
450		{
451	1	throw new IllegalStateException(
452		"Node cannot be modified when added to a parent!");
453		} /* if */
454	488906	}
455
456		/**
457		* Creates a <code>SubNodes</code> instance that is used for storing
458		* either this node's children or attributes.
459		*
460		* @param attributes <b>true</b> if the returned instance is used for
461		* storing attributes, <b>false</b> for storing child nodes
462		* @return the <code>SubNodes</code> object to use
463		*/
464		protected SubNodes createSubNodes(boolean attributes)
465		{
466	487924	return new SubNodes();
467		}
468
469		/**
470		* Deals with the reference when a node is removed. This method is called
471		* for each removed child node or attribute. It can be overloaded in sub
472		* classes, for which the reference has a concrete meaning and remove
473		* operations need some update actions. This default implementation is
474		* empty.
475		*/
476		protected void removeReference()
477		{
478	49	}
479
480		/**
481		* Helper method for initializing the sub nodes objects.
482		*/
483		private void initSubNodes()
484		{
485	243962	children = createSubNodes(false);
486	243962	attributes = createSubNodes(true);
487	243962	}
488
489		/**
490		* An internally used helper class for managing a collection of sub nodes.
491		*/
492	487924	protected static class SubNodes
493		{
494		/** Stores a list for the sub nodes. */
495		private List nodes;
496
497		/** Stores a map for accessing subnodes by name. */
498		private Map namedNodes;
499
500		/**
501		* Adds a new sub node.
502		*
503		* @param node the node to add
504		*/
505		public void addNode(ConfigurationNode node)
506		{
507	244308	if (node == null \|\| node.getName() == null)
508		{
509	2	throw new IllegalArgumentException(
510		"Node to add must have a defined name!");
511		}
512	244306	node.setParentNode(null); // reset, will later be set
513
514	244306	if (nodes == null)
515		{
516	143492	nodes = new ArrayList();
517	143492	namedNodes = new HashMap();
518		}
519
520	244306	nodes.add(node);
521	244306	List lst = (List) namedNodes.get(node.getName());
522	244306	if (lst == null)
523		{
524	172421	lst = new LinkedList();
525	172421	namedNodes.put(node.getName(), lst);
526		}
527	244306	lst.add(node);
528	244306	}
529
530		/**
531		* Removes a sub node.
532		*
533		* @param node the node to remove
534		* @return a flag if the node could be removed
535		*/
536		public boolean removeNode(ConfigurationNode node)
537		{
538	624	if (nodes != null && node != null && nodes.contains(node))
539		{
540	520	detachNode(node);
541	520	nodes.remove(node);
542
543	520	List lst = (List) namedNodes.get(node.getName());
544	520	if (lst != null)
545		{
546	520	lst.remove(node);
547	520	if (lst.isEmpty())
548		{
549	382	namedNodes.remove(node.getName());
550		}
551		}
552	520	return true;
553		}
554
555		else
556		{
557	104	return false;
558		}
559		}
560
561		/**
562		* Removes all sub nodes with the given name.
563		*
564		* @param name the name
565		* @return a flag if at least on sub node was removed
566		*/
567		public boolean removeNodes(String name)
568		{
569	16	if (nodes != null && name != null)
570		{
571	9	List lst = (List) namedNodes.remove(name);
572	9	if (lst != null)
573		{
574	7	detachNodes(lst);
575	7	nodes.removeAll(lst);
576	7	return true;
577		}
578		}
579	9	return false;
580		}
581
582		/**
583		* Removes all sub nodes.
584		*/
585		public void clear()
586		{
587	4	if (nodes != null)
588		{
589	3	detachNodes(nodes);
590	3	nodes = null;
591	3	namedNodes = null;
592		}
593	4	}
594
595		/**
596		* Returns the node with the given index. If this index cannot be found,
597		* an <code>IndexOutOfBoundException</code> exception will be thrown.
598		*
599		* @param index the index (0-based)
600		* @return the sub node at the specified index
601		*/
602		public ConfigurationNode getNode(int index)
603		{
604	7903	if (nodes == null)
605		{
606	1	throw new IndexOutOfBoundsException("No sub nodes available!");
607		}
608	7902	return (ConfigurationNode) nodes.get(index);
609		}
610
611		/**
612		* Returns a list with all stored sub nodes. The return value is never
613		* <b>null</b>.
614		*
615		* @return a list with the sub nodes
616		*/
617		public List getSubNodes()
618		{
619	71299	return (nodes == null) ? Collections.EMPTY_LIST : Collections
620		.unmodifiableList(nodes);
621		}
622
623		/**
624		* Returns a list of the sub nodes with the given name. The return value
625		* is never <b>null</b>.
626		*
627		* @param name the name; if <b>null</b> is passed, all sub nodes will
628		* be returned
629		* @return all sub nodes with this name
630		*/
631		public List getSubNodes(String name)
632		{
633	20484	if (name == null)
634		{
635	1	return getSubNodes();
636		}
637
638		List result;
639	20483	if (nodes == null)
640		{
641	608	result = null;
642		}
643		else
644		{
645	19875	result = (List) namedNodes.get(name);
646		}
647
648	20483	return (result == null) ? Collections.EMPTY_LIST : Collections
649		.unmodifiableList(result);
650		}
651
652		/**
653		* Let the passed in visitor visit all sub nodes.
654		*
655		* @param visitor the visitor
656		*/
657		public void visit(ConfigurationNodeVisitor visitor)
658		{
659	5678	if (nodes != null)
660		{
661	1398	for (Iterator it = nodes.iterator(); it.hasNext()
662	3199	&& !visitor.terminate();)
663		{
664	1801	((ConfigurationNode) it.next()).visit(visitor);
665		}
666		}
667	5678	}
668
669		/**
670		* This method is called whenever a sub node is removed from this
671		* object. It ensures that the removed node's parent is reset and its
672		* <code>removeReference()</code> method gets called.
673		*
674		* @param subNode the node to be removed
675		*/
676		protected void detachNode(ConfigurationNode subNode)
677		{
678	545	subNode.setParentNode(null);
679	545	if (subNode instanceof DefaultConfigurationNode)
680		{
681	545	((DefaultConfigurationNode) subNode).removeReference();
682		}
683	545	}
684
685		/**
686		* Detaches a list of sub nodes. This method calls
687		* <code>detachNode()</code> for each node contained in the list.
688		*
689		* @param subNodes the list with nodes to be detached
690		*/
691		protected void detachNodes(Collection subNodes)
692		{
693	45	for (Iterator it = subNodes.iterator(); it.hasNext();)
694		{
695	25	detachNode((ConfigurationNode) it.next());
696		}
697	10	}
698		}
699		}