/*
|
* 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 legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* 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 legal-notices/CDDLv1_0.txt.
|
* 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
|
*
|
*
|
* Copyright 2010 Sun Microsystems, Inc.
|
* Portions copyright 2011-2012 ForgeRock AS.
|
*/
|
|
package org.forgerock.opendj.ldap;
|
|
import static com.forgerock.opendj.util.StaticUtils.*;
|
import static org.forgerock.opendj.ldap.CoreMessages.*;
|
|
import java.util.Comparator;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.i18n.LocalizedIllegalArgumentException;
|
import org.forgerock.opendj.ldap.schema.AttributeType;
|
import org.forgerock.opendj.ldap.schema.MatchingRule;
|
import org.forgerock.opendj.ldap.schema.Schema;
|
import org.forgerock.opendj.ldap.schema.Syntax;
|
import org.forgerock.opendj.ldap.schema.UnknownSchemaElementException;
|
|
import com.forgerock.opendj.util.StaticUtils;
|
import com.forgerock.opendj.util.SubstringReader;
|
import com.forgerock.opendj.util.Validator;
|
|
/**
|
* An attribute value assertion (AVA) as defined in RFC 4512 section 2.3
|
* consists of an attribute description with zero options and an attribute
|
* value.
|
* <p>
|
* The following are examples of string representations of AVAs:
|
*
|
* <pre>
|
* uid=12345
|
* ou=Engineering
|
* cn=Kurt Zeilenga
|
* </pre>
|
*
|
* @see <a href="http://tools.ietf.org/html/rfc4512#section-2.3">RFC 4512 -
|
* Lightweight Directory Access Protocol (LDAP): Directory Information
|
* Models </a>
|
*/
|
public final class AVA implements Comparable<AVA> {
|
/**
|
* Parses the provided LDAP string representation of an AVA using the
|
* default schema.
|
*
|
* @param ava
|
* The LDAP string representation of an AVA.
|
* @return The parsed RDN.
|
* @throws LocalizedIllegalArgumentException
|
* If {@code ava} is not a valid LDAP string representation of a
|
* AVA.
|
* @throws NullPointerException
|
* If {@code ava} was {@code null}.
|
*/
|
public static AVA valueOf(final String ava) {
|
return valueOf(ava, Schema.getDefaultSchema());
|
}
|
|
/**
|
* Parses the provided LDAP string representation of an AVA using the
|
* provided schema.
|
*
|
* @param ava
|
* The LDAP string representation of a AVA.
|
* @param schema
|
* The schema to use when parsing the AVA.
|
* @return The parsed AVA.
|
* @throws LocalizedIllegalArgumentException
|
* If {@code ava} is not a valid LDAP string representation of a
|
* AVA.
|
* @throws NullPointerException
|
* If {@code ava} or {@code schema} was {@code null}.
|
*/
|
public static AVA valueOf(final String ava, final Schema schema) {
|
final SubstringReader reader = new SubstringReader(ava);
|
try {
|
return decode(reader, schema);
|
} catch (final UnknownSchemaElementException e) {
|
final LocalizableMessage message =
|
ERR_RDN_TYPE_NOT_FOUND.get(ava, e.getMessageObject());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
}
|
|
static AVA decode(final SubstringReader reader, final Schema schema) {
|
// Skip over any spaces at the beginning.
|
reader.skipWhitespaces();
|
|
if (reader.remaining() == 0) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_NO_NAME.get(reader.getString());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
final AttributeType attribute = readAttributeName(reader, schema);
|
|
// Skip over any spaces if we have.
|
reader.skipWhitespaces();
|
|
// Make sure that we're not at the end of the DN string because
|
// that would be invalid.
|
if (reader.remaining() == 0) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(reader.getString(), attribute
|
.getNameOrOID());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
// The next character must be an equal sign. If it is not, then
|
// that's an error.
|
char c;
|
if ((c = reader.read()) != '=') {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_NO_EQUAL
|
.get(reader.getString(), attribute.getNameOrOID(), c);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
// Skip over any spaces after the equal sign.
|
reader.skipWhitespaces();
|
|
// Parse the value for this RDN component.
|
final ByteString value = readAttributeValue(reader);
|
|
return new AVA(attribute, value);
|
}
|
|
static void escapeAttributeValue(final String str, final StringBuilder builder) {
|
if (str.length() > 0) {
|
char c = str.charAt(0);
|
int startPos = 0;
|
if ((c == ' ') || (c == '#')) {
|
builder.append('\\');
|
builder.append(c);
|
startPos = 1;
|
}
|
final int length = str.length();
|
for (int si = startPos; si < length; si++) {
|
c = str.charAt(si);
|
if (c < ' ') {
|
for (final byte b : getBytes(String.valueOf(c))) {
|
builder.append('\\');
|
builder.append(StaticUtils.byteToLowerHex(b));
|
}
|
} else {
|
if ((c == ' ' && si == length - 1)
|
|| (c == '"' || c == '+' || c == ',' || c == ';' || c == '<'
|
|| c == '=' || c == '>' || c == '\\' || c == '\u0000')) {
|
builder.append('\\');
|
}
|
builder.append(c);
|
}
|
}
|
}
|
}
|
|
private static void appendHexChars(final SubstringReader reader,
|
final StringBuilder valueBuffer, final StringBuilder hexBuffer) throws DecodeException {
|
final int length = hexBuffer.length();
|
if (length == 0) {
|
return;
|
}
|
|
if ((length % 2) != 0) {
|
final LocalizableMessage message = ERR_HEX_DECODE_INVALID_LENGTH.get(hexBuffer);
|
throw DecodeException.error(message);
|
}
|
|
int pos = 0;
|
final int arrayLength = (length / 2);
|
final byte[] hexArray = new byte[arrayLength];
|
for (int i = 0; i < arrayLength; i++) {
|
switch (hexBuffer.charAt(pos++)) {
|
case '0':
|
hexArray[i] = 0x00;
|
break;
|
case '1':
|
hexArray[i] = 0x10;
|
break;
|
case '2':
|
hexArray[i] = 0x20;
|
break;
|
case '3':
|
hexArray[i] = 0x30;
|
break;
|
case '4':
|
hexArray[i] = 0x40;
|
break;
|
case '5':
|
hexArray[i] = 0x50;
|
break;
|
case '6':
|
hexArray[i] = 0x60;
|
break;
|
case '7':
|
hexArray[i] = 0x70;
|
break;
|
case '8':
|
hexArray[i] = (byte) 0x80;
|
break;
|
case '9':
|
hexArray[i] = (byte) 0x90;
|
break;
|
case 'A':
|
case 'a':
|
hexArray[i] = (byte) 0xA0;
|
break;
|
case 'B':
|
case 'b':
|
hexArray[i] = (byte) 0xB0;
|
break;
|
case 'C':
|
case 'c':
|
hexArray[i] = (byte) 0xC0;
|
break;
|
case 'D':
|
case 'd':
|
hexArray[i] = (byte) 0xD0;
|
break;
|
case 'E':
|
case 'e':
|
hexArray[i] = (byte) 0xE0;
|
break;
|
case 'F':
|
case 'f':
|
hexArray[i] = (byte) 0xF0;
|
break;
|
default:
|
final LocalizableMessage message =
|
ERR_HEX_DECODE_INVALID_CHARACTER.get(hexBuffer, hexBuffer.charAt(pos - 1));
|
throw DecodeException.error(message);
|
}
|
|
switch (hexBuffer.charAt(pos++)) {
|
case '0':
|
// No action required.
|
break;
|
case '1':
|
hexArray[i] |= 0x01;
|
break;
|
case '2':
|
hexArray[i] |= 0x02;
|
break;
|
case '3':
|
hexArray[i] |= 0x03;
|
break;
|
case '4':
|
hexArray[i] |= 0x04;
|
break;
|
case '5':
|
hexArray[i] |= 0x05;
|
break;
|
case '6':
|
hexArray[i] |= 0x06;
|
break;
|
case '7':
|
hexArray[i] |= 0x07;
|
break;
|
case '8':
|
hexArray[i] |= 0x08;
|
break;
|
case '9':
|
hexArray[i] |= 0x09;
|
break;
|
case 'A':
|
case 'a':
|
hexArray[i] |= 0x0A;
|
break;
|
case 'B':
|
case 'b':
|
hexArray[i] |= 0x0B;
|
break;
|
case 'C':
|
case 'c':
|
hexArray[i] |= 0x0C;
|
break;
|
case 'D':
|
case 'd':
|
hexArray[i] |= 0x0D;
|
break;
|
case 'E':
|
case 'e':
|
hexArray[i] |= 0x0E;
|
break;
|
case 'F':
|
case 'f':
|
hexArray[i] |= 0x0F;
|
break;
|
default:
|
final LocalizableMessage message =
|
ERR_HEX_DECODE_INVALID_CHARACTER.get(hexBuffer, hexBuffer.charAt(pos - 1));
|
throw DecodeException.error(message);
|
}
|
}
|
try {
|
valueBuffer.append(new String(hexArray, "UTF-8"));
|
} catch (final Exception e) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE.get(reader.getString(), String
|
.valueOf(e));
|
throw DecodeException.error(message);
|
}
|
// Clean up the hex buffer.
|
hexBuffer.setLength(0);
|
}
|
|
private static ByteString delimitAndEvaluateEscape(final SubstringReader reader)
|
throws DecodeException {
|
char c = '\u0000';
|
final StringBuilder valueBuffer = new StringBuilder();
|
final StringBuilder hexBuffer = new StringBuilder();
|
reader.skipWhitespaces();
|
|
boolean escaped = false;
|
while (reader.remaining() > 0) {
|
c = reader.read();
|
if (escaped) {
|
// This character is escaped.
|
if (isHexDigit(c)) {
|
// Unicode characters.
|
if (!(reader.remaining() > 0)) {
|
final LocalizableMessage msg =
|
ERR_ATTR_SYNTAX_DN_ESCAPED_HEX_VALUE_INVALID
|
.get(reader.getString());
|
throw DecodeException.error(msg);
|
}
|
|
// Check the next byte for hex.
|
final char c2 = reader.read();
|
if (isHexDigit(c2)) {
|
hexBuffer.append(c);
|
hexBuffer.append(c2);
|
// We may be at the end.
|
if (reader.remaining() == 0) {
|
appendHexChars(reader, valueBuffer, hexBuffer);
|
}
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ESCAPED_HEX_VALUE_INVALID
|
.get(reader.getString());
|
throw DecodeException.error(message);
|
}
|
} else {
|
appendHexChars(reader, valueBuffer, hexBuffer);
|
valueBuffer.append(c);
|
}
|
escaped = false;
|
} else if (c == 0x5C /* The backslash character */) {
|
// We found an escape.
|
escaped = true;
|
} else {
|
// Check for delimited chars.
|
if (c == '+' || c == ',' || c == ';') {
|
reader.reset();
|
// Return what we have got here so far.
|
appendHexChars(reader, valueBuffer, hexBuffer);
|
return ByteString.valueOf(valueBuffer.toString());
|
}
|
// It is definitely not a delimiter at this point.
|
appendHexChars(reader, valueBuffer, hexBuffer);
|
valueBuffer.append(c);
|
// reader.mark();
|
}
|
reader.mark();
|
}
|
|
reader.reset();
|
return ByteString.valueOf(valueBuffer.toString());
|
}
|
|
private static AttributeType readAttributeName(final SubstringReader reader, final Schema schema) {
|
int length = 1;
|
reader.mark();
|
|
// The next character must be either numeric (for an OID) or
|
// alphabetic (for an attribute description).
|
char c = reader.read();
|
if (isDigit(c)) {
|
boolean lastWasPeriod = false;
|
while (reader.remaining() > 0) {
|
c = reader.read();
|
|
if (c == '=' || c == ' ') {
|
// This signals the end of the OID.
|
break;
|
} else if (c == '.') {
|
if (lastWasPeriod) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get(reader.getString(), c,
|
reader.pos() - 1);
|
throw new LocalizedIllegalArgumentException(message);
|
} else {
|
lastWasPeriod = true;
|
}
|
} else if (!isDigit(c)) {
|
// This must have been an illegal character.
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get(reader.getString(), c, reader
|
.pos() - 1);
|
throw new LocalizedIllegalArgumentException(message);
|
} else {
|
lastWasPeriod = false;
|
}
|
length++;
|
}
|
} else if (isAlpha(c)) {
|
// This must be an attribute description. In this case, we will
|
// only accept alphabetic characters, numeric digits, and the
|
// hyphen.
|
while (reader.remaining() > 0) {
|
c = reader.read();
|
|
if (c == '=' || c == ' ') {
|
// This signals the end of the OID.
|
break;
|
} else if (!isAlpha(c) && !isDigit(c) && c != '-') {
|
// This is an illegal character.
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get(reader.getString(), c, reader
|
.pos() - 1);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
length++;
|
}
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get(reader.getString(), c,
|
reader.pos() - 1);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
reader.reset();
|
|
// Return the position of the first non-space character after the
|
// token.
|
|
return schema.getAttributeType(reader.read(length));
|
}
|
|
private static ByteString readAttributeValue(final SubstringReader reader) {
|
// All leading spaces have already been stripped so we can start
|
// reading the value. However, it may be empty so check for that.
|
if (reader.remaining() == 0) {
|
return ByteString.empty();
|
}
|
|
reader.mark();
|
|
// Look at the first character. If it is an octothorpe (#), then
|
// that means that the value should be a hex string.
|
char c = reader.read();
|
int length = 0;
|
if (c == '#') {
|
// The first two characters must be hex characters.
|
reader.mark();
|
if (reader.remaining() < 2) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get(reader.getString());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
for (int i = 0; i < 2; i++) {
|
c = reader.read();
|
if (isHexDigit(c)) {
|
length++;
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(reader.getString(), c);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
}
|
|
// The rest of the value must be a multiple of two hex
|
// characters. The end of the value may be designated by the
|
// end of the DN, a comma or semicolon, or a space.
|
while (reader.remaining() > 0) {
|
c = reader.read();
|
if (isHexDigit(c)) {
|
length++;
|
|
if (reader.remaining() > 0) {
|
c = reader.read();
|
if (isHexDigit(c)) {
|
length++;
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(reader.getString(), c);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get(reader.getString());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
} else if ((c == ' ') || (c == ',') || (c == ';')) {
|
// This denotes the end of the value.
|
break;
|
} else {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(reader.getString(), c);
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
}
|
|
// At this point, we should have a valid hex string. Convert it
|
// to a byte array and set that as the value of the provided
|
// octet string.
|
try {
|
reader.reset();
|
return ByteString.wrap(hexStringToByteArray(reader.read(length)));
|
} catch (final Exception e) {
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE.get(reader.getString(), String
|
.valueOf(e));
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
} else if (c == '"') {
|
// If the first character is a quotation mark, then the value
|
// should continue until the corresponding closing quotation mark.
|
reader.mark();
|
while (true) {
|
if (reader.remaining() <= 0) {
|
// We hit the end of the AVA before the closing quote.
|
// That's an error.
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_UNMATCHED_QUOTE.get(reader.getString());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
|
if (reader.read() == '"') {
|
// This is the end of the value.
|
break;
|
}
|
length++;
|
}
|
reader.reset();
|
final ByteString retString = ByteString.valueOf(reader.read(length));
|
reader.read();
|
return retString;
|
} else {
|
// Otherwise, use general parsing to find the end of the value.
|
reader.reset();
|
ByteString bytes;
|
try {
|
bytes = delimitAndEvaluateEscape(reader);
|
} catch (final DecodeException e) {
|
throw new LocalizedIllegalArgumentException(e.getMessageObject());
|
}
|
if (bytes.length() == 0) {
|
// We don't allow an empty attribute value.
|
final LocalizableMessage message =
|
ERR_ATTR_SYNTAX_DN_INVALID_REQUIRES_ESCAPE_CHAR.get(reader.getString(),
|
reader.pos());
|
throw new LocalizedIllegalArgumentException(message);
|
}
|
return bytes;
|
}
|
}
|
|
private final AttributeType attributeType;
|
|
private final ByteString attributeValue;
|
|
// Cached normalized value using equality matching rule.
|
private ByteString equalityNormalizedAttributeValue = null;
|
|
// Cached normalized value using ordering matching rule.
|
private ByteString orderingNormalizedAttributeValue = null;
|
|
/**
|
* Creates a new attribute value assertion (AVA) using the provided
|
* attribute type and value.
|
* <p>
|
* If {@code attributeValue} is not an instance of {@code ByteString} then
|
* it will be converted using the {@link ByteString#valueOf(Object)} method.
|
*
|
* @param attributeType
|
* The attribute type.
|
* @param attributeValue
|
* The attribute value.
|
* @throws NullPointerException
|
* If {@code attributeType} or {@code attributeValue} was
|
* {@code null}.
|
*/
|
public AVA(final AttributeType attributeType, final Object attributeValue) {
|
Validator.ensureNotNull(attributeType, attributeValue);
|
|
this.attributeType = attributeType;
|
this.attributeValue = ByteString.valueOf(attributeValue);
|
}
|
|
/**
|
* Creates a new attribute value assertion (AVA) using the provided
|
* attribute type and value decoded using the default schema.
|
* <p>
|
* If {@code attributeValue} is not an instance of {@code ByteString} then
|
* it will be converted using the {@link ByteString#valueOf(Object)} method.
|
*
|
* @param attributeType
|
* The attribute type.
|
* @param attributeValue
|
* The attribute value.
|
* @throws UnknownSchemaElementException
|
* If {@code attributeType} was not found in the default schema.
|
* @throws NullPointerException
|
* If {@code attributeType} or {@code attributeValue} was
|
* {@code null}.
|
*/
|
public AVA(final String attributeType, final Object attributeValue) {
|
Validator.ensureNotNull(attributeType, attributeValue);
|
|
this.attributeType = Schema.getDefaultSchema().getAttributeType(attributeType);
|
this.attributeValue = ByteString.valueOf(attributeValue);
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public int compareTo(final AVA ava) {
|
final int result = attributeType.compareTo(ava.attributeType);
|
if (result != 0) {
|
return result > 0 ? 1 : -1;
|
}
|
|
final ByteString normalizedValue = getOrderingNormalizedValue();
|
final ByteString otherNormalizedValue = ava.getOrderingNormalizedValue();
|
final MatchingRule rule = attributeType.getOrderingMatchingRule();
|
if (rule != null) {
|
final Comparator<ByteSequence> comparator = rule.comparator();
|
return comparator.compare(normalizedValue, otherNormalizedValue);
|
} else {
|
return normalizedValue.compareTo(otherNormalizedValue);
|
}
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public boolean equals(final Object obj) {
|
if (this == obj) {
|
return true;
|
} else if (obj instanceof AVA) {
|
final AVA ava = (AVA) obj;
|
|
if (!attributeType.equals(ava.attributeType)) {
|
return false;
|
}
|
|
final ByteString normalizedValue = getEqualityNormalizedValue();
|
final ByteString otherNormalizedValue = ava.getEqualityNormalizedValue();
|
final MatchingRule rule = attributeType.getEqualityMatchingRule();
|
if (rule != null) {
|
final Comparator<ByteSequence> comparator = rule.comparator();
|
return comparator.compare(normalizedValue, otherNormalizedValue) != 0 ? false
|
: true;
|
} else {
|
return normalizedValue.equals(otherNormalizedValue);
|
}
|
} else {
|
return false;
|
}
|
}
|
|
/**
|
* Returns the attribute type associated with this AVA.
|
*
|
* @return The attribute type associated with this AVA.
|
*/
|
public AttributeType getAttributeType() {
|
return attributeType;
|
}
|
|
/**
|
* Returns the attribute value associated with this AVA.
|
*
|
* @return The attribute value associated with this AVA.
|
*/
|
public ByteString getAttributeValue() {
|
return attributeValue;
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public int hashCode() {
|
return attributeType.hashCode() * 31 + getEqualityNormalizedValue().hashCode();
|
}
|
|
/**
|
* Returns a single valued attribute having the same attribute type and
|
* value as this AVA.
|
*
|
* @return A single valued attribute having the same attribute type and
|
* value as this AVA.
|
*/
|
public Attribute toAttribute() {
|
AttributeDescription ad = AttributeDescription.create(attributeType);
|
return new LinkedAttribute(ad, attributeValue);
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public String toString() {
|
final StringBuilder builder = new StringBuilder();
|
return toString(builder).toString();
|
}
|
|
StringBuilder toString(final StringBuilder builder) {
|
if (!attributeType.getNames().iterator().hasNext()) {
|
builder.append(attributeType.getOID());
|
builder.append("=#");
|
StaticUtils.toHex(attributeValue, builder);
|
} else {
|
final String name = attributeType.getNameOrOID();
|
builder.append(name);
|
builder.append("=");
|
|
final Syntax syntax = attributeType.getSyntax();
|
if (!syntax.isHumanReadable()) {
|
builder.append("#");
|
StaticUtils.toHex(attributeValue, builder);
|
} else {
|
escapeAttributeValue(attributeValue.toString(), builder);
|
}
|
}
|
return builder;
|
}
|
|
private ByteString getEqualityNormalizedValue() {
|
final ByteString normalizedValue = equalityNormalizedAttributeValue;
|
|
if (normalizedValue != null) {
|
return normalizedValue;
|
}
|
|
final MatchingRule matchingRule = attributeType.getEqualityMatchingRule();
|
if (matchingRule != null) {
|
try {
|
equalityNormalizedAttributeValue =
|
matchingRule.normalizeAttributeValue(attributeValue);
|
} catch (final DecodeException de) {
|
// Unable to normalize, so default to byte-wise comparison.
|
equalityNormalizedAttributeValue = attributeValue;
|
}
|
} else {
|
// No matching rule, so default to byte-wise comparison.
|
equalityNormalizedAttributeValue = attributeValue;
|
}
|
|
return equalityNormalizedAttributeValue;
|
}
|
|
private ByteString getOrderingNormalizedValue() {
|
final ByteString normalizedValue = orderingNormalizedAttributeValue;
|
|
if (normalizedValue != null) {
|
return normalizedValue;
|
}
|
|
final MatchingRule matchingRule = attributeType.getEqualityMatchingRule();
|
if (matchingRule != null) {
|
try {
|
orderingNormalizedAttributeValue =
|
matchingRule.normalizeAttributeValue(attributeValue);
|
} catch (final DecodeException de) {
|
// Unable to normalize, so default to equality matching.
|
orderingNormalizedAttributeValue = getEqualityNormalizedValue();
|
}
|
} else {
|
// No matching rule, so default to equality matching.
|
orderingNormalizedAttributeValue = getEqualityNormalizedValue();
|
}
|
|
return orderingNormalizedAttributeValue;
|
}
|
}
|
