/*
* 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.api.ldap.model.entry;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.directory.api.i18n.I18n;
import org.apache.directory.api.ldap.model.constants.SchemaConstants;
import org.apache.directory.api.ldap.model.exception.LdapException;
import org.apache.directory.api.ldap.model.exception.LdapInvalidAttributeValueException;
import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
import org.apache.directory.api.ldap.model.ldif.LdapLdifException;
import org.apache.directory.api.ldap.model.ldif.LdifAttributesReader;
import org.apache.directory.api.ldap.model.message.ResultCodeEnum;
import org.apache.directory.api.ldap.model.name.Dn;
import org.apache.directory.api.ldap.model.schema.AttributeType;
import org.apache.directory.api.ldap.model.schema.SchemaManager;
import org.apache.directory.api.util.Base64;
import org.apache.directory.api.util.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A default implementation of a ServerEntry which should suite most
* use cases.<br/>
* <br/>
* This class is final, it should not be extended.
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
public final class DefaultEntry implements Entry
{
/** Used for serialization */
private static final long serialVersionUID = 2L;
/** The logger for this class */
private static final Logger LOG = LoggerFactory.getLogger( DefaultEntry.class );
/** The Dn for this entry */
private Dn dn;
/** A map containing all the attributes for this entry */
private Map<String, Attribute> attributes = new HashMap<String, Attribute>();
/** A speedup to get the ObjectClass attribute */
private static AttributeType objectClassAttributeType;
/** The SchemaManager */
private SchemaManager schemaManager;
/** The computed hashcode. We don't want to compute it each time the hashcode() method is called */
private volatile int h;
/** A mutex to manage synchronization*/
private static final Object MUTEX = new Object();
//-------------------------------------------------------------------------
// Constructors
//-------------------------------------------------------------------------
/**
* Creates a new instance of DefaultEntry.
* <p>
* This entry <b>must</b> be initialized before being used !
*/
public DefaultEntry()
{
this( ( SchemaManager ) null );
}
/**
* <p>
* Creates a new instance of DefaultEntry, schema aware.
* </p>
* <p>
* No attributes will be created.
* </p>
*
* @param schemaManager The reference to the schemaManager
*/
public DefaultEntry( SchemaManager schemaManager )
{
this.schemaManager = schemaManager;
dn = Dn.EMPTY_DN;
// Initialize the ObjectClass object
if ( schemaManager != null )
{
initObjectClassAT();
}
}
/**
* Creates a new instance of DefaultEntry, with a Dn.
*
* @param dn The String Dn for this serverEntry. Can be null.
* @throws LdapInvalidDnException If the Dn is invalid
*/
public DefaultEntry( String dn ) throws LdapInvalidDnException
{
this.dn = new Dn( dn );
}
/**
* Creates a new instance of DefaultEntry, with a Dn.
*
* @param dn The Dn for this serverEntry. Can be null.
*/
public DefaultEntry( Dn dn )
{
this.dn = dn;
}
/**
* <p>
* Creates a new instance of DefaultEntry, schema aware.
* </p>
* <p>
* No attributes will be created.
* </p>
*
* @param schemaManager The reference to the schemaManager
* @param dn The String Dn for this serverEntry. Can be null.
* @throws LdapInvalidDnException If the Dn is invalid
*/
public DefaultEntry( SchemaManager schemaManager, String dn ) throws LdapInvalidDnException
{
this.schemaManager = schemaManager;
if ( Strings.isEmpty( dn ) )
{
this.dn = Dn.EMPTY_DN;
}
else
{
this.dn = new Dn( dn );
normalizeDN( this.dn );
}
// Initialize the ObjectClass object
initObjectClassAT();
}
/**
* <p>
* Creates a new instance of DefaultEntry, schema aware.
* </p>
* <p>
* No attributes will be created.
* </p>
*
* @param schemaManager The reference to the schemaManager
* @param dn The Dn for this serverEntry. Can be null.
*/
public DefaultEntry( SchemaManager schemaManager, Dn dn )
{
this.schemaManager = schemaManager;
if ( dn == null )
{
this.dn = Dn.EMPTY_DN;
}
else
{
this.dn = dn;
normalizeDN( this.dn );
}
// Initialize the ObjectClass object
initObjectClassAT();
}
/**
* Creates a new instance of DefaultEntry, with a
* Dn and a list of IDs.
*
* @param dn The Dn for this serverEntry. Can be null.
* @param upIds The list of attributes to create.
*/
public DefaultEntry( String dn, Object... elements ) throws LdapException
{
this( null, dn, elements );
}
/**
* Creates a new instance of DefaultEntry, with a
* Dn and a list of IDs.
*
* @param dn The Dn for this serverEntry. Can be null.
* @param upIds The list of attributes to create.
*/
public DefaultEntry( Dn dn, Object... elements ) throws LdapException
{
this( null, dn, elements );
}
/**
* Creates a new instance of DefaultEntry, with a
* Dn and a list of IDs.
*
* @param dn The Dn for this serverEntry. Can be null.
* @param upIds The list of attributes to create.
*/
public DefaultEntry( SchemaManager schemaManager, String dn, Object... elements ) throws LdapException
{
this( schemaManager, new Dn( schemaManager, dn ), elements );
}
/**
* Creates a new instance of DefaultEntry, with a
* Dn and a list of IDs.
*
* @param dn The Dn for this serverEntry. Can be null.
* @param upIds The list of attributes to create.
*/
public DefaultEntry( SchemaManager schemaManager, Dn dn, Object... elements ) throws LdapException
{
DefaultEntry entry = ( DefaultEntry ) createEntry( schemaManager, elements );
this.dn = dn;
this.attributes = entry.attributes;
this.schemaManager = schemaManager;
if ( schemaManager != null )
{
this.dn.apply( schemaManager );
initObjectClassAT();
}
}
/**
* <p>
* Creates a new instance of DefaultEntry, copying
* another entry.
* </p>
* <p>
* No attributes will be created.
* </p>
*
* @param schemaManager The reference to the schemaManager
* @param entry the entry to copy
*/
public DefaultEntry( SchemaManager schemaManager, Entry entry ) throws LdapException
{
this.schemaManager = schemaManager;
// Initialize the ObjectClass object
initObjectClassAT();
// We will clone the existing entry, because it may be normalized
if ( entry.getDn() != null )
{
dn = entry.getDn();
normalizeDN( dn );
}
else
{
dn = Dn.EMPTY_DN;
}
// Init the attributes map
attributes = new HashMap<String, Attribute>( entry.size() );
// and copy all the attributes
for ( Attribute attribute : entry )
{
try
{
// First get the AttributeType
AttributeType attributeType = attribute.getAttributeType();
if ( attributeType == null )
{
attributeType = schemaManager.lookupAttributeTypeRegistry( attribute.getId() );
}
// Create a new ServerAttribute.
Attribute serverAttribute = new DefaultAttribute( attributeType, attribute );
// And store it
add( serverAttribute );
}
catch ( LdapException ne )
{
// Just log a warning
LOG.warn( "The attribute '" + attribute.getId() + "' cannot be stored" );
throw ne;
}
}
}
//-------------------------------------------------------------------------
// Helper methods
//-------------------------------------------------------------------------
private Entry createEntry( SchemaManager schemaManager, Object... elements )
throws LdapInvalidAttributeValueException, LdapLdifException
{
StringBuilder sb = new StringBuilder();
int pos = 0;
boolean valueExpected = false;
for ( Object element : elements )
{
if ( !valueExpected )
{
if ( !( element instanceof String ) )
{
throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n.err(
I18n.ERR_12085, ( pos + 1 ) ) );
}
String attribute = ( String ) element;
sb.append( attribute );
if ( attribute.indexOf( ':' ) != -1 )
{
sb.append( '\n' );
}
else
{
valueExpected = true;
}
}
else
{
if ( element instanceof String )
{
sb.append( ": " ).append( ( String ) element ).append( '\n' );
}
else if ( element instanceof byte[] )
{
sb.append( ":: " );
sb.append( new String( Base64.encode( ( byte[] ) element ) ) );
sb.append( '\n' );
}
else
{
throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n.err(
I18n.ERR_12086, ( pos + 1 ) ) );
}
valueExpected = false;
}
}
if ( valueExpected )
{
throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n
.err( I18n.ERR_12087 ) );
}
LdifAttributesReader reader = new LdifAttributesReader();
Entry entry = reader.parseEntry( schemaManager, sb.toString() );
return entry;
}
/**
* Get the trimmed and lower cased entry ID
*/
private String getId( String upId )
{
String id = Strings.trim( Strings.toLowerCase( upId ) );
// If empty, throw an error
if ( Strings.isEmpty( id ) )
{
String message = I18n.err( I18n.ERR_04133 );
LOG.error( message );
throw new IllegalArgumentException( message );
}
return id;
}
/**
* Get the UpId if it is null.
*
* @param upId The ID
*/
private String getUpId( String upId, AttributeType attributeType )
{
String normUpId = Strings.trim( upId );
if ( ( attributeType == null ) )
{
if ( Strings.isEmpty( normUpId ) )
{
String message = I18n.err( I18n.ERR_04458 );
LOG.error( message );
throw new IllegalArgumentException( message );
}
return upId;
}
else if ( Strings.isEmpty( normUpId ) )
{
String id = attributeType.getName();
if ( Strings.isEmpty( id ) )
{
id = attributeType.getOid();
}
return id;
}
else
{
return upId;
}
}
/**
* This method is used to initialize the OBJECT_CLASS_AT attributeType.
*
* We want to do it only once, so it's a synchronized method. Note that
* the alternative would be to call the lookup() every time, but this won't
* be very efficient, as it will get the AT from a map, which is also
* synchronized, so here, we have a very minimal cost.
*
* We can't do it once as a static part in the body of this class, because
* the access to the registries is mandatory to get back the AttributeType.
*/
private void initObjectClassAT()
{
if ( schemaManager == null )
{
return;
}
try
{
synchronized ( MUTEX )
{
if ( objectClassAttributeType == null )
{
objectClassAttributeType = schemaManager
.lookupAttributeTypeRegistry( SchemaConstants.OBJECT_CLASS_AT );
}
}
}
catch ( LdapException ne )
{
// do nothing...
}
}
/**
* normalizes the given Dn if it was not already normalized
*
* @param dn the Dn to be normalized
*/
private void normalizeDN( Dn dn )
{
if ( !dn.isSchemaAware() )
{
try
{
// The dn must be normalized
dn.apply( schemaManager );
}
catch ( LdapException ne )
{
LOG.warn( "The Dn '{}' cannot be normalized", dn );
}
}
}
/**
* A helper method to recompute the hash code
*/
private void rehash()
{
h = 37;
h = h * 17 + dn.hashCode();
}
/**
* Add a new EntryAttribute, with its upId. If the upId is null,
* default to the AttributeType name.
*
* Updates the AttributeMap.
*/
protected void createAttribute( String upId, AttributeType attributeType, byte[]... values )
throws LdapInvalidAttributeValueException
{
Attribute attribute = new DefaultAttribute( attributeType, values );
attribute.setUpId( upId, attributeType );
attributes.put( attributeType.getOid(), attribute );
}
/**
* Add a new EntryAttribute, with its upId. If the upId is null,
* default to the AttributeType name.
*
* Updates the AttributeMap.
*/
protected void createAttribute( String upId, AttributeType attributeType, String... values )
throws LdapInvalidAttributeValueException
{
Attribute attribute = new DefaultAttribute( attributeType, values );
attribute.setUpId( upId, attributeType );
attributes.put( attributeType.getOid(), attribute );
}
/**
* Add a new EntryAttribute, with its upId. If the upId is null,
* default to the AttributeType name.
*
* Updates the AttributeMap.
*/
protected void createAttribute( String upId, AttributeType attributeType, Value<?>... values )
throws LdapInvalidAttributeValueException
{
Attribute attribute = new DefaultAttribute( attributeType, values );
attribute.setUpId( upId, attributeType );
attributes.put( attributeType.getOid(), attribute );
}
/**
* Returns the attributeType from an Attribute ID.
*/
protected AttributeType getAttributeType( String upId ) throws LdapException
{
if ( Strings.isEmpty( Strings.trim( upId ) ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
return schemaManager.lookupAttributeTypeRegistry( upId );
}
//-------------------------------------------------------------------------
// Entry methods
//-------------------------------------------------------------------------
/**
* {@inheritDoc}
*/
public Entry add( AttributeType attributeType, byte[]... values ) throws LdapException
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( ( values == null ) || ( values.length == 0 ) )
{
String message = I18n.err( I18n.ERR_04478_NO_VALUE_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
// ObjectClass with binary values are not allowed
if ( attributeType.equals( objectClassAttributeType ) )
{
String message = I18n.err( I18n.ERR_04461 );
LOG.error( message );
throw new UnsupportedOperationException( message );
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
}
else
{
// We have to create a new Attribute and set the values.
// The upId, which is set to null, will be setup by the
// createAttribute method
createAttribute( null, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( AttributeType attributeType, String... values ) throws LdapException
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
}
else
{
// We have to create a new Attribute and set the values.
// The upId, which is set to null, will be setup by the
// createAttribute method
createAttribute( null, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( AttributeType attributeType, Value<?>... values ) throws LdapException
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
}
else
{
// We have to create a new Attribute and set the values.
// The upId, which is set to null, will be setup by the
// createAttribute method
createAttribute( null, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, AttributeType attributeType, byte[]... values ) throws LdapException
{
// ObjectClass with binary values are not allowed
if ( attributeType.equals( objectClassAttributeType ) )
{
String message = I18n.err( I18n.ERR_04461 );
LOG.error( message );
throw new UnsupportedOperationException( message );
}
Attribute attribute = attributes.get( attributeType.getOid() );
String id = getUpId( upId, attributeType );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
attribute.setUpId( id, attributeType );
}
else
{
// We have to create a new Attribute and set the values
// and the upId
createAttribute( id, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, AttributeType attributeType, Value<?>... values ) throws LdapException
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
String id = getUpId( upId, attributeType );
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
attribute.setUpId( id, attributeType );
}
else
{
createAttribute( id, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, AttributeType attributeType, String... values ) throws LdapException
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
String id = getUpId( upId, attributeType );
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it
attribute.add( values );
attribute.setUpId( id, attributeType );
}
else
{
// We have to create a new Attribute and set the values
// and the upId
createAttribute( id, attributeType, values );
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( Attribute... attributes ) throws LdapException
{
// Loop on all the added attributes
for ( Attribute attribute : attributes )
{
AttributeType attributeType = attribute.getAttributeType();
if ( attributeType != null )
{
String oid = attributeType.getOid();
if ( this.attributes.containsKey( oid ) )
{
// We already have an attribute with the same AttributeType
// Just add the new values into it.
Attribute existingAttribute = this.attributes.get( oid );
for ( Value<?> value : attribute )
{
existingAttribute.add( value );
}
// And update the upId
existingAttribute.setUpId( attribute.getUpId() );
}
else
{
// The attributeType does not exist, add it
this.attributes.put( oid, attribute );
}
}
else
{
// If the attribute already exist, we will add the new values.
if ( contains( attribute ) )
{
Attribute existingAttribute = get( attribute.getId() );
// Loop on all the values, and add them to the existing attribute
for ( Value<?> value : attribute )
{
existingAttribute.add( value );
}
}
else
{
// Stores the attribute into the entry
this.attributes.put( attribute.getId(), attribute );
}
}
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, byte[]... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
// First, transform the upID to a valid ID
String id = getId( upId );
if ( schemaManager != null )
{
add( upId, schemaManager.lookupAttributeTypeRegistry( id ), values );
}
else
{
// Now, check to see if we already have such an attribute
Attribute attribute = attributes.get( id );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it. (If the values already exists, they will
// not be added, but this is done in the add() method)
attribute.add( values );
attribute.setUpId( upId );
}
else
{
// We have to create a new Attribute and set the values
// and the upId
attributes.put( id, new DefaultAttribute( upId, values ) );
}
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, String... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
// First, transform the upID to a valid ID
String id = getId( upId );
if ( schemaManager != null )
{
add( upId, schemaManager.lookupAttributeTypeRegistry( upId ), values );
}
else
{
// Now, check to see if we already have such an attribute
Attribute attribute = attributes.get( id );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it. (If the values already exists, they will
// not be added, but this is done in the add() method)
attribute.add( values );
attribute.setUpId( upId );
}
else
{
// We have to create a new Attribute and set the values
// and the upId
attributes.put( id, new DefaultAttribute( upId, values ) );
}
}
return this;
}
/**
* {@inheritDoc}
*/
public Entry add( String upId, Value<?>... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
// First, transform the upID to a valid ID
String id = getId( upId );
if ( schemaManager != null )
{
add( upId, schemaManager.lookupAttributeTypeRegistry( upId ), values );
}
else
{
// Now, check to see if we already have such an attribute
Attribute attribute = attributes.get( id );
if ( attribute != null )
{
// This Attribute already exist, we add the values
// into it. (If the values already exists, they will
// not be added, but this is done in the add() method)
attribute.add( values );
attribute.setUpId( upId );
}
else
{
// We have to create a new Attribute and set the values
// and the upId
attributes.put( id, new DefaultAttribute( upId, values ) );
}
}
return this;
}
/**
* Clone an entry. 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
*/
public Entry clone()
{
// First, clone the structure
DefaultEntry clone = ( DefaultEntry ) shallowClone();
// now clone all the attributes
clone.attributes.clear();
if ( schemaManager != null )
{
for ( Attribute attribute : attributes.values() )
{
String oid = attribute.getAttributeType().getOid();
clone.attributes.put( oid, attribute.clone() );
}
}
else
{
for ( Attribute attribute : attributes.values() )
{
clone.attributes.put( attribute.getId(), attribute.clone() );
}
}
// We are done !
return clone;
}
/**
* Shallow clone an entry. We don't clone the Attributes
*/
@SuppressWarnings("unchecked")
public Entry shallowClone()
{
try
{
// First, clone the structure
DefaultEntry clone = ( DefaultEntry ) super.clone();
// Just in case ... Should *never* happen
if ( clone == null )
{
return null;
}
// An Entry has a Dn and many attributes.
clone.dn = dn; // note that Dn is immutable now
// then clone the ClientAttribute Map.
clone.attributes = ( Map<String, Attribute> ) ( ( ( HashMap<String, Attribute> ) attributes )
.clone() );
// We are done !
return clone;
}
catch ( CloneNotSupportedException cnse )
{
return null;
}
}
/**
* {@inheritDoc}
*/
public boolean contains( Attribute... attributes )
{
if ( schemaManager == null )
{
for ( Attribute attribute : attributes )
{
if ( attribute == null )
{
return this.attributes.size() == 0;
}
if ( !this.attributes.containsKey( attribute.getId() ) )
{
return false;
}
}
}
else
{
for ( Attribute entryAttribute : attributes )
{
if ( entryAttribute == null )
{
return this.attributes.size() == 0;
}
AttributeType attributeType = entryAttribute.getAttributeType();
if ( ( attributeType == null ) || !this.attributes.containsKey( attributeType.getOid() ) )
{
return false;
}
}
}
return true;
}
/**
* {@inheritDoc}
*/
public boolean containsAttribute( String... attributes )
{
if ( schemaManager == null )
{
for ( String attribute : attributes )
{
String id = getId( attribute );
if ( !this.attributes.containsKey( id ) )
{
return false;
}
}
return true;
}
else
{
for ( String attribute : attributes )
{
try
{
if ( !containsAttribute( schemaManager.lookupAttributeTypeRegistry( attribute ) ) )
{
return false;
}
}
catch ( LdapException ne )
{
return false;
}
}
return true;
}
}
/**
* {@inheritDoc}
*/
public boolean containsAttribute( AttributeType attributeType )
{
if ( attributeType == null )
{
return false;
}
return attributes.containsKey( attributeType.getOid() );
}
/**
* {@inheritDoc}
*/
public boolean contains( AttributeType attributeType, byte[]... values )
{
if ( attributeType == null )
{
return false;
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
return attribute.contains( values );
}
else
{
return false;
}
}
/**
* {@inheritDoc}
*/
public boolean contains( AttributeType attributeType, String... values )
{
if ( attributeType == null )
{
return false;
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
return attribute.contains( values );
}
else
{
return false;
}
}
/**
* {@inheritDoc}
*/
public boolean contains( AttributeType attributeType, Value<?>... values )
{
if ( attributeType == null )
{
return false;
}
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute != null )
{
return attribute.contains( values );
}
else
{
return false;
}
}
/**
* {@inheritDoc}
*/
public boolean contains( String upId, byte[]... values )
{
if ( Strings.isEmpty( upId ) )
{
return false;
}
String id = getId( upId );
if ( schemaManager != null )
{
try
{
return contains( schemaManager.lookupAttributeTypeRegistry( id ), values );
}
catch ( LdapException le )
{
return false;
}
}
Attribute attribute = attributes.get( id );
if ( attribute == null )
{
return false;
}
return attribute.contains( values );
}
/**
* {@inheritDoc}
*/
public boolean contains( String upId, String... values )
{
if ( Strings.isEmpty( upId ) )
{
return false;
}
String id = getId( upId );
if ( schemaManager != null )
{
try
{
return contains( schemaManager.lookupAttributeTypeRegistry( id ), values );
}
catch ( LdapException le )
{
return false;
}
}
Attribute attribute = attributes.get( id );
if ( attribute == null )
{
return false;
}
return attribute.contains( values );
}
/**
* {@inheritDoc}
*/
public boolean contains( String upId, Value<?>... values )
{
if ( Strings.isEmpty( upId ) )
{
return false;
}
String id = getId( upId );
if ( schemaManager != null )
{
try
{
return contains( schemaManager.lookupAttributeTypeRegistry( id ), values );
}
catch ( LdapException le )
{
return false;
}
}
Attribute attribute = attributes.get( id );
if ( attribute == null )
{
return false;
}
return attribute.contains( values );
}
/**
* {@inheritDoc}
*/
public Attribute get( String alias )
{
try
{
String id = getId( alias );
if ( schemaManager != null )
{
try
{
AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( id );
return attributes.get( attributeType.getOid() );
}
catch ( LdapException ne )
{
String message = ne.getLocalizedMessage();
LOG.error( message );
return null;
}
}
else
{
return attributes.get( id );
}
}
catch ( IllegalArgumentException iea )
{
LOG.error( I18n.err( I18n.ERR_04134, alias ) );
return null;
}
}
/**
* {@inheritDoc}
*/
public Attribute get( AttributeType attributeType )
{
if ( attributeType != null )
{
return attributes.get( attributeType.getOid() );
}
else
{
return null;
}
}
/**
* {@inheritDoc}
*/
public Collection<Attribute> getAttributes()
{
return Collections.unmodifiableMap( attributes ).values();
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, byte[]... values )
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( schemaManager == null )
{
// Get the normalized form of the ID
String id = getId( upId );
// Create a new attribute
Attribute clientAttribute = new DefaultAttribute( upId, values );
// Replace the previous one, and return it back
return attributes.put( id, clientAttribute );
}
else
{
try
{
return put( upId, getAttributeType( upId ), values );
}
catch ( LdapException ne )
{
String message = I18n.err( I18n.ERR_04464, upId, ne.getLocalizedMessage() );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, String... values )
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( schemaManager == null )
{
// Get the normalized form of the ID
String id = getId( upId );
// Create a new attribute
Attribute clientAttribute = new DefaultAttribute( upId, values );
// Replace the previous one, and return it back
return attributes.put( id, clientAttribute );
}
else
{
try
{
return put( upId, getAttributeType( upId ), values );
}
catch ( LdapException ne )
{
String message = I18n.err( I18n.ERR_04464, upId, ne.getLocalizedMessage() );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, Value<?>... values )
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( schemaManager == null )
{
// Get the normalized form of the ID
String id = getId( upId );
// Create a new attribute
Attribute clientAttribute = new DefaultAttribute( upId, values );
// Replace the previous one, and return it back
return attributes.put( id, clientAttribute );
}
else
{
try
{
return put( upId, getAttributeType( upId ), values );
}
catch ( LdapException ne )
{
String message = I18n.err( I18n.ERR_04464, upId, ne.getLocalizedMessage() );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
}
/**
* {@inheritDoc}
**
public List<Attribute> set( AttributeType... attributeTypes )
{
List<Attribute> removed = new ArrayList<Attribute>();
// Now, loop on all the attributeType to add
for ( AttributeType attributeType : attributeTypes )
{
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04467 );
LOG.error( message );
continue;
}
Attribute attribute = attributes.put( attributeType.getOid(),
new DefaultAttribute( attributeType ) );
if ( attribute != null )
{
removed.add( attribute );
}
}
if ( removed.size() == 0 )
{
return null;
}
else
{
return removed;
}
}
/**
* {@inheritDoc}
*/
public List<Attribute> put( Attribute... attributes ) throws LdapException
{
// First, get the existing attributes
List<Attribute> previous = new ArrayList<Attribute>();
if ( schemaManager == null )
{
for ( Attribute attribute : attributes )
{
String id = attribute.getId();
if ( containsAttribute( id ) )
{
// Store the attribute and remove it from the list
previous.add( get( id ) );
this.attributes.remove( id );
}
// add the new one
this.attributes.put( id, attribute );
}
}
else
{
for ( Attribute attribute : attributes )
{
if ( attribute == null )
{
String message = I18n.err( I18n.ERR_04462 );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( attribute.getAttributeType() == null )
{
AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( attribute.getId() );
attribute.apply( attributeType );
}
Attribute removed = this.attributes.put( attribute.getAttributeType().getOid(), attribute );
if ( removed != null )
{
previous.add( removed );
}
}
}
// return the previous attributes
return previous;
}
/**
* {@inheritDoc}
*/
public Attribute put( AttributeType attributeType, byte[]... values ) throws LdapException
{
return put( null, attributeType, values );
}
/**
* {@inheritDoc}
*/
public Attribute put( AttributeType attributeType, String... values ) throws LdapException
{
return put( null, attributeType, values );
}
/**
* {@inheritDoc}
*/
public Attribute put( AttributeType attributeType, Value<?>... values ) throws LdapException
{
return put( null, attributeType, values );
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, AttributeType attributeType, byte[]... values ) throws LdapException
{
if ( attributeType == null )
{
try
{
attributeType = getAttributeType( upId );
}
catch ( Exception e )
{
String message = I18n.err( I18n.ERR_04477_NO_VALID_AT_FOR_THIS_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
if ( !Strings.isEmpty( upId ) )
{
AttributeType tempAT = getAttributeType( upId );
if ( !tempAT.equals( attributeType ) )
{
String message = I18n.err( I18n.ERR_04463, upId, attributeType );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
upId = getUpId( upId, attributeType );
}
}
if ( attributeType.equals( objectClassAttributeType ) )
{
String message = I18n.err( I18n.ERR_04461 );
LOG.error( message );
throw new UnsupportedOperationException( message );
}
Attribute attribute = new DefaultAttribute( upId, attributeType, values );
return attributes.put( attributeType.getOid(), attribute );
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, AttributeType attributeType, String... values ) throws LdapException
{
if ( attributeType == null )
{
try
{
attributeType = getAttributeType( upId );
}
catch ( Exception e )
{
String message = I18n.err( I18n.ERR_04477_NO_VALID_AT_FOR_THIS_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
if ( !Strings.isEmpty( upId ) )
{
AttributeType tempAT = getAttributeType( upId );
if ( !tempAT.equals( attributeType ) )
{
String message = I18n.err( I18n.ERR_04463, upId, attributeType );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
upId = getUpId( upId, attributeType );
}
}
Attribute attribute = new DefaultAttribute( upId, attributeType, values );
return attributes.put( attributeType.getOid(), attribute );
}
/**
* {@inheritDoc}
*/
public Attribute put( String upId, AttributeType attributeType, Value<?>... values ) throws LdapException
{
if ( attributeType == null )
{
try
{
attributeType = getAttributeType( upId );
}
catch ( Exception e )
{
String message = I18n.err( I18n.ERR_04477_NO_VALID_AT_FOR_THIS_ID );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
if ( !Strings.isEmpty( upId ) )
{
AttributeType tempAT = getAttributeType( upId );
if ( !tempAT.equals( attributeType ) )
{
String message = I18n.err( I18n.ERR_04463, upId, attributeType );
LOG.error( message );
throw new IllegalArgumentException( message );
}
}
else
{
upId = getUpId( upId, attributeType );
}
}
Attribute attribute = new DefaultAttribute( upId, attributeType, values );
return attributes.put( attributeType.getOid(), attribute );
}
/**
* {@inheritDoc}
*/
public List<Attribute> remove( Attribute... attributes ) throws LdapException
{
List<Attribute> removedAttributes = new ArrayList<Attribute>();
if ( schemaManager == null )
{
for ( Attribute attribute : attributes )
{
if ( containsAttribute( attribute.getId() ) )
{
this.attributes.remove( attribute.getId() );
removedAttributes.add( attribute );
}
}
}
else
{
for ( Attribute attribute : attributes )
{
AttributeType attributeType = attribute.getAttributeType();
if ( attributeType == null )
{
String message = I18n.err( I18n.ERR_04460_ATTRIBUTE_TYPE_NULL_NOT_ALLOWED );
LOG.error( message );
throw new IllegalArgumentException( message );
}
if ( this.attributes.containsKey( attributeType.getOid() ) )
{
this.attributes.remove( attributeType.getOid() );
removedAttributes.add( attribute );
}
}
}
return removedAttributes;
}
/**
* {@inheritDoc}
*/
public boolean remove( AttributeType attributeType, byte[]... values ) throws LdapException
{
if ( attributeType == null )
{
return false;
}
try
{
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( attributeType.getOid() );
return true;
}
return nbOldValues != attribute.size();
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04465, attributeType ) );
return false;
}
}
/**
* {@inheritDoc}
*/
public boolean remove( AttributeType attributeType, String... values ) throws LdapException
{
if ( attributeType == null )
{
return false;
}
try
{
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( attributeType.getOid() );
return true;
}
return nbOldValues != attribute.size();
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04465, attributeType ) );
return false;
}
}
/**
* {@inheritDoc}
*/
public boolean remove( AttributeType attributeType, Value<?>... values ) throws LdapException
{
if ( attributeType == null )
{
return false;
}
try
{
Attribute attribute = attributes.get( attributeType.getOid() );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( attributeType.getOid() );
return true;
}
return nbOldValues != attribute.size();
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04465, attributeType ) );
return false;
}
}
/**
* <p>
* Removes the attribute with the specified AttributeTypes.
* </p>
* <p>
* The removed attribute are returned by this method.
* </p>
* <p>
* If there is no attribute with the specified AttributeTypes,
* the return value is <code>null</code>.
* </p>
*
* @param attributes the AttributeTypes to be removed
* @return the removed attributes, if any, as a list; otherwise <code>null</code>
*/
public void removeAttributes( AttributeType... attributes )
{
if ( ( attributes == null ) || ( attributes.length == 0 ) || ( schemaManager == null ) )
{
return;
}
for ( AttributeType attributeType : attributes )
{
if ( attributeType == null )
{
continue;
}
this.attributes.remove( attributeType.getOid() );
}
}
/**
* {@inheritDoc}
*/
public void removeAttributes( String... attributes )
{
if ( attributes.length == 0 )
{
return;
}
if ( schemaManager == null )
{
for ( String attribute : attributes )
{
Attribute attr = get( attribute );
if ( attr != null )
{
this.attributes.remove( attr.getId() );
}
else
{
String message = I18n.err( I18n.ERR_04137, attribute );
LOG.warn( message );
continue;
}
}
}
else
{
for ( String attribute : attributes )
{
AttributeType attributeType = null;
try
{
attributeType = schemaManager.lookupAttributeTypeRegistry( attribute );
}
catch ( LdapException ne )
{
String message = "The attribute '" + attribute + "' does not exist in the entry";
LOG.warn( message );
continue;
}
this.attributes.remove( attributeType.getOid() );
}
}
}
/**
* <p>
* Removes the specified binary values from an attribute.
* </p>
* <p>
* If at least one value is removed, this method returns <code>true</code>.
* </p>
* <p>
* If there is no more value after having removed the values, the attribute
* will be removed too.
* </p>
* <p>
* If the attribute does not exist, nothing is done and the method returns
* <code>false</code>
* </p>
*
* @param upId The attribute ID
* @param values the values to be removed
* @return <code>true</code> if at least a value is removed, <code>false</code>
* if not all the values have been removed or if the attribute does not exist.
*/
public boolean remove( String upId, byte[]... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.info( message );
return false;
}
if ( schemaManager == null )
{
String id = getId( upId );
Attribute attribute = get( id );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( id );
return true;
}
return nbOldValues != attribute.size();
}
else
{
try
{
AttributeType attributeType = getAttributeType( upId );
return remove( attributeType, values );
}
catch ( LdapException ne )
{
LOG.error( I18n.err( I18n.ERR_04465, upId ) );
return false;
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04466, upId ) );
return false;
}
}
}
/**
* <p>
* Removes the specified String values from an attribute.
* </p>
* <p>
* If at least one value is removed, this method returns <code>true</code>.
* </p>
* <p>
* If there is no more value after having removed the values, the attribute
* will be removed too.
* </p>
* <p>
* If the attribute does not exist, nothing is done and the method returns
* <code>false</code>
* </p>
*
* @param upId The attribute ID
* @param values the attributes to be removed
* @return <code>true</code> if at least a value is removed, <code>false</code>
* if not all the values have been removed or if the attribute does not exist.
*/
public boolean remove( String upId, String... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.info( message );
return false;
}
if ( schemaManager == null )
{
String id = getId( upId );
Attribute attribute = get( id );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( id );
return true;
}
return nbOldValues != attribute.size();
}
else
{
try
{
AttributeType attributeType = getAttributeType( upId );
return remove( attributeType, values );
}
catch ( LdapException ne )
{
LOG.error( I18n.err( I18n.ERR_04465, upId ) );
return false;
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04466, upId ) );
return false;
}
}
}
/**
* <p>
* Removes the specified values from an attribute.
* </p>
* <p>
* If at least one value is removed, this method returns <code>true</code>.
* </p>
* <p>
* If there is no more value after having removed the values, the attribute
* will be removed too.
* </p>
* <p>
* If the attribute does not exist, nothing is done and the method returns
* <code>false</code>
* </p>
*
* @param upId The attribute ID
* @param values the attributes to be removed
* @return <code>true</code> if at least a value is removed, <code>false</code>
* if not all the values have been removed or if the attribute does not exist.
*/
public boolean remove( String upId, Value<?>... values ) throws LdapException
{
if ( Strings.isEmpty( upId ) )
{
String message = I18n.err( I18n.ERR_04457_NULL_ATTRIBUTE_ID );
LOG.info( message );
return false;
}
if ( schemaManager == null )
{
String id = getId( upId );
Attribute attribute = get( id );
if ( attribute == null )
{
// Can't remove values from a not existing attribute !
return false;
}
int nbOldValues = attribute.size();
// Remove the values
attribute.remove( values );
if ( attribute.size() == 0 )
{
// No mare values, remove the attribute
attributes.remove( id );
return true;
}
return nbOldValues != attribute.size();
}
else
{
try
{
AttributeType attributeType = getAttributeType( upId );
return remove( attributeType, values );
}
catch ( LdapException ne )
{
LOG.error( I18n.err( I18n.ERR_04465, upId ) );
return false;
}
catch ( IllegalArgumentException iae )
{
LOG.error( I18n.err( I18n.ERR_04466, upId ) );
return false;
}
}
}
/**
* Get this entry's Dn.
*
* @return The entry's Dn
*/
public Dn getDn()
{
return dn;
}
/**
* {@inheritDoc}
*/
public void setDn( Dn dn )
{
this.dn = dn;
// Rehash the object
rehash();
}
/**
* {@inheritDoc}
*/
public void setDn( String dn ) throws LdapInvalidDnException
{
setDn( new Dn( dn ) );
}
/**
* Remove all the attributes for this entry. The Dn is not reset
*/
public void clear()
{
attributes.clear();
}
/**
* Returns an enumeration containing the zero or more attributes in the
* collection. The behavior of the enumeration is not specified if the
* attribute collection is changed.
*
* @return an enumeration of all contained attributes
*/
public Iterator<Attribute> iterator()
{
return Collections.unmodifiableMap( attributes ).values().iterator();
}
/**
* Returns the number of attributes.
*
* @return the number of attributes
*/
public int size()
{
return attributes.size();
}
/**
* This is the place where we serialize entries, and all theirs
* elements.
* <br/>
* The structure used to store the entry is the following :
* <ul>
* <li>
* <b>[Dn]</b> : If it's null, stores an empty Dn
* </li>
* <li>
* <b>[attributes number]</b> : the number of attributes.
* </li>
* <li>
* <b>[attribute]*</b> : each attribute, if we have some
* </li>
* </ul>
*
* {@inheritDoc}
*/
public void writeExternal( ObjectOutput out ) throws IOException
{
// First, the Dn
if ( dn == null )
{
// Write an empty Dn
Dn.EMPTY_DN.writeExternal( out );
}
else
{
// Write the Dn
dn.writeExternal( out );
}
// Then the attributes.
// Store the attributes' nulber first
out.writeInt( attributes.size() );
// Iterate through the keys.
for ( Attribute attribute : attributes.values() )
{
// Store the attribute
attribute.writeExternal( out );
}
out.flush();
}
/**
* {@inheritDoc}
*/
public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
{
// Read the Dn
dn = new Dn( schemaManager );
dn.readExternal( in );
// Read the number of attributes
int nbAttributes = in.readInt();
// Read the attributes
for ( int i = 0; i < nbAttributes; i++ )
{
// Read each attribute
Attribute attribute = new DefaultAttribute();
attribute.readExternal( in );
if ( schemaManager != null )
{
try
{
AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( attribute.getId() );
attribute.apply( attributeType );
attributes.put( attributeType.getOid(), attribute );
}
catch ( LdapException le )
{
String message = le.getLocalizedMessage();
LOG.error( message );
throw new IOException( message );
}
}
else
{
attributes.put( attribute.getId(), attribute );
}
}
}
/**
* Get the hash code of this ClientEntry. The Attributes will be sorted
* before the comparison can be done.
*
* @see java.lang.Object#hashCode()
* @return the instance's hash code
*/
public int hashCode()
{
if ( h == 0 )
{
rehash();
}
return h;
}
/**
* {@inheritDoc}
*/
public boolean hasObjectClass( String... objectClasses )
{
if ( ( objectClasses == null ) || ( objectClasses.length == 0 ) || ( objectClasses[0] == null ) )
{
return false;
}
for ( String objectClass : objectClasses )
{
if ( schemaManager != null )
{
if ( !contains( objectClassAttributeType, objectClass ) )
{
return false;
}
}
else
{
if ( !contains( "objectclass", objectClass ) )
{
return false;
}
}
}
return true;
}
/**
* {@inheritDoc}
*/
public boolean hasObjectClass( Attribute... objectClasses )
{
if ( ( objectClasses == null ) || ( objectClasses.length == 0 ) || ( objectClasses[0] == null ) )
{
return false;
}
for ( Attribute objectClass : objectClasses )
{
// We have to check that we are checking the ObjectClass attributeType
if ( !objectClass.getAttributeType().equals( objectClassAttributeType ) )
{
return false;
}
Attribute attribute = attributes.get( objectClassAttributeType.getOid() );
if ( attribute == null )
{
// The entry does not have an ObjectClass attribute
return false;
}
for ( Value<?> value : objectClass )
{
// Loop on all the values, and check if they are present
if ( !attribute.contains( value.getString() ) )
{
return false;
}
}
}
return true;
}
/**
* {@inheritDoc}
*/
public boolean isSchemaAware()
{
return schemaManager != null;
}
/**
* @see Object#equals(Object)
*/
public boolean equals( Object o )
{
// Short circuit
if ( this == o )
{
return true;
}
if ( !( o instanceof Entry ) )
{
return false;
}
Entry other = ( Entry ) o;
// Both Dn must be equal
if ( dn == null )
{
if ( other.getDn() != null )
{
return false;
}
}
else
{
if ( !dn.equals( other.getDn() ) )
{
return false;
}
}
// They must have the same number of attributes
if ( size() != other.size() )
{
return false;
}
// Each attribute must be equal
for ( Attribute attribute : other )
{
if ( !attribute.equals( this.get( attribute.getId() ) ) )
{
return false;
}
}
return true;
}
/**
* @see Object#toString()
*/
public String toString()
{
return toString( "" );
}
/**
* {@inheritDoc}
*/
public String toString( String tabs )
{
StringBuilder sb = new StringBuilder();
sb.append( tabs ).append( "Entry\n" );
sb.append( tabs ).append( " dn" );
if ( dn.isSchemaAware() )
{
sb.append( "[n]" );
}
sb.append( ": " );
sb.append( dn.getName() );
sb.append( '\n' );
// First dump the ObjectClass attribute
if ( schemaManager != null )
{
// First dump the ObjectClass attribute
if ( containsAttribute( objectClassAttributeType.getOid() ) )
{
Attribute objectClass = get( objectClassAttributeType );
sb.append( objectClass.toString( tabs + " " ) );
}
}
else
{
if ( containsAttribute( "objectClass" ) )
{
Attribute objectClass = get( "objectclass" );
sb.append( objectClass.toString( tabs + " " ) );
}
}
sb.append( '\n' );
if ( attributes.size() != 0 )
{
boolean isFirst = true;
for ( Attribute attribute : attributes.values() )
{
if ( isFirst )
{
isFirst = false;
}
else
{
sb.append( '\n' );
}
String id = attribute.getId();
if ( schemaManager != null )
{
AttributeType attributeType = schemaManager.getAttributeType( id );
if ( attributeType == null )
{
sb.append( tabs + "id: " + id );
}
else if ( !attributeType.equals( objectClassAttributeType ) )
{
sb.append( attribute.toString( tabs + " " ) );
continue;
}
}
else
{
if ( !id.equalsIgnoreCase( SchemaConstants.OBJECT_CLASS_AT )
&& !id.equals( SchemaConstants.OBJECT_CLASS_AT_OID ) )
{
sb.append( attribute.toString( tabs + " " ) );
continue;
}
}
}
}
return sb.toString();
}
}