/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  package org.apache.directory.server.core.entry;
  
  
  import java.io.IOException;
  import java.io.ObjectInput;
  import java.io.ObjectOutput;
  
  import javax.naming.NamingException;
  import javax.naming.directory.InvalidAttributeValueException;
  
  import org.apache.directory.shared.asn1.primitives.OID;
  import org.apache.directory.shared.ldap.entry.EntryAttribute;
  import org.apache.directory.shared.ldap.entry.Value;
  import org.apache.directory.shared.ldap.entry.client.ClientBinaryValue;
  import org.apache.directory.shared.ldap.entry.client.ClientStringValue;
  import org.apache.directory.shared.ldap.entry.client.DefaultClientAttribute;
  import org.apache.directory.shared.ldap.schema.AttributeType;
  import org.apache.directory.shared.ldap.util.StringTools;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * A server side entry attribute aware of schema.
   *
   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
   * @version $Rev$, $Date$
   */
  public final class DefaultServerAttribute extends DefaultClientAttribute implements ServerAttribute
  {
      public static final long serialVersionUID = 1L;
      
      /** logger for reporting errors that might not be handled properly upstream */
      private static final Logger LOG = LoggerFactory.getLogger( DefaultServerAttribute.class );
      
      /** The associated AttributeType */
      private AttributeType attributeType;
      
      
      //-----------------------------------------------------------------------
      // utility methods
      //-----------------------------------------------------------------------
      /**
       * Private helper method used to set an UpId from an attributeType
       * 
       * @param at The attributeType for which we want the upID
       * @return the ID of the given attributeType
       */
      private String getUpId( AttributeType at )
      {
          String atUpId = at.getName();
          
          if ( atUpId == null )
          {
              atUpId = at.getOid();
          }
          
          return atUpId;
      }
      
      
      //-------------------------------------------------------------------------
      // Constructors
      //-------------------------------------------------------------------------
      /**
       * 
       * Creates a new instance of DefaultServerAttribute, by copying
       * another attribute, which can be a ClientAttribute. If the other
       * attribute is a ServerAttribute, it will be copied.
       *
       * @param attributeType The attribute's type 
       * @param attribute The attribute to be copied
       */
      public DefaultServerAttribute( AttributeType attributeType, EntryAttribute attribute )
      {
          // Copy the common values. isHR is only available on a ServerAttribute 
          this.attributeType = attributeType;
          this.id = attribute.getId();
          this.upId = attribute.getUpId();
  
          if ( attribute instanceof ServerAttribute )
         {
             isHR = attribute.isHR();
 
             // Copy all the values
             for ( Value<?> value:attribute )
             {
                 add( value.clone() );
             }
         }
         else
         {
             
             try
             {
                 isHR = attributeType.getSyntax().isHumanReadable();
             }
             catch ( NamingException ne )
             {
                 // Do nothing : the syntax should always exist ...
             }
             
 
             // Copy all the values
             for ( Value<?> clientValue:attribute )
             {
                 Value<?> serverValue = null; 
 
                 // We have to convert the value first
                 if ( clientValue instanceof ClientStringValue )
                 {
                     if ( isHR )
                     {
                         serverValue = new ServerStringValue( attributeType, (String)clientValue.get() );
                     }
                     else
                     {
                         // We have to convert the value to a binary value first
                         serverValue = new ServerBinaryValue( attributeType, 
                             StringTools.getBytesUtf8( (String)clientValue.get() ) );
                     }
                 }
                 else if ( clientValue instanceof ClientBinaryValue )
                 {
                     if ( isHR )
                     {
                         // We have to convert the value to a String value first
                         serverValue = new ServerStringValue( attributeType, 
                             StringTools.utf8ToString( (byte[])clientValue.get() ) );
                     }
                     else
                     {
                         serverValue = new ServerBinaryValue( attributeType, (byte[])clientValue.get() );
                     }
                 }
 
                 add( serverValue );
             }
         }
     }
     
     
     // maybe have some additional convenience constructors which take
     // an initial value as a string or a byte[]
     /**
      * Create a new instance of a EntryAttribute, without ID nor value.
      * 
      * @param attributeType the attributeType for the empty attribute added into the entry
      */
     public DefaultServerAttribute( AttributeType attributeType )
     {
         if ( attributeType == null )
         {
             throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
         }
         
         setAttributeType( attributeType );
     }
 
 
     /**
      * Create a new instance of a EntryAttribute, without value.
      * 
      * @param upId the ID for the added attributeType
      * @param attributeType the added AttributeType
      */
     public DefaultServerAttribute( String upId, AttributeType attributeType )
     {
         if ( attributeType == null ) 
         {
             String message = "The AttributeType parameter should not be null";
             LOG.error( message );
             throw new IllegalArgumentException( message );
         }
 
         setAttributeType( attributeType );
         setUpId( upId );
     }
 
 
     /**
      * Doc me more!
      *
      * If the value does not correspond to the same attributeType, then it's
      * wrapped value is copied into a new Value which uses the specified
      * attributeType.
      *
      * @param attributeType the attribute type according to the schema
      * @param vals an initial set of values for this attribute
      */
     public DefaultServerAttribute( AttributeType attributeType, Value<?>... vals )
     {
         this( null, attributeType, vals );
     }
 
 
     /**
      * Doc me more!
      *
      * If the value does not correspond to the same attributeType, then it's
      * wrapped value is copied into a new Value which uses the specified
      * attributeType.
      * 
      * Otherwise, the value is stored, but as a reference. It's not a copy.
      *
      * @param upId the ID of the added attribute
      * @param attributeType the attribute type according to the schema
      * @param vals an initial set of values for this attribute
      */
     public DefaultServerAttribute( String upId, AttributeType attributeType, Value<?>... vals )
     {
         if ( attributeType == null )
         {
             throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
         }
         
         setAttributeType( attributeType );
         setUpId( upId, attributeType );
         add( vals );
     }
 
 
     /**
      * Create a new instance of a EntryAttribute, without ID but with some values.
      * 
      * @param attributeType The attributeType added on creation
      * @param vals The added value for this attribute
      */
     public DefaultServerAttribute( AttributeType attributeType, String... vals )
     {
         this( null, attributeType, vals );
     }
 
 
     /**
      * Create a new instance of a EntryAttribute.
      * 
      * @param upId the ID for the added attribute
      * @param attributeType The attributeType added on creation
      * @param vals the added values for this attribute
      */
     public DefaultServerAttribute( String upId, AttributeType attributeType, String... vals )
     {
         if ( attributeType == null )
         {
             throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
         }
 
         setAttributeType( attributeType );
         add( vals );
         setUpId( upId, attributeType );
     }
 
 
     /**
      * Create a new instance of a EntryAttribute, with some byte[] values.
      * 
      * @param attributeType The attributeType added on creation
      * @param vals The value for the added attribute
      */
     public DefaultServerAttribute( AttributeType attributeType, byte[]... vals )
     {
         this( null, attributeType, vals );
     }
 
 
     /**
      * Create a new instance of a EntryAttribute, with some byte[] values.
      * 
      * @param upId the ID for the added attribute
      * @param attributeType the AttributeType to be added
      * @param vals the values for the added attribute
      */
     public DefaultServerAttribute( String upId, AttributeType attributeType, byte[]... vals )
     {
         if ( attributeType == null )
         {
             throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
         }
 
         setAttributeType( attributeType );
         add( vals );
         setUpId( upId, attributeType );
     }
     
     
     //-------------------------------------------------------------------------
     // API
     //-------------------------------------------------------------------------
     /**
      * <p>
      * Adds some values to this attribute. If the new values are already present in
      * the attribute values, the method has no effect.
      * </p>
      * <p>
      * The new values are added at the end of list of values.
      * </p>
      * <p>
      * This method returns the number of values that were added.
      * </p>
      * <p>
      * If the value's type is different from the attribute's type,
      * the value is not added.
      * </p>
      * It's the responsibility of the caller to check if the stored
      * values are consistent with the attribute's type.
      * <p>
      *
      * @param vals some new values to be added which may be null
      * @return the number of added values, or 0 if none has been added
      */
     public int add( byte[]... vals )
     {
         if ( !isHR )
         {
             int nbAdded = 0;
             
             for ( byte[] val:vals )
             {
                 Value<?> value = new ServerBinaryValue( attributeType, val );
                 
                 try
                 {
                     value.normalize();
                 }
                 catch( NamingException ne )
                 {
                     // The value can't be normalized : we don't add it.
                     LOG.error( "The value '" + val + "' can't be normalized, it hasn't been added" );
                     return 0;
                 }
                 
                 if ( add( value ) != 0 )
                 {
                     nbAdded++;
                 }
                 else
                 {
                     LOG.error( "The value '" + val + "' is incorrect, it hasn't been added" );
                 }
             }
             
             return nbAdded;
         }
         else
         {
             // We can't add Binary values into a String serverAttribute
             return 0;
         }
     }    
 
 
     /**
      * <p>
      * Adds some values to this attribute. If the new values are already present in
      * the attribute values, the method has no effect.
      * </p>
      * <p>
      * The new values are added at the end of list of values.
      * </p>
      * <p>
      * This method returns the number of values that were added.
      * </p>
      * If the value's type is different from the attribute's type,
      * the value is not added.
      *
      * @param vals some new values to be added which may be null
      * @return the number of added values, or 0 if none has been added
      */
     public int add( String... vals )
     {
         if ( isHR )
         {
             int nbAdded = 0;
             
             for ( String val:vals )
             {
                 if ( add( new ServerStringValue( attributeType, val ) ) != 0 )
                 {
                     nbAdded++;
                 }
                 else
                 {
                     LOG.error( "The value '" + val + "' is incorrect, it hasn't been added" );
                 }
             }
             
             return nbAdded;
         }
         else
         {
             // We can't add String values into a Binary serverAttribute
             return 0;
         }
     }    
 
 
     /**
      * @see EntryAttribute#add(org.apache.directory.shared.ldap.entry.Value...)
      * 
      * @return the number of added values into this attribute
      */
     public int add( Value<?>... vals )
     {
         int nbAdded = 0;
         
         for ( Value<?> val:vals )
         {
             try
             {
                 if ( attributeType.getSyntax().isHumanReadable() )
                 {
                     if ( val == null )
                     {
                         Value<String> nullSV = new ServerStringValue( attributeType, (String)null );
                         
                         if ( !values.contains( nullSV ) )
                         {
                             values.add( nullSV );
                             nbAdded++;
                         }
                     }
                     else if ( val instanceof ServerStringValue )
                     {
                         if ( !values.contains( val ) )
                         {
                             if ( values.add( val ) )
                             {
                                 nbAdded++;
                             }
                         }
                     }
                     else if ( val instanceof ClientStringValue )
                     {
                         // If we get a Client value, convert it to a Server value first 
                         Value<String> serverStringValue = new ServerStringValue( attributeType, (String)val.get() ); 
                         
                         if ( !values.contains( serverStringValue ) )
                         {
                             if ( values.add( serverStringValue ) )
                             {
                                 nbAdded++;
                             }
                         }
                     }
                     else
                     {
                         String message = "The value must be a String, as its AttributeType is H/R";
                         LOG.error( message );
                     }
                 }
                 else
                 {
                     if ( val == null )
                     {
                         Value<byte[]> nullSV = new ServerBinaryValue( attributeType, (byte[])null );
                         
                         if ( !values.contains( nullSV ) )
                         {
                             values.add( nullSV );
                             nbAdded++;
                         }
                     }
                     else if ( ( val instanceof ClientBinaryValue ) )
                     {
                         Value<byte[]> serverBinaryValue = new ServerBinaryValue( attributeType, (byte[])val.get() ); 
                         
                         if ( !values.contains( serverBinaryValue ) )
                         {
                             if ( values.add( serverBinaryValue ) )
                             {
                                 nbAdded++;
                             }
                         }
                     }
                     else if ( val instanceof ServerBinaryValue )
                     {
                         if ( !values.contains( val ) )
                         {
                             if ( values.add( val ) )
                             {
                                 nbAdded++;
                             }
                         }
                     }
                     else
                     {
                         String message = "The value must be a byte[], as its AttributeType is not H/R";
                         LOG.error( message );
                     }
                 }
             }
             catch ( NamingException ne )
             {
                 String message = "Error while adding value '" + val.toString() +"' : " + ne.getMessage();
                 LOG.error( message );
             }
         }
         
         return nbAdded;
     }
 
 
     /**
      * Remove all the values from this attribute type, including a 
      * null value. 
      */
     public void clear()
     {
         values.clear();
     }
 
 
     /**
      * <p>
      * Indicates whether all the specified values are attribute's values. If
      * at least one value is not an attribute's value, this method will return 
      * <code>false</code>
      * </p>
      * <p>
      * If the Attribute is HR, this method will returns <code>false</code>
      * </p>
      *
      * @param vals the values
      * @return true if this attribute contains all the values, otherwise false
      */
     public boolean contains( byte[]... vals )
     {
         if ( !isHR )
         {
             // Iterate through all the values, and quit if we 
             // don't find one in the values
             for ( byte[] val:vals )
             {
                 ServerBinaryValue value = new ServerBinaryValue( attributeType, val );
                 
                 try
                 {
                     value.normalize();
                 }
                 catch ( NamingException ne )
                 {
                     return false;
                 }
                 
                 if ( !values.contains( value ) )
                 {
                     return false;
                 }
             }
             
             return true;
         }
         else
         {
             return false;
         }
     }
     
     
     /**
      * <p>
      * Indicates whether all the specified values are attribute's values. If
      * at least one value is not an attribute's value, this method will return 
      * <code>false</code>
      * </p>
      * <p>
      * If the Attribute is not HR, this method will returns <code>false</code>
      * </p>
      *
      * @param vals the values
      * @return true if this attribute contains all the values, otherwise false
      */
     public boolean contains( String... vals )
     {
         if ( isHR )
         {
             // Iterate through all the values, and quit if we 
             // don't find one in the values
             for ( String val:vals )
             {
                 ServerStringValue value = new ServerStringValue( attributeType, val );
                 
                 if ( !values.contains( value ) )
                 {
                     return false;
                 }
             }
             
             return true;
         }
         else
         {
             return false;
         }
     }
     
     
     /**
      * <p>
      * Indicates whether the specified values are some of the attribute's values.
      * </p>
      * <p>
      * If the Attribute is HR, te metho will only accept String Values. Otherwise, 
      * it will only accept Binary values.
      * </p>
      *
      * @param vals the values
      * @return true if this attribute contains all the values, otherwise false
      */
     public boolean contains( Value<?>... vals )
     {
         // Iterate through all the values, and quit if we 
         // don't find one in the values. We have to separate the check
         // depending on the isHR flag value.
         if ( isHR )
         {
             for ( Value<?> val:vals )
             {
                 if ( val instanceof ServerStringValue )
                 {
                     if ( !values.contains( val ) )
                     {
                         return false;
                     }
                 }
                 else if ( val instanceof ClientStringValue )
                 {
                     ServerStringValue serverValue = new ServerStringValue( attributeType, (String)val.get() );
                     
                     if ( !values.contains( serverValue ) )
                     {
                         return false;
                     }
                 }
                 else
                 {
                     // Not a String value
                     return false;
                 }
             }
         }
         else
         {
             for ( Value<?> val:vals )
             {
                 if ( val instanceof ClientBinaryValue )
                 {
                     if ( !values.contains( val ) )
                     {
                         return false;
                     }
                 }
                 else
                 {
                     // Not a Binary value
                     return false;
                 }
             }
         }
         
         return true;
     }
 
 
     /**
      * Get the attribute type associated with this ServerAttribute.
      *
      * @return the attributeType associated with this entry attribute
      */
     public AttributeType getAttributeType()
     {
         return attributeType;
     }
     
     
     /**
      * <p>
      * Check if the current attribute type is of the expected attributeType
      * </p>
      * <p>
      * This method won't tell if the current attribute is a descendant of 
      * the attributeType. For instance, the "CN" serverAttribute will return
      * false if we ask if it's an instance of "Name". 
      * </p> 
      *
      * @param attributeId The AttributeType ID to check
      * @return True if the current attribute is of the expected attributeType
      * @throws InvalidAttributeValueException If there is no AttributeType
      */
     public boolean instanceOf( String attributeId ) throws InvalidAttributeValueException
     {
         String trimmedId = StringTools.trim( attributeId );
         
         if ( StringTools.isEmpty( trimmedId ) )
         {
             return false;
         }
         
         String normId = StringTools.lowerCaseAscii( trimmedId );
         
         for ( String name:attributeType.getNamesRef() )
         {
             if ( normId.equalsIgnoreCase( name ) )
             {
                 return true;
             }
         }
         
         return normId.equalsIgnoreCase( attributeType.getOid() );
     }
     
 
     /**
      * <p>
      * Checks to see if this attribute is valid along with the values it contains.
      * </p>
      * <p>
      * An attribute is valid if :
      * <li>All of its values are valid with respect to the attributeType's syntax checker</li>
      * <li>If the attributeType is SINGLE-VALUE, then no more than a value should be present</li>
      *</p>
      * @return true if the attribute and it's values are valid, false otherwise
      * @throws NamingException if there is a failure to check syntaxes of values
      */
     public boolean isValid() throws NamingException
     {
         // First check if the attribute has more than one value
         // if the attribute is supposed to be SINGLE_VALUE
         if ( attributeType.isSingleValue() && ( values.size() > 1 ) )
         {
             return false;
         }
 
         for ( Value<?> value : values )
         {
             if ( ! value.isValid() )
             {
                 return false;
             }
         }
 
         return true;
     }
 
 
     /**
      * @see EntryAttribute#remove(byte[]...)
      * 
      * @return <code>true</code> if all the values shave been removed from this attribute
      */
     public boolean remove( byte[]... vals )
     {
         if ( isHR ) 
         {
             return false;
         }
         
         boolean removed = true;
         
         for ( byte[] val:vals )
         {
             ServerBinaryValue value = new ServerBinaryValue( attributeType, val );
             removed &= values.remove( value );
         }
         
         return removed;
     }
 
 
     /**
      * @see EntryAttribute#remove(String...)
      * 
      * @return <code>true</code> if all the values shave been removed from this attribute
      */
     public boolean remove( String... vals )
     {
         if ( !isHR )
         {
             return false;
         }
         
         boolean removed = true;
         
         for ( String val:vals )
         {
             ServerStringValue value = new ServerStringValue( attributeType, val );
             removed &= values.remove( value );
         }
         
         return removed;
     }
 
 
     /**
      * @see EntryAttribute#remove(org.apache.directory.shared.ldap.entry.Value...)
      * 
      * @return <code>true</code> if all the values shave been removed from this attribute
      */
     public boolean remove( Value<?>... vals )
     {
         boolean removed = true;
         
         // Loop through all the values to remove. If one of
         // them is not present, the method will return false.
         // As the attribute may be HR or not, we have two separated treatments
         if ( isHR )
         {
             for ( Value<?> val:vals )
             {
                 if ( val instanceof ClientStringValue )
                 {
                     ServerStringValue ssv = new ServerStringValue( attributeType, (String)val.get() );
                     removed &= values.remove( ssv );
                 }
                 else if ( val instanceof ServerStringValue )
                 {
                     removed &= values.remove( val );
                 }
                 else
                 {
                     removed = false;
                 }
             }
         }
         else
         {
             for ( Value<?> val:vals )
             {
                 if ( val instanceof ClientBinaryValue )
                 {
                     ServerBinaryValue sbv = new ServerBinaryValue( attributeType, (byte[])val.get() );
                     removed &= values.remove( sbv );
                 }
                 else if ( val instanceof ServerBinaryValue )
                 {
                     removed &= values.remove( val );
                 }
                 else
                 {
                     removed = false;
                 }
             }
         }
         
         return removed;
     }
 
 
     
     /**
      * <p>
      * Set the attribute type associated with this ServerAttribute.
      * </p>
      * <p>
      * The current attributeType will be replaced. It is the responsibility of
      * the caller to insure that the existing values are compatible with the new
      * AttributeType
      * </p>
      *
      * @param attributeType the attributeType associated with this entry attribute
      */
     public void setAttributeType( AttributeType attributeType )
     {
         if ( attributeType == null )
         {
             throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
         }
 
         this.attributeType = attributeType;
         setUpId( null, attributeType );
         
         try
         {
             if ( attributeType.getSyntax().isHumanReadable() )
             {
                 isHR = true;
             }
             else
             {
                 isHR = false;
             }
         }
         catch ( NamingException ne )
         {
             // If we have an exception while trying to get the Syntax for this attribute
             // just set it as Binary
             isHR = false;
         }
     }
     
     
     /**
      * <p>
      * Overload the ClientAttribte isHR method : we can't change this flag
      * for a ServerAttribute, as the HR is already set using the AttributeType.
      * Set the attribute to Human Readable or to Binary. 
      * </p>
      * 
      * @param isHR <code>true</code> for a Human Readable attribute, 
      * <code>false</code> for a Binary attribute.
      */
     public void setHR( boolean isHR )
     {
         // Do nothing...
     }
 
     
     /**
      * <p>
      * Overload the {@link DefaultClientAttribute#setId(String)} method.
      * </p>
      * <p>
      * As the attributeType has already been set, we have to be sure that the 
      * argument is compatible with the attributeType's name. 
      * </p>
      * <p>
      * If the given ID is not compatible with the attributeType's possible
      * names, the previously loaded ID will be kept.
      * </p>
      *
      * @param id The attribute ID
      */
     public void setId( String id )
     {
         if ( !StringTools.isEmpty( StringTools.trim( id  ) ) )
         {
             if ( attributeType.getName() == null )
             {
                 // If the name is null, then we may have to store an OID
                 if ( OID.isOID( id )  && attributeType.getOid().equals( id ) )
                 {
                     // Everything is fine, store the upId.
                     // This should not happen...
                     super.setId( id );
                 }
             }
             else
             {
                 // We have at least one name. Check that the normalized upId
                 // is one of those names. Otherwise, the upId may be an OID too.
                 // In this case, it must be equals to the attributeType OID.
                 String normId = StringTools.lowerCaseAscii( StringTools.trim( id ) );
                 
                 for ( String atName:attributeType.getNamesRef() )
                 {
                     if ( atName.equalsIgnoreCase( normId ) )
                     {
                         // Found ! We can store the upId and get out
                         super.setId( normId );
                         return;
                     }
                 }
                 
                 // Last case, the UpId is an OID
                 if ( OID.isOID( normId ) && attributeType.getOid().equals( normId ) )
                 {
                     // We have an OID : stores it
                     super.setUpId( normId );
                 }
                 else
                 {
                     // The id is incorrect : this is not allowed 
                     throw new IllegalArgumentException( "The ID '" + id + "'is incompatible with the AttributeType's id '" + 
                         attributeType.getName() + "'" );
                 }
             }
         }
         else
         {
             throw new IllegalArgumentException( "An ID cannnot be null, empty, or resolved to an emtpy" +
             " value when trimmed" );
         }
     }
     
     
     /**
      * <p>
      * Overload the {@link DefaultClientAttribute#setUpId(String)} method.
      * </p>
      * <p>
      * As the attributeType has already been set, we have to be sure that the 
      * argument is compatible with the attributeType's name. 
      * </p>
      * <p>
      * If the given ID is not compatible with the attributeType's possible
      * names, the previously loaded ID will be kept.
      * </p>
      *
      * @param upId The attribute ID
      */
     public void setUpId( String upId )
     {
         if ( !StringTools.isEmpty( StringTools.trim( upId  ) ) )
         {
             if ( attributeType.getName() == null )
             {
                 // If the name is null, then we may have to store an OID
                 if ( OID.isOID( upId )  && attributeType.getOid().equals( upId ) )
                 {
                     // Everything is fine, store the upId.
                     // This should not happen...
                     super.setUpId( upId );
                     
                 }
             }
             else
             {
                 // We have at least one name. Check that the normalized upId
                 // is one of those names. Otherwise, the upId may be an OID too.
                 // In this case, it must be equals to the attributeType OID.
                 String normUpId = StringTools.lowerCaseAscii( StringTools.trim( upId ) );
                 
                 for ( String atId:attributeType.getNamesRef() )
                 {
                     if ( atId.equalsIgnoreCase( normUpId ) )
                     {
                         // Found ! We can store the upId and get out
                         super.setUpId( upId );
                         return;
                     }
                 }
                 
                 // Last case, the UpId is an OID
                 if ( OID.isOID( normUpId ) && attributeType.getOid().equals( normUpId ) )
                 {
                     // We have an OID : stores it
                     super.setUpId( upId );
                 }
             }
         }
     }
     
     
     /**
      * <p>
      * Set the user provided ID. If we have none, the upId is assigned
      * the attributetype's name. If it does not have any name, we will
      * use the OID.
      * </p>
      * <p>
      * If we have an upId and an AttributeType, they must be compatible. :
      *  - if the upId is an OID, it must be the AttributeType's OID
      *  - otherwise, its normalized form must be equals to ones of
      *  the attributeType's names.
      * </p>
      * <p>
      * In any case, the ATtributeType will be changed. The caller is responsible for
      * the present values to be compatoble with the new AttributeType.
      * </p>
      *
      * @param upId The attribute ID
      * @param attributeType The associated attributeType
      */
     public void setUpId( String upId, AttributeType attributeType )
     {
         if ( StringTools.isEmpty( StringTools.trim( upId  ) ) )
         {
             super.setUpId( getUpId( attributeType ) );
             this.attributeType = attributeType;
         }
         else
         {
             String name = attributeType.getName();
             
             if ( name == null )
             {
                 // If the name is null, then we may have to store an OID
                 if ( OID.isOID( upId )  && attributeType.getOid().equals( upId ) )
                 {
                     //  Everything is fine, store the upId. 
                     super.setUpId( upId );
                     this.attributeType = attributeType;
                 }
                 else
                 {
                     // We have a difference or the upId is not a valid OID :
                     // we will use the attributeTypeOID in this case.
                     LOG.warn( "The upID ({}) is not an OID or is different from the AttributeType OID({})",
                         upId, attributeType.getOid() );
                     super.setUpId( attributeType.getOid() );
                     this.attributeType = attributeType;
                 }
             }
             else
             {
                 // We have at least one name. Check that the normalized upId
                 // is one of those names. Otherwise, the upId may be an OID too.
                 // In this case, it must be equals to the attributeType OID.
                 String normUpId = StringTools.lowerCaseAscii( StringTools.trim( upId ) );
                 
                 for ( String atId:attributeType.getNamesRef() )
                 {
                     if ( atId.equalsIgnoreCase( normUpId ) )
                     {
                         // Found ! We can store the upId and get out
                         super.setUpId( upId );
                         this.attributeType = attributeType;
                         return;
                     }
                 }
     
                 // UpId was not found in names. It should be an OID, or if not, we 
                 // will use the AttributeType name.
                 if ( OID.isOID( normUpId ) && attributeType.getOid().equals( normUpId ) )
                 {
                     // We have an OID : stores it
                     super.setUpId( upId );
                     this.attributeType = attributeType;
                 }
                 else
                 {
                     String message = "The upID (" + upId + ") is not an OID or is different from the AttributeType OID (" + 
                                         attributeType.getOid() + ")";
                     // Not a valid OID : use the AttributeTypes OID name instead
                     LOG.error( message );
                     throw new IllegalArgumentException( message );
                 }
             }
         }
     }
 
 
     /**
      * Convert the ServerAttribute to a ClientAttribute
      *
      * @return An instance of ClientAttribute
      */
     public EntryAttribute toClientAttribute()
     {
         // Create the new EntryAttribute
         EntryAttribute clientAttribute = new DefaultClientAttribute( upId );
         
         // Copy the values
         for ( Value<?> value:this )
         {
             Value<?> clientValue = null;
             
             if ( value instanceof ServerStringValue )
             {
                 clientValue = new ClientStringValue( (String)value.get() );
             }
             else
             {
                 clientValue = new ClientBinaryValue( (byte[])value.get() );
             }
             
             clientAttribute.add( clientValue );
         }
         
         return clientAttribute;
     }
 
 
     //-------------------------------------------------------------------------
     // Serialization methods
     //-------------------------------------------------------------------------
     
     /**
      * @see java.io.Externalizable#writeExternal(ObjectOutput)
      * 
      * We can't use this method for a ServerAttribute, as we have to feed the value
      * with an AttributeType object
      */
     public void writeExternal( ObjectOutput out ) throws IOException
     {
         throw new IllegalStateException( "Cannot use standard serialization for a ServerAttribute" );
     }
     
     
     /**
      * @see Externalizable#writeExternal(ObjectOutput)
      * <p>
      * 
      * This is the place where we serialize attributes, and all theirs
      * elements. 
      * 
      * The inner structure is the same as the client attribute, but we can't call
      * it as we won't be able to serialize the serverValues
      * 
      */
     public void serialize( ObjectOutput out ) throws IOException
     {
         // Write the UPId (the id will be deduced from the upID)
         out.writeUTF( upId );
         
         // Write the HR flag, if not null
         if ( isHR != null )
         {
             out.writeBoolean( true );
             out.writeBoolean( isHR );
         }
         else
         {
             out.writeBoolean( false );
         }
         
         // Write the number of values
         out.writeInt( size() );
         
         if ( size() > 0 ) 
         {
             // Write each value
             for ( Value<?> value:values )
             {
                 // Write the value, using the correct method
                 if ( value instanceof ServerStringValue )
                 {
                     ((ServerStringValue)value).serialize( out );
                 }
                 else
                 {
                     ((ServerBinaryValue)value).serialize( out );
                 }
             }
         }
     }
 
     
     /**
      * @see java.io.Externalizable#readExternal(ObjectInput)
      * 
      * We can't use this method for a ServerAttribute, as we have to feed the value
      * with an AttributeType object
      */
     public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
     {
         throw new IllegalStateException( "Cannot use standard serialization for a ServerAttribute" );
     }
     
     
     /**
      * @see Externalizable#readExternal(ObjectInput)
      */
     public void deserialize( ObjectInput in ) throws IOException, ClassNotFoundException
     {
         // Read the ID and the UPId
         upId = in.readUTF();
         
         // Compute the id
         setUpId( upId );
         
         // Read the HR flag, if not null
         if ( in.readBoolean() )
         {
             isHR = in.readBoolean();
         }
 
         // Read the number of values
         int nbValues = in.readInt();
 
         if ( nbValues > 0 )
         {
             for ( int i = 0; i < nbValues; i++ )
             {
                 Value<?> value = null;
                 
                 if ( isHR )
                 {
                     value  = new ServerStringValue( attributeType );
                     ((ServerStringValue)value).deserialize( in );
                 }
                 else
                 {
                     value  = new ServerBinaryValue( attributeType );
                     ((ServerBinaryValue)value).deserialize( in );
                 }
                 
                 try
                 {
                     value.normalize();
                 }
                 catch ( NamingException ne )
                 {
                     // Do nothing...
                 }
                     
                 values.add( value );
             }
         }
     }
     
     
     //-------------------------------------------------------------------------
     // Overloaded Object class methods
     //-------------------------------------------------------------------------
     /**
      * Clone an attribute. All the element are duplicated, so a modification on
      * the original object won't affect the cloned object, as a modification
      * on the cloned object has no impact on the original object
      * 
      * @return a clone of the current attribute
      */
     public ServerAttribute clone()
     {
         // clone the structure by cloner the inherited class
         ServerAttribute clone = (ServerAttribute)super.clone();
         
         // We are done !
         return clone;
     }
 
 
     /**
      * @see Object#equals(Object)
      * 
      * @return <code>true</code> if the two objects are equal
      */
     public boolean equals( Object obj )
     {
         if ( obj == this )
         {
             return true;
         }
         
         if ( ! (obj instanceof ServerAttribute ) )
         {
             return false;
         }
         
         ServerAttribute other = (ServerAttribute)obj;
         
         if ( !attributeType.equals( other.getAttributeType() ) )
         {
             return false;
         }
         
         if ( values.size() != other.size() )
         {
             return false;
         }
         
         for ( Value<?> val:values )
         {
             if ( ! other.contains( val ) )
             {
                 return false;
             }
         }
         
         return true;
     }
     
     
     /**
      * The hashCode is based on the id, the isHR flag and 
      * on the internal values.
      *  
      * @see Object#hashCode()
      * 
      * @return the instance's hash code 
      */
     public int hashCode()
     {
         int h = super.hashCode();
         
         if ( attributeType != null )
         {
             h = h*17 + attributeType.hashCode();
         }
         
         return h;
     }
     
     
     /**
      * @see Object#toString()
      * 
      * @return A String representation of this instance
      */
     public String toString()
     {
         StringBuilder sb = new StringBuilder();
         
         if ( ( values != null ) && ( values.size() != 0 ) )
         {
             for ( Value<?> value:values )
             {
                 sb.append( "    " ).append( upId ).append( ": " );
                 
                 if ( value.isNull() )
                 {
                     sb.append( "''" );
                 }
                 else
                 {
                     sb.append( value );
                 }
                 
                 sb.append( '\n' );
             }
         }
         else
         {
             sb.append( "    " ).append( upId ).append( ": (null)\n" );
         }
         
         return sb.toString();
     }
 }