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 029 import org.opends.server.types.DebugLogLevel; 030 import static org.opends.server.loggers.ErrorLogger.logError; 031 import static org.opends.server.loggers.debug.DebugLogger.*; 032 import org.opends.server.loggers.debug.DebugTracer; 033 import static org.opends.messages.SchemaMessages.*; 034 import org.opends.messages.MessageBuilder; 035 import static org.opends.server.schema.SchemaConstants.*; 036 037 import org.opends.server.admin.std.server.AttributeSyntaxCfg; 038 import org.opends.server.api.ApproximateMatchingRule; 039 import org.opends.server.api.AttributeSyntax; 040 import org.opends.server.api.AttributeValueDecoder; 041 import org.opends.server.api.EqualityMatchingRule; 042 import org.opends.server.api.OrderingMatchingRule; 043 import org.opends.server.api.SubstringMatchingRule; 044 import org.opends.server.config.ConfigException; 045 import org.opends.server.core.AbsoluteSubtreeSpecification; 046 import org.opends.server.core.DirectoryServer; 047 import org.opends.server.types.AttributeValue; 048 import org.opends.server.types.ByteString; 049 import org.opends.server.types.DirectoryException; 050 051 052 053 /** 054 * This class defines the absolute subtree specification attribute 055 * syntax, which is used to select sets of entries in dynamic groups and 056 * access control rules. 057 */ 058 public final class AbsoluteSubtreeSpecificationSyntax 059 extends AttributeSyntax<AttributeSyntaxCfg> 060 { 061 /** 062 * The tracer object for the debug logger. 063 */ 064 private static final DebugTracer TRACER = getTracer(); 065 066 // The default equality matching rule for this syntax. 067 private EqualityMatchingRule defaultEqualityMatchingRule; 068 069 // The default ordering matching rule for this syntax. 070 private OrderingMatchingRule defaultOrderingMatchingRule; 071 072 // The default substring matching rule for this syntax. 073 private SubstringMatchingRule defaultSubstringMatchingRule; 074 075 /** 076 * An {@link AbsoluteSubtreeSpecification} attribute value decoder for 077 * this syntax. 078 */ 079 public static final AttributeValueDecoder<AbsoluteSubtreeSpecification> 080 DECODER = new AttributeValueDecoder<AbsoluteSubtreeSpecification>() { 081 /** 082 * {@inheritDoc} 083 */ 084 public AbsoluteSubtreeSpecification decode(AttributeValue value) 085 throws DirectoryException { 086 return AbsoluteSubtreeSpecification.valueOf(value.getStringValue()); 087 } 088 }; 089 090 /** 091 * Creates a new instance of this syntax. Note that the only thing 092 * that should be done here is to invoke the default constructor for 093 * the superclass. All initialization should be performed in the 094 * <CODE>initializeSyntax</CODE> method. 095 */ 096 public AbsoluteSubtreeSpecificationSyntax() { 097 // No implementation required. 098 } 099 100 /** 101 * {@inheritDoc} 102 */ 103 public void initializeSyntax(AttributeSyntaxCfg configuration) 104 throws ConfigException { 105 106 defaultEqualityMatchingRule = DirectoryServer 107 .getEqualityMatchingRule(EMR_OCTET_STRING_OID); 108 if (defaultEqualityMatchingRule == null) { 109 logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( 110 EMR_OCTET_STRING_OID, SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_NAME)); 111 } 112 113 defaultOrderingMatchingRule = DirectoryServer 114 .getOrderingMatchingRule(OMR_OCTET_STRING_OID); 115 if (defaultOrderingMatchingRule == null) { 116 logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( 117 OMR_OCTET_STRING_OID, SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_NAME)); 118 } 119 120 defaultSubstringMatchingRule = DirectoryServer 121 .getSubstringMatchingRule(SMR_OCTET_STRING_OID); 122 if (defaultSubstringMatchingRule == null) { 123 logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( 124 SMR_OCTET_STRING_OID, SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_NAME)); 125 } 126 } 127 128 /** 129 * Retrieves the common name for this attribute syntax. 130 * 131 * @return The common name for this attribute syntax. 132 */ 133 public String getSyntaxName() { 134 135 return SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_NAME; 136 } 137 138 /** 139 * Retrieves the OID for this attribute syntax. 140 * 141 * @return The OID for this attribute syntax. 142 */ 143 public String getOID() { 144 145 return SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_OID; 146 } 147 148 /** 149 * Retrieves a description for this attribute syntax. 150 * 151 * @return A description for this attribute syntax. 152 */ 153 public String getDescription() { 154 155 return SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_DESCRIPTION; 156 } 157 158 /** 159 * Retrieves the default equality matching rule that will be used for 160 * attributes with this syntax. 161 * 162 * @return The default equality matching rule that will be used for 163 * attributes with this syntax, or <CODE>null</CODE> if 164 * equality matches will not be allowed for this type by 165 * default. 166 */ 167 public EqualityMatchingRule getEqualityMatchingRule() { 168 169 return defaultEqualityMatchingRule; 170 } 171 172 /** 173 * Retrieves the default ordering matching rule that will be used for 174 * attributes with this syntax. 175 * 176 * @return The default ordering matching rule that will be used for 177 * attributes with this syntax, or <CODE>null</CODE> if 178 * ordering matches will not be allowed for this type by 179 * default. 180 */ 181 public OrderingMatchingRule getOrderingMatchingRule() { 182 183 return defaultOrderingMatchingRule; 184 } 185 186 /** 187 * Retrieves the default substring matching rule that will be used for 188 * attributes with this syntax. 189 * 190 * @return The default substring matching rule that will be used for 191 * attributes with this syntax, or <CODE>null</CODE> if 192 * substring matches will not be allowed for this type by 193 * default. 194 */ 195 public SubstringMatchingRule getSubstringMatchingRule() { 196 197 return defaultSubstringMatchingRule; 198 } 199 200 /** 201 * Retrieves the default approximate matching rule that will be used 202 * for attributes with this syntax. 203 * 204 * @return The default approximate matching rule that will be used for 205 * attributes with this syntax, or <CODE>null</CODE> if 206 * approximate matches will not be allowed for this type by 207 * default. 208 */ 209 public ApproximateMatchingRule getApproximateMatchingRule() { 210 211 // There is no approximate matching rule by default. 212 return null; 213 } 214 215 /** 216 * Indicates whether the provided value is acceptable for use in an 217 * attribute with this syntax. If it is not, then the reason may be 218 * appended to the provided buffer. 219 * 220 * @param value 221 * The value for which to make the determination. 222 * @param invalidReason 223 * The buffer to which the invalid reason should be appended. 224 * @return <CODE>true</CODE> if the provided value is acceptable for 225 * use with this syntax, or <CODE>false</CODE> if not. 226 */ 227 public boolean valueIsAcceptable(ByteString value, 228 MessageBuilder invalidReason) 229 { 230 // Use the subtree specification code to make this determination. 231 try { 232 AbsoluteSubtreeSpecification.valueOf(value.stringValue()); 233 234 return true; 235 } catch (DirectoryException e) { 236 if (debugEnabled()) 237 { 238 TRACER.debugCaught(DebugLogLevel.ERROR, e); 239 } 240 241 invalidReason.append(e.getMessageObject()); 242 return false; 243 } 244 } 245 }