* *
*
* The LDAPMatchingRuleSchema class also specifies
* the matching rule "use description", which describes the
* attributes which can be used with the matching rule.
*
*
* When you construct an LDAPMatchingRuleSchema object, you can
* specify these types of information as arguments to the constructor or
* in the MatchingRuleDescription and MatchingRuleUseDescription formats
* specified in RFC 2252.
* When an LDAP client searches an LDAP server for the schema, the server
* returns schema information as an object with attribute values in this
* format.
*
*
* You can get the name, OID, and description of this matching rule
* definition by using the getName, getOID, and
* getDescription methods inherited from the abstract class
* LDAPSchemaElement. Custom qualifiers are
* accessed with getQualifier and getQualifierNames
* from LDAPSchemaElement.
*
*
* To add or remove this matching rule definition from the
* schema, use the add and remove
* methods, which this class inherits from the LDAPSchemaElement
* abstract class.
*
* RFC 2252 defines MatchingRuleDescription and MatchingRuleUseDescription * as follows: *
*
* MatchingRuleDescription = "(" whsp
* numericoid whsp ; MatchingRule identifier
* [ "NAME" qdescrs ]
* [ "DESC" qdstring ]
* [ "OBSOLETE" whsp ]
* "SYNTAX" numericoid
* whsp ")"
*
* Values of the matchingRuleUse list the attributes which are suitable
* for use with an extensible matching rule.
*
* MatchingRuleUseDescription = "(" whsp
* numericoid whsp ; MatchingRule identifier
* [ "NAME" qdescrs ]
* [ "DESC" qdstring ]
* [ "OBSOLETE" ]
* "APPLIES" oids ; AttributeType identifiers
* whsp ")"
*
*
* LDAPMatchingRuleSchema abstracts away from the two types and
* manages their relationships transparently.
*
* @version 1.0
* @see org.ietf.ldap.LDAPSchemaElement
**/
public class LDAPMatchingRuleSchema extends LDAPAttributeSchema {
static final long serialVersionUID = 6466155218986944131L;
/**
* Constructs a matching rule definition, using the specified
* information.
* @param names name of the matching rule
* @param oid object identifier (OID) of the matching rule
* in dotted-decimal format (for example, "1.2.3.4").
* @param description description of the matching rule.
* @param attributes array of the OIDs of the attributes for which
* the matching rule is applicable.
* @param obsolete true if the element is obsolete
* @param syntaxString syntax of this matching rule in dotted-decimal
* format
*/
public LDAPMatchingRuleSchema( String[] names,
String oid,
String description,
String[] attributes,
boolean obsolete,
String syntaxString ) {
if ( (oid == null) || (oid.trim().length() < 1) ) {
throw new IllegalArgumentException( "OID required" );
}
this.names = names;
this.oid = oid;
this.description = description;
attrName = "matchingrules";
syntaxElement.syntax = syntaxElement.syntaxCheck( syntaxString );
syntaxElement.syntaxString = syntaxString;
setQualifier( SYNTAX, syntaxElement.syntaxString );
_attributes = new String[attributes.length];
for( int i = 0; i < attributes.length; i++ ) {
this._attributes[i] = attributes[i];
}
if ( obsolete ) {
setQualifier( OBSOLETE, "" );
}
}
/**
* Constructs a matching rule definition based on descriptions in
* the MatchingRuleDescription format and MatchingRuleUseDescription
* format. For information on this format,
* (see RFC 2252, Lightweight Directory Access Protocol (v3):
* Attribute Syntax Definitions. This is the format that LDAP servers
* and clients use to exchange schema information. For example, when
* you search an LDAP server for its schema, the server returns an entry
* with attributes that include "matchingrule" and "matchingruleuse".
* The values of these attributes are matching rule descriptions
* in this format.
*
*
* @param raw definition of the matching rule in the
* MatchingRuleDescription format
* @param use definition of the use of the matching rule in the
* MatchingRuleUseDescription format
*/
public LDAPMatchingRuleSchema( String raw, String use ) {
attrName = "matchingrules";
if ( raw != null ) {
parseValue( raw );
}
if ( use != null ) {
parseValue( use );
}
Vector v = (Vector)properties.get( "APPLIES" );
if ( v != null ) {
_attributes = new String[v.size()];
v.copyInto( _attributes );
v.removeAllElements();
}
String val = (String)properties.get( "SYNTAX" );
if ( val != null ) {
syntaxElement.syntaxString = val;
syntaxElement.syntax = syntaxElement.syntaxCheck( val );
}
}
/**
* Gets the list of the OIDs of the attribute types which can be used
* with the matching rule.
* @return array of the OIDs of the attribute types which can be used
* with the matching rule.
*/
public String[] getAttributes() {
return _attributes;
}
/**
* Prepare a value in RFC 2252 format for submitting to a server
*
* @param quotingBug true if SUP and SYNTAX values are to
* be quoted; that is to satisfy bugs in certain LDAP servers.
* @return a String ready to be submitted to an LDAP server
*/
String getValue( boolean quotingBug ) {
String s = getValuePrefix();
if ( syntaxElement.syntaxString != null ) {
s += "SYNTAX ";
if ( quotingBug ) {
s += '\'';
}
s += syntaxElement.syntaxString;
if ( quotingBug ) {
s += '\'';
}
s += ' ';
}
String val = getCustomValues();
if ( val.length() > 0 ) {
s += val + ' ';
}
s += ')';
return s;
}
/**
* Gets the attribute name for a schema element
*
* @return The attribute name of the element
*/
String getAttributeName() {
return "matchingrules";
}
/**
* Gets the matching rule definition in the string representation
* of the MatchingRuleDescription data type defined in X.501 (see
* RFC 2252, Lightweight Directory Access Protocol
* (v3): Attribute Syntax Definitions
* for a description of these formats).
* This is the format that LDAP servers and clients use to exchange
* schema information. (For example, when
* you search an LDAP server for its schema, the server returns an entry
* with the attributes "matchingrules" and "matchingruleuse". The
* values of these attributes are matching rule description and
* matching rule use description in these formats.)
*
*
* @return a string in a format that can be used as the value of
* the matchingrule attribute (which describes
* a matching rule in the schema) of a subschema object
*/
String getValue() {
return getValue( false );
}
/**
* Gets the matching rule use definition in the string representation
* of the MatchingRuleUseDescription data type defined in X.501 (see
* RFC 2252, Lightweight Directory Access Protocol
* (v3): Attribute Syntax Definitions
* for a description of these formats).
* This is the format that LDAP servers and clients use to exchange
* schema information. (For example, when
* you search an LDAP server for its schema, the server returns an entry
* with the attributes "matchingrules" and "matchingruleuse". The
* values of these attributes are matching rule description and
* matching rule use description in these formats.)
*
*
* @return a string in a format that can be used as the value of
* the matchingruleuse attribute (which describes the use of
* a matching rule in the schema) of a subschema object
*/
public String getUseValue() {
String s = getValuePrefix();
if ( (_attributes != null) && (_attributes.length > 0) ) {
s += "APPLIES ( ";
for( int i = 0; i < _attributes.length; i++ ) {
if ( i > 0 )
s += " $ ";
s += _attributes[i];
}
s += " ) ";
}
s += ')';
return s;
}
/**
* Gets the definition of the matching rule in Directory format
*
* @return definition of the matching rule in Directory format
*/
public String toString() {
return getValue( false );
}
// Qualifiers tracked explicitly
static final String[] EXPLICIT = { OBSOLETE,
SYNTAX };
private String[] _attributes = null;
}