| /* |
| * 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 java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.naming.NamingException; |
| |
| import org.apache.directory.server.schema.registries.AttributeTypeRegistry; |
| import org.apache.directory.server.schema.registries.Registries; |
| import org.apache.directory.shared.ldap.NotImplementedException; |
| import org.apache.directory.shared.ldap.constants.SchemaConstants; |
| import org.apache.directory.shared.ldap.entry.AbstractEntry; |
| import org.apache.directory.shared.ldap.entry.Entry; |
| import org.apache.directory.shared.ldap.entry.EntryAttribute; |
| import org.apache.directory.shared.ldap.entry.Value; |
| import org.apache.directory.shared.ldap.entry.client.DefaultClientEntry; |
| import org.apache.directory.shared.ldap.name.LdapDN; |
| import org.apache.directory.shared.ldap.name.LdapDNSerializer; |
| 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 default implementation of a ServerEntry which should suite most |
| * use cases. |
| * |
| * This class is final, it should not be extended. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| * @version $Rev$, $Date$ |
| */ |
| public final class DefaultServerEntry extends AbstractEntry<AttributeType> implements ServerEntry |
| { |
| /** Used for serialization */ |
| private static final long serialVersionUID = 2L; |
| |
| /** The logger for this class */ |
| private static final Logger LOG = LoggerFactory.getLogger( DefaultServerEntry.class ); |
| |
| /** The AttributeType registries */ |
| private final transient AttributeTypeRegistry atRegistry; |
| |
| /** A speedup to get the ObjectClass attribute */ |
| private static transient AttributeType OBJECT_CLASS_AT; |
| |
| /** A mutex to manage synchronization*/ |
| private static transient Object MUTEX = new Object(); |
| |
| |
| //------------------------------------------------------------------------- |
| // Helper methods |
| //------------------------------------------------------------------------- |
| /** |
| * Returns the attributeType from an Attribute ID. |
| */ |
| private AttributeType getAttributeType( String upId ) throws NamingException |
| { |
| if ( StringTools.isEmpty( StringTools.trim( upId ) ) ) |
| { |
| String message = "The ID should not be null or empty"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| return atRegistry.lookup( upId ); |
| } |
| |
| |
| /** |
| * Get the UpId if it was null. |
| */ |
| public static String getUpId( String upId, AttributeType attributeType ) |
| { |
| String normUpId = StringTools.trim( upId ); |
| |
| if ( ( attributeType == null ) ) |
| { |
| if ( StringTools.isEmpty( normUpId ) ) |
| { |
| String message = "Cannot add an attribute without an ID"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| else if ( StringTools.isEmpty( normUpId ) ) |
| { |
| upId = attributeType.getName(); |
| |
| if ( StringTools.isEmpty( upId ) ) |
| { |
| upId = attributeType.getOid(); |
| } |
| } |
| |
| 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( Registries registries ) |
| { |
| try |
| { |
| if ( OBJECT_CLASS_AT == null ) |
| { |
| synchronized ( MUTEX ) |
| { |
| OBJECT_CLASS_AT = atRegistry.lookup( SchemaConstants.OBJECT_CLASS_AT ); |
| } |
| } |
| } |
| catch ( NamingException ne ) |
| { |
| // do nothing... |
| } |
| } |
| |
| |
| /** |
| * Add a new ServerAttribute, with its upId. If the upId is null, |
| * default to the AttributeType name. |
| * |
| * Updates the serverAttributeMap. |
| */ |
| private void createAttribute( String upId, AttributeType attributeType, byte[]... values ) |
| { |
| ServerAttribute attribute = new DefaultServerAttribute( attributeType, values ); |
| attribute.setUpId( upId, attributeType ); |
| attributes.put( attributeType, attribute ); |
| } |
| |
| |
| /** |
| * Add a new ServerAttribute, with its upId. If the upId is null, |
| * default to the AttributeType name. |
| * |
| * Updates the serverAttributeMap. |
| */ |
| private void createAttribute( String upId, AttributeType attributeType, String... values ) |
| { |
| ServerAttribute attribute = new DefaultServerAttribute( attributeType, values ); |
| attribute.setUpId( upId, attributeType ); |
| attributes.put( attributeType, attribute ); |
| } |
| |
| |
| /** |
| * Add a new ServerAttribute, with its upId. If the upId is null, |
| * default to the AttributeType name. |
| * |
| * Updates the serverAttributeMap. |
| */ |
| private void createAttribute( String upId, AttributeType attributeType, Value<?>... values ) |
| { |
| ServerAttribute attribute = new DefaultServerAttribute( attributeType, values ); |
| attribute.setUpId( upId, attributeType ); |
| attributes.put( attributeType, attribute ); |
| } |
| |
| |
| //------------------------------------------------------------------------- |
| // Constructors |
| //------------------------------------------------------------------------- |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry. |
| * </p> |
| * <p> |
| * This entry <b>must</b> be initialized before being used ! |
| * </p> |
| */ |
| /* no protection ! */ DefaultServerEntry() |
| { |
| atRegistry = null; |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| |
| |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry, with registries. |
| * </p> |
| * <p> |
| * No attributes will be created. |
| * </p> |
| * |
| * @param registries The reference to the global registries |
| */ |
| public DefaultServerEntry( Registries registries ) |
| { |
| atRegistry = registries.getAttributeTypeRegistry(); |
| dn = LdapDN.EMPTY_LDAPDN; |
| |
| // Initialize the ObjectClass object |
| initObjectClassAT( registries ); |
| } |
| |
| |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry, copying |
| * another entry, which can be a ClientEntry. |
| * </p> |
| * <p> |
| * No attributes will be created. |
| * </p> |
| * |
| * @param registries The reference to the global registries |
| * @param entry the entry to copy |
| */ |
| public DefaultServerEntry( Registries registries, Entry entry ) |
| { |
| atRegistry = registries.getAttributeTypeRegistry(); |
| |
| // Initialize the ObjectClass object |
| initObjectClassAT( registries ); |
| |
| // We will clone the existing entry, because it may be normalized |
| if ( entry.getDn() != null ) |
| { |
| dn = (LdapDN)entry.getDn().clone(); |
| } |
| else |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| |
| if ( !dn.isNormalized( ) ) |
| { |
| try |
| { |
| // The dn must be normalized |
| dn.normalize( registries.getAttributeTypeRegistry().getNormalizerMapping() ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.warn( "The DN '" + entry.getDn() + "' cannot be normalized" ); |
| } |
| } |
| |
| // Init the attributes map |
| attributes = new HashMap<AttributeType, EntryAttribute>( entry.size() ); |
| |
| // and copy all the attributes |
| for ( EntryAttribute attribute:entry ) |
| { |
| try |
| { |
| // First get the AttributeType |
| AttributeType attributeType = null; |
| |
| if ( attribute instanceof ServerAttribute ) |
| { |
| attributeType = ((ServerAttribute)attribute).getAttributeType(); |
| } |
| else |
| { |
| attributeType = registries.getAttributeTypeRegistry().lookup( attribute.getId() ); |
| } |
| |
| // Create a new ServerAttribute. |
| EntryAttribute serverAttribute = new DefaultServerAttribute( attributeType, attribute ); |
| |
| // And store it |
| add( serverAttribute ); |
| } |
| catch ( NamingException ne ) |
| { |
| // Just log a warning |
| LOG.warn( "The attribute '" + attribute.getId() + "' cannot be stored" ); |
| } |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry, with a |
| * DN and registries. |
| * </p> |
| * <p> |
| * No attributes will be created. |
| * </p> |
| * |
| * @param registries The reference to the global registries |
| * @param dn The DN for this serverEntry. Can be null. |
| */ |
| public DefaultServerEntry( Registries registries, LdapDN dn ) |
| { |
| if ( dn == null ) |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| else |
| { |
| this.dn = dn; |
| } |
| |
| atRegistry = registries.getAttributeTypeRegistry(); |
| |
| // Initialize the ObjectClass object |
| initObjectClassAT( registries ); |
| } |
| |
| |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry, with a |
| * DN, registries and a list of attributeTypes. |
| * </p> |
| * <p> |
| * The newly created entry is fed with the list of attributeTypes. No |
| * values are associated with those attributeTypes. |
| * </p> |
| * <p> |
| * If any of the AttributeType does not exist, they it's simply discarded. |
| * </p> |
| * |
| * @param registries The reference to the global registries |
| * @param dn The DN for this serverEntry. Can be null. |
| * @param attributeTypes The list of attributes to create, without value. |
| */ |
| public DefaultServerEntry( Registries registries, LdapDN dn, AttributeType... attributeTypes ) |
| { |
| if ( dn == null ) |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| else |
| { |
| this.dn = dn; |
| } |
| |
| atRegistry = registries.getAttributeTypeRegistry(); |
| |
| // Initialize the ObjectClass object |
| initObjectClassAT( registries ); |
| |
| // Add the attributeTypes |
| set( attributeTypes ); |
| } |
| |
| |
| /** |
| * <p> |
| * Creates a new instance of DefaultServerEntry, with a |
| * DN, registries and an attributeType with the user provided ID. |
| * </p> |
| * <p> |
| * The newly created entry is fed with the given attributeType. No |
| * values are associated with this attributeType. |
| * </p> |
| * <p> |
| * If the AttributeType does not exist, they it's simply discarded. |
| * </p> |
| * <p> |
| * We also check that the normalized upID equals the AttributeType ID |
| * </p> |
| * |
| * @param registries The reference to the global registries |
| * @param dn The DN for this serverEntry. Can be null. |
| * @param attributeType The attribute to create, without value. |
| * @param upId The User Provided ID fro this AttributeType |
| */ |
| public DefaultServerEntry( Registries registries, LdapDN dn, AttributeType attributeType, String upId ) |
| { |
| if ( dn == null ) |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| else |
| { |
| this.dn = dn; |
| } |
| |
| atRegistry = registries.getAttributeTypeRegistry(); |
| // Initialize the ObjectClass object |
| |
| // Initialize the ObjectClass object |
| initObjectClassAT( registries ); |
| |
| try |
| { |
| put( upId, attributeType, (String)null ); |
| } |
| catch ( NamingException ne ) |
| { |
| // Just discard the AttributeType |
| LOG.error( "We have had an error while adding the '{}' AttributeType : {}", upId, ne.getMessage() ); |
| } |
| } |
| |
| |
| /** |
| * Creates a new instance of DefaultServerEntry, with a |
| * DN, registries and a list of IDs. |
| * <p> |
| * No attributes will be created except the ObjectClass attribute, |
| * which will contains "top". |
| * <p> |
| * If any of the AttributeType does not exist, they are simply discarded. |
| * |
| * @param registries The reference to the global registries |
| * @param dn The DN for this serverEntry. Can be null. |
| * @param upIds The list of attributes to create. |
| */ |
| public DefaultServerEntry( Registries registries, LdapDN dn, String... upIds ) |
| { |
| if ( dn == null ) |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| else |
| { |
| this.dn = dn; |
| } |
| |
| atRegistry = registries.getAttributeTypeRegistry(); |
| |
| initObjectClassAT( registries ); |
| |
| set( upIds ); |
| } |
| |
| |
| /** |
| * Creates a new instance of DefaultServerEntry, with a |
| * DN, registries and a list of ServerAttributes. |
| * <p> |
| * No attributes will be created except the ObjectClass attribute, |
| * which will contains "top". |
| * <p> |
| * If any of the AttributeType does not exist, they are simply discarded. |
| * |
| * @param registries The reference to the global registries |
| * @param dn The DN for this serverEntry. Can be null |
| * @param attributes The list of attributes to create |
| */ |
| public DefaultServerEntry( Registries registries, LdapDN dn, ServerAttribute... attributes ) |
| { |
| if ( dn == null ) |
| { |
| dn = LdapDN.EMPTY_LDAPDN; |
| } |
| else |
| { |
| this.dn = dn; |
| } |
| |
| atRegistry = registries.getAttributeTypeRegistry(); |
| |
| initObjectClassAT( registries ); |
| |
| for ( ServerAttribute attribute:attributes ) |
| { |
| // Store a new ServerAttribute |
| try |
| { |
| put( attribute ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.warn( "The ServerAttribute '{}' does not exist. It has been discarded", attribute ); |
| } |
| } |
| } |
| |
| |
| //------------------------------------------------------------------------- |
| // API |
| //------------------------------------------------------------------------- |
| /** |
| * <p> |
| * Add an attribute (represented by its AttributeType and some binary values) into an |
| * entry. |
| * </p> |
| * <p> |
| * If we already have an attribute with the same values, nothing is done |
| * (duplicated values are not allowed) |
| * </p> |
| * <p> |
| * If the value cannot be added, or if the AttributeType is null or invalid, |
| * a NamingException is thrown. |
| * </p> |
| * |
| * @param attributeType The attribute Type. |
| * @param values The list of binary values to inject. It can be empty. |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( AttributeType attributeType, byte[]... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| // ObjectClass with binary values are not allowed |
| if ( attributeType.equals( OBJECT_CLASS_AT ) ) |
| { |
| String message = "Only String values supported for objectClass attribute"; |
| LOG.error( message ); |
| throw new UnsupportedOperationException( message ); |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Add an attribute (represented by its AttributeType and some String values) into an |
| * entry. |
| * </p> |
| * <p> |
| * If we already have an attribute with public the same value, nothing is done |
| * (duplicated values are not allowed) |
| * </p> |
| * <p>public |
| * If the value cannot be added, or if the AttributeType is null or invalid, |
| * a NamingException is thrown. |
| * </p> |
| *public |
| * @param attributeType The attribute Type |
| * @param values The list of binary values to inject. It can be empty |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( AttributeType attributeType, String... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Add an attribute (represented by its AttributeType and some values) into an |
| * entry. |
| * </p> |
| * <p> |
| * If we already have an attribute with the same value, nothing is done. |
| * (duplicated values are not allowed) |
| * </p> |
| * <p> |
| * If the value cannot be added, or if the AttributeType is null or invalid, |
| * a NamingException is thrown. |
| * </p> |
| * |
| * @param attributeType The attribute Type |
| * @param values The list of binary values to inject. It can be empty |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( AttributeType attributeType, Value<?>... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| } |
| } |
| |
| |
| /** |
| * Add some EntryAttributes to the current Entry. |
| * |
| * @param attributes The attributes to add |
| * @throws NamingException If we can't add any of the attributes |
| */ |
| public void add( EntryAttribute... attributes ) throws NamingException |
| { |
| for ( EntryAttribute attribute:attributes ) |
| { |
| ServerAttribute serverAttribute = (ServerAttribute)attribute; |
| AttributeType attributeType = serverAttribute.getAttributeType(); |
| |
| if ( this.attributes.containsKey( attributeType ) ) |
| { |
| // We already have an attribute with the same AttributeType |
| // Just add the new values into it. |
| EntryAttribute oldAttribute = this.attributes.get( attributeType ); |
| |
| for ( Value<?> value:serverAttribute ) |
| { |
| oldAttribute.add( value ); |
| } |
| |
| // And update the upId |
| oldAttribute.setUpId( serverAttribute.getUpId() ); |
| } |
| else |
| { |
| // The attributeType does not exist, add it |
| this.attributes.put( attributeType, attribute ); |
| } |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Add an attribute (represented by its AttributeType and some binary values) into an |
| * entry. Set the User Provider ID at the same time |
| * </p> |
| * <p> |
| * If we already have an attribute with the same values, nothing is done |
| * (duplicated values are not allowed) |
| * </p> |
| * <p> |
| * If the value cannot be added, or if the AttributeType is null or invalid, |
| * a NamingException is thrown. |
| * </p> |
| * |
| * @param upId The user provided ID for the added AttributeType |
| * @param attributeType The attribute Type. |
| * @param values The list of binary values to add. It can be empty. |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( String upId, AttributeType attributeType, byte[]... values ) throws NamingException |
| { |
| // ObjectClass with binary values are not allowed |
| if ( attributeType.equals( OBJECT_CLASS_AT ) ) |
| { |
| String message = "Only String values supported for objectClass attribute"; |
| LOG.error( message ); |
| throw new UnsupportedOperationException( message ); |
| } |
| |
| ServerAttribute attribute = (ServerAttribute)attributes.get( attributeType ); |
| |
| upId = getUpId( upId, attributeType ); |
| |
| if ( attribute != null ) |
| { |
| // This Attribute already exist, we add the values |
| // into it |
| attribute.add( values ); |
| attribute.setUpId( upId, attributeType ); |
| } |
| else |
| { |
| // We have to create a new Attribute and set the values |
| // and the upId |
| createAttribute( upId, attributeType, values ); |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Add an attribute (represented by its AttributeType and some values) into an |
| * entry. Set the User Provider ID at the same time |
| * </p> |
| * <p> |
| * If we already have an attribute with the same values, nothing is done |
| * (duplicated values are not allowed) |
| * </p> |
| * <p> |
| * If the value cannot be added, or if the AttributeType is null or invalid, |
| * a NamingException is thrown. |
| * </p> |
| * |
| * @param upId The user provided ID for the added AttributeType |
| * @param attributeType The attribute Type. |
| * @param values The list of values to add. It can be empty. |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( String upId, AttributeType attributeType, Value<?>... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| upId = getUpId( upId, attributeType ); |
| |
| ServerAttribute attribute = (ServerAttribute)attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| // This Attribute already exist, we add the values |
| // into it |
| attribute.add( values ); |
| attribute.setUpId( upId, attributeType ); |
| } |
| else |
| { |
| createAttribute( upId, attributeType, values ); |
| } |
| } |
| |
| |
| /** |
| * Adds a new attribute with some String values into an entry, setting |
| * the User Provided ID in the same time. |
| * |
| * @param upId The User provided ID |
| * @param attributeType The associated AttributeType |
| * @param values The String values to store into the new Attribute |
| * @throws NamingException |
| */ |
| public void add( String upId, AttributeType attributeType, String... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| upId = getUpId( upId, attributeType ); |
| |
| ServerAttribute attribute = (ServerAttribute)attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| // This Attribute already exist, we add the values |
| // into it |
| attribute.add( values ); |
| attribute.setUpId( upId, attributeType ); |
| } |
| else |
| { |
| // We have to create a new Attribute and set the values |
| // and the upId |
| createAttribute( upId, attributeType, values ); |
| } |
| } |
| |
| |
| /** |
| * Add an attribute (represented by its ID and binary values) into an entry. |
| * |
| * @param upId The attribute ID |
| * @param values The list of binary values to inject. It can be empty |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( String upId, byte[]... values ) throws NamingException |
| { |
| add( upId, getAttributeType( upId ), values ); |
| } |
| |
| |
| /** |
| * Add an attribute (represented by its ID and string values) into an entry. |
| * |
| * @param upId The attribute ID |
| * @param values The list of string values to inject. It can be empty |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( String upId, String... values ) throws NamingException |
| { |
| add( upId, getAttributeType( upId ), values ); |
| } |
| |
| |
| /** |
| * Add an attribute (represented by its ID and Value values) into an entry. |
| * |
| * @param upId The attribute ID |
| * @param values The list of Value values to inject. It can be empty |
| * @throws NamingException If the attribute does not exist |
| */ |
| public void add( String upId, Value<?>... values ) throws NamingException |
| { |
| add( upId, getAttributeType( upId ), values ); |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some given binary values. |
| * |
| * @param attributeType The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * <code>false</code> otherwise, or if the attributes does not exist. |
| */ |
| public boolean contains( AttributeType attributeType, byte[]... values ) |
| { |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some given String values. |
| * |
| * @param attributeType The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * <code>false</code> otherwise, or if the attributes does not exist. |
| */ |
| public boolean contains( AttributeType attributeType, String... values ) |
| { |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some given binary values. |
| * |
| * @param attributeType The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * <code>false</code> otherwise, or if the attributes does not exist. |
| */ |
| public boolean contains( AttributeType attributeType, Value<?>... values ) |
| { |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Checks if an entry contains a list of attributes. |
| * </p> |
| * <p> |
| * If the list is null or empty, this method will return <code>true</code> |
| * if the entry has no attribute, <code>false</code> otherwise. |
| * </p> |
| * |
| * @param attributes The Attributes to look for |
| * @return <code>true</code> if all the attributes are found within |
| * the entry, <code>false</code> if at least one of them is not present. |
| * @throws NamingException If the attribute does not exist |
| */ |
| public boolean contains( EntryAttribute... attributes ) throws NamingException |
| { |
| for ( EntryAttribute entryAttribute:attributes ) |
| { |
| if ( entryAttribute == null ) |
| { |
| return this.attributes.size() == 0; |
| } |
| |
| if ( !this.attributes.containsKey( ((ServerAttribute)entryAttribute).getAttributeType() ) ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some binary values. |
| * |
| * @param id The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * false if at least one value is not present or if the ID is not valid. |
| */ |
| public boolean contains( String id, byte[]... values ) |
| { |
| if ( id == null ) |
| { |
| return false; |
| } |
| |
| try |
| { |
| AttributeType attributeType = atRegistry.lookup( id ); |
| |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| catch ( NamingException ne ) |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some String values. |
| * |
| * @param id The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * false if at least one value is not present or if the ID is not valid. |
| */ |
| public boolean contains( String id, String... values ) |
| { |
| if ( id == null ) |
| { |
| return false; |
| } |
| |
| try |
| { |
| AttributeType attributeType = atRegistry.lookup( id ); |
| |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| catch ( NamingException ne ) |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Checks if an entry contains an attribute with some values. |
| * |
| * @param id The Attribute we are looking for. |
| * @param values The searched values. |
| * @return <code>true</code> if all the values are found within the attribute, |
| * false if at least one value is not present or if the ID is not valid. |
| */ |
| public boolean contains( String id, Value<?>... values ) |
| { |
| if ( id == null ) |
| { |
| return false; |
| } |
| |
| try |
| { |
| AttributeType attributeType = atRegistry.lookup( id ); |
| |
| if ( attributeType == null ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| if ( attribute != null ) |
| { |
| return attribute.contains( values ); |
| } |
| else |
| { |
| return false; |
| } |
| } |
| catch ( NamingException ne ) |
| { |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Checks if an entry contains a specific AttributeType. |
| * |
| * @param attributeType The AttributeType to look for. |
| * @return <code>true</code> if the attribute is found within the entry. |
| */ |
| public boolean containsAttribute( AttributeType attributeType ) |
| { |
| return attributes.containsKey( attributeType ); |
| } |
| |
| |
| /** |
| * Checks if an entry contains some specific attributes. |
| * |
| * @param attributes The Attributes to look for. |
| * @return <code>true</code> if the attributes are all found within the entry. |
| */ |
| public boolean containsAttribute( String... attributes ) |
| { |
| for ( String attribute:attributes ) |
| { |
| try |
| { |
| if ( !this.attributes.containsKey( getAttributeType( attribute ) ) ) |
| { |
| return false; |
| } |
| } |
| catch ( NamingException ne ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| /** |
| * <p> |
| * Returns the attribute with the specified AttributeType. The return value |
| * is <code>null</code> if no match is found. |
| * </p> |
| * |
| * @param attributeType The attributeType we are looking for. |
| * @return the attribute associated with the AttributeType. |
| */ |
| /** |
| * Returns the attribute associated with an AttributeType |
| * |
| * @param attributeType the AttributeType we are looking for |
| * @return the associated attribute |
| */ |
| public EntryAttribute get( AttributeType attributeType ) |
| { |
| return attributes.get( attributeType ); |
| } |
| |
| |
| /** |
| * <p> |
| * Returns the attribute with the specified alias. The return value |
| * is <code>null</code> if no match is found. |
| * </p> |
| * <p>An Attribute with an id different from the supplied alias may |
| * be returned: for example a call with 'cn' may in some implementations |
| * return an Attribute whose getId() field returns 'commonName'. |
| * </p> |
| * <p> |
| * If the attributeType is not found, returns null. |
| * </p> |
| * |
| * @param alias an aliased name of the attribute identifier |
| * @return the attribute associated with the alias |
| */ |
| public EntryAttribute get( String alias ) |
| { |
| try |
| { |
| return get( atRegistry.lookup( alias ) ); |
| } |
| catch ( NamingException ne ) |
| { |
| String message = ne.getMessage(); |
| LOG.error( message ); |
| return null; |
| } |
| } |
| |
| |
| /** |
| * Gets all the attributes type |
| * |
| * @return The combined set of all the attributes, including ObjectClass. |
| */ |
| public Set<AttributeType> getAttributeTypes() |
| { |
| return attributes.keySet(); |
| } |
| |
| |
| /** |
| * Tells if an entry has a specific ObjectClass value |
| * |
| * @param objectClass The ObjectClass ID we want to check |
| * @return <code>true</code> if the ObjectClass value is present |
| * in the ObjectClass attribute |
| */ |
| public boolean hasObjectClass( String objectClass ) |
| { |
| return contains( OBJECT_CLASS_AT, objectClass ); |
| } |
| |
| |
| /** |
| * Tells if an entry has a specific ObjectClass Attribute |
| * |
| * @param objectClass The ObjectClass we want to check |
| * @return <code>true</code> if the ObjectClass value is present |
| * in the ObjectClass attribute |
| */ |
| public boolean hasObjectClass( EntryAttribute objectClass ) |
| { |
| if ( objectClass == null ) |
| { |
| return false; |
| } |
| |
| // We have to check that we are checking the ObjectClass attributeType |
| if ( ((ServerAttribute)objectClass).getAttributeType() != OBJECT_CLASS_AT ) |
| { |
| return false; |
| } |
| |
| EntryAttribute attribute = attributes.get( OBJECT_CLASS_AT ); |
| |
| 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 ) ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| /** |
| * Fail fast check performed to determine entry consistency according to schema |
| * characteristics. |
| * |
| * @return true if the entry, it's attributes and their values are consistent |
| * with the schema |
| */ |
| public boolean isValid() |
| { |
| // @TODO Implement me ! |
| throw new NotImplementedException(); |
| } |
| |
| |
| /** |
| * Check performed to determine entry consistency according to the schema |
| * requirements of a particular objectClass. The entry must be of that objectClass |
| * to return true: meaning if the entry's objectClass attribute does not contain |
| * the objectClass argument, then false should be returned. |
| * |
| * @param objectClass the objectClass to use while checking for validity |
| * @return true if the entry, it's attributes and their values are consistent |
| * with the objectClass |
| */ |
| public boolean isValid( EntryAttribute objectClass ) |
| { |
| // @TODO Implement me ! |
| throw new NotImplementedException(); |
| } |
| |
| |
| /** |
| * Check performed to determine entry consistency according to the schema |
| * requirements of a particular objectClass. The entry must be of that objectClass |
| * to return true: meaning if the entry's objectClass attribute does not contain |
| * the objectClass argument, then false should be returned. |
| * |
| * @param objectClass the objectClass to use while checking for validity |
| * @return true if the entry, it's attributes and their values are consistent |
| * with the objectClass |
| */ |
| public boolean isValid( String objectClass ) |
| { |
| // @TODO Implement me ! |
| throw new NotImplementedException(); |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and binary values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param attributeType the type of the new attribute to be put |
| * @param values the binary values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures |
| */ |
| public EntryAttribute put( AttributeType attributeType, byte[]... values ) throws NamingException |
| { |
| return put( null, attributeType, values ); |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and String values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param attributeType the type of the new attribute to be put |
| * @param values the String values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures |
| */ |
| public EntryAttribute put( AttributeType attributeType, String... values ) throws NamingException |
| { |
| return put( null, attributeType, values ); |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and some values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param attributeType the type of the new attribute to be put |
| * @param values the values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures |
| */ |
| public EntryAttribute put( AttributeType attributeType, Value<?>... values ) throws NamingException |
| { |
| return put( null, attributeType, values ); |
| } |
| |
| |
| /** |
| * <p> |
| * Places attributes in the attribute collection. |
| * </p> |
| * <p>If there is already an attribute with the same ID as any of the |
| * new attributes, the old ones are removed from the collection and |
| * are returned by this method. If there was no attribute with the |
| * same ID the return value is <code>null</code>. |
| *</p> |
| * |
| * @param attributes the attributes to be put |
| * @return the old attributes with the same OID, if exist; otherwise |
| * <code>null</code> |
| * @exception NamingException if the operation fails |
| */ |
| public List<EntryAttribute> put( EntryAttribute... attributes ) throws NamingException |
| { |
| List<EntryAttribute> previous = new ArrayList<EntryAttribute>(); |
| |
| for ( EntryAttribute serverAttribute:attributes ) |
| { |
| if ( serverAttribute == null ) |
| { |
| String message = "The ServerAttribute list should not contain null elements"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| EntryAttribute removed = this.attributes.put( ((ServerAttribute)serverAttribute).getAttributeType(), serverAttribute ); |
| |
| if ( removed != null ) |
| { |
| previous.add( removed ); |
| } |
| } |
| |
| return previous; |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and some binary values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * The given User provided ID will be used for this new AttributeEntry. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param upId The User Provided ID to be stored into the AttributeEntry |
| * @param attributeType the type of the new attribute to be put |
| * @param values the binary values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures. |
| */ |
| public EntryAttribute put( String upId, AttributeType attributeType, byte[]... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| if ( !StringTools.isEmpty( upId ) ) |
| { |
| AttributeType tempAT = getAttributeType( upId ); |
| |
| if ( !tempAT.equals( attributeType ) ) |
| { |
| String message = "The '" + upId + "' id is not compatible with the '" + attributeType + "' attribute type"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| else |
| { |
| upId = getUpId( upId, attributeType ); |
| } |
| |
| if ( attributeType.equals( OBJECT_CLASS_AT ) ) |
| { |
| String message = "Only String values supported for objectClass attribute"; |
| LOG.error( message ); |
| throw new UnsupportedOperationException( message ); |
| } |
| |
| EntryAttribute attribute = new DefaultServerAttribute( upId, attributeType, values ); |
| return attributes.put( attributeType, attribute ); |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and some String values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * The given User provided ID will be used for this new AttributeEntry. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param upId The User Provided ID to be stored into the AttributeEntry |
| * @param attributeType the type of the new attribute to be put |
| * @param values the String values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures. |
| */ |
| public EntryAttribute put( String upId, AttributeType attributeType, String... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| try |
| { |
| attributeType = getAttributeType( upId ); |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| else |
| { |
| if ( !StringTools.isEmpty( upId ) ) |
| { |
| AttributeType tempAT = getAttributeType( upId ); |
| |
| if ( !tempAT.equals( attributeType ) ) |
| { |
| String message = "The '" + upId + "' id is not compatible with the '" + attributeType + "' attribute type"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| else |
| { |
| upId = getUpId( upId, attributeType ); |
| } |
| } |
| |
| EntryAttribute attribute = new DefaultServerAttribute( upId, attributeType, values ); |
| return attributes.put( attributeType, attribute ); |
| } |
| |
| |
| /** |
| * <p> |
| * Places a new attribute with the supplied AttributeType and some values |
| * into the attribute collection. |
| * </p> |
| * <p> |
| * The given User provided ID will be used for this new AttributeEntry. |
| * </p> |
| * <p> |
| * If there is already an attribute with the same AttributeType, the old |
| * one is removed from the collection and is returned by this method. |
| * </p> |
| * <p> |
| * This method provides a mechanism to put an attribute with a |
| * <code>null</code> value: the value may be <code>null</code>. |
| * |
| * @param upId The User Provided ID to be stored into the AttributeEntry |
| * @param attributeType the type of the new attribute to be put |
| * @param values the values of the new attribute to be put |
| * @return the old attribute with the same identifier, if exists; otherwise |
| * <code>null</code> |
| * @throws NamingException if there are failures. |
| */ |
| public EntryAttribute put( String upId, AttributeType attributeType, Value<?>... values ) throws NamingException |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The attributeType should not be null"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| |
| if ( !StringTools.isEmpty( upId ) ) |
| { |
| AttributeType tempAT = getAttributeType( upId ); |
| |
| if ( !tempAT.equals( attributeType ) ) |
| { |
| String message = "The '" + upId + "' id is not compatible with the '" + attributeType + "' attribute type"; |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| else |
| { |
| upId = getUpId( upId, attributeType ); |
| } |
| |
| EntryAttribute attribute = new DefaultServerAttribute( upId, attributeType, values ); |
| return attributes.put( attributeType, attribute ); |
| } |
| |
| |
| /** |
| * <p> |
| * Put an attribute (represented by its ID and some binary values) into an entry. |
| * </p> |
| * <p> |
| * If the attribute already exists, the previous attribute will be |
| * replaced and returned. |
| * </p> |
| * <p> |
| * If the upId is not the ID of an existing AttributeType, an IllegalArgumentException is thrown. |
| * </p> |
| * |
| * @param upId The attribute ID |
| * @param values The list of binary values to put. It can be empty. |
| * @return The replaced attribute |
| */ |
| public EntryAttribute put( String upId, byte[]... values ) |
| { |
| try |
| { |
| return put( upId, getAttributeType( upId ), values ); |
| } |
| catch ( NamingException ne ) |
| { |
| String message = "Error while adding values into the '" + upId + "' attribute. Error : " + |
| ne.getMessage(); |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Put an attribute (represented by its ID and some String values) into an entry. |
| * </p> |
| * <p> |
| * If the attribute already exists, the previous attribute will be |
| * replaced and returned. |
| * </p> |
| * <p> |
| * If the upId is not the ID of an existing AttributeType, an IllegalArgumentException is thrown. |
| * </p> |
| * |
| * @param upId The attribute ID |
| * @param values The list of String values to put. It can be empty. |
| * @return The replaced attribute |
| */ |
| public EntryAttribute put( String upId, String... values ) |
| { |
| |
| try |
| { |
| return put( upId, getAttributeType( upId ), values ); |
| } |
| catch ( NamingException ne ) |
| { |
| String message = "Error while adding values into the '" + upId + "' attribute. Error : " + |
| ne.getMessage(); |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Put an attribute (represented by its ID and some values) into an entry. |
| * </p> |
| * <p> |
| * If the attribute already exists, the previous attribute will be |
| * replaced and returned. |
| * </p> |
| * <p> |
| * If the upId is not the ID of an existing AttributeType, an IllegalArgumentException is thrown. |
| * </p> |
| * |
| * @param upId The attribute ID |
| * @param values The list of values to put. It can be empty. |
| * @return The replaced attribute |
| */ |
| public EntryAttribute put( String upId, Value<?>... values ) |
| { |
| try |
| { |
| return put( upId, getAttributeType( upId ), values ); |
| } |
| catch ( NamingException ne ) |
| { |
| String message = "Error while adding values into the '" + upId + "' attribute. Error : " + |
| ne.getMessage(); |
| LOG.error( message ); |
| throw new IllegalArgumentException( message ); |
| } |
| } |
| |
| |
| /** |
| * <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 attributeType The attribute type |
| * @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( AttributeType attributeType, byte[]... values ) throws NamingException |
| { |
| try |
| { |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| |
| return true; |
| } |
| |
| if ( nbOldValues != attribute.size() ) |
| { |
| // At least one value have been removed, return true. |
| return true; |
| } |
| else |
| { |
| // No values have been removed, return false. |
| return false; |
| } |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", attributeType ); |
| 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 attributeType The attribute type |
| * @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( AttributeType attributeType, String... values ) throws NamingException |
| { |
| try |
| { |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| |
| return true; |
| } |
| |
| if ( nbOldValues != attribute.size() ) |
| { |
| // At least one value have been removed, return true. |
| return true; |
| } |
| else |
| { |
| // No values have been removed, return false. |
| return false; |
| } |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", attributeType ); |
| 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 attributeType The attribute type |
| * @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( AttributeType attributeType, Value<?>... values ) throws NamingException |
| { |
| try |
| { |
| EntryAttribute attribute = attributes.get( attributeType ); |
| |
| 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 ); |
| |
| return true; |
| } |
| |
| if ( nbOldValues != attribute.size() ) |
| { |
| // At least one value have been removed, return true. |
| return true; |
| } |
| else |
| { |
| // No values have been removed, return false. |
| return false; |
| } |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", attributeType ); |
| return false; |
| } |
| } |
| |
| |
| public List<EntryAttribute> remove( EntryAttribute... attributes ) throws NamingException |
| { |
| List<EntryAttribute> removedAttributes = new ArrayList<EntryAttribute>(); |
| |
| for ( EntryAttribute serverAttribute:attributes ) |
| { |
| if ( this.attributes.containsKey( ((ServerAttribute)serverAttribute).getAttributeType() ) ) |
| { |
| this.attributes.remove( ((ServerAttribute)serverAttribute).getAttributeType() ); |
| removedAttributes.add( serverAttribute ); |
| } |
| } |
| |
| return removedAttributes; |
| } |
| |
| |
| /** |
| * <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 NamingException |
| { |
| try |
| { |
| AttributeType attributeType = getAttributeType( upId ); |
| |
| return remove( attributeType, values ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", upId ); |
| return false; |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the bad '{}' attribute is not possible", 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 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, String... values ) throws NamingException |
| { |
| try |
| { |
| AttributeType attributeType = getAttributeType( upId ); |
| |
| return remove( attributeType, values ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", upId ); |
| return false; |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the bad '{}' attribute is not possible", upId ); |
| return false; |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Removes the specified Value 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, Value<?>... values ) throws NamingException |
| { |
| try |
| { |
| AttributeType attributeType = getAttributeType( upId ); |
| |
| return remove( attributeType, values ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.error( "The removal of values for the missing '{}' attribute is not possible", upId ); |
| return false; |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.error( "The removal of values for the bad '{}' attribute is not possible", upId ); |
| 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 List<EntryAttribute> removeAttributes( AttributeType... attributes ) |
| { |
| if ( attributes.length == 0 ) |
| { |
| return null; |
| } |
| |
| List<EntryAttribute> removed = new ArrayList<EntryAttribute>( attributes.length ); |
| |
| for ( AttributeType attributeType:attributes ) |
| { |
| EntryAttribute attr = this.attributes.remove( attributeType ); |
| |
| if ( attr != null ) |
| { |
| removed.add( attr ); |
| } |
| } |
| |
| if ( removed.size() == 0 ) |
| { |
| return null; |
| } |
| else |
| { |
| return removed; |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Removes the attribute with the specified alias. |
| * </p> |
| * <p> |
| * The removed attribute are returned by this method. |
| * </p> |
| * <p> |
| * If there is no attribute with the specified alias, |
| * the return value is <code>null</code>. |
| * </p> |
| * |
| * @param attributes an aliased name of the attribute to be removed |
| * @return the removed attributes, if any, as a list; otherwise <code>null</code> |
| */ |
| public List<EntryAttribute> removeAttributes( String... attributes ) |
| { |
| if ( attributes.length == 0 ) |
| { |
| return null; |
| } |
| |
| List<EntryAttribute> removed = new ArrayList<EntryAttribute>( attributes.length ); |
| |
| for ( String attribute:attributes ) |
| { |
| AttributeType attributeType = null; |
| |
| try |
| { |
| attributeType = atRegistry.lookup( attribute ); |
| } |
| catch ( NamingException ne ) |
| { |
| String message = "The attribute '" + attribute + "' does not exist in the entry"; |
| LOG.warn( message ); |
| continue; |
| } |
| |
| EntryAttribute attr = this.attributes.remove( attributeType ); |
| |
| if ( attr != null ) |
| { |
| removed.add( attr ); |
| } |
| } |
| |
| if ( removed.size() == 0 ) |
| { |
| return null; |
| } |
| else |
| { |
| return removed; |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Put some new attributes using the attributeTypes. |
| * No value is inserted. |
| * </p> |
| * <p> |
| * If an existing Attribute is found, it will be replaced by an |
| * empty attribute, and returned to the caller. |
| * </p> |
| * |
| * @param attributeTypes The AttributeTypes to add. |
| * @return A list of replaced Attributes, of <code>null</code> if no attribute are removed. |
| */ |
| public List<EntryAttribute> set( AttributeType... attributeTypes ) |
| { |
| List<EntryAttribute> removed = new ArrayList<EntryAttribute>(); |
| |
| // Now, loop on all the attributeType to add |
| for ( AttributeType attributeType:attributeTypes ) |
| { |
| if ( attributeType == null ) |
| { |
| String message = "The AttributeType list should not contain null values"; |
| LOG.error( message ); |
| continue; |
| } |
| |
| EntryAttribute attribute = attributes.put( attributeType, new DefaultServerAttribute( attributeType ) ); |
| |
| if ( attribute != null ) |
| { |
| removed.add( attribute ); |
| } |
| } |
| |
| if ( removed.size() == 0 ) |
| { |
| return null; |
| } |
| else |
| { |
| return removed; |
| } |
| } |
| |
| |
| /** |
| * <p> |
| * Put some new EntryAttribute using the User Provided ID. |
| * No value is inserted. |
| * </p> |
| * <p> |
| * If an existing Attribute is found, it will be replaced by an |
| * empty attribute, and returned to the caller. |
| * </p> |
| * |
| * @param upIds The user provided IDs of the AttributeTypes to add. |
| * @return A list of replaced Attributes. |
| */ |
| public List<EntryAttribute> set( String... upIds ) |
| { |
| List<EntryAttribute> removed = new ArrayList<EntryAttribute>(); |
| |
| for ( String upId:upIds ) |
| { |
| // Search for the corresponding AttributeType, based on the upID |
| AttributeType attributeType = null; |
| |
| try |
| { |
| attributeType = getAttributeType( upId ); |
| } |
| catch ( NamingException ne ) |
| { |
| LOG.warn( "Trying to add a bad attribute type '{}', error : ", upId, ne.getMessage() ); |
| continue; |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| LOG.warn( "Trying to add a bad attribute type '{}', error : ", upId, iae.getMessage() ); |
| continue; |
| } |
| |
| EntryAttribute attribute = attributes.put( attributeType, |
| new DefaultServerAttribute( upId, attributeType )); |
| |
| if ( attribute != null ) |
| { |
| removed.add( attribute ); |
| } |
| } |
| |
| if ( removed.size() == 0 ) |
| { |
| return null; |
| } |
| else |
| { |
| return removed; |
| } |
| } |
| |
| |
| /** |
| * Convert the ServerEntry to a ClientEntry |
| * |
| * @return An instance of ClientEntry |
| */ |
| public Entry toClientEntry() throws NamingException |
| { |
| // Copy the DN |
| Entry clientEntry = new DefaultClientEntry( dn ); |
| |
| // Convert each attribute |
| for ( EntryAttribute serverAttribute:this ) |
| { |
| EntryAttribute clientAttribute = ((ServerAttribute)serverAttribute).toClientAttribute(); |
| clientEntry.add( clientAttribute ); |
| } |
| |
| return clientEntry; |
| } |
| |
| |
| //------------------------------------------------------------------------- |
| // Object methods |
| //------------------------------------------------------------------------- |
| /** |
| * 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 |
| DefaultServerEntry clone = (DefaultServerEntry)super.clone(); |
| |
| // A serverEntry has a DN, an ObjectClass attribute |
| // and many attributes. |
| // Clone the DN first. |
| if ( dn != null ) |
| { |
| clone.dn = (LdapDN)dn.clone(); |
| } |
| |
| // clone the ServerAttribute Map |
| clone.attributes = (Map<AttributeType, EntryAttribute>)(((HashMap<AttributeType, EntryAttribute>)attributes).clone()); |
| |
| // now clone all the servrAttributes |
| clone.attributes.clear(); |
| |
| for ( AttributeType key:attributes.keySet() ) |
| { |
| EntryAttribute value = (ServerAttribute)attributes.get( key ).clone(); |
| clone.attributes.put( key, value ); |
| } |
| |
| // We are done ! |
| return clone; |
| } |
| |
| |
| /** |
| * @see java.io.Externalizable#writeExternal(ObjectOutput) |
| * |
| * We can't use this method for a ServerEntry, as we have to feed the entry |
| * with an registries reference |
| */ |
| public void writeExternal( ObjectOutput out ) throws IOException |
| { |
| throw new IllegalStateException( "Cannot use standard serialization for a ServerEntry" ); |
| } |
| |
| |
| /** |
| * Serialize a server entry. |
| * |
| * The structure is the following : |
| * |
| * <b>[DN]</b> : The entry DN. can be empty |
| * <b>[numberAttr]</b> : the bumber of attributes. Can be 0 |
| * <b>[attribute's oid]*</b> : The attribute's OID to get back |
| * the attributeType on deserialization |
| * <b>[Attribute]*</b> The attribute |
| * |
| * @param out the buffer in which the data will be serialized |
| * @throws IOException if the serialization failed |
| */ |
| public void serialize( ObjectOutput out ) throws IOException |
| { |
| // First, the DN |
| // Write the DN |
| LdapDNSerializer.serialize( dn, out ); |
| |
| // Then the attributes. |
| out.writeInt( attributes.size() ); |
| |
| // Iterate through the keys. We store the Attribute |
| // here, to be able to restore it in the readExternal : |
| // we need access to the registries, which are not available |
| // in the ServerAttribute class. |
| for ( AttributeType attributeType:attributes.keySet() ) |
| { |
| // Write the oid to be able to restore the AttributeType when deserializing |
| // the attribute |
| String oid = attributeType.getOid(); |
| |
| out.writeUTF( oid ); |
| |
| // Get the attribute |
| DefaultServerAttribute attribute = (DefaultServerAttribute)attributes.get( attributeType ); |
| |
| // Write the attribute |
| attribute.serialize( out ); |
| } |
| } |
| |
| |
| /** |
| * @see java.io.Externalizable#readExternal(ObjectInput) |
| * |
| * We can't use this method for a ServerEntry, as we have to feed the entry |
| * with an registries reference |
| */ |
| public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException |
| { |
| throw new IllegalStateException( "Cannot use standard serialization for a ServerAttribute" ); |
| } |
| |
| |
| /** |
| * Deserialize a server entry. |
| * |
| * @param in The buffer containing the serialized serverEntry |
| * @throws IOException if there was a problem when deserializing |
| * @throws ClassNotFoundException if we can't deserialize an expected object |
| */ |
| public void deserialize( ObjectInput in ) throws IOException, ClassNotFoundException |
| { |
| // Read the DN |
| dn = LdapDNSerializer.deserialize( in ); |
| |
| // Read the number of attributes |
| int nbAttributes = in.readInt(); |
| |
| // Read the attributes |
| for ( int i = 0; i < nbAttributes; i++ ) |
| { |
| // Read the attribute's OID |
| String oid = in.readUTF(); |
| |
| try |
| { |
| AttributeType attributeType = atRegistry.lookup( oid ); |
| |
| // Create the attribute we will read |
| DefaultServerAttribute attribute = new DefaultServerAttribute( attributeType ); |
| |
| // Read the attribute |
| attribute.deserialize( in ); |
| |
| attributes.put( attributeType, attribute ); |
| } |
| catch ( NamingException ne ) |
| { |
| // We weren't able to find the OID. The attribute will not be added |
| LOG.warn( "Cannot read the attribute as it's OID ('" + oid + "') does not exist" ); |
| |
| } |
| } |
| } |
| |
| |
| /** |
| * Gets the hashCode of this ServerEntry. |
| * |
| * @see java.lang.Object#hashCode() |
| * @return the instance's hash code |
| */ |
| public int hashCode() |
| { |
| int result = 37; |
| |
| result = result*17 + dn.hashCode(); |
| |
| for ( EntryAttribute attribute:attributes.values() ) |
| { |
| result = result*17 + attribute.hashCode(); |
| } |
| |
| return result; |
| } |
| |
| |
| /** |
| * @see Object#equals(Object) |
| */ |
| public boolean equals( Object o ) |
| { |
| // Short circuit |
| if ( this == o ) |
| { |
| return true; |
| } |
| |
| if ( ! ( o instanceof DefaultServerEntry ) ) |
| { |
| return false; |
| } |
| |
| ServerEntry other = (DefaultServerEntry)o; |
| |
| if ( dn == null ) |
| { |
| if ( other.getDn() != null ) |
| { |
| return false; |
| } |
| } |
| else |
| { |
| if ( !dn.equals( other.getDn() ) ) |
| { |
| return false; |
| } |
| } |
| |
| if ( size() != other.size() ) |
| { |
| return false; |
| } |
| |
| for ( EntryAttribute attribute:other ) |
| { |
| EntryAttribute attr = attributes.get( ((ServerAttribute)attribute).getAttributeType() ); |
| |
| if ( attr == null ) |
| { |
| return false; |
| } |
| |
| if ( !attribute.equals( attr ) ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * @see Object#toString() |
| */ |
| public String toString() |
| { |
| StringBuilder sb = new StringBuilder(); |
| |
| sb.append( "ServerEntry\n" ); |
| sb.append( " dn" ); |
| |
| if ( dn.isNormalized() ) |
| { |
| sb.append( "[n]" ); |
| } |
| else |
| { |
| sb.append( "[]" ); |
| } |
| |
| sb.append( ": " ).append( dn ).append( '\n' ); |
| |
| // First dump the ObjectClass attribute |
| if ( containsAttribute( OBJECT_CLASS_AT ) ) |
| { |
| EntryAttribute objectClass = get( OBJECT_CLASS_AT ); |
| |
| sb.append( objectClass ); |
| } |
| |
| if ( attributes.size() != 0 ) |
| { |
| for ( EntryAttribute attribute:attributes.values() ) |
| { |
| if ( !((ServerAttribute)attribute).getAttributeType().equals( OBJECT_CLASS_AT ) ) |
| { |
| sb.append( attribute ); |
| } |
| } |
| } |
| |
| return sb.toString(); |
| } |
| } |
