/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at * trunk/opends/resource/legal-notices/OpenDS.LICENSE * or https://OpenDS.dev.java.net/OpenDS.LICENSE. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, * add the following below this CDDL HEADER, with the fields enclosed * by brackets "[]" replaced with your own identifying information: * Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END * * * Portions Copyright 2006-2007 Sun Microsystems, Inc. */ package org.opends.server.schema; import org.opends.server.api.ApproximateMatchingRule; import org.opends.server.api.AttributeSyntax; import org.opends.server.api.AttributeValueDecoder; import org.opends.server.api.EqualityMatchingRule; import org.opends.server.api.OrderingMatchingRule; import org.opends.server.api.SubstringMatchingRule; import org.opends.server.config.ConfigEntry; import org.opends.server.config.ConfigException; import org.opends.server.core.DirectoryServer; import org.opends.server.protocols.asn1.ASN1OctetString; import org.opends.server.types.AttributeValue; import org.opends.server.types.ByteString; import org.opends.server.types.DirectoryException; import org.opends.server.types.ErrorLogCategory; import org.opends.server.types.ErrorLogSeverity; import org.opends.server.types.ResultCode; import static org.opends.server.loggers.Error.*; import static org.opends.server.messages.MessageHandler.*; import static org.opends.server.messages.SchemaMessages.*; import static org.opends.server.schema.SchemaConstants.*; /** * This class defines the Boolean attribute syntax, which only allows values of * "TRUE" or "FALSE" (although this implementation is more flexible and will * also allow "YES", "ON", or "1" instead of "TRUE", or "NO", "OFF", or "0" * instead of "FALSE"). Only equality matching is allowed by default for this * syntax. */ public class BooleanSyntax extends AttributeSyntax { // The default equality matching rule for this syntax. private EqualityMatchingRule defaultEqualityMatchingRule; /** * A {@link Boolean} attribute value decoder for this syntax. */ public static final AttributeValueDecoder DECODER = new AttributeValueDecoder() { /** * {@inheritDoc} */ public Boolean decode(AttributeValue value) throws DirectoryException { ByteString octetString = value.getNormalizedValue(); return decodeBooleanValue(octetString); } }; /** * 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 * superclass. All initialization should be performed in the * initializeSyntax method. */ public BooleanSyntax() { super(); } /** * Initializes this attribute syntax based on the information in the provided * configuration entry. * * @param configEntry The configuration entry that contains the information * to use to initialize this attribute syntax. * * @throws ConfigException If an unrecoverable problem arises in the * process of performing the initialization. */ public void initializeSyntax(ConfigEntry configEntry) throws ConfigException { defaultEqualityMatchingRule = DirectoryServer.getEqualityMatchingRule(EMR_BOOLEAN_OID); if (defaultEqualityMatchingRule == null) { logError(ErrorLogCategory.SCHEMA, ErrorLogSeverity.SEVERE_ERROR, MSGID_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME); } } /** * Retrieves the common name for this attribute syntax. * * @return The common name for this attribute syntax. */ public String getSyntaxName() { return SYNTAX_BOOLEAN_NAME; } /** * Retrieves the OID for this attribute syntax. * * @return The OID for this attribute syntax. */ public String getOID() { return SYNTAX_BOOLEAN_OID; } /** * Retrieves a description for this attribute syntax. * * @return A description for this attribute syntax. */ public String getDescription() { return SYNTAX_BOOLEAN_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 null if equality * matches will not be allowed for this type by default. */ public EqualityMatchingRule 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 null if ordering * matches will not be allowed for this type by default. */ public OrderingMatchingRule getOrderingMatchingRule() { // Ordering matches are not allowed 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 null if substring * matches will not be allowed for this type by default. */ public SubstringMatchingRule getSubstringMatchingRule() { // Substring matches are not allowed by default. return null; } /** * 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 null if approximate * matches will not be allowed for this type by default. */ public ApproximateMatchingRule getApproximateMatchingRule() { // Approximate matches are not allowed 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 true if the provided value is acceptable for use with * this syntax, or false if not. */ public boolean valueIsAcceptable(ByteString value, StringBuilder invalidReason) { String valueString = value.stringValue().toUpperCase(); boolean returnValue = (valueString.equals("TRUE") || valueString.equals("YES") || valueString.equals("ON") || valueString.equals("1") || valueString.equals("FALSE") || valueString.equals("NO") || valueString.equals("OFF") || valueString.equals("0")); if (! returnValue) { invalidReason.append(getMessage(MSGID_ATTR_SYNTAX_ILLEGAL_BOOLEAN, value.stringValue())); } return returnValue; } /** * Retrieves an attribute value containing a representation of the provided * boolean value. * * @param b The boolean value for which to retrieve the attribute value. * * @return The attribute value created from the provided boolean value. */ public static AttributeValue createBooleanValue(boolean b) { if (b) { return new AttributeValue(new ASN1OctetString("TRUE"), new ASN1OctetString("TRUE")); } else { return new AttributeValue(new ASN1OctetString("FALSE"), new ASN1OctetString("FALSE")); } } /** * Decodes the provided normalized value as a boolean. * * @param normalizedValue The normalized value to decode as a boolean. * * @return The decoded boolean value. * * @throws DirectoryException If the provided value cannot be decoded as a * boolean. */ public static boolean decodeBooleanValue(ByteString normalizedValue) throws DirectoryException { String valueString = normalizedValue.stringValue(); if (valueString.equals("TRUE")) { return true; } else if (valueString.equals("FALSE")) { return false; } else { int msgID = MSGID_ATTR_SYNTAX_ILLEGAL_BOOLEAN; String message = getMessage(msgID, valueString); throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, msgID); } } }