| /* |
| * 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.registries.helper; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| import org.apache.directory.api.i18n.I18n; |
| import org.apache.directory.api.ldap.model.exception.LdapException; |
| import org.apache.directory.api.ldap.model.exception.LdapSchemaException; |
| import org.apache.directory.api.ldap.model.exception.LdapSchemaExceptionCodes; |
| import org.apache.directory.api.ldap.model.schema.AttributeType; |
| import org.apache.directory.api.ldap.model.schema.LdapSyntax; |
| import org.apache.directory.api.ldap.model.schema.MatchingRule; |
| import org.apache.directory.api.ldap.model.schema.SchemaErrorHandler; |
| import org.apache.directory.api.ldap.model.schema.UsageEnum; |
| import org.apache.directory.api.ldap.model.schema.registries.AttributeTypeRegistry; |
| import org.apache.directory.api.ldap.model.schema.registries.Registries; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * An helper class used to store all the methods associated with an AttributeType |
| * in relation with the Registries and SchemaManager. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public final class AttributeTypeHelper |
| { |
| /** A logger for this class */ |
| private static final Logger LOG = LoggerFactory.getLogger( AttributeTypeHelper.class ); |
| |
| private AttributeTypeHelper() |
| { |
| } |
| |
| /** |
| * Inject the AttributeType into the Registries, updating the references to |
| * other SchemaObject |
| * |
| * If one of the referenced SchemaObject does not exist (SUP, EQUALITY, ORDERING, SUBSTR, SYNTAX), |
| * an exception is thrown. |
| * |
| * @param attributeType The AttributeType to add to the Registries |
| * @param errorHandler Error handler |
| * @param registries The Registries |
| * @throws LdapException If the AttributeType is not valid |
| */ |
| public static void addToRegistries( AttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries ) throws LdapException |
| { |
| if ( registries != null ) |
| { |
| try |
| { |
| attributeType.unlock(); |
| AttributeTypeRegistry attributeTypeRegistry = registries.getAttributeTypeRegistry(); |
| |
| // The superior |
| if ( !buildSuperior( attributeType, errorHandler, registries ) ) |
| { |
| // We have had errors, let's stop here as we need a correct superior to continue |
| return; |
| } |
| |
| // The Syntax |
| buildSyntax( attributeType, errorHandler, registries ); |
| |
| // The EQUALITY matching rule |
| buildEquality( attributeType, errorHandler, registries ); |
| |
| // The ORDERING matching rule |
| buildOrdering( attributeType, errorHandler, registries ); |
| |
| // The SUBSTR matching rule |
| buildSubstring( attributeType, errorHandler, registries ); |
| |
| // Check the USAGE |
| checkUsage( attributeType, errorHandler ); |
| |
| // Check the COLLECTIVE element |
| checkCollective( attributeType, errorHandler ); |
| |
| // Inject the attributeType into the oid/normalizer map |
| attributeTypeRegistry.addMappingFor( attributeType ); |
| |
| // Register this AttributeType into the Descendant map |
| attributeTypeRegistry.registerDescendants( attributeType, attributeType.getSuperior() ); |
| |
| /** |
| * Add the AT references (using and usedBy) : |
| * AT -> MR (for EQUALITY, ORDERING and SUBSTR) |
| * AT -> S |
| * AT -> AT |
| */ |
| if ( attributeType.getEquality() != null ) |
| { |
| registries.addReference( attributeType, attributeType.getEquality() ); |
| } |
| |
| if ( attributeType.getOrdering() != null ) |
| { |
| registries.addReference( attributeType, attributeType.getOrdering() ); |
| } |
| |
| if ( attributeType.getSubstring() != null ) |
| { |
| registries.addReference( attributeType, attributeType.getSubstring() ); |
| } |
| |
| if ( attributeType.getSyntax() != null ) |
| { |
| registries.addReference( attributeType, attributeType.getSyntax() ); |
| } |
| |
| if ( attributeType.getSuperior() != null ) |
| { |
| registries.addReference( attributeType, attributeType.getSuperior() ); |
| } |
| } |
| finally |
| { |
| attributeType.lock(); |
| } |
| } |
| } |
| |
| |
| /** |
| * Build the Superior AttributeType reference for an AttributeType |
| * |
| * @param attributeType The AttributeType to process |
| * @param errorHandler The error handler |
| * @param registries The Registries instance |
| * @return <tt>true</tt> if the AttributeType superiors hierarchy is correct, or if we don't have any superior |
| */ |
| private static boolean buildSuperior( AttributeType attributeType, SchemaErrorHandler errorHandler, |
| Registries registries ) |
| { |
| AttributeType currentSuperior; |
| AttributeTypeRegistry attributeTypeRegistry = registries.getAttributeTypeRegistry(); |
| |
| String superiorOid = attributeType.getSuperiorOid(); |
| |
| if ( superiorOid != null ) |
| { |
| // This AT has a superior |
| try |
| { |
| currentSuperior = ( AttributeType ) attributeTypeRegistry.lookup( superiorOid ); |
| } |
| catch ( Exception e ) |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13752_CANNOT_FIND_SUPERIOR, superiorOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SUPERIOR, msg, e ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( superiorOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| // Get out now |
| return false; |
| } |
| |
| if ( currentSuperior != null ) |
| { |
| // a special case : if the superior is collective, this is an error |
| if ( currentSuperior.isCollective() ) |
| { |
| String msg = I18n.err( I18n.ERR_13776_CANNOT_SUBTYPE_COLLECTIVE, |
| currentSuperior, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_CANNOT_SUBTYPE_COLLECTIVE_AT, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return false; |
| } |
| |
| attributeType.setSuperior( currentSuperior ); |
| |
| // Recursively update the superior if not already done. We don't recurse |
| // if the superior's superior is not null, as it means it has already been |
| // handled. |
| if ( currentSuperior.getSuperior() == null ) |
| { |
| registries.buildReference( currentSuperior ); |
| } |
| |
| // Update the descendant MAP |
| try |
| { |
| attributeTypeRegistry.registerDescendants( attributeType, currentSuperior ); |
| } |
| catch ( LdapException ne ) |
| { |
| errorHandler.handle( LOG, ne.getMessage(), ne ); |
| |
| return false; |
| } |
| |
| // Check for cycles now |
| Set<String> superiors = new HashSet<>(); |
| superiors.add( attributeType.getOid() ); |
| AttributeType tmp = currentSuperior; |
| boolean isOk = true; |
| |
| while ( tmp != null ) |
| { |
| if ( superiors.contains( tmp.getOid() ) ) |
| { |
| // There is a cycle : bad bad bad ! |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13753_CYCLE_DETECTED, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_CYCLE_TYPE_HIERARCHY, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| isOk = false; |
| |
| break; |
| } |
| else |
| { |
| superiors.add( tmp.getOid() ); |
| tmp = tmp.getSuperior(); |
| } |
| } |
| |
| superiors.clear(); |
| |
| return isOk; |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13752_CANNOT_FIND_SUPERIOR, superiorOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SUPERIOR, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( superiorOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| // Get out now |
| return false; |
| } |
| } |
| else |
| { |
| // No superior, just return |
| return true; |
| } |
| } |
| |
| |
| /** |
| * Build the SYNTAX reference for an AttributeType |
| * |
| * @param attributeType The AttributeType to process |
| * @param errorHandler The error handler |
| * @param registries The Registries instance |
| */ |
| private static void buildSyntax( AttributeType attributeType, SchemaErrorHandler errorHandler, |
| Registries registries ) |
| { |
| String syntaxOid = attributeType.getSyntaxOid(); |
| |
| if ( syntaxOid != null ) |
| { |
| LdapSyntax currentSyntax = null; |
| |
| try |
| { |
| currentSyntax = registries.getLdapSyntaxRegistry().lookup( syntaxOid ); |
| } |
| catch ( LdapException ne ) |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13754_CANNOT_FIND_SYNTAX, syntaxOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SYNTAX, msg, ne ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( syntaxOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return; |
| } |
| |
| if ( currentSyntax != null ) |
| { |
| // Update the Syntax reference |
| attributeType.setSyntax( currentSyntax ); |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13754_CANNOT_FIND_SYNTAX, syntaxOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SYNTAX, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( syntaxOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| else |
| { |
| // We inherit from the superior's syntax, if any |
| if ( attributeType.getSuperior() != null ) |
| { |
| if ( attributeType.getSuperior().getSyntax() != null ) |
| { |
| attributeType.setSyntax( attributeType.getSuperior().getSyntax() ); |
| } |
| else |
| { |
| String msg = I18n.err( I18n.ERR_13754_CANNOT_FIND_SYNTAX, syntaxOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SYNTAX, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( syntaxOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13755_AT_MUST_HAVE_A_SYNTAX_OID, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_SYNTAX_OR_SUPERIOR_REQUIRED, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Build the EQUALITY MR reference for an AttributeType |
| * |
| * @param attributeType The AttributeType to process |
| * @param errorHandler The error handler |
| * @param registries The Registries instance |
| */ |
| private static void buildEquality( AttributeType attributeType, SchemaErrorHandler errorHandler, |
| Registries registries ) |
| { |
| String equalityOid = attributeType.getEqualityOid(); |
| |
| // The equality MR. It can be null |
| if ( equalityOid != null ) |
| { |
| MatchingRule currentEquality = null; |
| |
| try |
| { |
| currentEquality = registries.getMatchingRuleRegistry().lookup( equalityOid ); |
| } |
| catch ( LdapException ne ) |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13756_CANNOT_FIND_EQUALITY_MR_OBJECT, equalityOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_EQUALITY_MATCHING_RULE, msg, ne ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( equalityOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return; |
| } |
| |
| if ( currentEquality != null ) |
| { |
| attributeType.setEquality( currentEquality ); |
| |
| // Restore the old equality OID to preserve the user's provided value |
| attributeType.setEqualityOid( equalityOid ); |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13757_CANNOT_FIND_EQUALITY_MR_INSTANCE, equalityOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_EQUALITY_MATCHING_RULE, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( equalityOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| else |
| { |
| AttributeType superior = attributeType.getSuperior(); |
| |
| // If the AT has a superior, take its Equality MR if any |
| if ( ( superior != null ) && ( superior.getEquality() != null ) ) |
| { |
| attributeType.setEquality( superior.getEquality() ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Build the SUBSTR MR reference for an AttributeType |
| * |
| * @param attributeType The AttributeType to process |
| * @param errorHandler The error handler |
| * @param registries The Registries instance |
| */ |
| private static void buildSubstring( AttributeType attributeType, SchemaErrorHandler errorHandler, |
| Registries registries ) |
| { |
| String substringOid = attributeType.getSubstringOid(); |
| |
| // The Substring MR. It can be null |
| if ( substringOid != null ) |
| { |
| MatchingRule currentSubstring = null; |
| |
| try |
| { |
| currentSubstring = registries.getMatchingRuleRegistry().lookup( substringOid ); |
| } |
| catch ( LdapException ne ) |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13760_CANNOT_FIND_SUBSTR_MR_OBJECT, substringOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SUBSTRING_MATCHING_RULE, msg, ne ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( substringOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return; |
| } |
| |
| if ( currentSubstring != null ) |
| { |
| attributeType.setSubstring( currentSubstring ); |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13761_CANNOT_FIND_SUBSTR_MR_INSTANCE, substringOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_SUBSTRING_MATCHING_RULE, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( substringOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| else |
| { |
| AttributeType superior = attributeType.getSuperior(); |
| |
| // If the AT has a superior, take its Substring MR if any |
| if ( ( superior != null ) && ( superior.getSubstring() != null ) ) |
| { |
| attributeType.setSubstring( superior.getSubstring() ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Build the ORDERING MR reference for an AttributeType |
| * |
| * @param attributeType The AttributeType to process |
| * @param errorHandler The error handler |
| * @param registries The Registries instance |
| */ |
| private static void buildOrdering( AttributeType attributeType, SchemaErrorHandler errorHandler, |
| Registries registries ) |
| { |
| String orderingOid = attributeType.getOrderingOid(); |
| |
| if ( orderingOid != null ) |
| { |
| MatchingRule currentOrdering = null; |
| |
| try |
| { |
| currentOrdering = registries.getMatchingRuleRegistry().lookup( orderingOid ); |
| } |
| catch ( LdapException ne ) |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13758_CANNOT_FIND_ORDERING_MR_OBJECT, orderingOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_ORDERING_MATCHING_RULE, msg, ne ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( orderingOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return; |
| } |
| |
| if ( currentOrdering != null ) |
| { |
| attributeType.setOrdering( currentOrdering ); |
| } |
| else |
| { |
| // Not allowed. |
| String msg = I18n.err( I18n.ERR_13759_CANNOT_FIND_ORDERING_MR_INSTANCE, orderingOid, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_NONEXISTENT_ORDERING_MATCHING_RULE, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| ldapSchemaException.setRelatedId( orderingOid ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| else |
| { |
| AttributeType superior = attributeType.getSuperior(); |
| |
| // If the AT has a superior, take its Ordering MR if any |
| if ( ( superior != null ) && ( superior.getOrdering() != null ) ) |
| { |
| attributeType.setOrdering( superior.getOrdering() ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Check the constraints for the Usage field. |
| * |
| * @param attributeType The AttributeType to check |
| * @param errorHandler The error handler |
| */ |
| private static void checkUsage( AttributeType attributeType, SchemaErrorHandler errorHandler ) |
| { |
| AttributeType superior = attributeType.getSuperior(); |
| |
| // Check that the AT usage is the same that its superior |
| if ( ( superior != null ) && ( attributeType.getUsage() != superior.getUsage() ) ) |
| { |
| // This is an error |
| String msg = I18n.err( I18n.ERR_13762_AT_MUST_HAVE_SUPERIOR_USAGE, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_MUST_HAVE_SAME_USAGE_THAN_SUPERIOR, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| |
| return; |
| } |
| |
| // Now, check that the AttributeType's USAGE does not conflict |
| if ( !attributeType.isUserModifiable() && ( attributeType.getUsage() == UsageEnum.USER_APPLICATIONS ) ) |
| { |
| // Cannot have a not user modifiable AT which is not an operational AT |
| String msg = I18n.err( I18n.ERR_13763_AT_MUST_BE_USER_MODIFIABLE, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_USER_APPLICATIONS_USAGE_MUST_BE_USER_MODIFIABLE, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| |
| |
| /** |
| * Check the constraints for the Collective field. |
| * |
| * @param attributeType The AttributeType to check |
| * @param errorHandler The error handler |
| */ |
| private static void checkCollective( AttributeType attributeType, SchemaErrorHandler errorHandler ) |
| { |
| AttributeType superior = attributeType.getSuperior(); |
| |
| if ( ( superior != null ) && superior.isCollective() ) |
| { |
| // An AttributeType will be collective if its superior is collective |
| attributeType.setCollective( true ); |
| } |
| |
| if ( attributeType.isCollective() && ( attributeType.getUsage() != UsageEnum.USER_APPLICATIONS ) ) |
| { |
| // An AttributeType which is collective must be a USER attributeType |
| String msg = I18n.err( I18n.ERR_13764_AT_COLLECTIVE_SHOULD_BE_USER_APP, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_COLLECTIVE_MUST_HAVE_USER_APPLICATIONS_USAGE, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| |
| if ( attributeType.isCollective() && attributeType.isSingleValued() ) |
| { |
| // A collective attribute must be multi-valued |
| String msg = I18n.err( I18n.ERR_13777_COLLECTIVE_NOT_MULTI_VALUED, attributeType.getName() ); |
| |
| LdapSchemaException ldapSchemaException = new LdapSchemaException( |
| LdapSchemaExceptionCodes.AT_COLLECTIVE_CANNOT_BE_SINGLE_VALUED, msg ); |
| ldapSchemaException.setSourceObject( attributeType ); |
| errorHandler.handle( LOG, msg, ldapSchemaException ); |
| } |
| } |
| |
| |
| /** |
| * Remove the AttributeType from the registries, updating the references to |
| * other SchemaObject. |
| * |
| * If one of the referenced SchemaObject does not exist (SUP, EQUALITY, ORDERING, SUBSTR, SYNTAX), |
| * an exception is thrown. |
| * |
| * @param attributeType The AttributeType to remove from the Registries |
| * @param errorHandler Error handler |
| * @param registries The Registries |
| * @throws LdapException If the AttributeType is not valid |
| */ |
| public static void removeFromRegistries( AttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries ) throws LdapException |
| { |
| if ( registries != null ) |
| { |
| AttributeTypeRegistry attributeTypeRegistry = registries.getAttributeTypeRegistry(); |
| |
| // Remove the attributeType from the oid/normalizer map |
| attributeTypeRegistry.removeMappingFor( attributeType ); |
| |
| // Unregister this AttributeType into the Descendant map |
| attributeTypeRegistry.unregisterDescendants( attributeType, attributeType.getSuperior() ); |
| |
| /** |
| * Remove the AT references (using and usedBy) : |
| * AT -> MR (for EQUALITY, ORDERING and SUBSTR) |
| * AT -> S |
| * AT -> AT |
| */ |
| if ( attributeType.getEquality() != null ) |
| { |
| registries.delReference( attributeType, attributeType.getEquality() ); |
| } |
| |
| if ( attributeType.getOrdering() != null ) |
| { |
| registries.delReference( attributeType, attributeType.getOrdering() ); |
| } |
| |
| if ( attributeType.getSubstring() != null ) |
| { |
| registries.delReference( attributeType, attributeType.getSubstring() ); |
| } |
| |
| if ( attributeType.getSyntax() != null ) |
| { |
| registries.delReference( attributeType, attributeType.getSyntax() ); |
| } |
| |
| if ( attributeType.getSuperior() != null ) |
| { |
| registries.delReference( attributeType, attributeType.getSuperior() ); |
| } |
| } |
| } |
| } |
