/*
* 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.messages;
import static org.opends.server.config.ConfigConstants.*;
import static org.opends.server.messages.MessageHandler.*;
/**
* This class defines the set of message IDs and default format strings for
* messages associated with the server schema, including matching rules,
* syntaxes, attribute types, and objectclasses.
*/
public class SchemaMessages
{
/**
* The message ID for the message that will be used if an attribute syntax
* cannot retrieve the appropriate approximate matching rule. This takes two
* arguments, which are the name of the syntax and the OID for the matching
* rule.
*/
public static final int MSGID_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 1;
/**
* The message ID for the message that will be used if an attribute syntax
* cannot retrieve the appropriate equality matching rule. This takes two
* arguments, which are the name of the syntax and the OID for the matching
* rule.
*/
public static final int MSGID_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 2;
/**
* The message ID for the message that will be used if an attribute syntax
* cannot retrieve the appropriate ordering matching rule. This takes two
* arguments, which are the name of the syntax and the OID for the matching
* rule.
*/
public static final int MSGID_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 3;
/**
* The message ID for the message that will be used if an attribute syntax
* cannot retrieve the appropriate substring matching rule. This takes two
* arguments, which are the name of the syntax and the OID for the matching
* rule.
*/
public static final int MSGID_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 4;
/**
* The message ID for the message that will be used if an illegal value is
* provided for an attribute with a Boolean syntax. This takes a single
* string argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ILLEGAL_BOOLEAN =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 5;
/**
* The message ID for the message that will be used if a bit string value is
* too short to be valid. This takes a single string argument, which is the
* provided value.
*/
public static final int MSGID_ATTR_SYNTAX_BIT_STRING_TOO_SHORT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 6;
/**
* The message ID for the message that will be used if a bit string value is
* not surrounded by single quotes and followed by a capital B. This takes a
* single string argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_BIT_STRING_NOT_QUOTED =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 7;
/**
* The message ID for the message that will be used if a bit string value
* contains a bit element that is not a zero or a one. This takes two
* arguments, which are the provided value and the invalid binary digit.
*/
public static final int MSGID_ATTR_SYNTAX_BIT_STRING_INVALID_BIT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 8;
/**
* The message ID for the message that will be used if a country string value
* has a length that is not exactly two characters. This takes a single
* argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_COUNTRY_STRING_INVALID_LENGTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 9;
/**
* The message ID for the message that will be used if a country string value
* contains non-printable characters. This takes a single argument, which is
* the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_COUNTRY_STRING_NOT_PRINTABLE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 10;
/**
* The message ID for the message that will be used if a delivery method value
* does not contain any elements. This takes a single string argument, which
* is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_DELIVERY_METHOD_NO_ELEMENTS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 11;
/**
* The message ID for the message that will be used if a delivery method value
* contains an invalid element. This takes two arguments, which are the
* provided value and the invalid element.
*/
public static final int MSGID_ATTR_SYNTAX_DELIVERY_METHOD_INVALID_ELEMENT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 12;
/**
* The message ID for the message that will be used if a value is too short
* to be a valid generalized time value. This takes a single argument, which
* is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_TOO_SHORT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 13;
/**
* The message ID for the message that will be used if a generalized time
* value contains a century or year that is not valid. This takes two
* arguments, which are the provided value and illegal century or year
* character.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_YEAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 14;
/**
* The message ID for the message that will be used if a generalized time
* value contains a month that is not valid. This takes two arguments, which
* are the provided value and illegal month substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_MONTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 15;
/**
* The message ID for the message that will be used if a generalized time
* value contains a day that is not valid. This takes two arguments, which
* are the provided value and illegal day substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_DAY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 16;
/**
* The message ID for the message that will be used if a generalized time
* value contains an hour that is not valid. This takes two arguments, which
* are the provided value and illegal hour substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_HOUR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 17;
/**
* The message ID for the message that will be used if a generalized time
* value contains a minute that is not valid. This takes two arguments, which
* are the provided value and illegal minute substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_MINUTE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 18;
/**
* The message ID for the message that will be used if a generalized time
* value contains a second that is not valid. This takes two arguments, which
* are the provided value and illegal second substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_SECOND =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 19;
/**
* The message ID for the message that will be used if a generalized time
* value contains a subsecond that is not valid. This takes one argument,
* which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_SUBSECOND =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 20;
/**
* The message ID for the message that will be used if a generalized time
* value contains a subsecond that is too long. This takes one argument,
* which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_LONG_SUBSECOND =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 21;
/**
* The message ID for the message that will be used if a generalized time
* value contains an invalid GMT offset. This takes two arguments, which
* are the provided value and illegal offset substring.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_OFFSET =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 22;
/**
* The message ID for the message that will be used if a generalized time
* value contains an illegal character. This takes three arguments, which
* are the provided value, the illegal character, and the position of the
* illegal character.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 23;
/**
* The message ID for the message that will be used if a generalized time
* value cannot be parsed to a Java Date. This takes two
* arguments, which are the provided value and a string representation of the
* exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_CANNOT_PARSE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 24;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly. This takes two arguments, which are the
* provided value and a string representation of the exception that was
* caught.
*/
public static final int MSGID_ATTR_SYNTAX_DN_INVALID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 25;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it ends with a comma. This takes
* a single argument, which is the provided DN string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_END_WITH_COMMA =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 26;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* starts with a digit. This takes two arguments, which are the provided DN
* string and the illegal digit character.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_START_WITH_DIGIT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 27;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* contains an illegal character. This takes three arguments, which are the
* provided DN string, the illegal character, and the position of that
* character in the string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 28;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* contains an underscore character but attribute name exceptions are not
* allowed. This takes two arguments, which are the provided DN string and
* the name of the configuration option that would allow underscore
* characters.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_UNDERSCORE_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 29;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* starts with a dash. This takes a single argument, which is the provided DN
* string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DASH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 30;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* starts with an underscore. This takes two arguments, which are the
* provided DN string and the name of the configuration option that would
* allow underscore characters as long as they aren't in the first position.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_UNDERSCORE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 31;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* starts with a numeric digit in a way in which it is not allowed. This
* takes three arguments, which are the provided DN string, the illegal digit,
* and the name of the configuration attribute that would allow digits to be
* used as the first character of an attribute name.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DIGIT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 32;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains a zero-length attribute
* name. This takes a single argument, which is the provided DN string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_NO_NAME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 33;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an attribute name that
* contains a period but is not an OID. This takes two arguments, which are
* the provided DN string and the attribute name..
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 34;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it ends with the attribute name.
* This takes two arguments, which are the provided DN string and the
* attribute name.
*/
public static final int MSGID_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 35;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because the next non-space character after
* an attribute name is not an equal sign. This takes three arguments, which
* are the provided DN string, the attribute name, and the illegal character.
*/
public static final int MSGID_ATTR_SYNTAX_DN_NO_EQUAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 36;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains an invalid character.
* This takes three arguments, which are the provided DN string, the invalid
* character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DN_INVALID_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 37;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains a value that appears to
* be hex-encoded but without a positive multiple of two hex characters. This
* takes a single argument, which is the provided DN string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 38;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it contains a value that appears to
* be hex-encoded but included an invalid hexadecimal digit. This takes two
* arguments, which are the provided DN string and the invalid character.
*/
public static final int MSGID_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 39;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because an unexpected failure occurred
* while trying to parse an RDN component value. This takes two arguments,
* which are the provided DN string and a string representation of the
* exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 40;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it has a quoted value that is not
* properly terminated with another quote. This takes a single argument,
* which is the provided DN string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_UNMATCHED_QUOTE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 41;
/**
* The message ID for the message that will be used if a distinguished name
* value cannot be parsed properly because it has a value with an escaped
* hex digit that is not followed by a second hex digit. This takes a single
* argument, which is the provided DN string.
*/
public static final int MSGID_ATTR_SYNTAX_DN_ESCAPED_HEX_VALUE_INVALID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 42;
/**
* The message ID for the message that will be used if an integer value cannot
* be parsed because the first digit is zero but the value is not zero. This
* takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_INTEGER_INITIAL_ZERO =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 43;
/**
* The message ID for the message that will be used if an integer value cannot
* be parsed because the it contains a dash that is not in the first position.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_INTEGER_MISPLACED_DASH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 44;
/**
* The message ID for the message that will be used if an integer value cannot
* be parsed because it contains an illegal character. This takes three
* arguments, which are the provided value, the illegal character, and the
* position of the illegal character.
*/
public static final int MSGID_ATTR_SYNTAX_INTEGER_INVALID_CHARACTER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 45;
/**
* The message ID for the message that will be used if an integer value cannot
* be parsed because it is empty. This takes a single argument, which is the
* provided value.
*/
public static final int MSGID_ATTR_SYNTAX_INTEGER_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 46;
/**
* The message ID for the message that will be used if an integer value cannot
* be parsed because it starts with a dash but doesn't contain a value. This
* takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 47;
/**
* The message ID for the message that will be used if an OID value cannot
* be parsed because it is blank. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_OID_NO_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 48;
/**
* The message ID for the message that will be used if an OID value cannot
* be parsed because it contains an illegal character. This takes two
* arguments, which are the provided value and the position of the illegal
* character.
*/
public static final int MSGID_ATTR_SYNTAX_OID_ILLEGAL_CHARACTER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 49;
/**
* The message ID for the message that will be used if an OID value cannot
* be parsed because it contains consecutive periods. This takes two
* arguments, which are the provided value and the position of the illegal
* character.
*/
public static final int MSGID_ATTR_SYNTAX_OID_CONSECUTIVE_PERIODS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 50;
/**
* The message ID for the message that will be used if an OID value cannot
* be parsed because it ends with a period. This takes a single argument,
* which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_OID_ENDS_WITH_PERIOD =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 51;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 52;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 53;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 54;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 55;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 56;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 57;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 58;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 59;
/**
* The message ID for the message that will be used if an attribute type
* description value cannot be parsed because a quotation mark was expected
* but something else was found. This takes three arguments, which are the
* provided value, the name of the token after which the quote was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_QUOTE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 60;
/**
* The message ID for the message that will be used if an attribute type
* description references a superior attribute type that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* attribute type description being defined and the name or OID of the
* superior type that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SUPERIOR_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 61;
/**
* The message ID for the message that will be used if an attribute type
* description references an approximate matching rule that is not defined in
* the server schema. This takes two arguments, which are the OID of the
* attribute type description being defined and the OID of the approximate
* matching rule that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_APPROXIMATE_MR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 62;
/**
* The message ID for the message that will be used if an attribute type
* description references an equality matching rule that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* attribute type description being defined and the OID of the equality
* matching rule that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_EQUALITY_MR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 63;
/**
* The message ID for the message that will be used if an attribute type
* description references an ordering matching rule that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* attribute type description being defined and the OID of the ordering
* matching rule that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_ORDERING_MR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 64;
/**
* The message ID for the message that will be used if an attribute type
* description references a substring matching rule that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* attribute type description being defined and the OID of the substring
* matching rule that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SUBSTRING_MR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 65;
/**
* The message ID for the message that will be used if an attribute type
* description references a syntax that is not defined in the server schema.
* This takes two arguments, which are the OID of the attribute type
* description being defined and the OID of the syntax that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SYNTAX =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 66;
/**
* The message ID for the message that will be used if an attribute type
* description references an illegal attribute usage. This takes three
* arguments, which are the OID of the attribute type description being
* defined, the specified usage string, and the default usage string that will
* be used instead.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_INVALID_ATTRIBUTE_USAGE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 67;
/**
* The message ID for the message that will be used if an attribute type
* description cannot be parsed because it contains an unexpected character
* where a single quote should be. This takes three arguments, which are the
* provided attribute type description, the position in which the quote was
* expected, and the character that was found there instead.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 68;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 69;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 70;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 71;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 72;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 73;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 74;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 75;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 76;
/**
* The message ID for the message that will be used if an objectclass
* description value cannot be parsed because a quotation mark was expected
* but something else was found. This takes three arguments, which are the
* provided value, the name of the token after which the quote was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_QUOTE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 77;
/**
* The message ID for the message that will be used if an objectclass
* description references a superior objectclass that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* objectclass description being defined and the name or OID of the superior
* class that should be used.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_SUPERIOR_CLASS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 78;
/**
* The message ID for the message that will be used if an objectclass
* description cannot be parsed because it contains an unexpected character
* where a single quote should be. This takes three arguments, which are the
* provided objectclass description, the position in which the quote was
* expected, and the character that was found there instead.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 79;
/**
* The message ID for the message that will be used if an objectclass
* description includes a required attribute that is not defined in the server
* schema. This takes two arguments, which are the OID of the objectclass
* being defined, and the name or OID of the requested attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_REQUIRED_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 80;
/**
* The message ID for the message that will be used if an objectclass
* description includes an optional attribute that is not defined in the
* server schema. This takes two arguments, which are the OID of the
* objectclass being defined, and the name or OID of the requested attribute
* type.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_OPTIONAL_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 81;
/**
* The message ID for the message that will be used if an attribute is defined
* with the IA5 syntax but has an illegal character that is not allowed by
* that syntax. This takes two arguments, which are the provided value and
* the illegal character.
*/
public static final int MSGID_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 82;
/**
* The message ID for the message that will be used as the description for the
* configuration attribute indicating whether a strict telephone number format
* should be enforced. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_DESCRIPTION_STRICT_MODE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_INFORMATIONAL | 83;
/**
* The message ID for the message that will be used if a problem occurs when
* trying to determine whether the telephone number syntax should use strict
* mode. This takes two arguments, which are the DN of the configuration
* entry and a string representation of the exception that was caught.
*/
public static final int
MSGID_ATTR_SYNTAX_TELEPHONE_CANNOT_DETERMINE_STRICT_MODE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 84;
/**
* The message ID for the message that will be used if a proposed telephone
* number value is empty or null. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_EMPTY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 85;
/**
* The message ID for the message that will be used if strict telephone syntax
* checking is enabled but the provided value does not start with a plus sign.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_NO_PLUS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 86;
/**
* The message ID for the message that will be used if strict telephone syntax
* checking is enabled but the provided value contains an illegal character
* (i.e., not a digit and not a valid separator). This takes three arguments,
* which are the provided value, the illegal character and the position of
* that character.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 87;
/**
* The message ID for the message that will be used if a proposed telephone
* number value does not contain any numeric digits. This takes a single
* argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_NO_DIGITS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 88;
/**
* The message ID for the message that will be used to indicate that the
* configuration for the strict telephone number syntax checking has been
* changed. This takes two arguments, which are a string representation of
* the new value, and the DN of the configuration entry.
*/
public static final int MSGID_ATTR_SYNTAX_TELEPHONE_UPDATED_STRICT_MODE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_INFORMATIONAL | 89;
/**
* The message ID for the message that will be used if a numeric string value
* contains a character that is not a digit or a space. This takes three
* arguments, which are the provided value, the illegal character, and the
* position of that illegal character.
*/
public static final int MSGID_ATTR_SYNTAX_NUMERIC_STRING_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 90;
/**
* The message ID for the message that will be used if a numeric string value
* does not contain any characters. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_NUMERIC_STRING_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 91;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 92;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 93;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 94;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 95;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 96;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 97;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 98;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because an error occurred while trying
* to read the "DESC" token. This takes three arguments, which are the
* provided value, the position at which the DESC token was expected, and a
* string representation of the exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_CANNOT_READ_DESC_TOKEN =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 99;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because the "DESC" token was expected
* but something else was found instead. This takes two arguments, which are
* the provided value, and the token that was read instead of "DESC".
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_TOKEN_NOT_DESC =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 100;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because an error occurred while trying
* to read the value after the "DESC" token. This takes three arguments,
* which are the provided value, the position at which the value was expected,
* and a string representation of the exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_CANNOT_READ_DESC_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 101;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because a closing parenthesis was
* expected but a different character was found. This takes three arguments,
* which are the provided value, the position at which the parenthesis was
* expected, and the character that was found instead.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 102;
/**
* The message ID for the message that will be used if an attribute syntax
* description value cannot be parsed because a non-space character was found
* after the closing parenthesis. This takes three arguments, which are the
* provided value, the character that was read, and the position of that
* character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_AFTER_CLOSE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 103;
/**
* The message ID for the message that will be used if an attribute syntax
* description cannot be parsed because it contains an unexpected character
* where a single quote should be. This takes three arguments, which are the
* provided attribute type description, the position in which the quote was
* expected, and the character that was found there instead.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 104;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a printable string because it is empty or null. This does not
* take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_PRINTABLE_STRING_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 105;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a printable string because it contains an illegal character.
* This takes three arguments, which are the provided value, the illegal
* character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_PRINTABLE_STRING_ILLEGAL_CHARACTER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 106;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a substring assertion because it consists only of a wildcard.
* This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_SUBSTRING_ONLY_WILDCARD =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 107;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a substring assertion because it contains consecutive wildcard
* characters. This takes two arguments, which are the provided value and the
* position of the consecutive wildcards.
*/
public static final int MSGID_ATTR_SYNTAX_SUBSTRING_CONSECUTIVE_WILDCARDS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 108;
/**
* The message ID for the message that will be used if a value is too short
* to be a valid UTC time value. This takes a single argument, which is the
* provided value.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_TOO_SHORT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 109;
/**
* The message ID for the message that will be used if a UTC time value
* contains a century or year that is not valid. This takes two arguments,
* which are the provided value and illegal century or year character.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_YEAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 110;
/**
* The message ID for the message that will be used if a UTC time value
* contains a month that is not valid. This takes two arguments, which are
* the provided value and illegal month substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_MONTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 111;
/**
* The message ID for the message that will be used if a UTC time value
* contains a day that is not valid. This takes two arguments, which are the
* provided value and illegal day substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_DAY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 112;
/**
* The message ID for the message that will be used if a UTC time value
* contains an hour that is not valid. This takes two arguments, which are
* the provided value and illegal hour substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_HOUR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 113;
/**
* The message ID for the message that will be used if a UTC time value
* contains a minute that is not valid. This takes two arguments, which are
* the provided value and illegal minute substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_MINUTE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 114;
/**
* The message ID for the message that will be used if a UTC time value
* contains an illegal character. This takes three arguments, which are the
* provided value, the illegal character, and the position of the illegal
* character.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 115;
/**
* The message ID for the message that will be used if a UTC time value
* contains a second that is not valid. This takes two arguments, which are
* the provided value and illegal second substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_SECOND =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 116;
/**
* The message ID for the message that will be used if a UTC time value
* contains an invalid GMT offset. This takes two arguments, which are the
* provided value and illegal offset substring.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_OFFSET =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 117;
/**
* The message ID for the message that will be used if a UTC time value cannot
* be parsed to a Java Date. This takes two arguments, which are
* the provided value and a string representation of the exception that was
* caught.
*/
public static final int MSGID_ATTR_SYNTAX_UTC_TIME_CANNOT_PARSE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 118;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 119;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 120;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 121;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 122;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 123;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 124;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 125;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 126;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an unknown
* structural objectclass. This takes two arguments, which are the provided
* value and the OID of the unknown objectclass.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNKNOWN_STRUCTURAL_CLASS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 127;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references a structural
* objectclass that is not defined as structural. This takes four arguments,
* which are the provided value, the OID of the specified objectclass, the
* user-friendly name for the class, and a string representation of the
* objectclass type for the specified class.
*/
public static final int
MSGID_ATTR_SYNTAX_DCR_STRUCTURAL_CLASS_NOT_STRUCTURAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 128;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an unknown
* auxiliary objectclass. This takes two arguments, which are the provided
* value and the name or OID of the unknown auxiliary objectclass.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNKNOWN_AUXILIARY_CLASS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 129;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an auxiliary
* objectclass that is not defined as auxiliary. This takes four arguments,
* which are the provided value, the name or OID of the referenced
* objectclass, and a string representation of the objectclass type for the
* specified class
*/
public static final int MSGID_ATTR_SYNTAX_DCR_AUXILIARY_CLASS_NOT_AUXILIARY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 130;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an unknown
* required attribute type. This takes two arguments, which are the provided
* value and the name or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 131;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an unknown
* optional attribute type. This takes two arguments, which are the provided
* value and the name or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 132;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because it references an unknown
* prohibited attribute type. This takes two arguments, which are the
* provided value and the name or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_UNKNOWN_PROHIBITED_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 133;
/**
* The message ID for the message that will be used if a DIT content rule
* description value cannot be parsed because an invalid character was found
* where a single quote was expected. This takes three arguments, which are
* the provided value, the position at which the quote was expected, and the
* character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_DCR_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 134;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it is empty. This does not take any
* arguments.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 135;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it contains some other character where an
* open parenthesis was expected. This takes three arguments, which are the
* provided value, the position at which the parenthesis was expected, and the
* character that was found instead.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 136;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because the end of the value was reached while the
* server still expected to read more information. This takes a single
* argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 137;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because the OID contained two consecutive periods.
* This takes two arguments, which are the provided value and the position of
* the second period.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 138;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because the numeric OID contained an illegal
* character. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 139;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because the non-numeric OID contained an illegal
* character. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 140;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because a close parenthesis was found in an
* unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 141;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because an illegal character was encountered. This
* takes three arguments, which are the provided value, the illegal character,
* and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 142;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it references an unknown structural
* objectclass. This takes two arguments, which are the provided value and
* the OID of the unknown objectclass.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_STRUCTURAL_CLASS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 143;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it references a structural objectclass that
* is not defined as structural. This takes four arguments, which are the
* provided value, the OID of the specified objectclass, the user-friendly
* name for the class, and a string representation of the objectclass type for
* the specified class.
*/
public static final int
MSGID_ATTR_SYNTAX_NAME_FORM_STRUCTURAL_CLASS_NOT_STRUCTURAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 144;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it references an unknown required attribute
* type. This takes two arguments, which are the provided value and the name
* or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_REQUIRED_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 145;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it references an unknown optional attribute
* type. This takes two arguments, which are the provided value and the name
* or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_OPTIONAL_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 146;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because it does not specify a structural
* objectclass. This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_NO_STRUCTURAL_CLASS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 147;
/**
* The message ID for the message that will be used if a name form description
* value cannot be parsed because an invalid character was found where a
* single quote was expected. This takes three arguments, which are the
* provided value, the position at which the quote was expected, and the
* character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_NAME_FORM_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 148;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_MR_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 149;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_MR_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 150;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_MR_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 151;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int MSGID_ATTR_SYNTAX_MR_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 152;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 153;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 154;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int MSGID_ATTR_SYNTAX_MR_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 155;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 156;
/**
* The message ID for the message that will be used if a matching rule
* description refers to an attribute a syntax that is not defined in the
* server schema. This takes two arguments, which are the provided value and
* the OID of the unknown attribute syntax.
*/
public static final int MSGID_ATTR_SYNTAX_MR_UNKNOWN_SYNTAX =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 157;
/**
* The message ID for the message that will be used if a matching rule
* description does not specify the OID of the associated syntax. This takes
* a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_MR_NO_SYNTAX =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 158;
/**
* The message ID for the message that will be used if a matching rule
* description value cannot be parsed because an invalid character was found
* where a single quote was expected. This takes three arguments, which are
* the provided value, the position at which the quote was expected, and the
* character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_MR_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 159;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 160;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 161;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 162;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 163;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 164;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 165;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because the it is associated with an
* unknown matching rule. This takes two arguments, which are the provided
* value, and the unrecognized OID.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_UNKNOWN_MATCHING_RULE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 166;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 167;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 168;
/**
* The message ID for the message that will be used if a matching rule use
* description refers to an attribute type that is not defined in the
* server schema. This takes two arguments, which are the provided value and
* the name or OID of the unknown attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 169;
/**
* The message ID for the message that will be used if a matching rule use
* description does not specify any associated attribute types. This takes
* a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_NO_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 170;
/**
* The message ID for the message that will be used if a matching rule use
* description value cannot be parsed because an invalid character was found
* where a single quote was expected. This takes three arguments, which are
* the provided value, the position at which the quote was expected, and the
* character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_MRUSE_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 171;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because it is empty. This does not take
* any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 172;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because it contains some other character
* where an open parenthesis was expected. This takes three arguments, which
* are the provided value, the position at which the parenthesis was expected,
* and the character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_EXPECTED_OPEN_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 173;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because the end of the value was reached
* while the server still expected to read more information. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_TRUNCATED_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 174;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because the rule ID contained an illegal
* character. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_RULE_ID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 175;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because a close parenthesis was found in
* an unexpected location. This takes two arguments, which are the provided
* value and the position of the close parenthesis.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_UNEXPECTED_CLOSE_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 176;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because an illegal character was
* encountered. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 177;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because it references an unknown name
* form. This takes two arguments, which are the provided value and the name
* or OID of the specified name form.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_UNKNOWN_NAME_FORM =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 178;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because it references an unknown
* superior rule ID. This takes two arguments, which are the provided value
* and the rule ID of the superior DIT structure rule.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_UNKNOWN_RULE_ID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 179;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because it does not specify a name form.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_NO_NAME_FORM =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 180;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because an invalid character was found
* where a single quote was expected. This takes three arguments, which are
* the provided value, the position at which the quote was expected, and the
* character that was found instead.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_EXPECTED_QUOTE_AT_POS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 181;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because the OID contained two
* consecutive periods. This takes two arguments, which are the provided
* value and the position of the second period.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_DOUBLE_PERIOD_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 182;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because the numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_NUMERIC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 183;
/**
* The message ID for the message that will be used if a DIT structure rule
* description value cannot be parsed because the non-numeric OID contained an
* illegal character. This takes three arguments, which are the provided
* value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_STRING_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 184;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a telex number because it is too short to hold a valid number.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_TELEX_TOO_SHORT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 185;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a telex number because it contains an illegal character where a
* printable string character should be. This takes three arguments, which
* are the provided value, the illegal character, and the position of that
* character.
*/
public static final int MSGID_ATTR_SYNTAX_TELEX_NOT_PRINTABLE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 186;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a telex number because it contains an illegal character where a
* printable string character or dollar sign should be. This takes three
* arguments, which are the provided value, the illegal character, and the
* position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_TELEX_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 187;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a telex number because the end of the value was found before the
* complete number could be read. This takes a single argument, which is the
* provided value.
*/
public static final int MSGID_ATTR_SYNTAX_TELEX_TRUNCATED =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 188;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a facsimile telephone number because the value was empty. This
* does not take any arguments
*/
public static final int MSGID_ATTR_SYNTAX_FAXNUMBER_EMPTY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 189;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a facsimile telephone number because the telephone number portion
* contains an invalid character that is not from the printable string
* character set. This takes three arguments, which are the provided value,
* the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_FAXNUMBER_NOT_PRINTABLE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 190;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a facsimile telephone number because it ends with a dollar sign.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_FAXNUMBER_END_WITH_DOLLAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 191;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a facsimile telephone number because it contains an illegal fax
* parameter. This takes four arguments, which are the provided value, the
* illegal fax parameter, the start position, and the end position for that
* parameter.
*/
public static final int MSGID_ATTR_SYNTAX_FAXNUMBER_ILLEGAL_PARAMETER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 192;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a name and optional UID because an error occurred while trying to
* parse and normalize the DN portion. This takes two arguments, which are
* the provided value and a string representation of the exception that was
* caught.
*/
public static final int MSGID_ATTR_SYNTAX_NAMEANDUID_INVALID_DN =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 193;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a name and optional UID because it contained an illegal binary
* digit in the uid portion. This takes three arguments, which are the
* provided value, the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_NAMEANDUID_ILLEGAL_BINARY_DIGIT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 194;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a teletex terminal identifier because the value was empty. This
* does not take any arguments
*/
public static final int MSGID_ATTR_SYNTAX_TELETEXID_EMPTY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 195;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a teletex terminal identifier because the terminal identifier
* portion contains an invalid character that is not from the printable string
* character set. This takes three arguments, which are the provided value,
* the illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_TELETEXID_NOT_PRINTABLE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 196;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a teletex terminal identifier because it ends with a dollar sign.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_TELETEXID_END_WITH_DOLLAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 197;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a teletex terminal identifier because a TTX parameter does not
* contain a colon to separate the name from the value. This takes two
* arguments, which are the provided value and the invalid parameter string.
*/
public static final int MSGID_ATTR_SYNTAX_TELETEXID_PARAM_NO_COLON =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 198;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a teletex terminal identifier because it contains an illegal TTX
* parameter. This takes two arguments, which are the provided value and the
* invalid parameter name.
*/
public static final int MSGID_ATTR_SYNTAX_TELETEXID_ILLEGAL_PARAMETER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 199;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an other mailbox because the provided value was empty. This does
* not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_OTHER_MAILBOX_EMPTY_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 200;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an other mailbox because the it did not specify the mailbox type.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_OTHER_MAILBOX_NO_MBTYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 201;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an other mailbox because the mailbox type contained an illegal
* character. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_OTHER_MAILBOX_ILLEGAL_MBTYPE_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 202;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an other mailbox because the it did not specify the mailbox.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_OTHER_MAILBOX_NO_MAILBOX =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 203;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an other mailbox because the mailbox contained an illegal
* character. This takes three arguments, which are the provided value, the
* illegal character, and the position of that character.
*/
public static final int MSGID_ATTR_SYNTAX_OTHER_MAILBOX_ILLEGAL_MB_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 204;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it did not specify an objectclass. This takes a
* single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_NO_OC =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 205;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it contains an illegal character in the criteria.
* This takes four arguments, which are the provided value, the criteria
* portion, the illegal character, and the position of the illegal character
* thin the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_ILLEGAL_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 206;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it starts with an open parenthesis but does not
* contain a matching close parenthesis. This takes two arguments, which are
* the provided value and the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_MISSING_CLOSE_PAREN =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 207;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it contains a criteria portion that starts with a
* question mark but is not "?true" or "?false". This takes two arguments,
* which are the provided value and the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_INVALID_QUESTION_MARK =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 208;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it has a criteria with no dollar sign. This
* takes two arguments, which are the provided value and the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_NO_DOLLAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 209;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it has a criteria with no attribute type. This
* takes two arguments, which are the provided value and the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_NO_ATTR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 210;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it has a criteria with no match type. This takes
* two arguments, which are the provided value and the criteria portion.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_NO_MATCH_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 211;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as a guide because it has a criteria with an invalid match type.
* This takes three arguments, which are the provided value, the criteria
* portion, and the position of the invalid match type.
*/
public static final int MSGID_ATTR_SYNTAX_GUIDE_INVALID_MATCH_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 212;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it did not contain an octothorpe to
* separate the objectclass from the criteria. This takes a single argument,
* which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_SHARP =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 213;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it did not specify an objectclass.
* This takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_OC =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 214;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because the objectclass OID had two consecutive
* periods. This takes three arguments, which are the provided value, the
* objectclass OID, and the position of the double period.
*/
public static final int
MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_DOUBLE_PERIOD_IN_OC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 215;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because the objectclass OID had an illegal
* character. This takes four arguments, which are the provided value, the
* objectclass OID, the illegal character, and the position of that character.
*/
public static final int
MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_ILLEGAL_CHAR_IN_OC_OID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 216;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because the objectclass name had an illegal
* character. This takes four arguments, which are the provided value, the
* objectclass name, the illegal character, and the position of that
* character.
*/
public static final int
MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_ILLEGAL_CHAR_IN_OC_NAME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 217;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it did not contain an octothorpe to
* separate the criteria from the scope. This takes a single argument, which
* is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_FINAL_SHARP =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 218;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it did not contain a scope after the
* final octothorpe. This takes a single argument, which is the provided
* value.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_SCOPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 219;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it contained an invalid scope. This
* takes two arguments, which are the provided value and the invalid scope.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_INVALID_SCOPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 220;
/**
* The message ID for the message that will be used if a value cannot be
* parsed as an enhanced guide because it did not contain any criteria. This
* takes a single argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_CRITERIA =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 221;
/**
* The message ID for the message that will be used if an OID value cannot
* be parsed because it contains an invalid value. This takes two arguments,
* which are the provided value and a message explaining the problem.
*/
public static final int MSGID_ATTR_SYNTAX_OID_INVALID_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 222;
/**
* The message ID for the message that will be used if an unexpected failure
* occurs while attempting to normalize a generalized time value. This takes
* two arguments, which are the provided value and a string representation of
* the exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_NORMALIZE_FAILURE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 223;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the case exact
* ordering matching rule's compare method and it is not possible
* to obtain the normalized form of one of the values. This takes a single
* argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_CASE_EXACT_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 224;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the case exact ordering matching
* rule's compare method but the provided objects were of a type
* that is not supported for comparison. This takes a single argument, which
* is the fully-qualified name of the class with which the provided object
* is associated.
*/
public static final int MSGID_OMR_CASE_EXACT_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 225;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the case ignore
* ordering matching rule's compare method and it is not possible
* to obtain the normalized form of one of the values. This takes a single
* argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_CASE_IGNORE_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 226;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the case ignore ordering matching
* rule's compare method but the provided objects were of a type
* that is not supported for comparison. This takes a single argument, which
* is the fully-qualified name of the class with which the provided object
* is associated.
*/
public static final int MSGID_OMR_CASE_IGNORE_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 227;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the generalized
* time ordering matching rule's compare method and it is not
* possible to obtain the normalized form of one of the values. This takes a
* single argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_GENERALIZED_TIME_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 228;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the generalized time ordering
* matching rule's compare method but the provided objects were
* of a type that is not supported for comparison. This takes a single
* argument, which is the fully-qualified name of the class with which the
* provided object is associated.
*/
public static final int MSGID_OMR_GENERALIZED_TIME_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 229;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the integer
* ordering matching rule's compare method and it is not possible
* to obtain the normalized form of one of the values. This takes a single
* argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_INTEGER_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 230;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the integer ordering matching
* rule's compare method but the provided objects were of a type
* that is not supported for comparison. This takes a single argument, which
* is the fully-qualified name of the class with which the provided object
* is associated.
*/
public static final int MSGID_OMR_INTEGER_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 231;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the numeric string
* ordering matching rule's compare method and it is not possible
* to obtain the normalized form of one of the values. This takes a single
* argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_NUMERIC_STRING_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 232;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the numeric string ordering
* matching rule's compare method but the provided objects were
* of a type that is not supported for comparison. This takes a single
* argument, which is the fully-qualified name of the class with which the
* provided object is associated.
*/
public static final int MSGID_OMR_NUMERIC_STRING_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 233;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two attribute value objects using the octet string
* ordering matching rule's compare method and it is not possible
* to obtain the normalized form of one of the values. This takes a single
* argument, which is a string representation of the exception that was
* caught.
*/
public static final int MSGID_OMR_OCTET_STRING_COMPARE_CANNOT_NORMALIZE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 234;
/**
* The message ID for the message that will be used if an error occurs while
* attempting to compare two objects using the octet string ordering matching
* rule's compare method but the provided objects were of a type
* that is not supported for comparison. This takes a single argument, which
* is the fully-qualified name of the class with which the provided object is
* is associated.
*/
public static final int MSGID_OMR_OCTET_STRING_COMPARE_INVALID_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 235;
/**
* The message ID for the message that will be used if a UUID value has an
* invalid length. This takes two arguments, which are the provided value and
* the actual length of that value.
*/
public static final int MSGID_ATTR_SYNTAX_UUID_INVALID_LENGTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 236;
/**
* The message ID for the message that will be used if a UUID value has
* a non-dash character at a position that should contain a dash. This takes
* three arguments, which are the provided value, the position of the illegal
* character, and the character that was found in that position.
*/
public static final int MSGID_ATTR_SYNTAX_UUID_EXPECTED_DASH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 237;
/**
* The message ID for the message that will be used if a UUID value has
* a non-dash character at a position that should contain a hexadecimal digit.
* This takes three arguments, which are the provided value, the position of
* the illegal character, and the character that was found in that position.
*/
public static final int MSGID_ATTR_SYNTAX_UUID_EXPECTED_HEX =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 238;
/**
* The message ID for the message that will be used as the description of the
* configuration attribute that controls whether directory string attributes
* will be allowed to have zero-length values. It does not take any
* arguments.
*/
public static final int
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_DESCRIPTION_ALLOW_ZEROLENGTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_INFORMATIONAL | 239;
/**
* The message ID for the message that will be used if an error occurs while
* trying to determine whether to allow zero-length values for directory
* string attributes. This takes two arguments, which are the name of the
* configuration attribute that controls this behavior and a string
* representation of the exception that was caught.
*/
public static final int
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_CANNOT_DETERMINE_ZEROLENGTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 240;
/**
* The message ID for the message that will be used if a directory string
* attribute is assigned a zero-length value. This does not take any
* arguments.
*/
public static final int
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_INVALID_ZEROLENGTH_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 241;
/**
* The message ID for the message that will be used if the configuration
* attribute controlling whether to accept zero-length values is updated.
* This takes three arguments, which are the name of the configuration
* attribute, the DN of the configuration entry, and a string representation
* of the new value.
*/
public static final int
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_UPDATED_ALLOW_ZEROLENGTH =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_INFORMATIONAL | 242;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character in the scheme name. This takes a single argument,
* which is the position of the invalid character.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_INVALID_SCHEME_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 243;
/**
* The message ID for the message that will be used if an authPassword value
* has an empty scheme. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_NO_SCHEME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 244;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character between the scheme and authInfo elements. This
* does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_NO_SCHEME_SEPARATOR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 245;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character in the authInfo element. This takes a single
* argument, which is the position of the invalid character.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_INVALID_AUTH_INFO_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 246;
/**
* The message ID for the message that will be used if an authPassword value
* has an empty authInfo element. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_INFO =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 247;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character between the authInfo and authValue elements. This
* does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_INFO_SEPARATOR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 248;
/**
* The message ID for the message that will be used if a value does not start
* with an opening parenthesis. This takes a single argument, which is the
* provided value string.
*/
public static final int MSGID_EMR_INTFIRSTCOMP_NO_INITIAL_PARENTHESIS =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 249;
/**
* The message ID for the message that will be used if a value does not have
* any non-space characters after the opening parenthesis. This takes a
* single argument, which is the provided value string.
*/
public static final int MSGID_EMR_INTFIRSTCOMP_NO_NONSPACE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 250;
/**
* The message ID for the message that will be used if a value does not have
* any space characters after the first component. This takes a single
* argument, which is the provided value string.
*/
public static final int MSGID_EMR_INTFIRSTCOMP_NO_SPACE_AFTER_INT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 251;
/**
* The message ID for the message that will be used if the first component
* cannot be decoded as an integer. This takes a single argument, which is
* the provided value string.
*/
public static final int MSGID_EMR_INTFIRSTCOMP_FIRST_COMPONENT_NOT_INT =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 252;
/**
* The message ID for the message that will be used if a provided userpassword
* value is null or empty. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_USERPW_NO_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 253;
/**
* The message ID for the message that will be used if a provided userpassword
* value does not start with an opening curly brace. This does not take any
* arguments.
*/
public static final int MSGID_ATTR_SYNTAX_USERPW_NO_OPENING_BRACE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 254;
/**
* The message ID for the message that will be used if a provided userpassword
* value does not contain a closing curly brace. This does not take any
* arguments.
*/
public static final int MSGID_ATTR_SYNTAX_USERPW_NO_CLOSING_BRACE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 255;
/**
* The message ID for the message that will be used if a provided userpassword
* value does not contain a storage scheme name. This does not take any
* arguments.
*/
public static final int MSGID_ATTR_SYNTAX_USERPW_NO_SCHEME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 256;
/**
* The message ID for the message that will be used if an RFC 3672
* subtree specification value cannot be parsed properly. This takes a
* single argument: the provided invalid value.
*/
public static final int
MSGID_ATTR_SYNTAX_RFC3672_SUBTREE_SPECIFICATION_INVALID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 257;
/**
* The message ID for the message that will be used if an absolute
* subtree specification value cannot be parsed properly. This takes a
* single argument: the provided invalid value.
*/
public static final int
MSGID_ATTR_SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_INVALID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 258;
/**
* The message ID for the message that will be used if a relative
* subtree specification value cannot be parsed properly. This takes a
* single argument: the provided invalid value.
*/
public static final int
MSGID_ATTR_SYNTAX_RELATIVE_SUBTREE_SPECIFICATION_INVALID =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 259;
/**
* The message ID for the message that will be used if an illegal value is
* provided for an attribute with an Integer syntax. This takes a single
* string argument, which is the provided value.
*/
public static final int MSGID_ATTR_SYNTAX_ILLEGAL_INTEGER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 260;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character in the authValue element. This takes a single
* argument, which is the position of the invalid character.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_INVALID_AUTH_VALUE_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 261;
/**
* The message ID for the message that will be used if an authPassword value
* has an empty authValue element. This does not take any arguments.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_VALUE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 262;
/**
* The message ID for the message that will be used if an authPassword value
* has an invalid character after the authValue element. This takes a single
* argument, which is the position of the invalid character.
*/
public static final int MSGID_ATTR_SYNTAX_AUTHPW_INVALID_TRAILING_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_ERROR | 263;
/**
* The message ID for the message that will be used if an attribute syntax
* extension value cannot be parsed because an invalid character was found.
* This takes a two arguments, which are the provided value, and the position
* of the invalid character.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXTENSION_INVALID_CHARACTER =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 264;
/**
* The message ID for the message that will be used if an attribute syntax
* extension value cannot be parsed. This takes one argument, a string
* representation of the exception that was caught.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRSYNTAX_INVALID_EXTENSION =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 265;
/**
* The message ID for the message that will be used if an objectclass has
* an invalid superior type. This takes four arguments, which are the OID of
* the objectclass, the objectclass type for that class, the objectclass type
* type of the superior class, and the name or OID of the superior class.
*/
public static final int MSGID_ATTR_SYNTAX_OBJECTCLASS_INVALID_SUPERIOR_TYPE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 266;
/**
* The message ID for the message that will be used if a structural
* objectclass does not have a superior chain that includes the "top"
* objectclass. This takes a single argument, which is the OID for that
* objectclass.
*/
public static final int
MSGID_ATTR_SYNTAX_OBJECTCLASS_STRUCTURAL_SUPERIOR_NOT_TOP =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 267;
/**
* The message ID for the message that will be used if an attribute type
* has a usage that is not the same as the usage of its superior type. This
* takes three arguments, which is the OID of the attribute type, its
* attribute usage, and the name or OID of the superior type.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_INVALID_SUPERIOR_USAGE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 268;
/**
* The message ID for the message that will be used if an attribute type
* is defined as collective but the superior type is not collective. This
* takes two arguments, which are the OID of the attribute type and the name
* or OID of the superior type.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_COLLECTIVE_FROM_NONCOLLECTIVE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 269;
/**
* The message ID for the message that will be used if an attribute type
* is not defined as collective but the superior type is collective. This
* takes two arguments, which are the OID of the attribute type and the name
* or OID of the superior type.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_NONCOLLECTIVE_FROM_COLLECTIVE =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 270;
/**
* The message ID for the message that will be used if a DIT content rule
* description value is invalid because it prohibits an attribute type that is
* required by the rule's structural object class. This takes three
* arguments, which are the definition of the DIT content rule, the name or
* OID of the prohibited attribute type, and the name or OID of the structural
* object class that requires it.
*/
public static final int
MSGID_ATTR_SYNTAX_DCR_PROHIBITED_REQUIRED_BY_STRUCTURAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 271;
/**
* The message ID for the message that will be used if a DIT content rule
* description value is invalid because it prohibits an attribute type that is
* required by one the rule's allowed auxiliary object classes. This takes
* three arguments, which are the definition of the DIT content rule, the name
* or OID of the prohibited attribute type, and the name or OID of the
* auxiliary object class that requires it.
*/
public static final int
MSGID_ATTR_SYNTAX_DCR_PROHIBITED_REQUIRED_BY_AUXILIARY =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_MILD_ERROR | 272;
/**
* The message ID for the message that will be used if an attribute type
* is defined as collective but has a usage other than userApplications. This
* takes a single argument, which is the OID of the attribute type.
*/
public static final int MSGID_ATTR_SYNTAX_ATTRTYPE_COLLECTIVE_IS_OPERATIONAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 273;
/**
* The message ID for the message that will be used if an attribute type
* is defined as NO-USER-MODIFICATION but does not have an operational usage.
* This takes a single argument, which is the OID of the attribute type.
*/
public static final int
MSGID_ATTR_SYNTAX_ATTRTYPE_NO_USER_MOD_NOT_OPERATIONAL =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 274;
/**
* The message ID for the message that will be used if a generalized time
* value contains an illegal character in the fraction component. This takes
* two arguments, which are the value string and the illegal character.
*/
public static final int
MSGID_ATTR_SYNTAX_GENERALIZED_TIME_ILLEGAL_FRACTION_CHAR =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 275;
/**
* The message ID for the message that will be used if a generalized time
* value contains an empty fractional component. This takes a single
* argument, which is the value string.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_EMPTY_FRACTION =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 276;
/**
* The message ID for the message that will be used if a generalized time
* value does not contain any time zone information. This takes a single
* argument, which is the value string.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_NO_TIME_ZONE_INFO =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 277;
/**
* The message ID for the message that will be used if a generalized time
* value represents an invalid date or time (e.g., September 31). This takes
* two arguments, which are the value string and a string representation of
* the exception that was caught.
*/
public static final int MSGID_ATTR_SYNTAX_GENERALIZED_TIME_ILLEGAL_TIME =
CATEGORY_MASK_SCHEMA | SEVERITY_MASK_SEVERE_WARNING | 278;
/**
* Associates a set of generic messages with the message IDs defined in this
* class.
*/
public static void registerMessages()
{
registerMessage(MSGID_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE,
"Unable to retrieve approximate matching rule %s used as " +
"the default for the %s attribute syntax. Approximate " +
"matching will not be allowed by default for attributes " +
"with this syntax");
registerMessage(MSGID_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE,
"Unable to retrieve equality matching rule %s used as " +
"the default for the %s attribute syntax. Equality " +
"matching will not be allowed by default for attributes " +
"with this syntax");
registerMessage(MSGID_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE,
"Unable to retrieve ordering matching rule %s used as " +
"the default for the %s attribute syntax. Ordering " +
"matches will not be allowed by default for attributes " +
"with this syntax");
registerMessage(MSGID_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE,
"Unable to retrieve substring matching rule %s used as " +
"the default for the %s attribute syntax. Substring " +
"matching will not be allowed by default for attributes " +
"with this syntax");
registerMessage(MSGID_ATTR_SYNTAX_ILLEGAL_BOOLEAN,
"The provided value %s is not allowed for attributes " +
"with a Boolean syntax. The only allowed values are " +
"'TRUE' and 'FALSE'");
registerMessage(MSGID_ATTR_SYNTAX_BIT_STRING_TOO_SHORT,
"The provided value %s is too short to be a valid bit " +
"string. A bit string must be a series of binary digits " +
"surrounded by single quotes and followed by a capital " +
"letter B");
registerMessage(MSGID_ATTR_SYNTAX_BIT_STRING_NOT_QUOTED,
"The provided value %s is not a valid bit string because " +
"it is not surrounded by single quotes and followed by a " +
"capital letter B");
registerMessage(MSGID_ATTR_SYNTAX_BIT_STRING_INVALID_BIT,
"The provided value %s is not a valid bit string because " +
"%s is not a valid binary digit");
registerMessage(MSGID_ATTR_SYNTAX_COUNTRY_STRING_INVALID_LENGTH,
"The provided value %s is not a valid country string " +
"because the length is not exactly two characters");
registerMessage(MSGID_ATTR_SYNTAX_COUNTRY_STRING_NOT_PRINTABLE,
"The provided value %s is not a valid country string " +
"because it contains one or more non-printable " +
"characters");
registerMessage(MSGID_ATTR_SYNTAX_DELIVERY_METHOD_NO_ELEMENTS,
"The provided value %s is not a valid delivery method " +
"value because it does not contain any elements");
registerMessage(MSGID_ATTR_SYNTAX_DELIVERY_METHOD_INVALID_ELEMENT,
"The provided value %s is not a valid delivery method " +
"value because %s is not a valid method");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_TOO_SHORT,
"The provided value %s is too short to be a valid " +
"generalized time value");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_YEAR,
"The provided value %s is not a valid generalized time " +
"value because the %s character is not allowed in the " +
"century or year specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_MONTH,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid month specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_DAY,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid day specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_HOUR,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid hour specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_MINUTE,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid minute specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_SECOND,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid second specification");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_SUBSECOND,
"The provided value %s is not a valid generalized time " +
"value because the sub-second component is not valid " +
"(between 1 and 3 numeric digits)");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_LONG_SUBSECOND,
"The provided value %s is not a valid generalized time " +
"value because the sub-second value may not contain more " +
"than three digits");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_OFFSET,
"The provided value %s is not a valid generalized time " +
"value because %s is not a valid GMT offset");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_INVALID_CHAR,
"The provided value %s is not a valid generalized time " +
"value because it contains an invalid character %s at " +
"position %d");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_CANNOT_PARSE,
"The provided value %s could not be parsed as a valid " +
"generalized time: %s");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_NORMALIZE_FAILURE,
"An unexpected error occurred while trying to normalize " +
"value %s as a generalized time value: %s");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_ILLEGAL_FRACTION_CHAR,
"The provided value %s is not a valid generalized time " +
"value because it contains illegal character %s in the " +
"fraction component");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_EMPTY_FRACTION,
"The provided value %s is not a valid generalized time " +
"value because it does not contain at least one digit " +
"after the period to use as the fractional component");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_NO_TIME_ZONE_INFO,
"The provided value %s is not a valid generalized time " +
"value because it does not end with 'Z' or a time zone " +
"offset");
registerMessage(MSGID_ATTR_SYNTAX_GENERALIZED_TIME_ILLEGAL_TIME,
"The provided value %s is not a valid generalized time " +
"value because it represents an invalid time (e.g., a " +
"date that does not exist): %s");
registerMessage(MSGID_ATTR_SYNTAX_DN_INVALID,
"The provided value %s could not be parsed as a valid " +
"distinguished name: %s");
registerMessage(MSGID_ATTR_SYNTAX_DN_END_WITH_COMMA,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the last non-space character " +
"was a comma or semicolon");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_START_WITH_DIGIT,
"The provided value %s could not be parsed as a valid " +
"distinguished name because numeric digit %s is not " +
"allowed as the first character in an attribute name");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR,
"The provided value %s could not be parsed as a valid " +
"distinguished name because character %s at position %d " +
"is not allowed in an attribute name");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_UNDERSCORE_CHAR,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the underscore character is " +
"not allowed in an attribute name unless the %s " +
" configuration option is enabled");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DASH,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the hyphen character is not " +
"allowed as the first character of an attribute name");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_UNDERSCORE,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the underscore character is " +
"not allowed as the first character of an attribute name " +
"even if the %s configuration option is enabled");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DIGIT,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the digit %s is not allowed " +
"allowed as the first character of an attribute name " +
"unless the name is specified as an OID or the %s " +
" configuration option is enabled");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_NO_NAME,
"The provided value %s could not be parsed as a valid " +
"distinguished name because it contained an RDN " +
"containing an empty attribute name");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the parsed attribute name %s " +
"included a period but that name did not appear to be a " +
"valid OID");
registerMessage(MSGID_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the last non-space character " +
"was part of the attribute name %s");
registerMessage(MSGID_ATTR_SYNTAX_DN_NO_EQUAL,
"The provided value %s could not be parsed as a valid " +
"distinguished name because the next non-space character " +
"after attribute name %s should have been an equal sign " +
"but instead was %s");
registerMessage(MSGID_ATTR_SYNTAX_DN_INVALID_CHAR,
"The provided value %s could not be parsed as a valid " +
"distinguished name because character %s at position %d " +
"is not valid");
registerMessage(MSGID_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT,
"The provided value %s could not be parsed as a valid " +
"distinguished name because an attribute value started " +
"with an octothorpe (#) but was not followed by a " +
"positive multiple of two hexadecimal digits");
registerMessage(MSGID_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT,
"The provided value %s could not be parsed as a valid " +
"distinguished name because an attribute value started " +
"with an octothorpe (#) but contained a character %s " +
"that was not a valid hexadecimal digit");
registerMessage(MSGID_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE,
"The provided value %s could not be parsed as a valid " +
"distinguished name because an unexpected failure " +
"occurred while attempting to parse an attribute value " +
"from one of the RDN components: %s");
registerMessage(MSGID_ATTR_SYNTAX_DN_UNMATCHED_QUOTE,
"The provided value %s could not be parsed as a valid " +
"distinguished name because one of the RDN components " +
"included a quoted value that did not have a " +
"corresponding closing quotation mark");
registerMessage(MSGID_ATTR_SYNTAX_DN_ESCAPED_HEX_VALUE_INVALID,
"The provided value %s could not be parsed as a valid " +
"distinguished name because one of the RDN components " +
"included a value with an escaped hexadecimal digit that " +
"was not followed by a second hexadecimal digit");
registerMessage(MSGID_ATTR_SYNTAX_INTEGER_INITIAL_ZERO,
"The provided value %s could not be parsed as a valid " +
"integer because the first digit may not be zero unless " +
"it is the only digit");
registerMessage(MSGID_ATTR_SYNTAX_INTEGER_MISPLACED_DASH,
"The provided value %s could not be parsed as a valid " +
"integer because the dash may only appear if it is the " +
"first character of the value followed by one or more " +
"digits");
registerMessage(MSGID_ATTR_SYNTAX_INTEGER_INVALID_CHARACTER,
"The provided value %s could not be parsed as a valid " +
"integer because character %s at position %d is not " +
"allowed in an integer value");
registerMessage(MSGID_ATTR_SYNTAX_INTEGER_EMPTY_VALUE,
"The provided value %s could not be parsed as a valid " +
"integer because it did not contain any digits");
registerMessage(MSGID_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE,
"The provided value %s could not be parsed as a valid " +
"integer because it contained only a dash not followed " +
"by an integer value");
registerMessage(MSGID_ATTR_SYNTAX_ILLEGAL_INTEGER,
"The provided value %s is not allowed for attributes " +
"with a Integer syntax");
registerMessage(MSGID_ATTR_SYNTAX_OID_NO_VALUE,
"The provided value could not be parsed as a valid OID " +
"because it did not contain any characters");
registerMessage(MSGID_ATTR_SYNTAX_OID_ILLEGAL_CHARACTER,
"The provided value %s could not be parsed as a valid " +
"OID because it had an illegal character at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OID_CONSECUTIVE_PERIODS,
"The provided value %s could not be parsed as a valid " +
"OID because it had two consecutive periods at or near " +
"position %d");
registerMessage(MSGID_ATTR_SYNTAX_OID_ENDS_WITH_PERIOD,
"The provided value %s could not be parsed as a valid " +
"OID because it ends with a period");
registerMessage(MSGID_ATTR_SYNTAX_OID_INVALID_VALUE,
"The provided value %s could not be parsed as a valid " +
"OID: %s");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_EMPTY_VALUE,
"The provided value could not be parsed as a valid " +
"attribute type description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because an open parenthesis " +
"was expected at position %d but instead a '%s' " +
"character was found");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because the end of the " +
"value was encountered while the Directory Server " +
"expected more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because the non-numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because it contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_QUOTE,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because a single quote was " +
"expected as the first non-blank character following " +
"token %s. However, the character %s was found instead");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SUPERIOR_TYPE,
"The definition for the attribute type with OID %s " +
"declared a superior type with an OID of %s. No " +
"attribute type with this OID exists in the server " +
"schema");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_APPROXIMATE_MR,
"The definition for the attribute type with OID %s " +
"declared that approximate matching should be performed " +
"using the matching rule \"%s\". No such approximate " +
"matching rule is configured for use in the Directory " +
"Server");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_EQUALITY_MR,
"The definition for the attribute type with OID %s " +
"declared that equality matching should be performed " +
"using the matching rule \"%s\". No such equality " +
"matching rule is configured for use in the Directory " +
"Server");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_ORDERING_MR,
"The definition for the attribute type with OID %s " +
"declared that ordering matching should be performed " +
"using the matching rule \"%s\". No such ordering " +
"matching rule is configured for use in the Directory " +
"Server");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SUBSTRING_MR,
"The definition for the attribute type with OID %s " +
"declared that substring matching should be performed " +
"using the matching rule \"%s\". No such substring " +
"matching rule is configured for use in the Directory " +
"Server");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_UNKNOWN_SYNTAX,
"The definition for the attribute type with OID %s " +
"declared that it should have a syntax with OID %s. No " +
"such syntax is configured for use in the Directory " +
"Server");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_INVALID_ATTRIBUTE_USAGE,
"The definition for the attribute type with OID %s " +
"declared that it should have an attribute usage of " +
"%s. This is an invalid usage");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_INVALID_SUPERIOR_USAGE,
"The definition for attribute type %s is invalid because " +
"its attribute usage %s is not the same as the usage for " +
"its superior type %s");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_COLLECTIVE_FROM_NONCOLLECTIVE,
"The definition for attribute type %s is invalid because " +
"it is defined as a collective type but the superior " +
"type %s is not collective");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_NONCOLLECTIVE_FROM_COLLECTIVE,
"The definition for attribute type %s is invalid because " +
"it is not defined as a collective type but the superior " +
"type %s is collective");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_COLLECTIVE_IS_OPERATIONAL,
"The definition for attribute type %s is invalid because " +
"it is declared COLLECTIVE but does not have a usage " +
"of userApplications");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_NO_USER_MOD_NOT_OPERATIONAL,
"The definition for attribute type %s is invalid because " +
"it is declared NO-USER-MODIFICATION but does not have " +
"an operational usage");
registerMessage(MSGID_ATTR_SYNTAX_ATTRTYPE_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as an " +
"attribute type description because a single quote was " +
"expected at position %d but the character %s was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_EMPTY_VALUE,
"The provided value could not be parsed as a valid " +
"objectclass description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because an open parenthesis was " +
"expected at position %d but instead a '%s' character " +
"was found");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because the end of the value " +
"was encountered while the Directory Server expected " +
"more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because the non-numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because it contained an illegal " +
"character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_QUOTE,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because a single quote was " +
"expected as the first non-blank character following " +
"token %s. However, the character %s was found instead");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_SUPERIOR_CLASS,
"The definition for the objectclass with OID %s declared " +
"a superior objectclass with an OID of %s. No " +
"objectclass with this OID exists in the server schema");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as an " +
"objectclass description because a single quote was " +
"expected at position %d but the character %s was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_REQUIRED_ATTR,
"The definition for the objectclass with OID %s declared " +
"that it should include required attribute \"%s\". No " +
"attribute type matching this name or OID exists in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_UNKNOWN_OPTIONAL_ATTR,
"The definition for the objectclass with OID %s declared " +
"that it should include optional attribute \"%s\". No " +
"attribute type matching this name or OID exists in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_INVALID_SUPERIOR_TYPE,
"The definition for objectclass %s is invalid because it " +
"has an objectclass type of %s but this is incompatible " +
"with the objectclass type %s for the superior class %s");
registerMessage(MSGID_ATTR_SYNTAX_OBJECTCLASS_STRUCTURAL_SUPERIOR_NOT_TOP,
"The definition for objectclass %s is invalid because " +
"it is defined as a structural class but its superior " +
"chain does not include the \"top\" objectclass");
registerMessage(MSGID_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER,
"The provided value \"%s\" cannot be parsed as a valid " +
"IA5 string because it contains an illegal character " +
"\"%s\" that is not allowed in the IA5 (ASCII) character " +
"set");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_DESCRIPTION_STRICT_MODE,
"This indicates whether the telephone number attribute " +
"syntax should use a strict mode in which it will only " +
"accept values in the ITU-T E.123 format. If this is " +
"enabled, then any value not in this format will be " +
"rejected. If this is disabled, then any value will " +
"be accepted, but only the digits will be considered " +
"when performing matching");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_CANNOT_DETERMINE_STRICT_MODE,
"An error occurred while trying to retrieve attribute " +
ATTR_TELEPHONE_STRICT_MODE + " from configuration entry " +
"%s: %s. The Directory Server will not enforce strict " +
"compliance to the ITU-T E.123 format for telephone " +
"number values");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_EMPTY,
"The provided value is not a valid telephone number " +
"because it is empty or null");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_NO_PLUS,
"The provided value \"%s\" is not a valid telephone " +
"number because strict telephone number checking is " +
"enabled and the value does not start with a plus sign " +
"in compliance with the ITU-T E.123 specification");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_ILLEGAL_CHAR,
"The provided value \"%s\" is not a valid telephone " +
"number because strict telephone number checking is " +
"enabled and the character %s at position %d is not " +
"allowed by the ITU-T E.123 specification");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_NO_DIGITS,
"The provided value \"%s\" is not a valid telephone " +
"number because it does not contain any numeric digits");
registerMessage(MSGID_ATTR_SYNTAX_TELEPHONE_UPDATED_STRICT_MODE,
"The value of configuration attribute " +
ATTR_TELEPHONE_STRICT_MODE + ", which indicates whether " +
"to use strict telephone number syntax checking, has " +
"been updated to %s in configuration entry %s");
registerMessage(MSGID_ATTR_SYNTAX_NUMERIC_STRING_ILLEGAL_CHAR,
"The provided value \"%s\" is not a valid numeric string " +
"because it contained character %s at position %d that " +
"was neither a digit nor a space");
registerMessage(MSGID_ATTR_SYNTAX_NUMERIC_STRING_EMPTY_VALUE,
"The provided value is not a valid numeric string " +
"because it did not contain any characters. A numeric " +
"string value must contain at least one numeric digit " +
"or space");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_EMPTY_VALUE,
"The provided value could not be parsed as a valid " +
"attribute syntax description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because an open " +
"parenthesis was expected at position %d but instead a " +
"'%s' character was found");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because the end of the " +
"value was encountered while the Directory Server " +
"expected more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because the non-numeric " +
"OID contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_CANNOT_READ_DESC_TOKEN,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because an unexpected " +
"error occurred while trying to read the \"DESC\" token " +
"from the string at or near position %d: %s");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_TOKEN_NOT_DESC,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because the \"DESC\" token " +
"was expected but the string \"%s\" was found instead");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_CANNOT_READ_DESC_VALUE,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because an unexpected " +
"error occurred while trying to read the value of the " +
"\"DESC\" token from the string at or near position %d: " +
"%s");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because a close " +
"parenthesis was expected at position %d but instead a " +
"'%s' character was found");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_ILLEGAL_CHAR_AFTER_CLOSE,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because an illegal " +
"character %s was found at position %d after the close " +
"parenthesis");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax description because a single quote was " +
"expected at position %d but the character %s was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_PRINTABLE_STRING_EMPTY_VALUE,
"The provided value could not be parsed as a printable " +
"string because it was null or empty. A printable " +
"string must contain at least one character");
registerMessage(MSGID_ATTR_SYNTAX_PRINTABLE_STRING_ILLEGAL_CHARACTER,
"The provided value \"%s\" could not be parsed as a " +
"printable string because it contained an invalid " +
"character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_SUBSTRING_ONLY_WILDCARD,
"The provided value \"*\" could not be parsed as a " +
"substring assertion because it consists only of a " +
"wildcard character and zero-length substrings are not " +
"allowed");
registerMessage(MSGID_ATTR_SYNTAX_SUBSTRING_CONSECUTIVE_WILDCARDS,
"The provided value \"%s\" could not be parsed as a " +
"substring assertion because it contains consecutive " +
"wildcard characters at position %d and zero-length " +
"substrings are not allowed");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_TOO_SHORT,
"The provided value %s is too short to be a valid UTC " +
"time value");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_YEAR,
"The provided value %s is not a valid UTC time value " +
"because the %s character is not allowed in the century " +
"or year specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_MONTH,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid month specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_DAY,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid day specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_HOUR,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid hour specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_MINUTE,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid minute specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_CHAR,
"The provided value %s is not a valid UTC time value " +
"because it contains an invalid character %s at position " +
"%d");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_SECOND,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid second specification");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_INVALID_OFFSET,
"The provided value %s is not a valid UTC time value " +
"because %s is not a valid GMT offset");
registerMessage(MSGID_ATTR_SYNTAX_UTC_TIME_CANNOT_PARSE,
"The provided value %s could not be parsed as a valid " +
"UTC time: %s");
registerMessage(MSGID_ATTR_SYNTAX_DCR_EMPTY_VALUE,
"The provided value could not be parsed as a valid DIT " +
"content rule description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_DCR_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because an open parenthesis " +
"was expected at position %d but instead a '%s' " +
"character was found");
registerMessage(MSGID_ATTR_SYNTAX_DCR_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because the end of the value " +
"was encountered while the Directory Server expected " +
"more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_DCR_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because the non-numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNKNOWN_STRUCTURAL_CLASS,
"The DIT content rule \"%s\" is associated with a " +
"structural objectclass %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_DCR_STRUCTURAL_CLASS_NOT_STRUCTURAL,
"The DIT content rule \"%s\" is associated with the " +
"objectclass with OID %s (%s). This objectclass exists " +
"in the server schema but is defined as %s rather than " +
"structural");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DCR_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because it contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNKNOWN_AUXILIARY_CLASS,
"The DIT content rule \"%s\" is associated with an " +
"auxiliary objectclass %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_DCR_AUXILIARY_CLASS_NOT_AUXILIARY,
"The DIT content rule \"%s\" is associated with an " +
"auxiliary objectclass %s. This objectclass exists " +
"in the server schema but is defined as %s rather than " +
"auxiliary");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR,
"The DIT content rule \"%s\" is associated with a " +
"required attribute type %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR,
"The DIT content rule \"%s\" is associated with an " +
"optional attribute type %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_DCR_UNKNOWN_PROHIBITED_ATTR,
"The DIT content rule \"%s\" is associated with a " +
"prohibited attribute type %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_DCR_PROHIBITED_REQUIRED_BY_STRUCTURAL,
"The DIT content rule \"%s\" is not valid because it " +
"prohibits the use of attribute type %s which is " +
"required by the associated structural object class %s");
registerMessage(MSGID_ATTR_SYNTAX_DCR_PROHIBITED_REQUIRED_BY_AUXILIARY,
"The DIT content rule \"%s\" is not valid because it " +
"prohibits the use of attribute type %s which is " +
"required by the associated auxiliary object class %s");
registerMessage(MSGID_ATTR_SYNTAX_DCR_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as a DIT " +
"content rule description because a single quote was " +
"expected at position %d but the %s character was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_EMPTY_VALUE,
"The provided value could not be parsed as a valid name " +
"form description because it was empty or contained only " +
"whitespace");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a name " +
"form description because an open parenthesis was " +
"expected at position %d but instead a '%s' character " +
"was found");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as a name " +
"form description because the end of the value was " +
"encountered while the Directory Server expected more " +
"data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a name " +
"form description because the numeric OID contained two " +
"consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a name " +
"form description because the numeric OID contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as a name " +
"form description because the non-numeric OID contained " +
"an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a name " +
"form description because it contained an unexpected " +
"closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a name " +
"form description because it contained an illegal " +
"character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_STRUCTURAL_CLASS,
"The name form description \"%s\" is associated with a " +
"structural objectclass %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_STRUCTURAL_CLASS_NOT_STRUCTURAL,
"The name form description \"%s\" is associated with the " +
"objectclass with OID %s (%s). This objectclass exists " +
"in the server schema but is defined as %s rather than " +
"structural");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_REQUIRED_ATTR,
"The definition for the name form with OID %s declared " +
"that it should include required attribute \"%s\". No " +
"attribute type matching this name or OID exists in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_UNKNOWN_OPTIONAL_ATTR,
"The definition for the name form with OID %s declared " +
"that it should include optional attribute \"%s\". No " +
"attribute type matching this name or OID exists in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_NO_STRUCTURAL_CLASS,
"The provided value \"%s\" could not be parsed as a name " +
"form description because it does not specify the " +
"structural objectclass with which it is associated");
registerMessage(MSGID_ATTR_SYNTAX_NAME_FORM_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as a name " +
"form description because a single quote was expected at " +
"position %d but the %s character was found instead");
registerMessage(MSGID_ATTR_SYNTAX_MR_EMPTY_VALUE,
"The provided value could not be parsed as a valid " +
"matching rule description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_MR_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because an open parenthesis " +
"was expected at position %d but instead a '%s' " +
"character was found");
registerMessage(MSGID_ATTR_SYNTAX_MR_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because the end of the value " +
"was encountered while the Directory Server expected " +
"more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_MR_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because the non-numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MR_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MR_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because it contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MR_UNKNOWN_SYNTAX,
"The matching rule description \"%s\" is associated with " +
"attribute syntax %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_MR_NO_SYNTAX,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because it does not specify " +
"the attribute syntax with which it is associated");
registerMessage(MSGID_ATTR_SYNTAX_MR_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because a single quote was " +
"expected at position %d but the %s character was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_EMPTY_VALUE,
"The provided value could not be parsed as a valid " +
"matching rule use description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because an open " +
"parenthesis was expected at position %d but instead a " +
"'%s' character was found");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because the end of the " +
"value was encountered while the Directory Server " +
"expected more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because the non-numeric " +
"OID contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_UNKNOWN_MATCHING_RULE,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because the specified " +
"matching rule %s is unknown");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because it contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR,
"The matching rule use description \"%s\" is associated " +
"with attribute type %s that is not defined in the " +
"server schema");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_NO_ATTR,
"The provided value \"%s\" could not be parsed as a " +
"matching rule description because it does not specify " +
"the set of attribute types that may be used with the " +
"associated OID");
registerMessage(MSGID_ATTR_SYNTAX_MRUSE_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as a " +
"matching rule use description because a single quote " +
"was expected at position %d but the %s character was " +
"found instead");
registerMessage(MSGID_ATTR_SYNTAX_DSR_EMPTY_VALUE,
"The provided value could not be parsed as a valid DIT " +
"structure rule description because it was empty or " +
"contained only whitespace");
registerMessage(MSGID_ATTR_SYNTAX_DSR_EXPECTED_OPEN_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because an open parenthesis " +
"was expected at position %d but instead a '%s' " +
"character was found");
registerMessage(MSGID_ATTR_SYNTAX_DSR_TRUNCATED_VALUE,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because the end of the value " +
"was encountered while the Directory Server expected " +
"more data to be provided");
registerMessage(MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_RULE_ID,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because the rule ID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DSR_UNEXPECTED_CLOSE_PARENTHESIS,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because it contained an " +
"unexpected closing parenthesis at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because it contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DSR_UNKNOWN_NAME_FORM,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because it referenced an " +
"unknown name form %s");
registerMessage(MSGID_ATTR_SYNTAX_DSR_UNKNOWN_RULE_ID,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because it referenced an " +
"unknown rule ID %d for a superior DIT structure rule");
registerMessage(MSGID_ATTR_SYNTAX_DSR_NO_NAME_FORM,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because it did not specify " +
"the name form for the rule");
registerMessage(MSGID_ATTR_SYNTAX_DSR_EXPECTED_QUOTE_AT_POS,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because a single quote was " +
"expected at position %d but the %s character was found " +
"instead");
registerMessage(MSGID_ATTR_SYNTAX_DSR_DOUBLE_PERIOD_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because the numeric OID " +
"contained two consecutive periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_NUMERIC_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because the numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_DSR_ILLEGAL_CHAR_IN_STRING_OID,
"The provided value \"%s\" could not be parsed as a DIT " +
"structure rule description because the non-numeric OID " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_TELEX_TOO_SHORT,
"The provided value \"%s\" is too short to be a valid " +
"telex number value");
registerMessage(MSGID_ATTR_SYNTAX_TELEX_NOT_PRINTABLE,
"The provided value \"%s\" does not hold a valid telex " +
"number because a character %s at position %d was not " +
"a valid printable string character");
registerMessage(MSGID_ATTR_SYNTAX_TELEX_ILLEGAL_CHAR,
"The provided value \"%s\" does not hold a valid telex " +
"number because character %s at position %d was neither " +
"a valid printable string character nor a dollar sign to " +
"separate the telex number components");
registerMessage(MSGID_ATTR_SYNTAX_TELEX_TRUNCATED,
"The provided value \"%s\" does not hold a valid telex " +
"number because the end of the value was found before " +
"three dollar-delimited printable strings could be read");
registerMessage(MSGID_ATTR_SYNTAX_FAXNUMBER_EMPTY,
"The provided value could not be parsed as a valid " +
"facsimile telephone number because it was empty");
registerMessage(MSGID_ATTR_SYNTAX_FAXNUMBER_NOT_PRINTABLE,
"The provided value \"%s\" could not be parsed as a " +
"valid facsimile telephone number because character %s " +
"at position %d was not a valid printable string " +
"character");
registerMessage(MSGID_ATTR_SYNTAX_FAXNUMBER_END_WITH_DOLLAR,
"The provided value \"%s\" could not be parsed as a " +
"valid facsimile telephone number because it ends with " +
"a dollar sign, but that dollar sign should have been " +
"followed by a fax parameter");
registerMessage(MSGID_ATTR_SYNTAX_FAXNUMBER_ILLEGAL_PARAMETER,
"The provided value \"%s\" could not be parsed as a " +
"valid facsimile telephone number because the string " +
"\"%s\" between positions %d and %d was not a valid fax " +
"parameter");
registerMessage(MSGID_ATTR_SYNTAX_NAMEANDUID_INVALID_DN,
"The provided value \"%s\" could not be parsed as a " +
"valid name and optional UID value because an error " +
"occurred while trying to parse the DN portion: %s");
registerMessage(MSGID_ATTR_SYNTAX_NAMEANDUID_ILLEGAL_BINARY_DIGIT,
"The provided value \"%s\" could not be parsed as a " +
"valid name and optional UID value because the UID " +
"portion contained an illegal binary digit %s at " +
"position %d");
registerMessage(MSGID_ATTR_SYNTAX_TELETEXID_EMPTY,
"The provided value could not be parsed as a valid " +
"teletex terminal identifier because it was empty");
registerMessage(MSGID_ATTR_SYNTAX_TELETEXID_NOT_PRINTABLE,
"The provided value \"%s\" could not be parsed as a " +
"valid teletex terminal identifier because character %s " +
"at position %d was not a valid printable string " +
"character");
registerMessage(MSGID_ATTR_SYNTAX_TELETEXID_END_WITH_DOLLAR,
"The provided value \"%s\" could not be parsed as a " +
"valid teletex terminal identifier because it ends with " +
"a dollar sign, but that dollar sign should have been " +
"followed by a TTX parameter");
registerMessage(MSGID_ATTR_SYNTAX_TELETEXID_PARAM_NO_COLON,
"The provided value \"%s\" could not be parsed as a " +
"valid teletex terminal identifier because the parameter " +
"string does not contain a colon to separate the name " +
"from the value");
registerMessage(MSGID_ATTR_SYNTAX_TELETEXID_ILLEGAL_PARAMETER,
"The provided value \"%s\" could not be parsed as a " +
"valid teletex terminal identifier because the string " +
"\"%s\" is not a valid TTX parameter name");
registerMessage(MSGID_ATTR_SYNTAX_OTHER_MAILBOX_EMPTY_VALUE,
"The provided value could not be parsed as an other " +
"mailbox value because it was empty");
registerMessage(MSGID_ATTR_SYNTAX_OTHER_MAILBOX_NO_MBTYPE,
"The provided value \"%s\" could not be parsed as an " +
"other mailbox value because there was no mailbox type " +
"before the dollar sign");
registerMessage(MSGID_ATTR_SYNTAX_OTHER_MAILBOX_ILLEGAL_MBTYPE_CHAR,
"The provided value \"%s\" could not be parsed as an " +
"other mailbox value because the mailbox type contained " +
"an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_OTHER_MAILBOX_NO_MAILBOX,
"The provided value \"%s\" could not be parsed as an " +
"other mailbox value because there was no mailbox after " +
"the dollar sign");
registerMessage(MSGID_ATTR_SYNTAX_OTHER_MAILBOX_ILLEGAL_MB_CHAR,
"The provided value \"%s\" could not be parsed as an " +
"other mailbox value because the mailbox contained an " +
"illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_NO_OC,
"The provided value \"%s\" could not be parsed as a " +
"guide value because it did not contain an objectclass " +
"name or OID before the octothorpe (#) character");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_ILLEGAL_CHAR,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s contained " +
"an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_MISSING_CLOSE_PAREN,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s did not " +
"contain a close parenthesis that corresponded to the " +
"initial open parenthesis");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_INVALID_QUESTION_MARK,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s started " +
"with a question mark but was not followed by the string " +
"\"true\" or \"false\"");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_NO_DOLLAR,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s did not " +
"contain a dollar sign to separate the attribute type " +
"from the match type");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_NO_ATTR,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s did not " +
"specify an attribute type before the dollar sign");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_NO_MATCH_TYPE,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s did not " +
"specify a match type after the dollar sign");
registerMessage(MSGID_ATTR_SYNTAX_GUIDE_INVALID_MATCH_TYPE,
"The provided value \"%s\" could not be parsed as a " +
"guide value because the criteria portion %s had an " +
"invalid match type starting at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_SHARP,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because it did not contain an " +
"octothorpe (#) character to separate the objectclass " +
"from the criteria");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_OC,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because it did not contain an " +
"objectclass name or OID before the octothorpe (#) " +
"character");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_DOUBLE_PERIOD_IN_OC_OID,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because the numeric OID %s " +
"specifying the objectclass contained two consecutive " +
"periods at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_ILLEGAL_CHAR_IN_OC_OID,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because the numeric OID %s " +
"specifying the objectclass contained an illegal " +
"character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_ILLEGAL_CHAR_IN_OC_NAME,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because the objectclass name %s " +
"contained an illegal character %s at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_FINAL_SHARP,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because it did not have an " +
"octothorpe (#) character to separate the criteria from " +
"the scope");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_SCOPE,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because no scope was provided " +
"after the final octothorpe (#) character");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_INVALID_SCOPE,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because the specified scope %s " +
"was invalid");
registerMessage(MSGID_ATTR_SYNTAX_ENHANCEDGUIDE_NO_CRITERIA,
"The provided value \"%s\" could not be parsed as an " +
"enhanced guide value because it did not specify any " +
"criteria between the octothorpe (#) characters");
registerMessage(MSGID_OMR_CASE_EXACT_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the caseExactOrderingMatch " +
"matching rule because the normalized form of one of " +
"those values could not be retrieved: %s");
registerMessage(MSGID_OMR_CASE_EXACT_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the caseExactOrderingMatch matching rule " +
"because the objects were of an unsupported type %s. " +
"Only byte arrays, ASN.1 octet strings, and attribute " +
"value objects may be compared");
registerMessage(MSGID_OMR_CASE_IGNORE_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the " +
"caseIgnoreOrderingMatch matching rule because the " +
"normalized form of one of those values could not be " +
"retrieved: %s");
registerMessage(MSGID_OMR_CASE_IGNORE_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the caseIgnoreOrderingMatch matching rule " +
"because the objects were of an unsupported type %s. " +
"Only byte arrays, ASN.1 octet strings, and attribute " +
"value objects may be compared");
registerMessage(MSGID_OMR_GENERALIZED_TIME_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the " +
"generalizedTimeOrderingMatch matching rule because the " +
"normalized form of one of those values could not be " +
"retrieved: %s");
registerMessage(MSGID_OMR_GENERALIZED_TIME_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the generalizedTimeOrderingMatch matching " +
"rule because the objects were of an unsupported type " +
"%s. Only byte arrays, ASN.1 octet strings, and " +
"attribute value objects may be compared");
registerMessage(MSGID_OMR_INTEGER_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the integerOrderingMatch " +
"matching rule because the normalized form of one of " +
"those values could not be retrieved: %s");
registerMessage(MSGID_OMR_INTEGER_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the integerOrderingMatch matching rule " +
"because the objects were of an unsupported type %s. " +
"Only byte arrays, ASN.1 octet strings, and attribute " +
"value objects may be compared");
registerMessage(MSGID_OMR_NUMERIC_STRING_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the " +
"numericStringOrderingMatch matching rule because the " +
"normalized form of one of those values could not be " +
"retrieved: %s");
registerMessage(MSGID_OMR_NUMERIC_STRING_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the numericStringOrderingMatch matching " +
"rule because the objects were of an unsupported type " +
"%s. Only byte arrays, ASN.1 octet strings, and " +
"attribute value objects may be compared");
registerMessage(MSGID_OMR_OCTET_STRING_COMPARE_CANNOT_NORMALIZE,
"An error occurred while attempting to compare two " +
"AttributeValue objects using the " +
"octetStringOrderingMatch matching rule because the " +
"normalized form of one of those values could not be " +
"retrieved: %s");
registerMessage(MSGID_OMR_OCTET_STRING_COMPARE_INVALID_TYPE,
"An error occurred while attempting to compare two " +
"objects using the octetStringOrderingMatch matching " +
"rule because the objects were of an unsupported type " +
"%s. Only byte arrays, ASN.1 octet strings, and " +
"attribute value objects may be compared");
registerMessage(MSGID_ATTR_SYNTAX_UUID_INVALID_LENGTH,
"The provided value \"%s\" has an invalid length for a " +
"UUID. All UUID values must have a length of exactly 36 " +
"bytes, but the provided value had a length of %d bytes");
registerMessage(MSGID_ATTR_SYNTAX_UUID_EXPECTED_DASH,
"The provided value \"%s\" should have had a dash at " +
"position %d, but the character '%s' was found instead");
registerMessage(MSGID_ATTR_SYNTAX_UUID_EXPECTED_HEX,
"The provided value \"%s\" should have had a hexadecimal " +
"digit at position %d, but the character '%s' was found " +
"instead");
registerMessage(
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_DESCRIPTION_ALLOW_ZEROLENGTH,
"Indicates whether attributes with the directory string syntax will " +
"be allowed to have zero-length values. This is technically not " +
"allowed by the LDAP specifications, but it may be useful for " +
"backward compatibility with previous Directory Server releases");
registerMessage(
MSGID_ATTR_SYNTAX_DIRECTORYSTRING_CANNOT_DETERMINE_ZEROLENGTH,
"An error occurred while trying to determine the value of the %s " +
"configuration attribute, which indicates whether directory string " +
"attributes should be allowed to have zero-length values: %s");
registerMessage(MSGID_ATTR_SYNTAX_DIRECTORYSTRING_INVALID_ZEROLENGTH_VALUE,
"The operation attempted to assign a zero-length value " +
"to an attribute with the directory string syntax");
registerMessage(MSGID_ATTR_SYNTAX_DIRECTORYSTRING_UPDATED_ALLOW_ZEROLENGTH,
"The %s attribute in configuration entry %s has been " +
"updated with a new value of %s");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_INVALID_SCHEME_CHAR,
"The provided authPassword value had an invalid scheme " +
"character at position %d");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_NO_SCHEME,
"The provided authPassword value had a zero-length " +
"scheme element");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_NO_SCHEME_SEPARATOR,
"The provided authPassword value was missing the " +
"separator character or had an illegal character between " +
"the scheme and authInfo elements");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_INVALID_AUTH_INFO_CHAR,
"The provided authPassword value had an invalid authInfo " +
"character at position %d");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_INFO,
"The provided authPassword value had a zero-length " +
"authInfo element");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_INFO_SEPARATOR,
"The provided authPassword value was missing the " +
"separator character or had an illegal character between " +
"the authInfo and authValue elements");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_INVALID_AUTH_VALUE_CHAR,
"The provided authPassword value had an invalid " +
"authValue character at position %d");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_NO_AUTH_VALUE,
"The provided authPassword value had a zero-length " +
"authValue element");
registerMessage(MSGID_ATTR_SYNTAX_AUTHPW_INVALID_TRAILING_CHAR,
"The provided authPassword value had an invalid trailing " +
"character at position %d");
registerMessage(MSGID_EMR_INTFIRSTCOMP_NO_INITIAL_PARENTHESIS,
"The provided value \"%s\" could not be parsed by the " +
"integer first component matching rule because it did " +
"not start with a parenthesis");
registerMessage(MSGID_EMR_INTFIRSTCOMP_NO_NONSPACE,
"The provided value \"%s\" could not be parsed by the " +
"integer first component matching rule because it did " +
"not have any non-space characters after the opening " +
"parenthesis");
registerMessage(MSGID_EMR_INTFIRSTCOMP_NO_SPACE_AFTER_INT,
"The provided value \"%s\" could not be parsed by the " +
"integer first component matching rule because it did " +
"not have any space characters after the first component");
registerMessage(MSGID_EMR_INTFIRSTCOMP_FIRST_COMPONENT_NOT_INT,
"The provided value \"%s\" could not be parsed by the " +
"integer first component matching rule because the first " +
"component does not appear to be an integer value");
registerMessage(MSGID_ATTR_SYNTAX_USERPW_NO_VALUE,
"No value was given to decode by the user password " +
"attribute syntax");
registerMessage(MSGID_ATTR_SYNTAX_USERPW_NO_OPENING_BRACE,
"Unable to decode the provided value according to the " +
"user password syntax because the value does not start " +
"with the opening curly brace (\"{\") character");
registerMessage(MSGID_ATTR_SYNTAX_USERPW_NO_CLOSING_BRACE,
"Unable to decode the provided value according to the " +
"user password syntax because the value does not contain " +
"a closing curly brace (\"}\") character");
registerMessage(MSGID_ATTR_SYNTAX_USERPW_NO_SCHEME,
"Unable to decode the provided value according to the " +
"user password syntax because the value does not contain " +
"a storage scheme name");
registerMessage(MSGID_ATTR_SYNTAX_RFC3672_SUBTREE_SPECIFICATION_INVALID,
"The provided value \"%s\" could not be parsed as a" +
" valid RFC 3672 subtree specification");
registerMessage(MSGID_ATTR_SYNTAX_ABSOLUTE_SUBTREE_SPECIFICATION_INVALID,
"The provided value \"%s\" could not be parsed as a" +
" valid absolute subtree specification");
registerMessage(MSGID_ATTR_SYNTAX_RELATIVE_SUBTREE_SPECIFICATION_INVALID,
"The provided value \"%s\" could not be parsed as a" +
" valid relative subtree specification");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_EXTENSION_INVALID_CHARACTER,
"The provided value \"%s\" could not be parsed as an " +
"attribute syntax extension because an invalid character"+
"was found at position %d");
registerMessage(MSGID_ATTR_SYNTAX_ATTRSYNTAX_INVALID_EXTENSION,
"The attribute syntax could not be parsed because of an"+
"invalid extension."+ "%s");
}
}