| /* |
| * 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 |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| package org.apache.directory.api.ldap.model.schema; |
| |
| |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.directory.api.i18n.I18n; |
| import org.apache.directory.api.util.Strings; |
| |
| |
| /** |
| * Most schema objects have some common attributes. This class |
| * contains the minimum set of properties exposed by a SchemaObject.<br> |
| * We have 11 types of SchemaObjects : |
| * <ul> |
| * <li> AttributeType</li> |
| * <li> DitCOntentRule</li> |
| * <li> DitStructureRule</li> |
| * <li> LdapComparator (specific to ADS)</li> |
| * <li> LdapSyntaxe</li> |
| * <li> MatchingRule</li> |
| * <li> MatchingRuleUse</li> |
| * <li> NameForm</li> |
| * <li> Normalizer (specific to ADS)</li> |
| * <li> ObjectClass</li> |
| * <li> SyntaxChecker (specific to ADS)</li> |
| * </ul> |
| * <br> |
| * <br> |
| * This class provides accessors and setters for the following attributes, |
| * which are common to all those SchemaObjects : |
| * <ul> |
| * <li>oid : The numeric OID</li> |
| * <li>description : The SchemaObject description</li> |
| * <li>obsolete : Tells if the schema object is obsolete</li> |
| * <li>extensions : The extensions, a key/Values map</li> |
| * <li>schemaObjectType : The SchemaObject type (see upper)</li> |
| * <li>schema : The schema the SchemaObject is associated with (it's an extension). |
| * Can be null</li> |
| * <li>isEnabled : The SchemaObject status (it's related to the schema status)</li> |
| * <li>isReadOnly : Tells if the SchemaObject can be modified or not</li> |
| * </ul> |
| * <br><br> |
| * Some of those attributes are not used by some Schema elements, even if they should |
| * have been used. Here is the list : |
| * <ul> |
| * <li><b>name</b> : LdapSyntax, Comparator, Normalizer, SyntaxChecker</li> |
| * <li><b>numericOid</b> : DitStructureRule</li> |
| * <li><b>obsolete</b> : LdapSyntax, Comparator, Normalizer, SyntaxChecker</li> |
| * </ul> |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public abstract class AbstractSchemaObject implements SchemaObject, Serializable |
| { |
| /** The serial version UID */ |
| private static final long serialVersionUID = 2L; |
| |
| /** The SchemaObject numeric OID */ |
| protected String oid; |
| |
| /** The optional names for this SchemaObject */ |
| protected transient List<String> names; |
| |
| /** Whether or not this SchemaObject is enabled */ |
| protected boolean isEnabled = true; |
| |
| /** Whether or not this SchemaObject is obsolete */ |
| protected boolean isObsolete = false; |
| |
| /** A short description of this SchemaObject */ |
| protected String description; |
| |
| /** The SchemaObject specification */ |
| protected String specification; |
| |
| /** The name of the schema this object is associated with */ |
| protected String schemaName; |
| |
| /** The SchemaObjectType */ |
| protected SchemaObjectType objectType; |
| |
| /** A map containing the list of supported extensions */ |
| protected transient Map<String, List<String>> extensions; |
| |
| /** A locked to avoid modifications when set to true */ |
| protected volatile boolean locked; |
| |
| /** The hashcode for this schemaObject */ |
| protected volatile int h = 0; |
| |
| |
| /** |
| * A constructor for a SchemaObject instance. It must be |
| * invoked by the inherited class. |
| * |
| * @param objectType The SchemaObjectType to create |
| * @param oid the SchemaObject numeric OID |
| */ |
| protected AbstractSchemaObject( SchemaObjectType objectType, String oid ) |
| { |
| this.objectType = objectType; |
| this.oid = oid; |
| extensions = new HashMap<>(); |
| names = new ArrayList<>(); |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Constructor used when a generic reusable SchemaObject is assigned an |
| * OID after being instantiated. |
| * |
| * @param objectType The SchemaObjectType to create |
| */ |
| protected AbstractSchemaObject( SchemaObjectType objectType ) |
| { |
| this.objectType = objectType; |
| extensions = new HashMap<>(); |
| names = new ArrayList<>(); |
| } |
| |
| |
| /** |
| * Gets usually what is the numeric object identifier assigned to this |
| * SchemaObject. All schema objects except for MatchingRuleUses have an OID |
| * assigned specifically to then. A MatchingRuleUse's OID really is the OID |
| * of it's MatchingRule and not specific to the MatchingRuleUse. This |
| * effects how MatchingRuleUse objects are maintained by the system. |
| * |
| * @return an OID for this SchemaObject or its MatchingRule if this |
| * SchemaObject is a MatchingRuleUse object |
| */ |
| @Override |
| public String getOid() |
| { |
| return oid; |
| } |
| |
| |
| /** |
| * A special method used when renaming an SchemaObject: we may have to |
| * change it's OID |
| * @param oid The new OID |
| */ |
| @Override |
| public void setOid( String oid ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| this.oid = oid; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Gets short names for this SchemaObject if any exists for it, otherwise, |
| * returns an empty list. |
| * |
| * @return the names for this SchemaObject |
| */ |
| @Override |
| public List<String> getNames() |
| { |
| if ( names != null ) |
| { |
| return Collections.unmodifiableList( names ); |
| } |
| else |
| { |
| return Collections.emptyList(); |
| } |
| } |
| |
| |
| /** |
| * Gets the first name in the set of short names for this SchemaObject if |
| * any exists for it. |
| * |
| * @return the first of the names for this SchemaObject or the oid |
| * if one does not exist |
| */ |
| @Override |
| public String getName() |
| { |
| if ( ( names != null ) && !names.isEmpty() ) |
| { |
| return names.get( 0 ); |
| } |
| else |
| { |
| return oid; |
| } |
| } |
| |
| |
| /** |
| * Add a new name to the list of names for this SchemaObject. The name |
| * is lower cased and trimmed. |
| * |
| * @param namesToAdd The names to add |
| */ |
| @Override |
| public void addName( String... namesToAdd ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| // We must avoid duplicated names, as names are case insensitive |
| Set<String> lowerNames = new HashSet<>(); |
| |
| // Fills a set with all the existing names |
| for ( String name : this.names ) |
| { |
| lowerNames.add( Strings.toLowerCaseAscii( name ) ); |
| } |
| |
| for ( String name : namesToAdd ) |
| { |
| if ( name != null ) |
| { |
| String lowerName = Strings.toLowerCaseAscii( name ); |
| // Check that the lower cased names is not already present |
| if ( !lowerNames.contains( lowerName ) ) |
| { |
| this.names.add( name ); |
| lowerNames.add( lowerName ); |
| } |
| } |
| } |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Sets the list of names for this SchemaObject. The names are |
| * lowercased and trimmed. |
| * |
| * @param names The list of names. Can be empty |
| */ |
| @Override |
| public void setNames( List<String> names ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| if ( names == null ) |
| { |
| return; |
| } |
| |
| this.names = new ArrayList<>( names.size() ); |
| |
| for ( String name : names ) |
| { |
| if ( name != null ) |
| { |
| this.names.add( name ); |
| } |
| } |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Sets the list of names for this SchemaObject. The names are |
| * lowercased and trimmed. |
| * |
| * @param names The list of names. |
| */ |
| public void setNames( String... names ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| if ( names == null ) |
| { |
| return; |
| } |
| |
| this.names.clear(); |
| |
| for ( String name : names ) |
| { |
| if ( name != null ) |
| { |
| this.names.add( name ); |
| } |
| } |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Gets a short description about this SchemaObject. |
| * |
| * @return a short description about this SchemaObject |
| */ |
| @Override |
| public String getDescription() |
| { |
| return description; |
| } |
| |
| |
| /** |
| * Sets the SchemaObject's description |
| * |
| * @param description The SchemaObject's description |
| */ |
| @Override |
| public void setDescription( String description ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| this.description = description; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Gets the SchemaObject specification. |
| * |
| * @return the SchemaObject specification |
| */ |
| @Override |
| public String getSpecification() |
| { |
| return specification; |
| } |
| |
| |
| /** |
| * Sets the SchemaObject's specification |
| * |
| * @param specification The SchemaObject's specification |
| */ |
| @Override |
| public void setSpecification( String specification ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| this.specification = specification; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Tells if this SchemaObject is enabled. |
| * |
| * @return true if the SchemaObject is enabled, or if it depends on |
| * an enabled schema |
| */ |
| @Override |
| public boolean isEnabled() |
| { |
| return isEnabled; |
| } |
| |
| |
| /** |
| * Tells if this SchemaObject is disabled. |
| * |
| * @return true if the SchemaObject is disabled |
| */ |
| @Override |
| public boolean isDisabled() |
| { |
| return !isEnabled; |
| } |
| |
| |
| /** |
| * Sets the SchemaObject state, either enabled or disabled. |
| * |
| * @param enabled The current SchemaObject state |
| */ |
| @Override |
| public void setEnabled( boolean enabled ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| isEnabled = enabled; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Gets whether or not this SchemaObject has been inactivated. All |
| * SchemaObjects except Syntaxes allow for this parameter within their |
| * definition. For Syntaxes this property should always return false in |
| * which case it is never included in the description. |
| * |
| * @return true if inactive, false if active |
| */ |
| @Override |
| public boolean isObsolete() |
| { |
| return isObsolete; |
| } |
| |
| |
| /** |
| * Sets the Obsolete flag. |
| * |
| * @param obsolete The Obsolete flag state |
| */ |
| @Override |
| public void setObsolete( boolean obsolete ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| this.isObsolete = obsolete; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public Map<String, List<String>> getExtensions() |
| { |
| return extensions; |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public boolean hasExtension( String extension ) |
| { |
| return extensions.containsKey( Strings.toUpperCaseAscii( extension ) ); |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public List<String> getExtension( String extension ) |
| { |
| String name = Strings.toUpperCaseAscii( extension ); |
| |
| if ( hasExtension( name ) ) |
| { |
| for ( Map.Entry<String, List<String>> entry : extensions.entrySet() ) |
| { |
| String key = entry.getKey(); |
| |
| if ( name.equalsIgnoreCase( key ) ) |
| { |
| return entry.getValue(); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| |
| /** |
| * Add an extension with its values |
| * @param key The extension key |
| * @param values The associated values |
| */ |
| @Override |
| public void addExtension( String key, String... values ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| List<String> valueList = new ArrayList<>(); |
| |
| for ( String value : values ) |
| { |
| valueList.add( value ); |
| } |
| |
| extensions.put( Strings.toUpperCaseAscii( key ), valueList ); |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Add an extension with its values |
| * @param key The extension key |
| * @param values The associated values |
| */ |
| @Override |
| public void addExtension( String key, List<String> values ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| extensions.put( Strings.toUpperCaseAscii( key ), values ); |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * Add an extensions with their values. (Actually do a copy) |
| * |
| * @param extensions The extensions map |
| */ |
| @Override |
| public void setExtensions( Map<String, List<String>> extensions ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| if ( extensions != null ) |
| { |
| this.extensions = new HashMap<>(); |
| |
| for ( Map.Entry<String, List<String>> entry : extensions.entrySet() ) |
| { |
| List<String> values = new ArrayList<>(); |
| |
| for ( String value : entry.getValue() ) |
| { |
| values.add( value ); |
| } |
| |
| this.extensions.put( Strings.toUpperCaseAscii( entry.getKey() ), values ); |
| } |
| |
| computeHashCode(); |
| } |
| } |
| |
| |
| /** |
| * The SchemaObject type : |
| * <ul> |
| * <li> AttributeType |
| * <li> DitCOntentRule |
| * <li> DitStructureRule |
| * <li> LdapComparator (specific to ADS) |
| * <li> LdapSyntaxe |
| * <li> MatchingRule |
| * <li> MatchingRuleUse |
| * <li> NameForm |
| * <li> Normalizer (specific to ADS) |
| * <li> ObjectClass |
| * <li> SyntaxChecker (specific to ADS) |
| * </ul> |
| * |
| * @return the SchemaObject type |
| */ |
| @Override |
| public SchemaObjectType getObjectType() |
| { |
| return objectType; |
| } |
| |
| |
| /** |
| * Gets the name of the schema this SchemaObject is associated with. |
| * |
| * @return the name of the schema associated with this schemaObject |
| */ |
| @Override |
| public String getSchemaName() |
| { |
| return schemaName; |
| } |
| |
| |
| /** |
| * Sets the name of the schema this SchemaObject is associated with. |
| * |
| * @param schemaName the new schema name |
| */ |
| @Override |
| public void setSchemaName( String schemaName ) |
| { |
| if ( locked ) |
| { |
| throw new UnsupportedOperationException( I18n.err( I18n.ERR_13700_CANNOT_MODIFY_LOCKED_SCHEMA_OBJECT, getName() ) ); |
| } |
| |
| this.schemaName = schemaName; |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public boolean equals( Object o1 ) |
| { |
| if ( this == o1 ) |
| { |
| return true; |
| } |
| |
| if ( !( o1 instanceof AbstractSchemaObject ) ) |
| { |
| return false; |
| } |
| |
| AbstractSchemaObject that = ( AbstractSchemaObject ) o1; |
| |
| // Two schemaObject are equals if their oid is equal, |
| // their ObjectType is equal, their names are equals |
| // their schema name is the same, all their flags are equals, |
| // the description is the same and their extensions are equals |
| if ( !compareOid( oid, that.oid ) ) |
| { |
| return false; |
| } |
| |
| // Compare the names |
| if ( names == null ) |
| { |
| if ( that.names != null ) |
| { |
| return false; |
| } |
| } |
| else if ( that.names == null ) |
| { |
| return false; |
| } |
| else |
| { |
| int nbNames = 0; |
| |
| for ( String name : names ) |
| { |
| if ( !that.names.contains( name ) ) |
| { |
| return false; |
| } |
| |
| nbNames++; |
| } |
| |
| if ( nbNames != names.size() ) |
| { |
| return false; |
| } |
| } |
| |
| if ( schemaName == null ) |
| { |
| if ( that.schemaName != null ) |
| { |
| return false; |
| } |
| } |
| else |
| { |
| if ( !schemaName.equalsIgnoreCase( that.schemaName ) ) |
| { |
| return false; |
| } |
| } |
| |
| if ( objectType != that.objectType ) |
| { |
| return false; |
| } |
| |
| if ( extensions != null ) |
| { |
| if ( that.extensions == null ) |
| { |
| return false; |
| } |
| else |
| { |
| for ( Map.Entry<String, List<String>> entry : extensions.entrySet() ) |
| { |
| String key = entry.getKey(); |
| |
| if ( !that.extensions.containsKey( key ) ) |
| { |
| return false; |
| } |
| |
| List<String> thisValues = entry.getValue(); |
| List<String> thatValues = that.extensions.get( key ); |
| |
| if ( thisValues != null ) |
| { |
| if ( thatValues == null ) |
| { |
| return false; |
| } |
| else |
| { |
| if ( thisValues.size() != thatValues.size() ) |
| { |
| return false; |
| } |
| |
| // TODO compare the values |
| } |
| } |
| else if ( thatValues != null ) |
| { |
| return false; |
| } |
| } |
| } |
| } |
| else if ( that.extensions != null ) |
| { |
| return false; |
| } |
| |
| if ( this.isEnabled != that.isEnabled ) |
| { |
| return false; |
| } |
| |
| if ( this.isObsolete != that.isObsolete ) |
| { |
| return false; |
| } |
| |
| if ( this.description == null ) |
| { |
| return that.description == null; |
| } |
| else |
| { |
| return this.description.equalsIgnoreCase( that.description ); |
| } |
| } |
| |
| |
| /** |
| * Compare two oids, and return true if they are both null or equal. |
| * |
| * @param oid1 the first OID |
| * @param oid2 the second OID |
| * @return <code>true</code> if both OIDs are null or equal |
| */ |
| protected boolean compareOid( String oid1, String oid2 ) |
| { |
| if ( oid1 == null ) |
| { |
| return oid2 == null; |
| } |
| else |
| { |
| return oid1.equals( oid2 ); |
| } |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public SchemaObject copy( SchemaObject original ) |
| { |
| // copy the description |
| description = original.getDescription(); |
| |
| // copy the flags |
| isEnabled = original.isEnabled(); |
| isObsolete = original.isObsolete(); |
| |
| // copy the names |
| names = new ArrayList<>(); |
| |
| for ( String name : original.getNames() ) |
| { |
| names.add( name ); |
| } |
| |
| // copy the extensions |
| extensions = new HashMap<>(); |
| |
| for ( String key : original.getExtensions().keySet() ) |
| { |
| List<String> extensionValues = original.getExtension( key ); |
| |
| List<String> cloneExtension = new ArrayList<>(); |
| |
| for ( String value : extensionValues ) |
| { |
| cloneExtension.add( value ); |
| } |
| |
| extensions.put( key, cloneExtension ); |
| } |
| |
| // The SchemaName |
| schemaName = original.getSchemaName(); |
| |
| // The specification |
| specification = original.getSpecification(); |
| |
| return this; |
| } |
| |
| |
| /** |
| * Clear the current SchemaObject : remove all the references to other objects, |
| * and all the Maps. |
| */ |
| @Override |
| public void clear() |
| { |
| // Clear the extensions |
| for ( Map.Entry<String, List<String>> entry : extensions.entrySet() ) |
| { |
| List<String> extensionList = entry.getValue(); |
| |
| extensionList.clear(); |
| } |
| |
| extensions.clear(); |
| |
| // Clear the names |
| names.clear(); |
| |
| computeHashCode(); |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public final void lock() |
| { |
| locked = true; |
| } |
| |
| |
| /** |
| * Unlock the Schema Object and make it modifiable again. |
| */ |
| public void unlock() |
| { |
| locked = false; |
| } |
| |
| |
| /** |
| * Compute the hashcode, and store it in the 'h' variable |
| */ |
| protected void computeHashCode() |
| { |
| int hash = 37; |
| |
| // The OID |
| if ( oid != null ) |
| { |
| hash += hash * 17 + oid.hashCode(); |
| } |
| |
| // The SchemaObject type |
| if ( objectType != null ) |
| { |
| hash += hash * 17 + objectType.getValue(); |
| } |
| |
| // The Names, if any |
| if ( ( names != null ) && !names.isEmpty() ) |
| { |
| int tempHash = 0; |
| |
| for ( String name : names ) |
| { |
| tempHash *= name.hashCode(); |
| } |
| |
| hash = hash * 17 + tempHash; |
| } |
| |
| // The schemaName if any |
| if ( schemaName != null ) |
| { |
| hash += hash * 17 + schemaName.hashCode(); |
| } |
| |
| hash += hash * 17 + ( isEnabled ? 1 : 0 ); |
| |
| // The description, if any |
| if ( description != null ) |
| { |
| hash += hash * 17 + description.hashCode(); |
| } |
| |
| // The extensions, if any |
| // Because the extensions and their values are stored un-ordered |
| // we have to be careful when computing the hashcode so that it does |
| // not depend on the extensions/values order |
| int tempHash = 0; |
| |
| for ( Map.Entry<String, List<String>> entry : extensions.entrySet() ) |
| { |
| String key = entry.getKey(); |
| int tempHash2 = key.hashCode(); |
| |
| List<String> values = entry.getValue(); |
| |
| if ( values != null ) |
| { |
| int tempHash3 = 0; |
| |
| for ( String value : values ) |
| { |
| tempHash3 += value.hashCode(); |
| } |
| |
| tempHash += tempHash2 * tempHash3; |
| } |
| } |
| |
| hash = hash * 17 + tempHash; |
| |
| h = hash; |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public int hashCode() |
| { |
| return h; |
| } |
| } |
