View Javadoc
1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
18   *  
19   */
20  
21  package org.apache.directory.api.ldap.model.filter;
22  
23  
24  import java.util.List;
25  
26  
27  /**
28   * Node representing an OR connector in a filter operation
29   * 
30   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
31   */
32  public class OrNode extends BranchNode
33  {
34      /**
35       * Creates a OrNode using a logical operator and a list of children.
36       * 
37       * @param childList the child nodes under this branch node.
38       */
39      public OrNode( List<ExprNode> childList )
40      {
41          super( AssertionType.OR, childList );
42      }
43  
44  
45      /**
46       * Creates a OrNode using a logical operator and a list of children.
47       * 
48       * @param childList the child nodes under this branch node.
49       */
50      public OrNode( ExprNode... childList )
51      {
52          super( AssertionType.OR, childList );
53      }
54  
55  
56      /**
57       * Creates an empty OrNode
58       */
59      public OrNode()
60      {
61          super( AssertionType.OR );
62      }
63  
64  
65      /**
66       * Gets the operator for this branch node.
67       * 
68       * @return the operator constant.
69       */
70      public AssertionType getOperator()
71      {
72          return AssertionType.OR;
73      }
74  
75  
76      /**
77       * Tests whether or not this node is a disjunction (a OR'ed branch).
78       * 
79       * @return true if the operation is a OR, false otherwise.
80       */
81      public boolean isDisjunction()
82      {
83          return true;
84      }
85  
86  
87      /**
88       * Tests whether or not this node is a conjunction (a AND'ed branch).
89       * 
90       * @return true if the operation is a AND, false otherwise.
91       */
92      public boolean isConjunction()
93      {
94          return false;
95      }
96  
97  
98      /**
99       * Tests whether or not this node is a negation (a NOT'ed branch).
100      * 
101      * @return true if the operation is a NOT, false otherwise.
102      */
103     public boolean isNegation()
104     {
105         return false;
106     }
107 
108 
109     /**
110      * @see ExprNode#printRefinementToBuffer(StringBuffer)
111      * 
112      * @return The buffer in which the refinement has been appended
113      * @throws UnsupportedOperationException if this node isn't a part of a refinement.
114      */
115     public StringBuilder printRefinementToBuffer( StringBuilder buf )
116     {
117         buf.append( "or: {" );
118         boolean isFirst = true;
119 
120         for ( ExprNode node : children )
121         {
122             if ( isFirst )
123             {
124                 isFirst = false;
125                 buf.append( ' ' );
126             }
127             else
128             {
129                 buf.append( ", " );
130             }
131 
132             node.printRefinementToBuffer( buf );
133         }
134 
135         buf.append( " }" );
136 
137         return buf;
138     }
139 
140 
141     /**
142      * Gets the recursive prefix string represent of the filter from this node
143      * down.
144      * 
145      * @see java.lang.Object#toString()
146      * @return A string representing the AndNode
147      */
148     public String toString()
149     {
150         StringBuilder buf = new StringBuilder();
151         buf.append( "(|" );
152 
153         buf.append( super.toString() );
154 
155         for ( ExprNode child : getChildren() )
156         {
157             buf.append( child );
158         }
159 
160         buf.append( ')' );
161 
162         return buf.toString();
163     }
164 
165 
166     /**
167      * @see Object#hashCode()
168      * @return the instance's hash code 
169      */
170     public int hashCode()
171     {
172         int hash = 37;
173         hash = hash * 17 + AssertionType.OR.hashCode();
174         hash = hash * 17 + ( annotations == null ? 0 : annotations.hashCode() );
175         return hash;
176     }
177 
178 
179     /**
180      * @see java.lang.Object#equals(java.lang.Object)
181      */
182     public boolean equals( Object other )
183     {
184         if ( this == other )
185         {
186             return true;
187         }
188 
189         if ( !( other instanceof OrNode ) )
190         {
191             return false;
192         }
193 
194         OrNode otherExprNode = ( OrNode ) other;
195 
196         List<ExprNode> otherChildren = otherExprNode.getChildren();
197 
198         if ( otherChildren == children )
199         {
200             return true;
201         }
202 
203         if ( children.size() != otherChildren.size() )
204         {
205             return false;
206         }
207 
208         for ( int i = 0; i < children.size(); i++ )
209         {
210             ExprNode child = children.get( i );
211             ExprNode otherChild = otherChildren.get( i );
212 
213             if ( !child.equals( otherChild ) )
214             {
215                 return false;
216             }
217         }
218 
219         return true;
220     }
221 }