external-software/github_OpenIdentityPlatform_OpenDJ.git

			@@ -26,19 +26,12 @@
			*/
			package org.opends.server.schema;

			import org.opends.server.admin.std.server.AttributeSyntaxCfg;
			import org.forgerock.opendj.ldap.schema.MatchingRule;
			import org.opends.server.api.AttributeSyntax;
			import org.forgerock.opendj.config.server.ConfigException;
			import org.opends.server.core.DirectoryServer;
			import org.opends.server.types.DN;

			import org.forgerock.i18n.slf4j.LocalizedLogger;
			import org.forgerock.opendj.ldap.ByteSequence;
			import static org.opends.messages.SchemaMessages.*;
			import org.forgerock.i18n.LocalizableMessageBuilder;
			import static org.opends.server.schema.SchemaConstants.*;
			import static org.opends.server.util.StaticUtils.*;

			import org.forgerock.opendj.ldap.schema.Schema;
			import org.forgerock.opendj.ldap.schema.Syntax;
			import org.opends.server.admin.std.server.AttributeSyntaxCfg;
			import org.opends.server.api.AttributeSyntax;

			/**
			* This class implements the name and optional UID attribute syntax, which holds
			@@ -48,14 +41,6 @@
			public class NameAndOptionalUIDSyntax
			extends AttributeSyntax<AttributeSyntaxCfg>
			{
			private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();

			/** The default equality matching rule for this syntax. */
			private MatchingRule defaultEqualityMatchingRule;

			/** The default substring matching rule for this syntax. */
			private MatchingRule defaultSubstringMatchingRule;

			/**
			* Creates a new instance of this syntax. Note that the only thing that
			* should be done here is to invoke the default constructor for the
			@@ -68,24 +53,10 @@
			}

			/** {@inheritDoc} */
			public void initializeSyntax(AttributeSyntaxCfg configuration)
			throws ConfigException
			@Override
			public Syntax getSDKSyntax(Schema schema)
			{
			defaultEqualityMatchingRule =
			DirectoryServer.getMatchingRule(EMR_UNIQUE_MEMBER_OID);
			if (defaultEqualityMatchingRule == null)
			{
			logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE,
			EMR_UNIQUE_MEMBER_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME);
			}

			defaultSubstringMatchingRule =
			DirectoryServer.getMatchingRule(SMR_CASE_IGNORE_OID);
			if (defaultSubstringMatchingRule == null)
			{
			logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE,
			SMR_CASE_IGNORE_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME);
			}
			return schema.getSyntax(SchemaConstants.SYNTAX_NAME_AND_OPTIONAL_UID_OID);
			}

			/**
			@@ -93,6 +64,7 @@
			*
			* @return The common name for this attribute syntax.
			*/
			@Override
			public String getName()
			{
			return SYNTAX_NAME_AND_OPTIONAL_UID_NAME;
			@@ -103,6 +75,7 @@
			*
			* @return The OID for this attribute syntax.
			*/
			@Override
			public String getOID()
			{
			return SYNTAX_NAME_AND_OPTIONAL_UID_OID;
			@@ -113,147 +86,10 @@
			*
			* @return A description for this attribute syntax.
			*/
			@Override
			public String getDescription()
			{
			return SYNTAX_NAME_AND_OPTIONAL_UID_DESCRIPTION;
			}

			/**
			* Retrieves the default equality matching rule that will be used for
			* attributes with this syntax.
			*
			* @return The default equality matching rule that will be used for
			* attributes with this syntax, or <CODE>null</CODE> if equality
			* matches will not be allowed for this type by default.
			*/
			public MatchingRule getEqualityMatchingRule()
			{
			return defaultEqualityMatchingRule;
			}

			/**
			* Retrieves the default ordering matching rule that will be used for
			* attributes with this syntax.
			*
			* @return The default ordering matching rule that will be used for
			* attributes with this syntax, or <CODE>null</CODE> if ordering
			* matches will not be allowed for this type by default.
			*/
			public MatchingRule getOrderingMatchingRule()
			{
			// There is no ordering matching rule by default.
			return null;
			}

			/**
			* Retrieves the default substring matching rule that will be used for
			* attributes with this syntax.
			*
			* @return The default substring matching rule that will be used for
			* attributes with this syntax, or <CODE>null</CODE> if substring
			* matches will not be allowed for this type by default.
			*/
			public MatchingRule getSubstringMatchingRule()
			{
			return defaultSubstringMatchingRule;
			}

			/**
			* Retrieves the default approximate matching rule that will be used for
			* attributes with this syntax.
			*
			* @return The default approximate matching rule that will be used for
			* attributes with this syntax, or <CODE>null</CODE> if approximate
			* matches will not be allowed for this type by default.
			*/
			public MatchingRule getApproximateMatchingRule()
			{
			// There is no approximate matching rule by default.
			return null;
			}

			/**
			* Indicates whether the provided value is acceptable for use in an attribute
			* with this syntax. If it is not, then the reason may be appended to the
			* provided buffer.
			*
			* @param value The value for which to make the determination.
			* @param invalidReason The buffer to which the invalid reason should be
			* appended.
			*
			* @return <CODE>true</CODE> if the provided value is acceptable for use with
			* this syntax, or <CODE>false</CODE> if not.
			*/
			public boolean valueIsAcceptable(ByteSequence value,
			LocalizableMessageBuilder invalidReason)
			{
			String valueString = value.toString().trim();
			int valueLength = valueString.length();


			// See if the value contains the "optional uid" portion. If we think it
			// does, then mark its location.
			int dnEndPos = valueLength;
			int sharpPos = -1;
			if (valueString.endsWith("'B") \|\| valueString.endsWith("'b"))
			{
			sharpPos = valueString.lastIndexOf("#'");
			if (sharpPos > 0)
			{
			dnEndPos = sharpPos;
			}
			}


			// Take the DN portion of the string and try to normalize it.
			try
			{
			DN.valueOf(valueString.substring(0, dnEndPos));
			}
			catch (Exception e)
			{
			logger.traceException(e);

			// We couldn't normalize the DN for some reason. The value cannot be
			// acceptable.

			invalidReason.append(ERR_ATTR_SYNTAX_NAMEANDUID_INVALID_DN.get(
			valueString, getExceptionMessage(e)));
			return false;
			}

			// If there is an "optional uid", then normalize it and make sure it only
			// contains valid binary digits.
			if (sharpPos > 0)
			{
			int endPos = valueLength - 2;
			for (int i=sharpPos+2; i < endPos; i++)
			{
			char c = valueString.charAt(i);
			if (c != '0' && c != '1')
			{
			invalidReason.append(
			ERR_ATTR_SYNTAX_NAMEANDUID_ILLEGAL_BINARY_DIGIT.get(valueString, c, i));
			return false;
			}
			}
			}


			// If we've gotten here, then the value is acceptable.
			return true;
			}

			/** {@inheritDoc} */
			public boolean isBEREncodingRequired()
			{
			return false;
			}

			/** {@inheritDoc} */
			public boolean isHumanReadable()
			{
			return true;
			}
			}