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  package org.apache.directory.api.ldap.model.schema;
21  
22  
23  import java.util.ArrayList;
24  import java.util.List;
25  
26  
27  /**
28   * An objectClass definition.
29   * <p>
30   * According to ldapbis [MODELS]:
31   * </p>
32   *
33   * <pre>
34   *  Object Class definitions are written according to the ABNF:
35   *
36   *    ObjectClassDescription = LPAREN WSP
37   *        numericoid                ; object identifier
38   *        [ SP &quot;NAME&quot; SP qdescrs ]  ; short names (descriptors)
39   *        [ SP &quot;DESC&quot; SP qdstring ] ; description
40   *        [ SP &quot;OBSOLETE&quot; ]         ; not active
41   *        [ SP &quot;SUP&quot; SP oids ]      ; superior object classes
42   *        [ SP kind ]               ; kind of class
43   *        [ SP &quot;MUST&quot; SP oids ]     ; attribute types
44   *        [ SP &quot;MAY&quot; SP oids ]      ; attribute types
45   *        extensions WSP RPAREN
46   *
47   *     kind = &quot;ABSTRACT&quot; / &quot;STRUCTURAL&quot; / &quot;AUXILIARY&quot;
48   *
49   *   where:
50   *     [numericoid] is object identifier assigned to this object class;
51   *     NAME [qdescrs] are short names (descriptors) identifying this object
52   *         class;
53   *     DESC [qdstring] is a short descriptive string;
54   *     OBSOLETE indicates this object class is not active;
55   *     SUP [oids] specifies the direct superclasses of this object class;
56   *     the kind of object class is indicated by one of ABSTRACT,
57   *         STRUCTURAL, or AUXILIARY, default is STRUCTURAL;
58   *     MUST and MAY specify the sets of required and allowed attribute
59   *         types, respectively; and
60   *    [extensions] describe extensions.
61   * </pre>
62   *
63   * @see <a href="http://www.faqs.org/rfcs/rfc2252.html">RFC2252 Section 4.4</a>
64   * @see <a
65   *      href="http://www.ietf.org/internet-drafts/draft-ietf-ldapbis-models-11.txt">ldapbis
66   *      [MODELS]</a>
67   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
68   */
69  public class ObjectClass extends AbstractSchemaObject
70  {
71      /** The mandatory serialVersionUID */
72      public static final long serialVersionUID = 1L;
73  
74      /** The ObjectClass type : ABSTRACT, AUXILIARY or STRUCTURAL */
75      protected ObjectClassTypeEnum objectClassType = ObjectClassTypeEnum.STRUCTURAL;
76  
77      /** The ObjectClass superior OIDs */
78      protected List<String> superiorOids;
79  
80      /** The ObjectClass superiors */
81      protected List<ObjectClass> superiors;
82  
83      /** The list of allowed AttributeType OIDs */
84      protected List<String> mayAttributeTypeOids;
85  
86      /** The list of allowed AttributeTypes */
87      protected List<AttributeType> mayAttributeTypes;
88  
89      /** The list of required AttributeType OIDs */
90      protected List<String> mustAttributeTypeOids;
91  
92      /** The list of required AttributeTypes */
93      protected List<AttributeType> mustAttributeTypes;
94  
95  
96      /**
97       * Creates a new instance of MatchingRuleUseDescription
98       * @param oid the OID for this objectClass
99       */
100     public ObjectClass( String oid )
101     {
102         super( SchemaObjectType.OBJECT_CLASS, oid );
103 
104         mayAttributeTypeOids = new ArrayList<>();
105         mustAttributeTypeOids = new ArrayList<>();
106         superiorOids = new ArrayList<>();
107 
108         mayAttributeTypes = new ArrayList<>();
109         mustAttributeTypes = new ArrayList<>();
110         superiors = new ArrayList<>();
111         objectClassType = ObjectClassTypeEnum.STRUCTURAL;
112     }
113 
114 
115     /**
116      * @return the mayAttributeTypeOids
117      */
118     public List<String> getMayAttributeTypeOids()
119     {
120         return mayAttributeTypeOids;
121     }
122 
123 
124     /**
125      * @return the mayAttributeTypes
126      */
127     public List<AttributeType> getMayAttributeTypes()
128     {
129         return mayAttributeTypes;
130     }
131 
132 
133     /**
134      * @return the mustAttributeTypeOids
135      */
136     public List<String> getMustAttributeTypeOids()
137     {
138         return mustAttributeTypeOids;
139     }
140 
141 
142     /**
143      * @return the mustAttributeTypes
144      */
145     public List<AttributeType> getMustAttributeTypes()
146     {
147         return mustAttributeTypes;
148     }
149 
150 
151     /**
152      * Gets the superclasses of this ObjectClass.
153      *
154      * @return the superclasses
155      */
156     public List<ObjectClass> getSuperiors()
157     {
158         return superiors;
159     }
160 
161 
162     /**
163      * Gets the superclasses OIDsof this ObjectClass.
164      *
165      * @return the superclasses OIDs
166      */
167     public List<String> getSuperiorOids()
168     {
169         return superiorOids;
170     }
171 
172 
173     /**
174      * Gets the type of this ObjectClass as a type safe enum.
175      *
176      * @return the ObjectClass type as an enum
177      */
178     public ObjectClassTypeEnum getType()
179     {
180         return objectClassType;
181     }
182 
183 
184     /**
185      * Tells if the current ObjectClass is STRUCTURAL
186      *
187      * @return <code>true</code> if the ObjectClass is STRUCTURAL
188      */
189     public boolean isStructural()
190     {
191         return objectClassType == ObjectClassTypeEnum.STRUCTURAL;
192     }
193 
194 
195     /**
196      * Tells if the current ObjectClass is ABSTRACT
197      *
198      * @return <code>true</code> if the ObjectClass is ABSTRACT
199      */
200     public boolean isAbstract()
201     {
202         return objectClassType == ObjectClassTypeEnum.ABSTRACT;
203     }
204 
205 
206     /**
207      * Tells if the current ObjectClass is AUXILIARY
208      *
209      * @return <code>true</code> if the ObjectClass is AUXILIARY
210      */
211     public boolean isAuxiliary()
212     {
213         return objectClassType == ObjectClassTypeEnum.AUXILIARY;
214     }
215 
216 
217     /**
218      * {@inheritDoc}
219      */
220     @Override
221     public String toString()
222     {
223         return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this );
224     }
225 
226 
227     /**
228      * Copy an ObjectClass
229      */
230     @Override
231     public ObjectClass copy()
232     {
233         ObjectClass copy = new ObjectClass( oid );
234 
235         // Copy the SchemaObject common data
236         copy.copy( this );
237 
238         // Copy the ObjectClass type
239         copy.objectClassType = objectClassType;
240 
241         // Copy the Superiors ObjectClasses OIDs
242         copy.superiorOids = new ArrayList<>();
243 
244         for ( String oid : superiorOids )
245         {
246             copy.superiorOids.add( oid );
247         }
248 
249         // Copy the Superiors ObjectClasses ( will be empty )
250         copy.superiors = new ArrayList<>();
251 
252         // Copy the MAY AttributeTypes OIDs
253         copy.mayAttributeTypeOids = new ArrayList<>();
254 
255         for ( String oid : mayAttributeTypeOids )
256         {
257             copy.mayAttributeTypeOids.add( oid );
258         }
259 
260         // Copy the MAY AttributeTypes ( will be empty )
261         copy.mayAttributeTypes = new ArrayList<>();
262 
263         // Copy the MUST AttributeTypes OIDs
264         copy.mustAttributeTypeOids = new ArrayList<>();
265 
266         for ( String oid : mustAttributeTypeOids )
267         {
268             copy.mustAttributeTypeOids.add( oid );
269         }
270 
271         // Copy the MUST AttributeTypes ( will be empty )
272         copy.mustAttributeTypes = new ArrayList<>();
273 
274         return copy;
275     }
276 
277     /**
278      * @see Object#equals(Object)
279      */
280     @Override
281     public boolean equals( Object o )
282     {
283         if ( !super.equals( o ) )
284         {
285             return false;
286         }
287 
288         if ( !( o instanceof ObjectClass ) )
289         {
290             return false;
291         }
292 
293         ObjectClass that = ( ObjectClass ) o;
294 
295         // The ObjectClassType
296         if ( objectClassType != that.objectClassType )
297         {
298             return false;
299         }
300 
301         // The Superiors OIDs
302         if ( superiorOids.size() != that.superiorOids.size() )
303         {
304             return false;
305         }
306 
307         // One way
308         for ( String oid : superiorOids )
309         {
310             if ( !that.superiorOids.contains( oid ) )
311             {
312                 return false;
313             }
314         }
315 
316         // The other way
317         for ( String oid : that.superiorOids )
318         {
319             if ( !superiorOids.contains( oid ) )
320             {
321                 return false;
322             }
323         }
324 
325         // The Superiors
326         if ( superiors.size() != that.superiors.size() )
327         {
328             return false;
329         }
330 
331         // One way
332         for ( ObjectClass oid : superiors )
333         {
334             if ( !that.superiors.contains( oid ) )
335             {
336                 return false;
337             }
338         }
339 
340         // The other way
341         for ( ObjectClass oid : that.superiors )
342         {
343             if ( !superiors.contains( oid ) )
344             {
345                 return false;
346             }
347         }
348 
349         // The MAY OIDs
350         if ( mayAttributeTypeOids.size() != that.mayAttributeTypeOids.size() )
351         {
352             return false;
353         }
354 
355         // One way
356         for ( String oid : mayAttributeTypeOids )
357         {
358             if ( !that.mayAttributeTypeOids.contains( oid ) )
359             {
360                 return false;
361             }
362         }
363 
364         // The other way
365         for ( String oid : that.mayAttributeTypeOids )
366         {
367             if ( !mayAttributeTypeOids.contains( oid ) )
368             {
369                 return false;
370             }
371         }
372 
373         // The MAY
374         if ( mayAttributeTypes.size() != that.mayAttributeTypes.size() )
375         {
376             return false;
377         }
378 
379         // One way
380         for ( AttributeType oid : mayAttributeTypes )
381         {
382             if ( !that.mayAttributeTypes.contains( oid ) )
383             {
384                 return false;
385             }
386         }
387 
388         // The other way
389         for ( AttributeType oid : that.mayAttributeTypes )
390         {
391             if ( !mayAttributeTypes.contains( oid ) )
392             {
393                 return false;
394             }
395         }
396 
397         // The MUST OIDs
398         if ( mustAttributeTypeOids.size() != that.mustAttributeTypeOids.size() )
399         {
400             return false;
401         }
402 
403         // One way
404         for ( String oid : mustAttributeTypeOids )
405         {
406             if ( !that.mustAttributeTypeOids.contains( oid ) )
407             {
408                 return false;
409             }
410         }
411 
412         // The other way
413         for ( String oid : that.mustAttributeTypeOids )
414         {
415             if ( !mustAttributeTypeOids.contains( oid ) )
416             {
417                 return false;
418             }
419         }
420 
421         // The MUST
422         if ( mustAttributeTypes.size() != that.mustAttributeTypes.size() )
423         {
424             return false;
425         }
426 
427         // One way
428         for ( AttributeType oid : mustAttributeTypes )
429         {
430             if ( !that.mustAttributeTypes.contains( oid ) )
431             {
432                 return false;
433             }
434         }
435 
436         // The other way
437         for ( AttributeType oid : that.mustAttributeTypes )
438         {
439             if ( !mustAttributeTypes.contains( oid ) )
440             {
441                 return false;
442             }
443         }
444 
445         return true;
446     }
447 }