/*
* 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.shared.ldap.model.schema;
import java.util.ArrayList;
import java.util.List;
import org.apache.directory.shared.i18n.I18n;
import org.apache.directory.shared.ldap.model.exception.LdapException;
import org.apache.directory.shared.ldap.model.exception.LdapSchemaException;
import org.apache.directory.shared.ldap.model.exception.LdapSchemaExceptionCodes;
import org.apache.directory.shared.ldap.model.schema.registries.AttributeTypeRegistry;
import org.apache.directory.shared.ldap.model.schema.registries.ObjectClassRegistry;
import org.apache.directory.shared.ldap.model.schema.registries.Registries;
/**
* An objectClass definition.
* <p>
* According to ldapbis [MODELS]:
* </p>
*
* <pre>
* Object Class definitions are written according to the ABNF:
*
* ObjectClassDescription = LPAREN WSP
* numericoid ; object identifier
* [ SP "NAME" SP qdescrs ] ; short names (descriptors)
* [ SP "DESC" SP qdstring ] ; description
* [ SP "OBSOLETE" ] ; not active
* [ SP "SUP" SP oids ] ; superior object classes
* [ SP kind ] ; kind of class
* [ SP "MUST" SP oids ] ; attribute types
* [ SP "MAY" SP oids ] ; attribute types
* extensions WSP RPAREN
*
* kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
*
* where:
* [numericoid] is object identifier assigned to this object class;
* NAME [qdescrs] are short names (descriptors) identifying this object
* class;
* DESC [qdstring] is a short descriptive string;
* OBSOLETE indicates this object class is not active;
* SUP [oids] specifies the direct superclasses of this object class;
* the kind of object class is indicated by one of ABSTRACT,
* STRUCTURAL, or AUXILIARY, default is STRUCTURAL;
* MUST and MAY specify the sets of required and allowed attribute
* types, respectively; and
* [extensions] describe extensions.
* </pre>
*
* @see <a href="http://www.faqs.org/rfcs/rfc2252.html">RFC2252 Section 4.4</a>
* @see <a
* href="http://www.ietf.org/internet-drafts/draft-ietf-ldapbis-models-11.txt">ldapbis
* [MODELS]</a>
* @see DescriptionUtils#getDescription(ObjectClass)
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
// super.hashCode is final
@SuppressWarnings("PMD.OverrideBothEqualsAndHashcode")
public class ObjectClass extends AbstractSchemaObject
{
/** The ObjectClass type : ABSTRACT, AUXILIARY or STRUCTURAL */
private ObjectClassTypeEnum objectClassType = ObjectClassTypeEnum.STRUCTURAL;
/** The ObjectClass superior OIDs */
private List<String> superiorOids;
/** The ObjectClass superiors */
private List<ObjectClass> superiors;
/** The list of allowed AttributeType OIDs */
private List<String> mayAttributeTypeOids;
/** The list of allowed AttributeTypes */
private List<AttributeType> mayAttributeTypes;
/** The list of required AttributeType OIDs */
private List<String> mustAttributeTypeOids;
/** The list of required AttributeTypes */
private List<AttributeType> mustAttributeTypes;
/**
* Creates a new instance of MatchingRuleUseDescription
* @param oid the OID for this objectClass
*/
public ObjectClass( String oid )
{
super( SchemaObjectType.OBJECT_CLASS, oid );
mayAttributeTypeOids = new ArrayList<String>();
mustAttributeTypeOids = new ArrayList<String>();
superiorOids = new ArrayList<String>();
mayAttributeTypes = new ArrayList<AttributeType>();
mustAttributeTypes = new ArrayList<AttributeType>();
superiors = new ArrayList<ObjectClass>();
objectClassType = ObjectClassTypeEnum.STRUCTURAL;
}
private void buildSuperiors( List<Throwable> errors, Registries registries )
{
ObjectClassRegistry ocRegistry = registries.getObjectClassRegistry();
if ( superiorOids != null )
{
superiors = new ArrayList<ObjectClass>( superiorOids.size() );
for ( String superiorName : superiorOids )
{
try
{
ObjectClass superior = ocRegistry.lookup( ocRegistry.getOidByName( superiorName ) );
// Before adding the superior, check that the ObjectClass type is consistent
switch ( objectClassType )
{
case ABSTRACT:
if ( superior.objectClassType != ObjectClassTypeEnum.ABSTRACT )
{
// An ABSTRACT OC can only inherit from ABSTRACT OCs
String msg = I18n.err( I18n.ERR_04318, oid, superior.getObjectType(), superior );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_ABSTRACT_MUST_INHERIT_FROM_ABSTRACT_OC, msg );
ldapSchemaException.setSourceObject( this );
errors.add( ldapSchemaException );
return;
}
break;
case AUXILIARY:
if ( superior.objectClassType == ObjectClassTypeEnum.STRUCTURAL )
{
// An AUXILIARY OC cannot inherit from STRUCTURAL OCs
String msg = I18n.err( I18n.ERR_04319, oid, superior );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_AUXILIARY_CANNOT_INHERIT_FROM_STRUCTURAL_OC, msg );
ldapSchemaException.setSourceObject( this );
errors.add( ldapSchemaException );
return;
}
break;
case STRUCTURAL:
if ( superior.objectClassType == ObjectClassTypeEnum.AUXILIARY )
{
// A STRUCTURAL OC cannot inherit from AUXILIARY OCs
String msg = I18n.err( I18n.ERR_04320, oid, superior );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_STRUCTURAL_CANNOT_INHERIT_FROM_AUXILIARY_OC, msg );
ldapSchemaException.setSourceObject( this );
errors.add( ldapSchemaException );
return;
}
break;
}
superiors.add( superior );
}
catch ( LdapException ne )
{
// Cannot find the OC
String msg = I18n.err( I18n.ERR_04321, oid, superiorName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_NONEXISTENT_SUPERIOR, msg, ne );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( superiorName );
errors.add( ldapSchemaException );
return;
}
}
}
}
private void buildMay( List<Throwable> errors, Registries registries )
{
AttributeTypeRegistry atRegistry = registries.getAttributeTypeRegistry();
if ( mayAttributeTypeOids != null )
{
mayAttributeTypes = new ArrayList<AttributeType>( mayAttributeTypeOids.size() );
for ( String mayAttributeTypeName : mayAttributeTypeOids )
{
try
{
AttributeType attributeType = atRegistry.lookup( mayAttributeTypeName );
if ( attributeType.isCollective() )
{
// Collective Attributes are not allowed in MAY or MUST
String msg = I18n.err( I18n.ERR_04485_COLLECTIVE_NOT_ALLOWED_IN_MAY, mayAttributeTypeName, oid );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_COLLECTIVE_NOT_ALLOWED_IN_MAY, msg );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mayAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
if ( mayAttributeTypes.contains( attributeType ) )
{
// Already registered : this is an error
String msg = I18n.err( I18n.ERR_04322, oid, mayAttributeTypeName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_DUPLICATE_AT_IN_MAY, msg );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mayAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
mayAttributeTypes.add( attributeType );
}
catch ( LdapException ne )
{
// Cannot find the AT
String msg = I18n.err( I18n.ERR_04323, oid, mayAttributeTypeName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_NONEXISTENT_MAY_AT, msg, ne );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mayAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
}
}
}
private void buildMust( List<Throwable> errors, Registries registries )
{
AttributeTypeRegistry atRegistry = registries.getAttributeTypeRegistry();
if ( mustAttributeTypeOids != null )
{
mustAttributeTypes = new ArrayList<AttributeType>( mustAttributeTypeOids.size() );
for ( String mustAttributeTypeName : mustAttributeTypeOids )
{
try
{
AttributeType attributeType = atRegistry.lookup( mustAttributeTypeName );
if ( attributeType.isCollective() )
{
// Collective Attributes are not allowed in MAY or MUST
String msg = I18n.err( I18n.ERR_04484_COLLECTIVE_NOT_ALLOWED_IN_MUST, mustAttributeTypeName,
oid );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_COLLECTIVE_NOT_ALLOWED_IN_MUST, msg );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mustAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
if ( mustAttributeTypes.contains( attributeType ) )
{
// Already registered : this is an error
String msg = I18n.err( I18n.ERR_04324, oid, mustAttributeTypeName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_DUPLICATE_AT_IN_MUST, msg );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mustAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
// Check that the MUST AT is not also present in the MAY AT
if ( mayAttributeTypes.contains( attributeType ) )
{
// Already registered : this is an error
String msg = I18n.err( I18n.ERR_04325, oid, mustAttributeTypeName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_DUPLICATE_AT_IN_MAY_AND_MUST,
msg );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mustAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
mustAttributeTypes.add( attributeType );
}
catch ( LdapException ne )
{
// Cannot find the AT
String msg = I18n.err( I18n.ERR_04326, oid, mustAttributeTypeName );
LdapSchemaException ldapSchemaException = new LdapSchemaException(
LdapSchemaExceptionCodes.OC_NONEXISTENT_MUST_AT, msg, ne );
ldapSchemaException.setSourceObject( this );
ldapSchemaException.setRelatedId( mustAttributeTypeName );
errors.add( ldapSchemaException );
break;
}
}
}
}
/**
* Inject the ObjectClass into the registries, updating the references to
* other SchemaObject
*
* @param errors The errors we got while adding the ObjectClass to the registries
* @param registries The Registries
* @throws Exception on failure
*
*/
public void addToRegistries( List<Throwable> errors, Registries registries ) throws LdapException
{
if ( registries != null )
{
// The superiors
buildSuperiors( errors, registries );
// The MAY AttributeTypes
buildMay( errors, registries );
// The MUST AttributeTypes
buildMust( errors, registries );
/**
* Add the OC references (using and usedBy) :
* OC -> AT (MAY and MUST)
* OC -> OC (SUPERIORS)
*/
for ( AttributeType mayAttributeType : mayAttributeTypes )
{
registries.addReference( this, mayAttributeType );
}
for ( AttributeType mustAttributeType : mustAttributeTypes )
{
registries.addReference( this, mustAttributeType );
}
for ( ObjectClass superiorObjectClass : superiors )
{
registries.addReference( this, superiorObjectClass );
}
}
}
/**
* Remove the ObjectClass from the registries, updating the references to
* other SchemaObject.
*
* If one of the referenced SchemaObject does not exist (SUPERIORS, MAY, MUST),
* an exception is thrown.
*
* @param errors The errors we got while removing the ObjectClass from the registries
* @param registries The Registries
* @exception If the ObjectClass is not valid
*/
public void removeFromRegistries( List<Throwable> errors, Registries registries ) throws LdapException
{
if ( registries != null )
{
ObjectClassRegistry objectClassRegistry = registries.getObjectClassRegistry();
// Unregister this ObjectClass into the Descendant map
objectClassRegistry.unregisterDescendants( this, superiors );
/**
* Remove the OC references (using and usedBy) :
* OC -> AT (for MAY and MUST)
* OC -> OC
*/
if ( mayAttributeTypes != null )
{
for ( AttributeType may : mayAttributeTypes )
{
registries.delReference( this, may );
}
}
if ( mustAttributeTypes != null )
{
for ( AttributeType must : mustAttributeTypes )
{
registries.delReference( this, must );
}
}
if ( superiors != null )
{
for ( ObjectClass superior : superiors )
{
registries.delReference( this, superior );
}
}
}
}
/**
* @return the mayAttributeTypeOids
*/
public List<String> getMayAttributeTypeOids()
{
return mayAttributeTypeOids;
}
/**
* @return the mayAttributeTypes
*/
public List<AttributeType> getMayAttributeTypes()
{
return mayAttributeTypes;
}
/**
* Add some allowed AttributeType
*
* @param oids The attributeType oids
*/
public void addMayAttributeTypeOids( String... oids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( String oid : oids )
{
mayAttributeTypeOids.add( oid );
}
}
}
/**
* Add some allowed AttributeTypes
*
* @param attributeTypes The attributeTypes
*/
public void addMayAttributeTypes( AttributeType... attributeTypes )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( AttributeType attributeType : attributeTypes )
{
if ( !mayAttributeTypeOids.contains( attributeType.getOid() ) )
{
mayAttributeTypes.add( attributeType );
mayAttributeTypeOids.add( attributeType.getOid() );
}
}
}
}
/**
* @param mayAttributeTypeOids the mayAttributeTypeOids to set
*/
public void setMayAttributeTypeOids( List<String> mayAttributeTypeOids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.mayAttributeTypeOids = mayAttributeTypeOids;
}
}
/**
* Sets the list of allowed AttributeTypes
*
* @param mayAttributeTypes the list of allowed AttributeTypes
*/
public void setMayAttributeTypes( List<AttributeType> mayAttributeTypes )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.mayAttributeTypes = mayAttributeTypes;
// update the OIDS now
mayAttributeTypeOids.clear();
for ( AttributeType may : mayAttributeTypes )
{
mayAttributeTypeOids.add( may.getOid() );
}
}
}
/**
* Update the associated MAY AttributeType, even if the SchemaObject is readOnly
*
* @param mayAttributeTypes the list of allowed AttributeTypes
*/
public void updateMayAttributeTypes( List<AttributeType> mayAttributeTypes )
{
this.mayAttributeTypes.clear();
this.mayAttributeTypes.addAll( mayAttributeTypes );
// update the OIDS now
mayAttributeTypeOids.clear();
for ( AttributeType may : mayAttributeTypes )
{
mayAttributeTypeOids.add( may.getOid() );
}
}
/**
* @return the mustAttributeTypeOids
*/
public List<String> getMustAttributeTypeOids()
{
return mustAttributeTypeOids;
}
/**
* @return the mustAttributeTypes
*/
public List<AttributeType> getMustAttributeTypes()
{
return mustAttributeTypes;
}
/**
* Add some required AttributeType OIDs
*
* @param oids The attributeType OIDs
*/
public void addMustAttributeTypeOids( String... oids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( String oid : oids )
{
mustAttributeTypeOids.add( oid );
}
}
}
/**
* Add some required AttributeTypes
*
* @param attributeTypes The attributeTypse
*/
public void addMustAttributeTypes( AttributeType... attributeTypes )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( AttributeType attributeType : attributeTypes )
{
if ( !mustAttributeTypeOids.contains( attributeType.getOid() ) )
{
mustAttributeTypes.add( attributeType );
mustAttributeTypeOids.add( attributeType.getOid() );
}
}
}
}
/**
* @param mustAttributeTypeOids the mustAttributeTypeOids to set
*/
public void setMustAttributeTypeOids( List<String> mustAttributeTypeOids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.mustAttributeTypeOids = mustAttributeTypeOids;
}
}
/**
* Sets the list of required AttributeTypes
*
* @param mustAttributeTypes the list of required AttributeTypes
*/
public void setMustAttributeTypes( List<AttributeType> mustAttributeTypes )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.mustAttributeTypes = mustAttributeTypes;
// update the OIDS now
mustAttributeTypeOids.clear();
for ( AttributeType may : mustAttributeTypes )
{
mustAttributeTypeOids.add( may.getOid() );
}
}
}
/**
* Update the associated MUST AttributeType, even if the SchemaObject is readOnly
*
* @param mustAttributeTypes the list of allowed AttributeTypes
*/
public void updateMustAttributeTypes( List<AttributeType> mustAttributeTypes )
{
this.mustAttributeTypes.clear();
this.mustAttributeTypes.addAll( mustAttributeTypes );
// update the OIDS now
mustAttributeTypeOids.clear();
for ( AttributeType must : mustAttributeTypes )
{
mustAttributeTypeOids.add( must.getOid() );
}
}
/**
* Gets the superclasses of this ObjectClass.
*
* @return the superclasses
*/
public List<ObjectClass> getSuperiors()
{
return superiors;
}
/**
* Gets the superclasses OIDsof this ObjectClass.
*
* @return the superclasses OIDs
*/
public List<String> getSuperiorOids()
{
return superiorOids;
}
/**
* Add some superior ObjectClass OIDs
*
* @param oids The superior ObjectClass OIDs
*/
public void addSuperiorOids( String... oids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( String oid : oids )
{
if ( !superiorOids.contains( oid ) )
{
superiorOids.add( oid );
}
}
}
}
/**
* Add some superior ObjectClasses
*
* @param objectClasses The superior ObjectClasses
*/
public void addSuperior( ObjectClass... objectClasses )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
for ( ObjectClass objectClass : objectClasses )
{
if ( !superiorOids.contains( objectClass.getOid() ) )
{
superiorOids.add( objectClass.getOid() );
superiors.add( objectClass );
}
}
}
}
/**
* Sets the superior object classes
*
* @param superiors the object classes to set
*/
public void setSuperiors( List<ObjectClass> superiors )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.superiors = superiors;
// update the OIDS now
superiorOids.clear();
for ( ObjectClass oc : superiors )
{
superiorOids.add( oc.getOid() );
}
}
}
/**
* Update the associated SUPERIORS ObjectClasses, even if the SchemaObject is readOnly
*
* @param superiors the object classes to set
*/
public void updateSuperiors( List<ObjectClass> superiors )
{
this.superiors.clear();
this.superiors.addAll( superiors );
// update the OIDS now
superiorOids.clear();
for ( ObjectClass oc : superiors )
{
superiorOids.add( oc.getOid() );
}
}
/**
* Sets the superior object class OIDs
*
* @param superiorOids the object class OIDs to set
*/
public void setSuperiorOids( List<String> superiorOids )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.superiorOids = superiorOids;
}
}
/**
* Gets the type of this ObjectClass as a type safe enum.
*
* @return the ObjectClass type as an enum
*/
public ObjectClassTypeEnum getType()
{
return objectClassType;
}
/**
* Set the ObjectClass type, one of ABSTRACT, AUXILIARY or STRUCTURAL.
*
* @param objectClassType The ObjectClassType value
*/
public void setType( ObjectClassTypeEnum objectClassType )
{
if ( locked )
{
throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
}
if ( !isReadOnly )
{
this.objectClassType = objectClassType;
}
}
/**
* Tells if the current ObjectClass is STRUCTURAL
*
* @return <code>true</code> if the ObjectClass is STRUCTURAL
*/
public boolean isStructural()
{
return objectClassType == ObjectClassTypeEnum.STRUCTURAL;
}
/**
* Tells if the current ObjectClass is ABSTRACT
*
* @return <code>true</code> if the ObjectClass is ABSTRACT
*/
public boolean isAbstract()
{
return objectClassType == ObjectClassTypeEnum.ABSTRACT;
}
/**
* Tells if the current ObjectClass is AUXILIARY
*
* @return <code>true</code> if the ObjectClass is AUXILIARY
*/
public boolean isAuxiliary()
{
return objectClassType == ObjectClassTypeEnum.AUXILIARY;
}
/**
* @see Object#toString()
*/
public String toString()
{
return objectType + " " + DescriptionUtils.getDescription( this );
}
/**
* Copy an ObjectClass
*/
public ObjectClass copy()
{
ObjectClass copy = new ObjectClass( oid );
// Copy the SchemaObject common data
copy.copy( this );
// Copy the ObjectClass type
copy.objectClassType = objectClassType;
// Copy the Superiors ObjectClasses OIDs
copy.superiorOids = new ArrayList<String>();
for ( String oid : superiorOids )
{
copy.superiorOids.add( oid );
}
// Copy the Superiors ObjectClasses ( will be empty )
copy.superiors = new ArrayList<ObjectClass>();
// Copy the MAY AttributeTypes OIDs
copy.mayAttributeTypeOids = new ArrayList<String>();
for ( String oid : mayAttributeTypeOids )
{
copy.mayAttributeTypeOids.add( oid );
}
// Copy the MAY AttributeTypes ( will be empty )
copy.mayAttributeTypes = new ArrayList<AttributeType>();
// Copy the MUST AttributeTypes OIDs
copy.mustAttributeTypeOids = new ArrayList<String>();
for ( String oid : mustAttributeTypeOids )
{
copy.mustAttributeTypeOids.add( oid );
}
// Copy the MUST AttributeTypes ( will be empty )
copy.mustAttributeTypes = new ArrayList<AttributeType>();
return copy;
}
/**
* @see Object#equals(Object)
*/
@Override
public boolean equals( Object o )
{
if ( !super.equals( o ) )
{
return false;
}
if ( !( o instanceof ObjectClass ) )
{
return false;
}
ObjectClass that = ( ObjectClass ) o;
// The ObjectClassType
if ( objectClassType != that.objectClassType )
{
return false;
}
// The Superiors OIDs
if ( superiorOids.size() != that.superiorOids.size() )
{
return false;
}
// One way
for ( String oid : superiorOids )
{
if ( !that.superiorOids.contains( oid ) )
{
return false;
}
}
// The other way
for ( String oid : that.superiorOids )
{
if ( !superiorOids.contains( oid ) )
{
return false;
}
}
// The Superiors
if ( superiors.size() != that.superiors.size() )
{
return false;
}
// One way
for ( ObjectClass oid : superiors )
{
if ( !that.superiors.contains( oid ) )
{
return false;
}
}
// The other way
for ( ObjectClass oid : that.superiors )
{
if ( !superiors.contains( oid ) )
{
return false;
}
}
// The MAY OIDs
if ( mayAttributeTypeOids.size() != that.mayAttributeTypeOids.size() )
{
return false;
}
// One way
for ( String oid : mayAttributeTypeOids )
{
if ( !that.mayAttributeTypeOids.contains( oid ) )
{
return false;
}
}
// The other way
for ( String oid : that.mayAttributeTypeOids )
{
if ( !mayAttributeTypeOids.contains( oid ) )
{
return false;
}
}
// The MAY
if ( mayAttributeTypes.size() != that.mayAttributeTypes.size() )
{
return false;
}
// One way
for ( AttributeType oid : mayAttributeTypes )
{
if ( !that.mayAttributeTypes.contains( oid ) )
{
return false;
}
}
// The other way
for ( AttributeType oid : that.mayAttributeTypes )
{
if ( !mayAttributeTypes.contains( oid ) )
{
return false;
}
}
// The MUST OIDs
if ( mustAttributeTypeOids.size() != that.mustAttributeTypeOids.size() )
{
return false;
}
// One way
for ( String oid : mustAttributeTypeOids )
{
if ( !that.mustAttributeTypeOids.contains( oid ) )
{
return false;
}
}
// The other way
for ( String oid : that.mustAttributeTypeOids )
{
if ( !mustAttributeTypeOids.contains( oid ) )
{
return false;
}
}
// The MUST
if ( mustAttributeTypes.size() != that.mustAttributeTypes.size() )
{
return false;
}
// One way
for ( AttributeType oid : mustAttributeTypes )
{
if ( !that.mustAttributeTypes.contains( oid ) )
{
return false;
}
}
// The other way
for ( AttributeType oid : that.mustAttributeTypes )
{
if ( !mustAttributeTypes.contains( oid ) )
{
return false;
}
}
return true;
}
/**
* {@inheritDoc}
*/
public void clear()
{
// Clear the common elements
super.clear();
// Clear the references
mayAttributeTypes.clear();
mayAttributeTypeOids.clear();
mustAttributeTypes.clear();
mustAttributeTypeOids.clear();
superiors.clear();
superiorOids.clear();
}
}