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   */
20  package org.apache.directory.api.ldap.schema.converter;
21  
22  
23  import org.apache.directory.api.ldap.model.constants.SchemaConstants;
24  import org.apache.directory.api.ldap.model.entry.DefaultEntry;
25  import org.apache.directory.api.ldap.model.entry.Entry;
26  import org.apache.directory.api.ldap.model.exception.LdapException;
27  import org.apache.directory.api.ldap.model.ldif.LdifUtils;
28  import org.apache.directory.api.ldap.model.name.Rdn;
29  import org.apache.directory.api.ldap.model.schema.UsageEnum;
30  
31  
32  /**
33   * A bean used to hold the literal values of an AttributeType parsed out of an
34   * OpenLDAP schema configuration file.
35   * 
36   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
37   */
38  public class AttributeTypeHolder extends SchemaElementImpl
39  {
40      /** A flag for single valued attributes. Default to false */
41      private boolean singleValue = false;
42  
43      /** A flag for collective attribute. Default to false */
44      private boolean collective = false;
45  
46      /** A flaf for immutable attribue. Default to false */
47      private boolean noUserModification = false;
48  
49      /** The optional superior */
50      private String superior;
51  
52      /** The equality matching rule */
53      private String equality;
54  
55      /** The ordering matching rule */
56      private String ordering;
57  
58      /** The substring matching rule */
59      private String substr;
60  
61      /** The syntax this attribute respects */
62      private String syntax;
63  
64      /** The optional length for this attribute */
65      private long oidLen = -1;
66  
67      /** The attribute uase. Default to userApplication */
68      private UsageEnum usage = UsageEnum.USER_APPLICATIONS;
69  
70  
71      /**
72       * Create an instance of an attributeType
73       * 
74       * @param oid The attributeType's OID
75       */
76      public AttributeTypeHolder( String oid )
77      {
78          this.oid = oid;
79      }
80  
81  
82      /**
83       * Tells if the attribute is single-valued
84       * 
85       * @return true if the attribute is single-valued, false otherwise
86       */
87      public boolean isSingleValue()
88      {
89          return singleValue;
90      }
91  
92  
93      /**
94       * Set the attributeType singleValue flag
95       * 
96       * @param singleValue The value for this flag
97       */
98      public void setSingleValue( boolean singleValue )
99      {
100         this.singleValue = singleValue;
101     }
102 
103 
104     /**
105      * Tells if the attributeType is collectove or not
106      * 
107      * @return True if the attributeType is collective, false otherwise
108      */
109     public boolean isCollective()
110     {
111         return collective;
112     }
113 
114 
115     /**
116      * Set the attributeType collective flag
117      * 
118      * @param collective The value for this flag
119      */
120     public void setCollective( boolean collective )
121     {
122         this.collective = collective;
123     }
124 
125 
126     /**
127      * Tells if the attributeType is mutable or not
128      * 
129      * @return True if the attributeType is immutable, false otherwise
130      */
131     public boolean isNoUserModification()
132     {
133         return noUserModification;
134     }
135 
136 
137     /**
138      * Set the attributeType noUserModification flag
139      * 
140      * @param noUserModification The value for this flag
141      */
142     public void setNoUserModification( boolean noUserModification )
143     {
144         this.noUserModification = noUserModification;
145     }
146 
147 
148     /**
149      * Get the optional attributeType's superior
150      * 
151      * @return The attributeType's superior, if any
152      */
153     public String getSuperior()
154     {
155         return superior;
156     }
157 
158 
159     /**
160      * Set the attributeType's superior
161      * 
162      * @param superior The attributeType's superior
163      */
164     public void setSuperior( String superior )
165     {
166         this.superior = superior;
167     }
168 
169 
170     /**
171      * Get the equality Matching Rule
172      * 
173      * @return The equality matchingRule
174      */
175     public String getEquality()
176     {
177         return equality;
178     }
179 
180 
181     /**
182      * Set the equality Matching Rule
183      * 
184      * @param equality The equality Matching Rule
185      */
186     public void setEquality( String equality )
187     {
188         this.equality = equality;
189     }
190 
191 
192     /**
193      * Get the ordering Matching Rule
194      * 
195      * @return The ordering matchingRule
196      */
197     public String getOrdering()
198     {
199         return ordering;
200     }
201 
202 
203     /**
204      * Set the ordering Matching Rule
205      * 
206      * @param ordering The ordering Matching Rule
207      */
208     public void setOrdering( String ordering )
209     {
210         this.ordering = ordering;
211     }
212 
213 
214     /**
215      * Get the substring Matching Rule
216      * 
217      * @return The substring matchingRule
218      */
219     public String getSubstr()
220     {
221         return substr;
222     }
223 
224 
225     /**
226      * Set the substring Matching Rule
227      * 
228      * @param substr The substring Matching Rule
229      */
230     public void setSubstr( String substr )
231     {
232         this.substr = substr;
233     }
234 
235 
236     /**
237      * Get the attributeType's syntax
238      * 
239      * @return The attributeType's syntax
240      */
241     public String getSyntax()
242     {
243         return syntax;
244     }
245 
246 
247     /**
248      * Set the attributeType's syntax
249      * 
250      * @param syntax The attributeType's syntax
251      */
252     public void setSyntax( String syntax )
253     {
254         this.syntax = syntax;
255     }
256 
257 
258     /**
259      * Get the attributeType's usage
260      * 
261      * @return The attributeType's usage
262      */
263     public UsageEnum getUsage()
264     {
265         return usage;
266     }
267 
268 
269     /**
270      * Set the attributeType's usage
271      * 
272      * @param usage The attributeType's usage
273      */
274     public void setUsage( UsageEnum usage )
275     {
276         this.usage = usage;
277     }
278 
279 
280     /**
281      * Get the attributeType's syntax length
282      * 
283      * @return The attributeType's syntax length
284      */
285     public long getOidLen()
286     {
287         return oidLen;
288     }
289 
290 
291     /**
292      * Set the attributeType's syntax length
293      * 
294      * @param oidLen The attributeType's syntax length
295      */
296     public void setOidLen( long oidLen )
297     {
298         this.oidLen = oidLen;
299     }
300 
301 
302     /**
303      * Convert this attributeType to a Ldif string
304      * 
305      * @param schemaName The name of the schema file containing this attributeType
306      * @return A ldif formatted string
307      * @throws org.apache.directory.api.ldap.model.exception.LdapException If something went wrong
308      */
309     @Override
310     public String toLdif( String schemaName ) throws LdapException
311     {
312         StringBuilder sb = new StringBuilder();
313 
314         sb.append( schemaToLdif( schemaName, "metaAttributeType" ) );
315 
316         // The superior
317         if ( superior != null )
318         {
319             sb.append( "m-supAttributeType: " ).append( superior ).append( '\n' );
320         }
321 
322         // The equality matching rule
323         if ( equality != null )
324         {
325             sb.append( "m-equality: " ).append( equality ).append( '\n' );
326         }
327 
328         // The ordering matching rule
329         if ( ordering != null )
330         {
331             sb.append( "m-ordering: " ).append( ordering ).append( '\n' );
332         }
333 
334         // The substrings matching rule
335         if ( substr != null )
336         {
337             sb.append( "m-substr: " ).append( substr ).append( '\n' );
338         }
339 
340         // The value syntax
341         if ( syntax != null )
342         {
343             sb.append( "m-syntax: " ).append( syntax ).append( '\n' );
344 
345             if ( oidLen != -1 )
346             {
347                 sb.append( "m-length: " ).append( oidLen ).append( '\n' );
348             }
349         }
350 
351         // The single value flag
352         if ( singleValue )
353         {
354             sb.append( "m-singleValue: TRUE\n" );
355         }
356 
357         // The collective flag
358         if ( collective )
359         {
360             sb.append( "m-collective: TRUE\n" );
361         }
362 
363         // The not user modifiable flag
364         if ( noUserModification )
365         {
366             sb.append( "m-noUserModification: TRUE\n" );
367         }
368 
369         // The usage value
370         if ( usage != UsageEnum.USER_APPLICATIONS )
371         {
372             sb.append( "m-usage: " ).append( usage.toString() ).append( '\n' );
373         }
374 
375         // The extensions
376         if ( extensions.size() != 0 )
377         {
378             extensionsToLdif( "m-extensionAttributeType" );
379         }
380 
381         return sb.toString();
382 
383     }
384 
385 
386     /**
387      * @return a String representing this AttributeType.
388      */
389     @Override
390     public String toString()
391     {
392         return getOid();
393     }
394 
395 
396     /**
397      * Transform a schema name to a Dn pointing to the correct position in the DIT
398      * 
399      * @param schemaName The schema name
400      * @return the Dn associated with this schema in the DIT
401      */
402     @Override
403     public String dnToLdif( String schemaName ) throws LdapException
404     {
405         StringBuilder sb = new StringBuilder();
406 
407         String dn = "m-oid=" + oid + ", " + SchemaConstants.ATTRIBUTE_TYPES_PATH + ", cn="
408             + Rdn.escapeValue( schemaName ) + ", ou=schema";
409 
410         // First dump the Dn only
411         Entry entry = new DefaultEntry( dn );
412         sb.append( LdifUtils.convertToLdif( entry ) );
413 
414         return sb.toString();
415     }
416 }