001    /*
002     * Copyright 2009-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2009-2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.sdk.migrate.ldapjdk;
022    
023    
024    
025    import java.io.Serializable;
026    import java.util.Arrays;
027    import java.util.Enumeration;
028    import java.util.Set;
029    
030    import com.unboundid.ldap.sdk.Attribute;
031    import com.unboundid.util.Mutable;
032    import com.unboundid.util.NotExtensible;
033    import com.unboundid.util.ThreadSafety;
034    import com.unboundid.util.ThreadSafetyLevel;
035    
036    import static com.unboundid.util.StaticUtils.*;
037    
038    
039    
040    /**
041     * This class provides a data structure that holds information about an LDAP
042     * attribute, including an attribute description (a base name or OID and
043     * optional set of options) and zero or more values.
044     * <BR><BR>
045     * This class is primarily intended to be used in the process of updating
046     * applications which use the Netscape Directory SDK for Java to switch to or
047     * coexist with the UnboundID LDAP SDK for Java.  For applications not written
048     * using the Netscape Directory SDK for Java, the {@link Attribute} class should
049     * be used instead.
050     */
051    @NotExtensible()
052    @Mutable()
053    @ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
054    public class LDAPAttribute
055           implements Serializable
056    {
057      /**
058       * The serial version UID for this serializable attribute.
059       */
060      private static final long serialVersionUID = 839217229050750570L;
061    
062    
063    
064      // The Attribute object wrapped by this LDAPAttribute.
065      private Attribute attribute;
066    
067    
068    
069      /**
070       * Creates a new LDAP attribute from the provided {@link Attribute} object.
071       *
072       * @param  attr  The LDAP attribute to use to create this attribute.
073       */
074      public LDAPAttribute(final Attribute attr)
075      {
076        attribute = attr;
077      }
078    
079    
080    
081      /**
082       * Creates a new LDAP attribute that is a duplicate of the provided attribute.
083       *
084       * @param  attr  The LDAP attribute to use to create this attribute.
085       */
086      public LDAPAttribute(final LDAPAttribute attr)
087      {
088        attribute = attr.attribute;
089      }
090    
091    
092    
093      /**
094       * Creates a new LDAP attribute with the specified name and no values.
095       *
096       * @param  attrName  The name for this attribute.
097       */
098      public LDAPAttribute(final String attrName)
099      {
100        attribute = new Attribute(attrName);
101      }
102    
103    
104    
105      /**
106       * Creates a new LDAP attribute with the specified name and value.
107       *
108       * @param  attrName   The name for this attribute.
109       * @param  attrBytes  The value for this attribute.
110       */
111      public LDAPAttribute(final String attrName, final byte[] attrBytes)
112      {
113        attribute = new Attribute(attrName, attrBytes);
114      }
115    
116    
117    
118      /**
119       * Creates a new LDAP attribute with the specified name and value.
120       *
121       * @param  attrName    The name for this attribute.
122       * @param  attrString  The value for this attribute.
123       */
124      public LDAPAttribute(final String attrName, final String attrString)
125      {
126        attribute = new Attribute(attrName, attrString);
127      }
128    
129    
130    
131      /**
132       * Creates a new LDAP attribute with the specified name and values.
133       *
134       * @param  attrName     The name for this attribute.
135       * @param  attrStrings  The values for this attribute.
136       */
137      public LDAPAttribute(final String attrName, final String[] attrStrings)
138      {
139        attribute = new Attribute(attrName, attrStrings);
140      }
141    
142    
143    
144      /**
145       * Retrieves the name for this attribute.
146       *
147       * @return  The name for this attribute.
148       */
149      public String getName()
150      {
151        return attribute.getName();
152      }
153    
154    
155    
156      /**
157       * Retrieves the base name for this attribute, without any options.
158       *
159       * @return  The base name for this attribute.
160       */
161      public String getBaseName()
162      {
163        return attribute.getBaseName();
164      }
165    
166    
167    
168      /**
169       * Retrieves the base name for the attribute with the provided name.
170       *
171       * @param  attrName  The attribute name for which to retrieve the base name.
172       *
173       * @return  The base name for the attribute with the provided name.
174       */
175      public static String getBaseName(final String attrName)
176      {
177        return Attribute.getBaseName(attrName);
178      }
179    
180    
181    
182      /**
183       * Retrieves the subtypes (i.e., attribute options) contained in the name for
184       * this attribute.
185       *
186       * @return  The subtypes contained in the name for this attribute, or
187       *          {@code null} if there are none.
188       */
189      public String[] getSubtypes()
190      {
191        final Set<String> optionSet = attribute.getOptions();
192        if (optionSet.isEmpty())
193        {
194          return null;
195        }
196    
197        final String[] options = new String[optionSet.size()];
198        return optionSet.toArray(options);
199      }
200    
201    
202    
203      /**
204       * Retrieves the subtypes (i.e., attribute options) contained in the provided
205       * attribute name.
206       *
207       * @param  attrName  The attribute name from which to extract the subtypes.
208       *
209       * @return  The subtypes contained in the provided attribute name, or
210       *          {@code null} if there are none.
211       */
212      public static String[] getSubtypes(final String attrName)
213      {
214        return new LDAPAttribute(attrName).getSubtypes();
215      }
216    
217    
218    
219      /**
220       * Retrieves the language subtype (i.e., the attribute option which begins
221       * with "lang-") for this attribute, if present.
222       *
223       * @return  The language subtype for this attribute, or {@code null} if there
224       *          is none.
225       */
226      public String getLangSubtype()
227      {
228        for (final String s : attribute.getOptions())
229        {
230          final String lowerName = toLowerCase(s);
231          if (lowerName.startsWith("lang-"))
232          {
233            return s;
234          }
235        }
236    
237        return null;
238      }
239    
240    
241    
242      /**
243       * Indicates whether this attribute contains the specified subtype.
244       *
245       * @param  subtype  The subtype for which to make the determination.
246       *
247       * @return  {@code true} if this option has the specified subtype, or
248       *          {@code false} if not.
249       */
250      public boolean hasSubtype(final String subtype)
251      {
252        return attribute.hasOption(subtype);
253      }
254    
255    
256    
257      /**
258       * Indicates whether this attribute contains all of the specified subtypes.
259       *
260       * @param  subtypes  The subtypes for which to make the determination.
261       *
262       * @return  {@code true} if this option has all of the specified subtypes, or
263       *          {@code false} if not.
264       */
265      public boolean hasSubtypes(final String[] subtypes)
266      {
267        for (final String s : subtypes)
268        {
269          if (! attribute.hasOption(s))
270          {
271            return false;
272          }
273        }
274    
275        return true;
276      }
277    
278    
279    
280      /**
281       * Retrieves an enumeration over the string values for this attribute.
282       *
283       * @return  An enumeration over the string values for this attribute.
284       */
285      public Enumeration<String> getStringValues()
286      {
287        return new IterableEnumeration<String>(
288             Arrays.asList(attribute.getValues()));
289      }
290    
291    
292    
293      /**
294       * Retrieves an array of the values for this attribute.
295       *
296       * @return  An array of the values for this attribute.
297       */
298      public String[] getStringValueArray()
299      {
300        return attribute.getValues();
301      }
302    
303    
304    
305      /**
306       * Retrieves an enumeration over the binary values for this attribute.
307       *
308       * @return  An enumeration over the binary values for this attribute.
309       */
310      public Enumeration<byte[]> getByteValues()
311      {
312        return new IterableEnumeration<byte[]>(
313             Arrays.asList(attribute.getValueByteArrays()));
314      }
315    
316    
317    
318      /**
319       * Retrieves an array of the values for this attribute.
320       *
321       * @return  An array of the values for this attribute.
322       */
323      public byte[][] getByteValueArray()
324      {
325        return attribute.getValueByteArrays();
326      }
327    
328    
329    
330    
331      /**
332       * Adds the provided value to the set of values for this attribute.
333       *
334       * @param  attrString  The value to add to this attribute.
335       */
336      public void addValue(final String attrString)
337      {
338        attribute = Attribute.mergeAttributes(attribute,
339             new Attribute(attribute.getName(), attrString));
340      }
341    
342    
343    
344      /**
345       * Adds the provided value to the set of values for this attribute.
346       *
347       * @param  attrBytes  The value to add to this attribute.
348       */
349      public void addValue(final byte[] attrBytes)
350      {
351        attribute = Attribute.mergeAttributes(attribute,
352             new Attribute(attribute.getName(), attrBytes));
353      }
354    
355    
356    
357      /**
358       * Removes the provided value from this attribute.
359       *
360       * @param  attrValue  The value to remove.
361       */
362      public void removeValue(final String attrValue)
363      {
364        attribute = Attribute.removeValues(attribute,
365             new Attribute(attribute.getName(), attrValue));
366      }
367    
368    
369    
370      /**
371       * Removes the provided value from this attribute.
372       *
373       * @param  attrValue  The value to remove.
374       */
375      public void removeValue(final byte[] attrValue)
376      {
377        attribute = Attribute.removeValues(attribute,
378             new Attribute(attribute.getName(), attrValue));
379      }
380    
381    
382    
383      /**
384       * Retrieves the number of values for this attribute.
385       *
386       * @return  The number of values for this attribute.
387       */
388      public int size()
389      {
390        return attribute.size();
391      }
392    
393    
394    
395      /**
396       * Converts this LDAP attribute to an {@link Attribute} object.
397       *
398       * @return  The {@code Attribute} object which corresponds to this LDAP
399       *          attribute.
400       */
401      public final Attribute toAttribute()
402      {
403        return attribute;
404      }
405    
406    
407    
408      /**
409       * Retrieves a string representation of this LDAP attribute.
410       *
411       * @return  A string representation of this LDAP attribute.
412       */
413      @Override()
414      public String toString()
415      {
416        return attribute.toString();
417      }
418    }