AttributeUtils (Apache Directory Shared 0.9.19 API)

java.lang.Object
- org.apache.directory.shared.ldap.util.AttributeUtils

```
public class AttributeUtils
extends Object
```
A set of utility fuctions for working with Attributes.

Version:

$Rev: 923893 $

Author:

Apache Directory Project

Constructor Summary

Constructors
Constructor and Description

AttributeUtils()

Constructors
Constructor and Description
`AttributeUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`applyModification(Entry entry, Modification modification)` A method to apply a modification to an existing entry.
`static Object`	`cloneValue(Object value)` Clone the value.
`static boolean`	`containsValue(Attribute attr, Value<?> compared, AttributeType type)` Check if an attribute contains a specific value, using the associated matchingRule for that
`static boolean`	`containsValueCaseIgnore(Attribute attr, Object value)` Check if an attribute contains a value.
`static boolean`	`equals(Object value1, Object value2)` Compare two values and return true if they are equal.
`static Attribute`	`getAttribute(Attributes attrs, AttributeType type)` Utility method to extract an attribute from Attributes object using all combinationos of the name including aliases.
`static Attribute`	`getDifference(Attribute attr0, Attribute attr1)` Creates a new attribute which contains the values representing the difference of two attributes.
`static Attribute`	`getUnion(Attribute attr0, Attribute attr1)` Creates a new attribute which contains the values representing the union of two attributes.
`static String`	`parseAttribute(String str, Position pos, boolean withOption)` Parse an attribute.
`static void`	`parseOID(String str, Position pos)` Parse an OID.
`static Attribute`	`removeAttribute(AttributeType type, Attributes entry)` Correctly removes an attribute from an entry using it's attributeType information.
`static Attribute`	`toAttribute(EntryAttribute entryAttribute)` Converts an `EntryAttribute` to an `Attribute`.
`static Attributes`	`toAttributes(Entry entry)` Converts an `Entry` to an `Attributes`.
`static Attribute`	`toBasicAttribute(Attribute attribute)` Switch from a BasicAttribute to a AttributeImpl.
`static Attributes`	`toCaseInsensitive(Attributes attributes)` Check if the attributes is a BasicAttributes, and if so, switch the case sensitivity to false to avoid tricky problems in the server.
`static EntryAttribute`	`toClientAttribute(Attribute attribute)` Convert a BasicAttribute or a AttributeImpl to a EntryAttribute
`static Entry`	`toClientEntry(Attributes attributes, DN dn)` Check if an attribute contains a specific value and remove it using the associated matchingRule for the attribute type supplied.
`static String`	`toString(Attribute attribute)` Return a string representing the attribute
`static String`	`toString(Attributes attributes)` Return a string representing the attributes
`static String`	`toString(String tabs, Attribute attribute)` Return a string representing the attributes with tabs in front of the string
`static String`	`toString(String tabs, Attributes attributes)` Return a string representing the attributes with tabs in front of the string

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AttributeUtils
```
public AttributeUtils()
```
- Method Detail
  - removeAttribute
```
public static Attribute removeAttribute(AttributeType type,
                                        Attributes entry)
```
    Correctly removes an attribute from an entry using it's attributeType information.
    
    Parameters:
    
    type - the attributeType of the attribute to remove
    
    entry - the entry to remove the attribute from
    
    Returns:
    
    the Attribute that is removed
  - equals
```
public static final boolean equals(Object value1,
                                   Object value2)
```
    Compare two values and return true if they are equal.
    
    Parameters:
    
    value1 - The first value
    
    value2 - The second value
    
    Returns:
    
    true if both value are null or if they are equal.
  - cloneValue
```
public static Object cloneValue(Object value)
```
    Clone the value. An attribute value is supposed to be either a String or a byte array. If it's a String, then we just return it ( as String is immutable, we don't need to copy it). If it's a bu=yte array, we create a new byte array and copy the bytes into it.
    
    Parameters:
    
    value - The value to clone
    
    Returns:
    
    The cloned value
  - toBasicAttribute
```
public static final Attribute toBasicAttribute(Attribute attribute)
```
    Switch from a BasicAttribute to a AttributeImpl. This is necessary to allow cloning to be correctly handled.
    
    Parameters:
    
    attribute - The attribute to transform
    
    Returns:
    
    A instance of AttributeImpl
  - getAttribute
```
public static final Attribute getAttribute(Attributes attrs,
                                           AttributeType type)
```
    Utility method to extract an attribute from Attributes object using all combinationos of the name including aliases.
    
    Parameters:
    
    attrs - the Attributes to get the Attribute object from
    
    type - the attribute type specification
    
    Returns:
    
    an Attribute with matching the attributeType spec or null
  - containsValue
```
public static boolean containsValue(Attribute attr,
                                    Value<?> compared,
                                    AttributeType type)
                             throws LdapException
```
    Check if an attribute contains a specific value, using the associated matchingRule for that
    
    Parameters:
    
    attr - The attribute we are searching in
    
    compared - The object we are looking for
    
    type - The attribute type
    
    Returns:
    
    true if the value exists in the attribute
    
    Throws:
    
    LdapException - If something went wrong while accessing the data
  - containsValueCaseIgnore
```
public static boolean containsValueCaseIgnore(Attribute attr,
                                              Object value)
```
    Check if an attribute contains a value. The test is case insensitive, and the value is supposed to be a String. If the value is a byte[], then the case sensitivity is useless.
    
    Parameters:
    
    attr - The attribute to check
    
    value - The value to look for
    
    Returns:
    
    true if the value is present in the attribute
  - getDifference
```
public static Attribute getDifference(Attribute attr0,
                                      Attribute attr1)
                               throws NamingException
```
    Creates a new attribute which contains the values representing the difference of two attributes. If both attributes are null then we cannot determine the attribute ID and an IllegalArgumentException is raised. Note that the order of arguments makes a difference.
    
    Parameters:
    
    attr0 - the first attribute
    
    attr1 - the second attribute
    
    Returns:
    
    a new attribute with the difference of values from both attribute arguments
    
    Throws:
    
    NamingException - if there are problems accessing attribute values
  - getUnion
```
public static Attribute getUnion(Attribute attr0,
                                 Attribute attr1)
                          throws NamingException
```
    Creates a new attribute which contains the values representing the union of two attributes. If one attribute is null then the resultant attribute returned is a copy of the non-null attribute. If both are null then we cannot determine the attribute ID and an IllegalArgumentException is raised.
    
    Parameters:
    
    attr0 - the first attribute
    
    attr1 - the second attribute
    
    Returns:
    
    a new attribute with the union of values from both attribute arguments
    
    Throws:
    
    NamingException - if there are problems accessing attribute values
  - toCaseInsensitive
```
public static Attributes toCaseInsensitive(Attributes attributes)
```
    Check if the attributes is a BasicAttributes, and if so, switch the case sensitivity to false to avoid tricky problems in the server. (Ldap attributeTypes are *always* case insensitive)
    
    Parameters:
    
    attributes - The Attributes to check
  - toString
```
public static String toString(String tabs,
                              Attribute attribute)
```
    Return a string representing the attributes with tabs in front of the string
    
    Parameters:
    
    tabs - Spaces to be added before the string
    
    attribute - The attribute to print
    
    Returns:
    
    A string
  - toString
```
public static String toString(Attribute attribute)
```
    Return a string representing the attribute
    
    Parameters:
    
    attribute - The attribute to print
    
    Returns:
    
    A string
  - toString
```
public static String toString(String tabs,
                              Attributes attributes)
```
    Return a string representing the attributes with tabs in front of the string
    
    Parameters:
    
    tabs - Spaces to be added before the string
    
    attributes - The attributes to print
    
    Returns:
    
    A string
  - parseOID
```
public static void parseOID(String str,
                            Position pos)
                     throws ParseException
```
    Parse an OID. numericoid = number 1*( '.' number ) number = '0'-'9' / ( '1'-'9' 1*'0'-'9' )
    
    Parameters:
    
    str - The OID to parse
    
    pos - The current position in the string
    
    Throws:
    
    ParseException - If we don't have a valid OID
  - parseAttribute
```
public static String parseAttribute(String str,
                                    Position pos,
                                    boolean withOption)
                             throws ParseException
```
    Parse an attribute. The grammar is : attributedescription = attributetype options attributetype = oid oid = descr / numericoid descr = keystring numericoid = number 1*( '.' number ) options = *( ';' option ) option = 1*keychar keystring = leadkeychar *keychar leadkeychar = 'a'-z' | 'A'-'Z' keychar = 'a'-z' | 'A'-'Z' / '0'-'9' / '-' number = '0'-'9' / ( '1'-'9' 1*'0'-'9' )
    
    Parameters:
    
    str - The parsed attribute,
    
    pos - The position of the attribute in the current string
    
    Returns:
    
    The parsed attribute if valid
    
    Throws:
    
    ParseException
  - toString
```
public static String toString(Attributes attributes)
```
    Return a string representing the attributes
    
    Parameters:
    
    attributes - The attributes to print
    
    Returns:
    
    A string
  - applyModification
```
public static void applyModification(Entry entry,
                                     Modification modification)
                              throws LdapException
```
    A method to apply a modification to an existing entry.
    
    Parameters:
    
    entry - The entry on which we want to apply a modification
    
    modification - the Modification to be applied
    
    Throws:
    
    LdapException - if some operation fails.
  - toClientEntry
```
public static Entry toClientEntry(Attributes attributes,
                                  DN dn)
                           throws LdapException
```
    Check if an attribute contains a specific value and remove it using the associated matchingRule for the attribute type supplied.
    
    Parameters:
    
    attr - the attribute we are searching in
    
    compared - the object we are looking for
    
    type - the attribute type
    
    attributes - the BasicAttributes or AttributesImpl instance to convert
    
    registries - The registries, needed ro build a ServerEntry
    
    dn - The DN which is needed by the ServerEntry
    
    Returns:
    
    the value removed from the attribute, otherwise null
    
    Throws:
    
    NamingException - if something went wrong while removing the value public static Object removeValue( Attribute attr, Object compared, AttributeType type ) throws NamingException { // quick bypass test if ( attr.contains( compared ) ) { return attr.remove( compared ); } MatchingRule matchingRule = type.getEquality(); Normalizer normalizer; if ( matchingRule != null ) { normalizer = type.getEquality().getNormalizer(); } else { normalizer = new NoOpNormalizer(); } if ( type.getSyntax().isHumanReadable() ) { String comparedStr = ( String ) normalizer.normalize( compared ); for ( NamingEnumeration values = attr.getAll(); values.hasMoreElements(); ) { String value = ( String ) values.nextElement(); if ( comparedStr.equals( normalizer.normalize( value ) ) ) { return attr.remove( value ); } } } else { byte[] comparedBytes = null; if ( compared instanceof String ) { if ( ( ( String ) compared ).length() < 3 ) { return null; } // Tansform the String to a byte array int state = 1; comparedBytes = new byte[( ( String ) compared ).length() / 3]; int pos = 0; for ( char c : ( ( String ) compared ).toCharArray() ) { switch ( state ) { case 1: if ( c != '\\' ) { return null; } state++; break; case 2: int high = StringTools.getHexValue( c ); if ( high == -1 ) { return null; } comparedBytes[pos] = ( byte ) ( high << 4 ); state++; break; case 3: int low = StringTools.getHexValue( c ); if ( low == -1 ) { return null; } comparedBytes[pos] += ( byte ) low; pos++; state = 1; break; } } } else { comparedBytes = ( byte[] ) compared; } for ( NamingEnumeration values = attr.getAll(); values.hasMoreElements(); ) { Object value = values.nextElement(); if ( value instanceof byte[] ) { if ( ArrayUtils.isEquals( comparedBytes, value ) ) { return attr.remove( value ); } } } } return null; } /** Convert a BasicAttributes or a AttributesImpl to a ServerEntry
    
    InvalidAttributeIdentifierException - If we get an invalid attribute
    
    LdapException
  - toAttributes
```
public static Attributes toAttributes(Entry entry)
```
    Converts an Entry to an Attributes.
    
    Parameters:
    
    entry - the Entry to convert
    
    Returns:
    
    the equivalent Attributes
  - toAttribute
```
public static Attribute toAttribute(EntryAttribute entryAttribute)
```
    Converts an EntryAttribute to an Attribute.
    
    Parameters:
    
    entryAttribute - the EntryAttribute to convert
    
    Returns:
    
    the equivalent Attribute
  - toClientAttribute
```
public static EntryAttribute toClientAttribute(Attribute attribute)
```
    Convert a BasicAttribute or a AttributeImpl to a EntryAttribute
    
    Parameters:
    
    attribute - the BasicAttributes or AttributesImpl instance to convert
    
    attributeType -
    
    Returns:
    
    An instance of a ClientEntry object
    
    Throws:
    
    InvalidAttributeIdentifierException - If we had an incorrect attribute

Class AttributeUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AttributeUtils

Method Detail

removeAttribute

equals

cloneValue

toBasicAttribute

getAttribute

containsValue

containsValueCaseIgnore

getDifference

getUnion

toCaseInsensitive

toString

toString

toString

parseOID

parseAttribute

toString

applyModification

toClientEntry

toAttributes

toAttribute

toClientAttribute