001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2006-2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.schema; 028 import org.opends.messages.Message; 029 030 031 032 import org.opends.server.admin.std.server.AttributeSyntaxCfg; 033 import org.opends.server.api.ApproximateMatchingRule; 034 import org.opends.server.api.AttributeSyntax; 035 import org.opends.server.api.AttributeValueDecoder; 036 import org.opends.server.api.EqualityMatchingRule; 037 import org.opends.server.api.OrderingMatchingRule; 038 import org.opends.server.api.SubstringMatchingRule; 039 import org.opends.server.config.ConfigException; 040 import org.opends.server.core.DirectoryServer; 041 import org.opends.server.protocols.asn1.ASN1OctetString; 042 import org.opends.server.types.AttributeValue; 043 import org.opends.server.types.ByteString; 044 import org.opends.server.types.DirectoryException; 045 046 047 import org.opends.server.types.ResultCode; 048 049 import static org.opends.server.loggers.ErrorLogger.*; 050 import static org.opends.messages.SchemaMessages.*; 051 import org.opends.messages.MessageBuilder; 052 import static org.opends.server.schema.SchemaConstants.*; 053 054 055 /** 056 * This class defines the Boolean attribute syntax, which only allows values of 057 * "TRUE" or "FALSE" (although this implementation is more flexible and will 058 * also allow "YES", "ON", or "1" instead of "TRUE", or "NO", "OFF", or "0" 059 * instead of "FALSE"). Only equality matching is allowed by default for this 060 * syntax. 061 */ 062 public class BooleanSyntax 063 extends AttributeSyntax<AttributeSyntaxCfg> 064 { 065 // The default equality matching rule for this syntax. 066 private EqualityMatchingRule defaultEqualityMatchingRule; 067 068 069 070 /** 071 * A {@link Boolean} attribute value decoder for this syntax. 072 */ 073 public static final AttributeValueDecoder<Boolean> DECODER = 074 new AttributeValueDecoder<Boolean>() 075 { 076 /** 077 * {@inheritDoc} 078 */ 079 public Boolean decode(AttributeValue value) throws DirectoryException 080 { 081 ByteString octetString = value.getNormalizedValue(); 082 return decodeBooleanValue(octetString); 083 } 084 }; 085 086 087 088 /** 089 * Creates a new instance of this syntax. Note that the only thing that 090 * should be done here is to invoke the default constructor for the 091 * superclass. All initialization should be performed in the 092 * <CODE>initializeSyntax</CODE> method. 093 */ 094 public BooleanSyntax() 095 { 096 super(); 097 } 098 099 100 101 /** 102 * {@inheritDoc} 103 */ 104 public void initializeSyntax(AttributeSyntaxCfg configuration) 105 throws ConfigException 106 { 107 defaultEqualityMatchingRule = 108 DirectoryServer.getEqualityMatchingRule(EMR_BOOLEAN_OID); 109 if (defaultEqualityMatchingRule == null) 110 { 111 logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( 112 EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME)); 113 } 114 } 115 116 117 118 /** 119 * Retrieves the common name for this attribute syntax. 120 * 121 * @return The common name for this attribute syntax. 122 */ 123 public String getSyntaxName() 124 { 125 return SYNTAX_BOOLEAN_NAME; 126 } 127 128 129 130 /** 131 * Retrieves the OID for this attribute syntax. 132 * 133 * @return The OID for this attribute syntax. 134 */ 135 public String getOID() 136 { 137 return SYNTAX_BOOLEAN_OID; 138 } 139 140 141 142 /** 143 * Retrieves a description for this attribute syntax. 144 * 145 * @return A description for this attribute syntax. 146 */ 147 public String getDescription() 148 { 149 return SYNTAX_BOOLEAN_DESCRIPTION; 150 } 151 152 153 154 /** 155 * Retrieves the default equality matching rule that will be used for 156 * attributes with this syntax. 157 * 158 * @return The default equality matching rule that will be used for 159 * attributes with this syntax, or <CODE>null</CODE> if equality 160 * matches will not be allowed for this type by default. 161 */ 162 public EqualityMatchingRule getEqualityMatchingRule() 163 { 164 return defaultEqualityMatchingRule; 165 } 166 167 168 169 /** 170 * Retrieves the default ordering matching rule that will be used for 171 * attributes with this syntax. 172 * 173 * @return The default ordering matching rule that will be used for 174 * attributes with this syntax, or <CODE>null</CODE> if ordering 175 * matches will not be allowed for this type by default. 176 */ 177 public OrderingMatchingRule getOrderingMatchingRule() 178 { 179 // Ordering matches are not allowed by default. 180 return null; 181 } 182 183 184 185 /** 186 * Retrieves the default substring matching rule that will be used for 187 * attributes with this syntax. 188 * 189 * @return The default substring matching rule that will be used for 190 * attributes with this syntax, or <CODE>null</CODE> if substring 191 * matches will not be allowed for this type by default. 192 */ 193 public SubstringMatchingRule getSubstringMatchingRule() 194 { 195 // Substring matches are not allowed by default. 196 return null; 197 } 198 199 200 201 /** 202 * Retrieves the default approximate matching rule that will be used for 203 * attributes with this syntax. 204 * 205 * @return The default approximate matching rule that will be used for 206 * attributes with this syntax, or <CODE>null</CODE> if approximate 207 * matches will not be allowed for this type by default. 208 */ 209 public ApproximateMatchingRule getApproximateMatchingRule() 210 { 211 // Approximate matches are not allowed by default. 212 return null; 213 } 214 215 216 217 /** 218 * Indicates whether the provided value is acceptable for use in an attribute 219 * with this syntax. If it is not, then the reason may be appended to the 220 * provided buffer. 221 * 222 * @param value The value for which to make the determination. 223 * @param invalidReason The buffer to which the invalid reason should be 224 * appended. 225 * 226 * @return <CODE>true</CODE> if the provided value is acceptable for use with 227 * this syntax, or <CODE>false</CODE> if not. 228 */ 229 public boolean valueIsAcceptable(ByteString value, 230 MessageBuilder invalidReason) 231 { 232 String valueString = value.stringValue().toUpperCase(); 233 234 boolean returnValue = (valueString.equals("TRUE") || 235 valueString.equals("YES") || 236 valueString.equals("ON") || 237 valueString.equals("1") || 238 valueString.equals("FALSE") || 239 valueString.equals("NO") || 240 valueString.equals("OFF") || 241 valueString.equals("0")); 242 243 if (! returnValue) 244 { 245 invalidReason.append(WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get( 246 value.stringValue())); 247 } 248 249 return returnValue; 250 } 251 252 253 254 /** 255 * Retrieves an attribute value containing a representation of the provided 256 * boolean value. 257 * 258 * @param b The boolean value for which to retrieve the attribute value. 259 * 260 * @return The attribute value created from the provided boolean value. 261 */ 262 public static AttributeValue createBooleanValue(boolean b) 263 { 264 if (b) 265 { 266 return new AttributeValue(new ASN1OctetString("TRUE"), 267 new ASN1OctetString("TRUE")); 268 } 269 else 270 { 271 return new AttributeValue(new ASN1OctetString("FALSE"), 272 new ASN1OctetString("FALSE")); 273 } 274 } 275 276 277 278 /** 279 * Decodes the provided normalized value as a boolean. 280 * 281 * @param normalizedValue The normalized value to decode as a boolean. 282 * 283 * @return The decoded boolean value. 284 * 285 * @throws DirectoryException If the provided value cannot be decoded as a 286 * boolean. 287 */ 288 public static boolean decodeBooleanValue(ByteString normalizedValue) 289 throws DirectoryException 290 { 291 String valueString = normalizedValue.stringValue(); 292 if (valueString.equals("TRUE")) 293 { 294 return true; 295 } 296 else if (valueString.equals("FALSE")) 297 { 298 return false; 299 } 300 else 301 { 302 Message message = WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get(valueString); 303 throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, 304 message); 305 } 306 } 307 } 308