##### Coverage Report - org.apache.commons.configuration.tree.NodeCombiner

Classes in this File | Line Coverage | Branch Coverage | Complexity
NodeCombiner |
100% | 8/8
N/A | N/A
| 1.0;1

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.Collections;
20 |  |
     import java.util.HashSet;
21 |  |
     import java.util.Set;
22 |  |
23 |  |
     /**
24 |  |
      * <p>
25 |  |
      * A base class for node combiner implementations.
26 |  |
      * </p>
27 |  |
      * <p>
28 |  |
      * A <em>node combiner</em> is an object that knows how two hierarchical node
29 |  |
      * structures can be combined into a single one. Of course, there are many
30 |  |
      * possible ways of implementing such a combination, e.g. constructing a union,
31 |  |
      * an intersection, or an "override" structure (were nodes in the first
32 |  |
      * hierarchy take precedence over nodes in the second hierarchy). This abstract
33 |  |
      * base class only provides some helper methods and defines the common interface
34 |  |
      * for node combiners. Concrete sub classes will implement the diverse
35 |  |
      * combination algorithms.
36 |  |
      * </p>
37 |  |
      * <p>
38 |  |
      * For some concrete combiner implementations it is important to distinguish
39 |  |
      * whether a node is a single node or whether it belongs to a list structure.
40 |  |
      * Alone from the input structures, the combiner will not always be able to make
41 |  |
      * this decision. So sometimes it may be necessary for the developer to
42 |  |
      * configure the combiner and tell it, which nodes should be treated as list
43 |  |
      * nodes. For this purpose the <code>addListNode()</code> method exists. It
44 |  |
      * can be passed the name of a node, which should be considered a list node.
45 |  |
      * </p>
46 |  |
      *
47 |  |
      * @author <a
48 |  |
      * href="http://jakarta.apache.org/commons/configuration/team-list.html">Commons
49 |  |
      * Configuration team</a>
50 |  |
      * @version $Id: NodeCombiner.java 439648 2006-09-02 20:42:10Z oheger $
51 |  |
      * @since 1.3
52 |  |
      */
53 |  |
     public abstract class NodeCombiner
54 |  |
     {
55 |  |
         /** Stores a list with node names that are known to be list nodes. */
56 |  |
         protected Set listNodes;
57 |  |
58 |  |
         /**
59 |  |
          * Creates a new instance of <code>NodeCombiner</code>.
60 |  |
          */
61 |  |
         public NodeCombiner()
62 | 41 |
         {
63 | 41 |
             listNodes = new HashSet();
64 | 41 |
         }
65 |  |
66 |  |
         /**
67 |  |
          * Adds the name of a node to the list of known list nodes. This means that
68 |  |
          * nodes with this name will never be combined.
69 |  |
          *
70 |  |
          * @param nodeName the name to be added
71 |  |
          */
72 |  |
         public void addListNode(String nodeName)
73 |  |
         {
74 | 8 |
             listNodes.add(nodeName);
75 | 8 |
         }
76 |  |
77 |  |
         /**
78 |  |
          * Returns a set with the names of nodes that are known to be list nodes.
79 |  |
          *
80 |  |
          * @return a set with the names of list nodes
81 |  |
          */
82 |  |
         public Set getListNodes()
83 |  |
         {
84 | 4 |
             return Collections.unmodifiableSet(listNodes);
85 |  |
         }
86 |  |
87 |  |
         /**
88 |  |
          * Checks if a node is a list node. This implementation tests if the given
89 |  |
          * node name is contained in the set of known list nodes. Derived classes
90 |  |
          * which use different criteria may overload this method.
91 |  |
          *
92 |  |
          * @param node the node to be tested
93 |  |
          * @return a flag whether this is a list node
94 |  |
          */
95 |  |
         public boolean isListNode(ConfigurationNode node)
96 |  |
         {
97 | 293 |
             return listNodes.contains(node.getName());
98 |  |
         }
99 |  |
100 |  |
         /**
101 |  |
          * Combines the hierarchies represented by the given root nodes. This method
102 |  |
          * must be defined in concrete sub classes with the implementation of a
103 |  |
          * specific combination algorithm.
104 |  |
          *
105 |  |
          * @param node1 the first root node
106 |  |
          * @param node2 the second root node
107 |  |
          * @return the resulting combined node structure
108 |  |
          */
109 |  |
         public abstract ConfigurationNode combine(ConfigurationNode node1,
110 |  |
                 ConfigurationNode node2);
111 |  |
112 |  |
         /**
113 |  |
          * Creates a new view node. This method will be called whenever a new view
114 |  |
          * node is to be created. It can be overriden to create special view nodes.
115 |  |
          * This base implementation returns a new instance of
116 |  |
          * <code>{@link ViewNode}</code>.
117 |  |
          *
118 |  |
          * @return the new view node
119 |  |
          */
120 |  |
         protected ViewNode createViewNode()
121 |  |
         {
122 | 240 |
             return new ViewNode();
123 |  |
         }
124 |  |
     }