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   *  https://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  package org.apache.directory.api.ldap.model.entry;
20  
21  
22  import java.io.IOException;
23  import java.io.ObjectInput;
24  import java.io.ObjectOutput;
25  import java.util.Collection;
26  import java.util.Iterator;
27  import java.util.List;
28  
29  import org.apache.directory.api.i18n.I18n;
30  import org.apache.directory.api.ldap.model.exception.LdapException;
31  import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
32  import org.apache.directory.api.ldap.model.name.Dn;
33  import org.apache.directory.api.ldap.model.schema.AttributeType;
34  import org.apache.directory.api.util.exception.NotImplementedException;
35  
36  
37  /**
38   * A default implementation of a ServerEntry which should suite most
39   * use cases.
40   *
41   * This class is final, it should not be extended.
42   *
43   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
44   */
45  public class ImmutableEntry implements Entry
46  {
47      /** Used for serialization */
48      private static final long serialVersionUID = 2L;
49  
50      /** The wrapped Entry for this entry */
51      private Entry entry;
52  
53  
54      //-------------------------------------------------------------------------
55      // Constructors
56      //-------------------------------------------------------------------------
57      /**
58       * Creates a new instance of DefaultEntry.
59       * <p>
60       * This entry <b>must</b> be initialized before being used !
61       *
62       * @param entry The encapsulated entry
63       */
64      public ImmutableEntry( Entry entry )
65      {
66          this.entry = entry;
67      }
68  
69  
70      //-------------------------------------------------------------------------
71      // Entry methods
72      //-------------------------------------------------------------------------
73      /**
74       * {@inheritDoc}
75       */
76      @Override
77      public Entry add( AttributeType attributeType, byte[]... values ) throws LdapException
78      {
79          new Exception().printStackTrace();
80          throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
81      }
82  
83  
84      /**
85       * {@inheritDoc}
86       */
87      @Override
88      public Entry add( AttributeType attributeType, String... values ) throws LdapException
89      {
90          new Exception().printStackTrace();
91          throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
92      }
93  
94  
95      /**
96       * {@inheritDoc}
97       */
98      @Override
99      public Entry add( AttributeType attributeType, Value... values ) throws LdapException
100     {
101         new Exception().printStackTrace();
102         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
103     }
104 
105 
106     /**
107      * {@inheritDoc}
108      */
109     @Override
110     public Entry add( String upId, AttributeType attributeType, byte[]... values ) throws LdapException
111     {
112         new Exception().printStackTrace();
113         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
114     }
115 
116 
117     /**
118      * {@inheritDoc}
119      */
120     @Override
121     public Entry add( String upId, AttributeType attributeType, Value... values ) throws LdapException
122     {
123         new Exception().printStackTrace();
124         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
125     }
126 
127 
128     /**
129      * {@inheritDoc}
130      */
131     @Override
132     public Entry add( String upId, AttributeType attributeType, String... values ) throws LdapException
133     {
134         new Exception().printStackTrace();
135         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
136     }
137 
138 
139     /**
140      * {@inheritDoc}
141      */
142     @Override
143     public Entry add( Attribute... attributes ) throws LdapException
144     {
145         new Exception().printStackTrace();
146         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
147     }
148 
149 
150     /**
151      * {@inheritDoc}
152      */
153     @Override
154     public Entry add( String upId, byte[]... values ) throws LdapException
155     {
156         new Exception().printStackTrace();
157         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
158     }
159 
160 
161     /**
162      * {@inheritDoc}
163      */
164     @Override
165     public Entry add( String upId, String... values ) throws LdapException
166     {
167         new Exception().printStackTrace();
168         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
169     }
170 
171 
172     /**
173      * {@inheritDoc}
174      */
175     @Override
176 public Entry add( String upId, Value... values ) throws LdapException
177     {
178         new Exception().printStackTrace();
179         throw new NotImplementedException( I18n.err( I18n.ERR_13236_ENTRY_IMMUTABLE_CANT_ADD_ATTRIBUTE, entry.getDn() ) );
180     }
181 
182 
183     /**
184      * Clone an entry. All the element are duplicated, so a modification on
185      * the original object won't affect the cloned object, as a modification
186      * on the cloned object has no impact on the original object
187      */
188     @Override
189     public Entry clone()
190     {
191         return entry.clone();
192     }
193 
194 
195     /**
196      * {@inheritDoc}
197      */
198     @Override
199     public Entry shallowClone()
200     {
201         return entry.shallowClone();
202     }
203 
204 
205     /**
206      * {@inheritDoc}
207      */
208     @Override
209     public boolean contains( Attribute... attributes )
210     {
211         return entry.contains( attributes );
212     }
213 
214 
215     /**
216      * {@inheritDoc}
217      */
218     @Override
219     public boolean containsAttribute( String... attributes )
220     {
221         return entry.containsAttribute( attributes );
222     }
223 
224 
225     /**
226      * {@inheritDoc}
227      */
228     @Override
229     public boolean containsAttribute( AttributeType attributeType )
230     {
231         return entry.containsAttribute( attributeType );
232     }
233 
234 
235     /**
236      * {@inheritDoc}
237      */
238     @Override
239     public boolean contains( AttributeType attributeType, byte[]... values )
240     {
241         return entry.contains( attributeType, values );
242     }
243 
244 
245     /**
246      * {@inheritDoc}
247      */
248     @Override
249     public boolean contains( AttributeType attributeType, String... values )
250     {
251         return entry.contains( attributeType, values );
252     }
253 
254 
255     /**
256      * {@inheritDoc}
257      */
258     @Override
259     public boolean contains( AttributeType attributeType, Value... values )
260     {
261         return entry.contains( attributeType, values );
262     }
263 
264 
265     /**
266      * {@inheritDoc}
267      */
268     @Override
269     public boolean contains( String upId, byte[]... values )
270     {
271         return entry.contains( upId, values );
272     }
273 
274 
275     /**
276      * {@inheritDoc}
277      */
278     @Override
279     public boolean contains( String upId, String... values )
280     {
281         return entry.contains( upId, values );
282     }
283 
284 
285     /**
286      * {@inheritDoc}
287      */
288     @Override
289     public boolean contains( String upId, Value... values )
290     {
291         return entry.contains( upId, values );
292     }
293 
294 
295     /**
296      * {@inheritDoc}
297      */
298     @Override
299     public Attribute get( String alias )
300     {
301         return entry.get( alias );
302     }
303 
304 
305     /**
306      * {@inheritDoc}
307      */
308     @Override
309     public Attribute get( AttributeType attributeType )
310     {
311         return entry.get( attributeType );
312     }
313 
314 
315     /**
316      * {@inheritDoc}
317      */
318     @Override
319     public Collection<Attribute> getAttributes()
320     {
321         return entry.getAttributes();
322     }
323 
324 
325     /**
326      * {@inheritDoc}
327      */
328     @Override
329     public Attribute put( String upId, byte[]... values )
330     {
331         new Exception().printStackTrace();
332         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
333     }
334 
335 
336     /**
337      * {@inheritDoc}
338      */
339     @Override
340     public Attribute put( String upId, String... values )
341     {
342         new Exception().printStackTrace();
343         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
344     }
345 
346 
347     /**
348      * {@inheritDoc}
349      */
350     @Override
351     public Attribute put( String upId, Value... values )
352     {
353         new Exception().printStackTrace();
354         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
355     }
356 
357 
358     /**
359      * {@inheritDoc}
360      */
361     @Override
362     public List<Attribute> put( Attribute... attributes ) throws LdapException
363     {
364         new Exception().printStackTrace();
365         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
366     }
367 
368 
369     /**
370      * {@inheritDoc}
371      */
372     @Override
373     public Attribute put( AttributeType attributeType, byte[]... values ) throws LdapException
374     {
375         new Exception().printStackTrace();
376         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
377     }
378 
379 
380     /**
381      * {@inheritDoc}
382      */
383     @Override
384     public Attribute put( AttributeType attributeType, String... values ) throws LdapException
385     {
386         new Exception().printStackTrace();
387         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
388     }
389 
390 
391     /**
392      * {@inheritDoc}
393      */
394     @Override
395     public Attribute put( AttributeType attributeType, Value... values ) throws LdapException
396     {
397         new Exception().printStackTrace();
398         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
399     }
400 
401 
402     /**
403      * {@inheritDoc}
404      */
405     @Override
406     public Attribute put( String upId, AttributeType attributeType, byte[]... values ) throws LdapException
407     {
408         new Exception().printStackTrace();
409         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
410     }
411 
412 
413     /**
414      * {@inheritDoc}
415      */
416     @Override
417     public Attribute put( String upId, AttributeType attributeType, String... values ) throws LdapException
418     {
419         new Exception().printStackTrace();
420         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
421     }
422 
423 
424     /**
425      * {@inheritDoc}
426      */
427     @Override
428     public Attribute put( String upId, AttributeType attributeType, Value... values ) throws LdapException
429     {
430         new Exception().printStackTrace();
431         throw new NotImplementedException( I18n.err( I18n.ERR_13237_ENTRY_IMMUTABLE_CANT_PUT_VALUE, entry.getDn() ) );
432     }
433 
434 
435     /**
436      * {@inheritDoc}
437      */
438     @Override
439     public List<Attribute> remove( Attribute... attributes ) throws LdapException
440     {
441         new Exception().printStackTrace();
442         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
443     }
444 
445 
446     /**
447      * {@inheritDoc}
448      */
449     @Override
450     public boolean remove( AttributeType attributeType, byte[]... values ) throws LdapException
451     {
452         new Exception().printStackTrace();
453         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
454     }
455 
456 
457     /**
458      * {@inheritDoc}
459      */
460     @Override
461     public boolean remove( AttributeType attributeType, String... values ) throws LdapException
462     {
463         new Exception().printStackTrace();
464         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
465     }
466 
467 
468     /**
469      * {@inheritDoc}
470      */
471     @Override
472     public boolean remove( AttributeType attributeType, Value... values ) throws LdapException
473     {
474         new Exception().printStackTrace();
475         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
476     }
477 
478 
479     /**
480      * <p>
481      * Removes the attribute with the specified AttributeTypes.
482      * </p>
483      * <p>
484      * The removed attribute are returned by this method.
485      * </p>
486      * <p>
487      * If there is no attribute with the specified AttributeTypes,
488      * the return value is <code>null</code>.
489      * </p>
490      *
491      * @param attributes the AttributeTypes to be removed
492      */
493     @Override
494     public void removeAttributes( AttributeType... attributes )
495     {
496         new Exception().printStackTrace();
497         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
498     }
499 
500 
501     /**
502      * {@inheritDoc}
503      */
504     @Override
505     public void removeAttributes( String... attributes )
506     {
507         new Exception().printStackTrace();
508         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
509     }
510 
511 
512     /**
513      * <p>
514      * Removes the specified binary values from an attribute.
515      * </p>
516      * <p>
517      * If at least one value is removed, this method returns <code>true</code>.
518      * </p>
519      * <p>
520      * If there is no more value after having removed the values, the attribute
521      * will be removed too.
522      * </p>
523      * <p>
524      * If the attribute does not exist, nothing is done and the method returns
525      * <code>false</code>
526      * </p>
527      *
528      * @param upId The attribute ID
529      * @param values the values to be removed
530      * @return <code>true</code> if at least a value is removed, <code>false</code>
531      * if not all the values have been removed or if the attribute does not exist.
532      */
533     @Override
534     public boolean remove( String upId, byte[]... values ) throws LdapException
535     {
536         new Exception().printStackTrace();
537         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
538     }
539 
540 
541     /**
542      * <p>
543      * Removes the specified String values from an attribute.
544      * </p>
545      * <p>
546      * If at least one value is removed, this method returns <code>true</code>.
547      * </p>
548      * <p>
549      * If there is no more value after having removed the values, the attribute
550      * will be removed too.
551      * </p>
552      * <p>
553      * If the attribute does not exist, nothing is done and the method returns
554      * <code>false</code>
555      * </p>
556      *
557      * @param upId The attribute ID
558      * @param values the attributes to be removed
559      * @return <code>true</code> if at least a value is removed, <code>false</code>
560      * if not all the values have been removed or if the attribute does not exist.
561      */
562     @Override
563     public boolean remove( String upId, String... values ) throws LdapException
564     {
565         new Exception().printStackTrace();
566         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
567     }
568 
569 
570     /**
571      * <p>
572      * Removes the specified values from an attribute.
573      * </p>
574      * <p>
575      * If at least one value is removed, this method returns <code>true</code>.
576      * </p>
577      * <p>
578      * If there is no more value after having removed the values, the attribute
579      * will be removed too.
580      * </p>
581      * <p>
582      * If the attribute does not exist, nothing is done and the method returns
583      * <code>false</code>
584      * </p>
585      *
586      * @param upId The attribute ID
587      * @param values the attributes to be removed
588      * @return <code>true</code> if at least a value is removed, <code>false</code>
589      * if not all the values have been removed or if the attribute does not exist.
590      */
591     @Override
592     public boolean remove( String upId, Value... values ) throws LdapException
593     {
594         new Exception().printStackTrace();
595         throw new NotImplementedException( I18n.err( I18n.ERR_13238_ENTRY_IMMUTABLE_CANT_REMOVE_VALUE, entry.getDn() ) );
596     }
597 
598 
599     /**
600      * Get this entry's Dn.
601      *
602      * @return The entry's Dn
603      */
604     @Override
605     public Dn getDn()
606     {
607         return entry.getDn();
608     }
609 
610 
611     /**
612      * {@inheritDoc}
613      */
614     @Override
615     public void setDn( Dn dn )
616     {
617         new Exception().printStackTrace();
618         throw new NotImplementedException( I18n.err( I18n.ERR_13239_ENTRY_IMMUTABLE_CANT_RENAME_ENTRY, entry.getDn() ) );
619     }
620 
621 
622     /**
623      * {@inheritDoc}
624      */
625     @Override
626     public void setDn( String dn ) throws LdapInvalidDnException
627     {
628         new Exception().printStackTrace();
629         throw new NotImplementedException( I18n.err( I18n.ERR_13239_ENTRY_IMMUTABLE_CANT_RENAME_ENTRY, entry.getDn() ) );
630     }
631 
632 
633     /**
634      * Remove all the attributes for this entry. The Dn is not reset
635      */
636     @Override
637     public void clear()
638     {
639         new Exception().printStackTrace();
640         throw new NotImplementedException( I18n.err( I18n.ERR_13240_ENTRY_IMMUTABLE_CANT_CLEAR_ENTRY, entry.getDn() ) );
641     }
642 
643 
644     /**
645      * Returns an enumeration containing the zero or more attributes in the
646      * collection. The behavior of the enumeration is not specified if the
647      * attribute collection is changed.
648      *
649      * @return an enumeration of all contained attributes
650      */
651     @Override
652     public Iterator<Attribute> iterator()
653     {
654         return entry.iterator();
655     }
656 
657 
658     /**
659      * Returns the number of attributes.
660      *
661      * @return the number of attributes
662      */
663     @Override
664     public int size()
665     {
666         return entry.size();
667     }
668 
669 
670     /**
671      * This is the place where we serialize entries, and all theirs
672      * elements.
673      * <br>
674      * The structure used to store the entry is the following :
675      * <ul>
676      *   <li>
677      *     <b>[Dn]</b> : If it's null, stores an empty Dn
678      *   </li>
679      *   <li>
680      *     <b>[attributes number]</b> : the number of attributes.
681      *   </li>
682      *   <li>
683      *     <b>[attribute]*</b> : each attribute, if we have some
684      *   </li>
685      * </ul>
686      *
687      * {@inheritDoc}
688      */
689     @Override
690     public void writeExternal( ObjectOutput out ) throws IOException
691     {
692         entry.writeExternal( out );
693     }
694 
695 
696     /**
697      * {@inheritDoc}
698      */
699     @Override
700     public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
701     {
702         new Exception().printStackTrace();
703         throw new NotImplementedException( I18n.err( I18n.ERR_13241_ENTRY_IMMUTABLE_CANT_READ_ENTRY, entry.getDn() ) );
704     }
705 
706 
707     /**
708      * Serialize an Entry.
709      *
710      * The structure is the following :
711      * <b>[a byte]</b> : if the Dn is empty 0 will be written else 1
712      * <b>[Rdn]</b> : The entry's Rdn.
713      * <b>[numberAttr]</b> : the bumber of attributes. Can be 0
714      * <b>[attribute's oid]*</b> : The attribute's OID to get back
715      * the attributeType on deserialization
716      * <b>[Attribute]*</b> The attribute
717      *
718      * @param out the buffer in which the data will be serialized
719      * @throws IOException if the serialization failed
720      */
721     public void serialize( ObjectOutput out ) throws IOException
722     {
723         new Exception().printStackTrace();
724         throw new NotImplementedException( I18n.err( I18n.ERR_13242_ENTRY_IMMUTABLE_CANT_SERIALIZE, entry.getDn() ) );
725     }
726 
727 
728     /**
729      * Deserialize an entry.
730      *
731      * @param in The buffer containing the serialized serverEntry
732      * @throws IOException if there was a problem when deserializing
733      * @throws ClassNotFoundException if we can't deserialize an expected object
734      */
735     public void deserialize( ObjectInput in ) throws IOException, ClassNotFoundException
736     {
737         new Exception().printStackTrace();
738         throw new NotImplementedException( I18n.err( I18n.ERR_13243_ENTRY_IMMUTABLE_CANT_DESERIALIZE, entry.getDn() ) );
739     }
740 
741 
742     /**
743      * Get the hash code of this ClientEntry. The Attributes will be sorted
744      * before the comparison can be done.
745      *
746      * @see java.lang.Object#hashCode()
747      * @return the instance's hash code
748      */
749     @Override
750     public int hashCode()
751     {
752         return entry.hashCode();
753     }
754 
755 
756     /**
757      * {@inheritDoc}
758      */
759     @Override
760     public boolean hasObjectClass( String... objectClasses )
761     {
762         return entry.hasObjectClass( objectClasses );
763     }
764 
765 
766     /**
767      * {@inheritDoc}
768      */
769     @Override
770     public boolean hasObjectClass( Attribute... objectClasses )
771     {
772         return entry.hasObjectClass( objectClasses );
773     }
774 
775 
776     /**
777      * {@inheritDoc}
778      */
779     @Override
780     public boolean isSchemaAware()
781     {
782         return entry.isSchemaAware();
783     }
784 
785 
786     /**
787      * @see Object#equals(Object)
788      */
789     @Override
790     public boolean equals( Object o )
791     {
792         return entry.equals( o );
793     }
794 
795 
796     /**
797      * @see Object#toString()
798      */
799     @Override
800     public String toString()
801     {
802         return entry.toString();
803     }
804 
805 
806     /**
807      * {@inheritDoc}
808      */
809     @Override
810     public String toString( String tabs )
811     {
812         return entry.toString( tabs );
813     }
814 }