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
030
031 import org.opends.server.admin.std.server.AttributeSyntaxCfg;
032 import org.opends.server.api.ApproximateMatchingRule;
033 import org.opends.server.api.AttributeSyntax;
034 import org.opends.server.api.EqualityMatchingRule;
035 import org.opends.server.api.OrderingMatchingRule;
036 import org.opends.server.api.SubstringMatchingRule;
037 import org.opends.server.config.ConfigException;
038 import org.opends.server.core.DirectoryServer;
039 import org.opends.server.types.ByteString;
040
041
042
043 import static org.opends.server.loggers.ErrorLogger.*;
044 import static org.opends.messages.SchemaMessages.*;
045 import org.opends.messages.MessageBuilder;
046 import static org.opends.server.schema.SchemaConstants.*;
047
048
049 /**
050 * This class implements the printable string attribute syntax, which is simply
051 * a string of characters from a limited ASCII character set (uppercase and
052 * lowercase letters, numeric digits, the space, and a set of various symbols).
053 * By default, they will be treated in a case-insensitive manner, and equality,
054 * ordering, substring, and approximate matching will be allowed.
055 */
056 public class PrintableStringSyntax
057 extends AttributeSyntax<AttributeSyntaxCfg>
058 {
059 // The default approximate matching rule for this syntax.
060 private ApproximateMatchingRule defaultApproximateMatchingRule;
061
062 // The default equality matching rule for this syntax.
063 private EqualityMatchingRule defaultEqualityMatchingRule;
064
065 // The default ordering matching rule for this syntax.
066 private OrderingMatchingRule defaultOrderingMatchingRule;
067
068 // The default substring matching rule for this syntax.
069 private SubstringMatchingRule defaultSubstringMatchingRule;
070
071
072
073 /**
074 * Creates a new instance of this syntax. Note that the only thing that
075 * should be done here is to invoke the default constructor for the
076 * superclass. All initialization should be performed in the
077 * <CODE>initializeSyntax</CODE> method.
078 */
079 public PrintableStringSyntax()
080 {
081 super();
082 }
083
084
085
086 /**
087 * {@inheritDoc}
088 */
089 public void initializeSyntax(AttributeSyntaxCfg configuration)
090 throws ConfigException
091 {
092 defaultApproximateMatchingRule =
093 DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID);
094 if (defaultApproximateMatchingRule == null)
095 {
096 logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get(
097 AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRINTABLE_STRING_NAME));
098 }
099
100 defaultEqualityMatchingRule =
101 DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID);
102 if (defaultEqualityMatchingRule == null)
103 {
104 logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(
105 EMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME));
106 }
107
108 defaultOrderingMatchingRule =
109 DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID);
110 if (defaultOrderingMatchingRule == null)
111 {
112 logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(
113 OMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME));
114 }
115
116 defaultSubstringMatchingRule =
117 DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID);
118 if (defaultSubstringMatchingRule == null)
119 {
120 logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(
121 SMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME));
122 }
123 }
124
125
126
127 /**
128 * Retrieves the common name for this attribute syntax.
129 *
130 * @return The common name for this attribute syntax.
131 */
132 public String getSyntaxName()
133 {
134 return SYNTAX_PRINTABLE_STRING_NAME;
135 }
136
137
138
139 /**
140 * Retrieves the OID for this attribute syntax.
141 *
142 * @return The OID for this attribute syntax.
143 */
144 public String getOID()
145 {
146 return SYNTAX_PRINTABLE_STRING_OID;
147 }
148
149
150
151 /**
152 * Retrieves a description for this attribute syntax.
153 *
154 * @return A description for this attribute syntax.
155 */
156 public String getDescription()
157 {
158 return SYNTAX_PRINTABLE_STRING_DESCRIPTION;
159 }
160
161
162
163 /**
164 * Retrieves the default equality matching rule that will be used for
165 * attributes with this syntax.
166 *
167 * @return The default equality matching rule that will be used for
168 * attributes with this syntax, or <CODE>null</CODE> if equality
169 * matches will not be allowed for this type by default.
170 */
171 public EqualityMatchingRule getEqualityMatchingRule()
172 {
173 return defaultEqualityMatchingRule;
174 }
175
176
177
178 /**
179 * Retrieves the default ordering matching rule that will be used for
180 * attributes with this syntax.
181 *
182 * @return The default ordering matching rule that will be used for
183 * attributes with this syntax, or <CODE>null</CODE> if ordering
184 * matches will not be allowed for this type by default.
185 */
186 public OrderingMatchingRule getOrderingMatchingRule()
187 {
188 return defaultOrderingMatchingRule;
189 }
190
191
192
193 /**
194 * Retrieves the default substring matching rule that will be used for
195 * attributes with this syntax.
196 *
197 * @return The default substring matching rule that will be used for
198 * attributes with this syntax, or <CODE>null</CODE> if substring
199 * matches will not be allowed for this type by default.
200 */
201 public SubstringMatchingRule getSubstringMatchingRule()
202 {
203 return defaultSubstringMatchingRule;
204 }
205
206
207
208 /**
209 * Retrieves the default approximate matching rule that will be used for
210 * attributes with this syntax.
211 *
212 * @return The default approximate matching rule that will be used for
213 * attributes with this syntax, or <CODE>null</CODE> if approximate
214 * matches will not be allowed for this type by default.
215 */
216 public ApproximateMatchingRule getApproximateMatchingRule()
217 {
218 return defaultApproximateMatchingRule;
219 }
220
221
222
223 /**
224 * Indicates whether the provided value is acceptable for use in an attribute
225 * with this syntax. If it is not, then the reason may be appended to the
226 * provided buffer.
227 *
228 * @param value The value for which to make the determination.
229 * @param invalidReason The buffer to which the invalid reason should be
230 * appended.
231 *
232 * @return <CODE>true</CODE> if the provided value is acceptable for use with
233 * this syntax, or <CODE>false</CODE> if not.
234 */
235 public boolean valueIsAcceptable(ByteString value,
236 MessageBuilder invalidReason)
237 {
238 // Check to see if the provided value was null. If so, then that's not
239 // acceptable.
240 if (value == null)
241 {
242
243 invalidReason.append(WARN_ATTR_SYNTAX_PRINTABLE_STRING_EMPTY_VALUE.get());
244 return false;
245 }
246
247
248 // Get the value as a string and determine its length. If it is empty, then
249 // that's not acceptable.
250 String valueString = value.stringValue();
251 int valueLength = valueString.length();
252 if (valueLength == 0)
253 {
254
255 invalidReason.append(WARN_ATTR_SYNTAX_PRINTABLE_STRING_EMPTY_VALUE.get());
256 return false;
257 }
258
259
260 // Iterate through all the characters and see if they are acceptable.
261 for (int i=0; i < valueLength; i++)
262 {
263 char c = valueString.charAt(i);
264 if (! PrintableString.isPrintableCharacter(c))
265 {
266
267 invalidReason.append(
268 WARN_ATTR_SYNTAX_PRINTABLE_STRING_ILLEGAL_CHARACTER.get(
269 valueString, String.valueOf(c), i));
270 return false;
271 }
272 }
273
274
275 // If we've gotten here, then the value is OK.
276 return true;
277 }
278 }
279