001    /*
002     *  Licensed to the Apache Software Foundation (ASF) under one
003     *  or more contributor license agreements.  See the NOTICE file
004     *  distributed with this work for additional information
005     *  regarding copyright ownership.  The ASF licenses this file
006     *  to you under the Apache License, Version 2.0 (the
007     *  "License"); you may not use this file except in compliance
008     *  with the License.  You may obtain a copy of the License at
009     *  
010     *    http://www.apache.org/licenses/LICENSE-2.0
011     *  
012     *  Unless required by applicable law or agreed to in writing,
013     *  software distributed under the License is distributed on an
014     *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015     *  KIND, either express or implied.  See the License for the
016     *  specific language governing permissions and limitations
017     *  under the License. 
018     *  
019     */
020    
021    package org.apache.directory.shared.ldap.filter;
022    
023    
024    import java.util.List;
025    
026    import org.apache.directory.shared.i18n.I18n;
027    
028    /**
029     * Node representing an Not connector in a filter operation
030     * 
031     * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
032     * @version $Rev: 517453 $
033     */
034    public class NotNode extends BranchNode
035    {
036        /**
037         * Creates a NotNode using a logical NOT operator and a list of children.
038         * 
039         * A Not node could contain only one child
040         * 
041         * @param childList the child nodes under this branch node.
042         */
043        public NotNode( List<ExprNode> childList )
044        {
045            super( AssertionType.NOT );
046    
047            if ( childList != null )
048            {
049                setChildren( childList );
050            }
051        }
052    
053    
054        /**
055         * Creates a NotNode using a logical NOT operator and the given child.
056         * 
057         * @param child the child node under this branch node.
058         */
059        public NotNode( ExprNode child )
060        {
061            super( AssertionType.NOT );
062    
063            if ( child != null )
064            {
065                addNode( child );
066            }
067        }
068    
069        
070        /**
071         * Clone the Node
072         */
073        @Override public ExprNode clone()
074        {
075            return super.clone();
076        }
077        
078    
079    
080        /**
081         * Creates an empty NotNode
082         */
083        public NotNode()
084        {
085            this( (ExprNode)null );
086        }
087    
088        /**
089         * Adds a child node to this NOT node node
090         * 
091         * @param node the child expression to add to this NOT node
092         */
093        public void addNode( ExprNode node )
094        {
095            if ( ( children != null ) && ( children.size() >= 1 ) )
096            {
097                throw new IllegalStateException( I18n.err( I18n.ERR_04159 ) );
098            }
099            
100            children.add( node );
101        }
102    
103    
104        /**
105         * Adds a child node to this NOT node at the head rather than the tail. 
106         * 
107         * @param node the child expression to add to this branch node
108         */
109        public void addNodeToHead( ExprNode node )
110        {
111            if ( children.size() >= 1 )
112            {
113                throw new IllegalStateException( I18n.err( I18n.ERR_04159 ) );            
114            }
115            
116            children.add( node );
117        }
118    
119    
120        /**
121         * Sets the list of children under this node.
122         * 
123         * @param childList the list of children to set.
124         */
125        public void setChildren( List<ExprNode> childList )
126        {
127            if ( ( childList != null ) && ( childList.size() > 1 ) )
128            {
129                throw new IllegalStateException( I18n.err( I18n.ERR_04159 ) );            
130            }
131    
132            children = childList;
133        }
134    
135        
136        /**
137         * Gets the operator for this branch node.
138         * 
139         * @return the operator constant.
140         */
141        public AssertionType getOperator()
142        {
143            return AssertionType.NOT;
144        }
145    
146    
147        /**
148         * Tests whether or not this node is a disjunction (a OR'ed branch).
149         * 
150         * @return true if the operation is a OR, false otherwise.
151         */
152        public boolean isDisjunction()
153        {
154            return false;
155        }
156    
157    
158        /**
159         * Tests whether or not this node is a conjunction (a AND'ed branch).
160         * 
161         * @return true if the operation is a AND, false otherwise.
162         */
163        public boolean isConjunction()
164        {
165            return false;
166        }
167    
168    
169        /**
170         * Tests whether or not this node is a negation (a NOT'ed branch).
171         * 
172         * @return true if the operation is a NOT, false otherwise.
173         */
174        public boolean isNegation()
175        {
176            return true;
177        }
178    
179    
180        /**
181         * @see ExprNode#printRefinementToBuffer(StringBuffer)
182         * 
183         * @return The buffer in which the refinement has been appended
184         * @throws UnsupportedOperationException if this node isn't a part of a refinement.
185         */
186        public StringBuilder printRefinementToBuffer( StringBuilder buf )
187        {
188            buf.append( "not: {" );
189            boolean isFirst = true;
190            
191            for ( ExprNode node:children )
192            {
193                if ( isFirst )
194                {
195                    isFirst = false;
196                }
197                else
198                {
199                    buf.append( ", " );
200                }
201                
202                node.printRefinementToBuffer( buf );
203            }
204            
205            buf.append( '}' );
206            
207            return buf;
208        }
209    
210        /**
211         * Gets the recursive prefix string represent of the filter from this node
212         * down.
213         * 
214         * @see java.lang.Object#toString()
215         * @return A string representing the AndNode
216         */
217        public String toString()
218        {
219            StringBuilder buf = new StringBuilder();
220            buf.append( "(!" );
221            
222            buf.append( super.toString() );
223    
224            buf.append( getFirstChild() );
225            buf.append( ')' );
226            
227            return buf.toString();
228        }
229    }