Filter (UnboundID LDAP SDK for Java 7.0.1)

java.lang.Object
- com.unboundid.ldap.sdk.Filter

All Implemented Interfaces:

java.io.Serializable
```
@NotMutable
 @ThreadSafety(level=COMPLETELY_THREADSAFE)
public final class Filter
extends java.lang.Object
implements java.io.Serializable
```
This class provides a data structure that represents an LDAP search filter. It provides methods for creating various types of filters, as well as parsing a filter from a string. See RFC 4515 for more information about representing search filters as strings.

The following filter types are defined:
- AND -- This is used to indicate that a filter should match an entry only if all of the embedded filter components match that entry. An AND filter with zero embedded filter components is considered an LDAP TRUE filter as defined in RFC 4526 and will match any entry. AND filters contain only a set of embedded filter components, and each of those embedded components can itself be any type of filter, including an AND, OR, or NOT filter with additional embedded components.
- OR -- This is used to indicate that a filter should match an entry only if at least one of the embedded filter components matches that entry. An OR filter with zero embedded filter components is considered an LDAP FALSE filter as defined in RFC 4526 and will never match any entry. OR filters contain only a set of embedded filter components, and each of those embedded components can itself be any type of filter, including an AND, OR, or NOT filter with additional embedded components.
- NOT -- This is used to indicate that a filter should match an entry only if the embedded NOT component does not match the entry. A NOT filter contains only a single embedded NOT filter component, but that embedded component can itself be any type of filter, including an AND, OR, or NOT filter with additional embedded components.
- EQUALITY -- This is used to indicate that a filter should match an entry only if the entry contains a value for the specified attribute that is equal to the provided assertion value. An equality filter contains only an attribute name and an assertion value.
- SUBSTRING -- This is used to indicate that a filter should match an entry only if the entry contains at least one value for the specified attribute that matches the provided substring assertion. The substring assertion must contain at least one element of the following types:
  - subInitial -- This indicates that the specified string must appear at the beginning of the attribute value. There can be at most one subInitial element in a substring assertion.
  - subAny -- This indicates that the specified string may appear anywhere in the attribute value. There can be any number of substring subAny elements in a substring assertion. If there are multiple subAny elements, then they must match in the order that they are provided.
  - subFinal -- This indicates that the specified string must appear at the end of the attribute value. There can be at most one subFinal element in a substring assertion.
  A substring filter contains only an attribute name and subInitial, subAny, and subFinal elements.
- GREATER-OR-EQUAL -- This is used to indicate that a filter should match an entry only if that entry contains at least one value for the specified attribute that is greater than or equal to the provided assertion value. A greater-or-equal filter contains only an attribute name and an assertion value.
- LESS-OR-EQUAL -- This is used to indicate that a filter should match an entry only if that entry contains at least one value for the specified attribute that is less than or equal to the provided assertion value. A less-or-equal filter contains only an attribute name and an assertion value.
- PRESENCE -- This is used to indicate that a filter should match an entry only if the entry contains at least one value for the specified attribute. A presence filter contains only an attribute name.
- APPROXIMATE-MATCH -- This is used to indicate that a filter should match an entry only if the entry contains at least one value for the specified attribute that is approximately equal to the provided assertion value. The definition of "approximately equal to" may vary from one server to another, and from one attribute to another, but it is often implemented as a "sounds like" match using a variant of the metaphone or double-metaphone algorithm. An approximate-match filter contains only an attribute name and an assertion value.
- EXTENSIBLE-MATCH -- This is used to perform advanced types of matching against entries, according to the following criteria:
  - If an attribute name is provided, then the assertion value must match one of the values for that attribute (potentially including values contained in the entry's DN). If a matching rule ID is also provided, then the associated matching rule will be used to determine whether there is a match; otherwise the default equality matching rule for that attribute will be used.
  - If no attribute name is provided, then a matching rule ID must be given, and the corresponding matching rule will be used to determine whether any attribute in the target entry (potentially including attributes contained in the entry's DN) has at least one value that matches the provided assertion value.
  - If the dnAttributes flag is set, then attributes contained in the entry's DN will also be evaluated to determine if they match the filter criteria. If it is not set, then attributes contained in the entry's DN (other than those contained in its RDN which are also present as separate attributes in the entry) will not be examined.
  An extensible match filter contains only an attribute name, matching rule ID, dnAttributes flag, and an assertion value.
There are two primary ways to create a search filter. The first is to create a filter from its string representation with the create(String) method, using the syntax described in RFC 4515. For example:
```
   Filter f1 = Filter.create("(objectClass=*)");
   Filter f2 = Filter.create("(uid=john.doe)");
   Filter f3 = Filter.create("(|(givenName=John)(givenName=Johnathan))");
 
```
Creating a filter from its string representation is a common approach and seems to be relatively straightforward, but it does have some hidden dangers. This primarily comes from the potential for special characters in the filter string which need to be properly escaped. If this isn't done, then the search may fail or behave unexpectedly, or worse it could lead to a vulnerability in the application in which a malicious user could trick the application into retrieving more information than it should have. To avoid these problems, it may be better to construct filters from their individual components rather than their string representations, like:
```
   Filter f1 = Filter.present("objectClass");
   Filter f2 = Filter.equals("uid", "john.doe");
   Filter f3 = Filter.or(
                    Filter.equals("givenName", "John"),
                    Filter.equals("givenName", "Johnathan"));
 
```
In general, it is recommended to avoid creating filters from their string representations if any of that string representation may include user-provided data or special characters including non-ASCII characters, parentheses, asterisks, or backslashes.
See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static byte`	`FILTER_TYPE_AND` The BER type for AND search filters.
`static byte`	`FILTER_TYPE_APPROXIMATE_MATCH` The BER type for approximate match search filters.
`static byte`	`FILTER_TYPE_EQUALITY` The BER type for equality search filters.
`static byte`	`FILTER_TYPE_EXTENSIBLE_MATCH` The BER type for extensible match search filters.
`static byte`	`FILTER_TYPE_GREATER_OR_EQUAL` The BER type for greaterOrEqual search filters.
`static byte`	`FILTER_TYPE_LESS_OR_EQUAL` The BER type for lessOrEqual search filters.
`static byte`	`FILTER_TYPE_NOT` The BER type for NOT search filters.
`static byte`	`FILTER_TYPE_OR` The BER type for OR search filters.
`static byte`	`FILTER_TYPE_PRESENCE` The BER type for presence search filters.
`static byte`	`FILTER_TYPE_SUBSTRING` The BER type for substring search filters.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Filter`	`and(java.util.Collection<Filter> andComponents)` Creates a new AND search filter with the provided components.
`static Filter`	`and(Filter... andComponents)` Creates a new AND search filter with the provided components.
`static Filter`	`approximateMatch(java.lang.String attributeName, byte[] assertionValue)` Creates a new approximate match search filter with the provided information.
`static Filter`	`approximateMatch(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new approximate match search filter with the provided information.
`static Filter`	`create(java.lang.String filterString)` Creates a new search filter from the provided string representation.
`static Filter`	`createANDFilter(java.util.Collection<Filter> andComponents)` Creates a new AND search filter with the provided components.
`static Filter`	`createANDFilter(Filter... andComponents)` Creates a new AND search filter with the provided components.
`static Filter`	`createANDFilter(java.util.List<Filter> andComponents)` Creates a new AND search filter with the provided components.
`static Filter`	`createApproximateMatchFilter(java.lang.String attributeName, byte[] assertionValue)` Creates a new approximate match search filter with the provided information.
`static Filter`	`createApproximateMatchFilter(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new approximate match search filter with the provided information.
`static Filter`	`createEqualityFilter(java.lang.String attributeName, byte[] assertionValue)` Creates a new equality search filter with the provided information.
`static Filter`	`createEqualityFilter(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new equality search filter with the provided information.
`static Filter`	`createExtensibleMatchFilter(java.lang.String attributeName, java.lang.String matchingRuleID, boolean dnAttributes, byte[] assertionValue)` Creates a new extensible match search filter with the provided information.
`static Filter`	`createExtensibleMatchFilter(java.lang.String attributeName, java.lang.String matchingRuleID, boolean dnAttributes, java.lang.String assertionValue)` Creates a new extensible match search filter with the provided information.
`static Filter`	`createGreaterOrEqualFilter(java.lang.String attributeName, byte[] assertionValue)` Creates a new greater-or-equal search filter with the provided information.
`static Filter`	`createGreaterOrEqualFilter(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new greater-or-equal search filter with the provided information.
`static Filter`	`createLessOrEqualFilter(java.lang.String attributeName, byte[] assertionValue)` Creates a new less-or-equal search filter with the provided information.
`static Filter`	`createLessOrEqualFilter(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new less-or-equal search filter with the provided information.
`static Filter`	`createNOTFilter(Filter notComponent)` Creates a new NOT search filter with the provided component.
`static Filter`	`createORFilter(java.util.Collection<Filter> orComponents)` Creates a new OR search filter with the provided components.
`static Filter`	`createORFilter(Filter... orComponents)` Creates a new OR search filter with the provided components.
`static Filter`	`createORFilter(java.util.List<Filter> orComponents)` Creates a new OR search filter with the provided components.
`static Filter`	`createPresenceFilter(java.lang.String attributeName)` Creates a new presence search filter with the provided information.
`static Filter`	`createSubAnyFilter(java.lang.String attributeName, byte[]... subAny)` Creates a new substring search filter with only a subAny (contains) component.
`static Filter`	`createSubAnyFilter(java.lang.String attributeName, java.lang.String... subAny)` Creates a new substring search filter with only a subAny (contains) component.
`static Filter`	`createSubFinalFilter(java.lang.String attributeName, byte[] subFinal)` Creates a new substring search filter with only a subFinal (ends with) component.
`static Filter`	`createSubFinalFilter(java.lang.String attributeName, java.lang.String subFinal)` Creates a new substring search filter with only a subFinal (ends with) component.
`static Filter`	`createSubInitialFilter(java.lang.String attributeName, byte[] subInitial)` Creates a new substring search filter with only a subInitial (starts with) component.
`static Filter`	`createSubInitialFilter(java.lang.String attributeName, java.lang.String subInitial)` Creates a new substring search filter with only a subInitial (starts with) component.
`static java.lang.String`	`createSubstringAssertion(byte[] subInitial, byte[][] subAny, byte[] subFinal)` Creates the string representation of a substring assertion with the provided components.
`static java.lang.String`	`createSubstringAssertion(java.lang.String subInitial, java.lang.String[] subAny, java.lang.String subFinal)` Creates the string representation of a substring assertion with the provided components.
`static Filter`	`createSubstringFilter(java.lang.String attributeName, byte[] subInitial, byte[][] subAny, byte[] subFinal)` Creates a new substring search filter with the provided information.
`static Filter`	`createSubstringFilter(java.lang.String attributeName, java.lang.String subInitial, java.lang.String[] subAny, java.lang.String subFinal)` Creates a new substring search filter with the provided information.
`static Filter`	`decode(ASN1Element filterElement)` Decodes the provided ASN.1 element as a search filter.
`ASN1Element`	`encode()` Encodes this search filter to an ASN.1 element suitable for inclusion in an LDAP search request protocol op.
`static void`	`encodeValue(ASN1OctetString value, java.lang.StringBuilder buffer)` Appends the assertion value for this filter to the provided buffer, encoding any special characters as necessary.
`static java.lang.String`	`encodeValue(byte[] value)` Encodes the provided value into a form suitable for use as the assertion value in the string representation of a search filter.
`static java.lang.String`	`encodeValue(java.lang.String value)` Encodes the provided value into a form suitable for use as the assertion value in the string representation of a search filter.
`boolean`	`equals(java.lang.Object o)` Indicates whether the provided object is equal to this search filter.
`static Filter`	`equals(java.lang.String attributeName, byte[] assertionValue)` Creates a new equality search filter with the provided information.
`static Filter`	`equals(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new equality search filter with the provided information.
`static Filter`	`extensibleMatch(java.lang.String attributeName, java.lang.String matchingRuleID, boolean dnAttributes, byte[] assertionValue)` Creates a new extensible match search filter with the provided information.
`static Filter`	`extensibleMatch(java.lang.String attributeName, java.lang.String matchingRuleID, boolean dnAttributes, java.lang.String assertionValue)` Creates a new extensible match search filter with the provided information.
`java.lang.String`	`getAssertionValue()` Retrieves the string representation of the assertion value for this search filter.
`byte[]`	`getAssertionValueBytes()` Retrieves the binary representation of the assertion value for this search filter.
`java.lang.String`	`getAttributeName()` Retrieves the name of the attribute type for this search filter.
`Filter[]`	`getComponents()` Retrieves the set of filter components used in this AND or OR filter.
`boolean`	`getDNAttributes()` Retrieves the dnAttributes flag for this extensible match filter.
`byte`	`getFilterType()` Retrieves the filter type for this filter.
`java.lang.String`	`getMatchingRuleID()` Retrieves the matching rule ID for this extensible match filter.
`Filter`	`getNOTComponent()` Retrieves the filter component used in this NOT filter.
`ASN1OctetString`	`getRawAssertionValue()` Retrieves the raw assertion value for this search filter as an ASN.1 octet string.
`ASN1OctetString[]`	`getRawSubAnyValues()` Retrieves the raw subAny values for this substring filter.
`ASN1OctetString`	`getRawSubFinalValue()` Retrieves the raw subFinal element for this filter as an ASN.1 octet string.
`ASN1OctetString`	`getRawSubInitialValue()` Retrieves the raw subInitial element for this filter as an ASN.1 octet string.
`byte[][]`	`getSubAnyBytes()` Retrieves the binary representations of the subAny elements for this substring filter.
`java.lang.String[]`	`getSubAnyStrings()` Retrieves the string representations of the subAny elements for this substring filter.
`byte[]`	`getSubFinalBytes()` Retrieves the binary representation of the subFinal element for this substring filter.
`java.lang.String`	`getSubFinalString()` Retrieves the string representation of the subFinal element for this substring filter.
`byte[]`	`getSubInitialBytes()` Retrieves the binary representation of the subInitial element for this substring filter.
`java.lang.String`	`getSubInitialString()` Retrieves the string representation of the subInitial element for this substring filter.
`static Filter`	`greaterOrEqual(java.lang.String attributeName, byte[] assertionValue)` Creates a new greater-or-equal search filter with the provided information.
`static Filter`	`greaterOrEqual(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new greater-or-equal search filter with the provided information.
`int`	`hashCode()` Generates a hash code for this search filter.
`static Filter`	`lessOrEqual(java.lang.String attributeName, byte[] assertionValue)` Creates a new less-or-equal search filter with the provided information.
`static Filter`	`lessOrEqual(java.lang.String attributeName, java.lang.String assertionValue)` Creates a new less-or-equal search filter with the provided information.
`boolean`	`matchesEntry(Entry entry)` Indicates whether this filter matches the provided entry.
`boolean`	`matchesEntry(Entry entry, Schema schema)` Indicates whether this filter matches the provided entry.
`static Filter`	`not(Filter notComponent)` Creates a new NOT search filter with the provided component.
`static Filter`	`or(java.util.Collection<Filter> orComponents)` Creates a new OR search filter with the provided components.
`static Filter`	`or(Filter... orComponents)` Creates a new OR search filter with the provided components.
`static Filter`	`present(java.lang.String attributeName)` Creates a new presence search filter with the provided information.
`static Filter`	`readFrom(ASN1StreamReader reader)` Reads and decodes a search filter from the provided ASN.1 stream reader.
`static Filter`	`simplifyFilter(Filter filter, boolean reOrderElements)` Attempts to simplify the provided filter to allow it to be more efficiently processed by the server.
`static Filter`	`subAny(java.lang.String attributeName, byte[]... subAny)` Creates a new substring search filter with only a subAny (contains) component.
`static Filter`	`subAny(java.lang.String attributeName, java.lang.String... subAny)` Creates a new substring search filter with only a subAny (contains) component.
`static Filter`	`subFinal(java.lang.String attributeName, byte[] subFinal)` Creates a new substring search filter with only a subFinal (ends with) component.
`static Filter`	`subFinal(java.lang.String attributeName, java.lang.String subFinal)` Creates a new substring search filter with only a subFinal (ends with) component.
`static Filter`	`subInitial(java.lang.String attributeName, byte[] subInitial)` Creates a new substring search filter with only a subInitial (starts with) component.
`static Filter`	`subInitial(java.lang.String attributeName, java.lang.String subInitial)` Creates a new substring search filter with only a subInitial (starts with) component.
`static Filter`	`substring(java.lang.String attributeName, byte[] subInitial, byte[][] subAny, byte[] subFinal)` Creates a new substring search filter with the provided information.
`static Filter`	`substring(java.lang.String attributeName, java.lang.String subInitial, java.lang.String[] subAny, java.lang.String subFinal)` Creates a new substring search filter with the provided information.
`void`	`toCode(java.util.List<java.lang.String> lineList, int indentSpaces, java.lang.String firstLinePrefix, java.lang.String lastLineSuffix)` Appends a number of lines comprising the Java source code that can be used to recreate this filter to the given list.
`java.lang.String`	`toNormalizedString()` Retrieves a normalized string representation of this search filter.
`void`	`toNormalizedString(java.lang.StringBuilder buffer)` Appends a normalized string representation of this search filter to the provided buffer.
`java.lang.String`	`toString()` Retrieves a string representation of this search filter.
`void`	`toString(java.lang.StringBuilder buffer)` Appends a string representation of this search filter to the provided buffer.
`void`	`writeTo(ASN1Buffer buffer)` Writes an ASN.1-encoded representation of this filter to the provided ASN.1 buffer.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - FILTER_TYPE_AND
```
public static final byte FILTER_TYPE_AND
```
    The BER type for AND search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_OR
```
public static final byte FILTER_TYPE_OR
```
    The BER type for OR search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_NOT
```
public static final byte FILTER_TYPE_NOT
```
    The BER type for NOT search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_EQUALITY
```
public static final byte FILTER_TYPE_EQUALITY
```
    The BER type for equality search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_SUBSTRING
```
public static final byte FILTER_TYPE_SUBSTRING
```
    The BER type for substring search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_GREATER_OR_EQUAL
```
public static final byte FILTER_TYPE_GREATER_OR_EQUAL
```
    The BER type for greaterOrEqual search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_LESS_OR_EQUAL
```
public static final byte FILTER_TYPE_LESS_OR_EQUAL
```
    The BER type for lessOrEqual search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_PRESENCE
```
public static final byte FILTER_TYPE_PRESENCE
```
    The BER type for presence search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_APPROXIMATE_MATCH
```
public static final byte FILTER_TYPE_APPROXIMATE_MATCH
```
    The BER type for approximate match search filters.
    
    See Also:
    
    Constant Field Values
  - FILTER_TYPE_EXTENSIBLE_MATCH
```
public static final byte FILTER_TYPE_EXTENSIBLE_MATCH
```
    The BER type for extensible match search filters.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - and
```
@NotNull
public static Filter and(@NotNull
                                  Filter... andComponents)
```
    Creates a new AND search filter with the provided components.
    
    This method does exactly the same thing as createANDFilter(Filter...), but with a shorter method name for convenience.
    
    Parameters:
    
    andComponents - The set of filter components to include in the AND filter. It must not be null.
    
    Returns:
    
    The created AND search filter.
  - and
```
@NotNull
public static Filter and(@NotNull
                                  java.util.Collection<Filter> andComponents)
```
    Creates a new AND search filter with the provided components.
    
    This method does exactly the same thing as createANDFilter(Collection), but with a shorter method name for convenience.
    
    Parameters:
    
    andComponents - The set of filter components to include in the AND filter. It must not be null.
    
    Returns:
    
    The created AND search filter.
  - createANDFilter
```
@NotNull
public static Filter createANDFilter(@NotNull
                                              Filter... andComponents)
```
    Creates a new AND search filter with the provided components.
    
    Parameters:
    
    andComponents - The set of filter components to include in the AND filter. It must not be null.
    
    Returns:
    
    The created AND search filter.
  - createANDFilter
```
@NotNull
public static Filter createANDFilter(@NotNull
                                              java.util.List<Filter> andComponents)
```
    Creates a new AND search filter with the provided components.
    
    Parameters:
    
    andComponents - The set of filter components to include in the AND filter. It must not be null.
    
    Returns:
    
    The created AND search filter.
  - createANDFilter
```
@NotNull
public static Filter createANDFilter(@NotNull
                                              java.util.Collection<Filter> andComponents)
```
    Creates a new AND search filter with the provided components.
    
    Parameters:
    
    andComponents - The set of filter components to include in the AND filter. It must not be null.
    
    Returns:
    
    The created AND search filter.
  - or
```
@NotNull
public static Filter or(@NotNull
                                 Filter... orComponents)
```
    Creates a new OR search filter with the provided components.
    
    This method does exactly the same thing as createORFilter(Filter...), but with a shorter method name for convenience.
    
    Parameters:
    
    orComponents - The set of filter components to include in the OR filter. It must not be null.
    
    Returns:
    
    The created OR search filter.
  - or
```
@NotNull
public static Filter or(@NotNull
                                 java.util.Collection<Filter> orComponents)
```
    Creates a new OR search filter with the provided components.
    
    This method does exactly the same thing as createORFilter(Collection), but with a shorter method name for convenience.
    
    Parameters:
    
    orComponents - The set of filter components to include in the OR filter. It must not be null.
    
    Returns:
    
    The created OR search filter.
  - createORFilter
```
@NotNull
public static Filter createORFilter(@NotNull
                                             Filter... orComponents)
```
    Creates a new OR search filter with the provided components.
    
    Parameters:
    
    orComponents - The set of filter components to include in the OR filter. It must not be null.
    
    Returns:
    
    The created OR search filter.
  - createORFilter
```
@NotNull
public static Filter createORFilter(@NotNull
                                             java.util.List<Filter> orComponents)
```
    Creates a new OR search filter with the provided components.
    
    Parameters:
    
    orComponents - The set of filter components to include in the OR filter. It must not be null.
    
    Returns:
    
    The created OR search filter.
  - createORFilter
```
@NotNull
public static Filter createORFilter(@NotNull
                                             java.util.Collection<Filter> orComponents)
```
    Creates a new OR search filter with the provided components.
    
    Parameters:
    
    orComponents - The set of filter components to include in the OR filter. It must not be null.
    
    Returns:
    
    The created OR search filter.
  - not
```
@NotNull
public static Filter not(@NotNull
                                  Filter notComponent)
```
    Creates a new NOT search filter with the provided component.
    
    This method does exactly the same thing as createNOTFilter(Filter), but with a shorter method name for convenience.
    
    Parameters:
    
    notComponent - The filter component to include in this NOT filter. It must not be null.
    
    Returns:
    
    The created NOT search filter.
  - createNOTFilter
```
@NotNull
public static Filter createNOTFilter(@NotNull
                                              Filter notComponent)
```
    Creates a new NOT search filter with the provided component.
    
    Parameters:
    
    notComponent - The filter component to include in this NOT filter. It must not be null.
    
    Returns:
    
    The created NOT search filter.
  - equals
```
@NotNull
public static Filter equals(@NotNull
                                     java.lang.String attributeName,
                                     @NotNull
                                     java.lang.String assertionValue)
```
    Creates a new equality search filter with the provided information.
    
    This method does exactly the same thing as createEqualityFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this equality filter. It must not be null.
    
    assertionValue - The assertion value for this equality filter. It must not be null.
    
    Returns:
    
    The created equality search filter.
  - equals
```
@NotNull
public static Filter equals(@NotNull
                                     java.lang.String attributeName,
                                     @NotNull
                                     byte[] assertionValue)
```
    Creates a new equality search filter with the provided information.
    
    This method does exactly the same thing as createEqualityFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this equality filter. It must not be null.
    
    assertionValue - The assertion value for this equality filter. It must not be null.
    
    Returns:
    
    The created equality search filter.
  - createEqualityFilter
```
@NotNull
public static Filter createEqualityFilter(@NotNull
                                                   java.lang.String attributeName,
                                                   @NotNull
                                                   java.lang.String assertionValue)
```
    Creates a new equality search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this equality filter. It must not be null.
    
    assertionValue - The assertion value for this equality filter. It must not be null.
    
    Returns:
    
    The created equality search filter.
  - createEqualityFilter
```
@NotNull
public static Filter createEqualityFilter(@NotNull
                                                   java.lang.String attributeName,
                                                   @NotNull
                                                   byte[] assertionValue)
```
    Creates a new equality search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this equality filter. It must not be null.
    
    assertionValue - The assertion value for this equality filter. It must not be null.
    
    Returns:
    
    The created equality search filter.
  - substring
```
@NotNull
public static Filter substring(@NotNull
                                        java.lang.String attributeName,
                                        @Nullable
                                        java.lang.String subInitial,
                                        @Nullable
                                        java.lang.String[] subAny,
                                        @Nullable
                                        java.lang.String subFinal)
```
    Creates a new substring search filter with the provided information. At least one of the subInitial, subAny, and subFinal components must not be null.
    
    This method does exactly the same thing as createSubstringFilter(String,String,String[],String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The created substring search filter.
  - substring
```
@NotNull
public static Filter substring(@NotNull
                                        java.lang.String attributeName,
                                        @Nullable
                                        byte[] subInitial,
                                        @Nullable
                                        byte[][] subAny,
                                        @Nullable
                                        byte[] subFinal)
```
    Creates a new substring search filter with the provided information. At least one of the subInitial, subAny, and subFinal components must not be null.
    
    This method does exactly the same thing as createSubstringFilter(String,byte[],byte[][],byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The created substring search filter.
  - createSubstringFilter
```
@NotNull
public static Filter createSubstringFilter(@NotNull
                                                    java.lang.String attributeName,
                                                    @Nullable
                                                    java.lang.String subInitial,
                                                    @Nullable
                                                    java.lang.String[] subAny,
                                                    @Nullable
                                                    java.lang.String subFinal)
```
    Creates a new substring search filter with the provided information. At least one of the subInitial, subAny, and subFinal components must not be null.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The created substring search filter.
  - createSubstringFilter
```
@NotNull
public static Filter createSubstringFilter(@NotNull
                                                    java.lang.String attributeName,
                                                    @Nullable
                                                    byte[] subInitial,
                                                    @Nullable
                                                    byte[][] subAny,
                                                    @Nullable
                                                    byte[] subFinal)
```
    Creates a new substring search filter with the provided information. At least one of the subInitial, subAny, and subFinal components must not be null.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The created substring search filter.
  - subInitial
```
@NotNull
public static Filter subInitial(@NotNull
                                         java.lang.String attributeName,
                                         @NotNull
                                         java.lang.String subInitial)
```
    Creates a new substring search filter with only a subInitial (starts with) component.
    
    This method does exactly the same thing as createSubInitialFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - subInitial
```
@NotNull
public static Filter subInitial(@NotNull
                                         java.lang.String attributeName,
                                         @NotNull
                                         byte[] subInitial)
```
    Creates a new substring search filter with only a subInitial (starts with) component.
    
    This method does exactly the same thing as createSubInitialFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubInitialFilter
```
@NotNull
public static Filter createSubInitialFilter(@NotNull
                                                     java.lang.String attributeName,
                                                     @NotNull
                                                     java.lang.String subInitial)
```
    Creates a new substring search filter with only a subInitial (starts with) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubInitialFilter
```
@NotNull
public static Filter createSubInitialFilter(@NotNull
                                                     java.lang.String attributeName,
                                                     @NotNull
                                                     byte[] subInitial)
```
    Creates a new substring search filter with only a subInitial (starts with) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subInitial - The subInitial component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - subAny
```
@NotNull
public static Filter subAny(@NotNull
                                     java.lang.String attributeName,
                                     @NotNull
                                     java.lang.String... subAny)
```
    Creates a new substring search filter with only a subAny (contains) component.
    
    This method does exactly the same thing as createSubAnyFilter(String,String...), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subAny - The subAny values for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - subAny
```
@NotNull
public static Filter subAny(@NotNull
                                     java.lang.String attributeName,
                                     @NotNull
                                     byte[]... subAny)
```
    Creates a new substring search filter with only a subAny (contains) component.
    
    This method does exactly the same thing as createSubAnyFilter(String,byte[][]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subAny - The subAny values for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubAnyFilter
```
@NotNull
public static Filter createSubAnyFilter(@NotNull
                                                 java.lang.String attributeName,
                                                 @NotNull
                                                 java.lang.String... subAny)
```
    Creates a new substring search filter with only a subAny (contains) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subAny - The subAny values for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubAnyFilter
```
@NotNull
public static Filter createSubAnyFilter(@NotNull
                                                 java.lang.String attributeName,
                                                 @NotNull
                                                 byte[]... subAny)
```
    Creates a new substring search filter with only a subAny (contains) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subAny - The subAny values for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - subFinal
```
@NotNull
public static Filter subFinal(@NotNull
                                       java.lang.String attributeName,
                                       @NotNull
                                       java.lang.String subFinal)
```
    Creates a new substring search filter with only a subFinal (ends with) component.
    
    This method does exactly the same thing as createSubFinalFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subFinal - The subFinal component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - subFinal
```
@NotNull
public static Filter subFinal(@NotNull
                                       java.lang.String attributeName,
                                       @NotNull
                                       byte[] subFinal)
```
    Creates a new substring search filter with only a subFinal (ends with) component.
    
    This method does exactly the same thing as createSubFinalFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subFinal - The subFinal component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubFinalFilter
```
@NotNull
public static Filter createSubFinalFilter(@NotNull
                                                   java.lang.String attributeName,
                                                   @NotNull
                                                   java.lang.String subFinal)
```
    Creates a new substring search filter with only a subFinal (ends with) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subFinal - The subFinal component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - createSubFinalFilter
```
@NotNull
public static Filter createSubFinalFilter(@NotNull
                                                   java.lang.String attributeName,
                                                   @NotNull
                                                   byte[] subFinal)
```
    Creates a new substring search filter with only a subFinal (ends with) component.
    
    Parameters:
    
    attributeName - The attribute name for this substring filter. It must not be null.
    
    subFinal - The subFinal component for this substring filter. It must not be null or empty.
    
    Returns:
    
    The created substring search filter.
  - greaterOrEqual
```
@NotNull
public static Filter greaterOrEqual(@NotNull
                                             java.lang.String attributeName,
                                             @NotNull
                                             java.lang.String assertionValue)
```
    Creates a new greater-or-equal search filter with the provided information.
    
    This method does exactly the same thing as createGreaterOrEqualFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this greater-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this greater-or-equal filter. It must not be null.
    
    Returns:
    
    The created greater-or-equal search filter.
  - greaterOrEqual
```
@NotNull
public static Filter greaterOrEqual(@NotNull
                                             java.lang.String attributeName,
                                             @NotNull
                                             byte[] assertionValue)
```
    Creates a new greater-or-equal search filter with the provided information.
    
    This method does exactly the same thing as createGreaterOrEqualFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this greater-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this greater-or-equal filter. It must not be null.
    
    Returns:
    
    The created greater-or-equal search filter.
  - createGreaterOrEqualFilter
```
@NotNull
public static Filter createGreaterOrEqualFilter(@NotNull
                                                         java.lang.String attributeName,
                                                         @NotNull
                                                         java.lang.String assertionValue)
```
    Creates a new greater-or-equal search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this greater-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this greater-or-equal filter. It must not be null.
    
    Returns:
    
    The created greater-or-equal search filter.
  - createGreaterOrEqualFilter
```
@NotNull
public static Filter createGreaterOrEqualFilter(@NotNull
                                                         java.lang.String attributeName,
                                                         @NotNull
                                                         byte[] assertionValue)
```
    Creates a new greater-or-equal search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this greater-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this greater-or-equal filter. It must not be null.
    
    Returns:
    
    The created greater-or-equal search filter.
  - lessOrEqual
```
@NotNull
public static Filter lessOrEqual(@NotNull
                                          java.lang.String attributeName,
                                          @NotNull
                                          java.lang.String assertionValue)
```
    Creates a new less-or-equal search filter with the provided information.
    
    This method does exactly the same thing as createLessOrEqualFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this less-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this less-or-equal filter. It must not be null.
    
    Returns:
    
    The created less-or-equal search filter.
  - lessOrEqual
```
@NotNull
public static Filter lessOrEqual(@NotNull
                                          java.lang.String attributeName,
                                          @NotNull
                                          byte[] assertionValue)
```
    Creates a new less-or-equal search filter with the provided information.
    
    This method does exactly the same thing as createLessOrEqualFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this less-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this less-or-equal filter. It must not be null.
    
    Returns:
    
    The created less-or-equal search filter.
  - createLessOrEqualFilter
```
@NotNull
public static Filter createLessOrEqualFilter(@NotNull
                                                      java.lang.String attributeName,
                                                      @NotNull
                                                      java.lang.String assertionValue)
```
    Creates a new less-or-equal search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this less-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this less-or-equal filter. It must not be null.
    
    Returns:
    
    The created less-or-equal search filter.
  - createLessOrEqualFilter
```
@NotNull
public static Filter createLessOrEqualFilter(@NotNull
                                                      java.lang.String attributeName,
                                                      @NotNull
                                                      byte[] assertionValue)
```
    Creates a new less-or-equal search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this less-or-equal filter. It must not be null.
    
    assertionValue - The assertion value for this less-or-equal filter. It must not be null.
    
    Returns:
    
    The created less-or-equal search filter.
  - present
```
@NotNull
public static Filter present(@NotNull
                                      java.lang.String attributeName)
```
    Creates a new presence search filter with the provided information.
    
    This method does exactly the same thing as createPresenceFilter(String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this presence filter. It must not be null.
    
    Returns:
    
    The created presence search filter.
  - createPresenceFilter
```
@NotNull
public static Filter createPresenceFilter(@NotNull
                                                   java.lang.String attributeName)
```
    Creates a new presence search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this presence filter. It must not be null.
    
    Returns:
    
    The created presence search filter.
  - approximateMatch
```
@NotNull
public static Filter approximateMatch(@NotNull
                                               java.lang.String attributeName,
                                               @NotNull
                                               java.lang.String assertionValue)
```
    Creates a new approximate match search filter with the provided information.
    
    This method does exactly the same thing as createApproximateMatchFilter(String,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this approximate match filter. It must not be null.
    
    assertionValue - The assertion value for this approximate match filter. It must not be null.
    
    Returns:
    
    The created approximate match search filter.
  - approximateMatch
```
@NotNull
public static Filter approximateMatch(@NotNull
                                               java.lang.String attributeName,
                                               @NotNull
                                               byte[] assertionValue)
```
    Creates a new approximate match search filter with the provided information.
    
    This method does exactly the same thing as createApproximateMatchFilter(String,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this approximate match filter. It must not be null.
    
    assertionValue - The assertion value for this approximate match filter. It must not be null.
    
    Returns:
    
    The created approximate match search filter.
  - createApproximateMatchFilter
```
@NotNull
public static Filter createApproximateMatchFilter(@NotNull
                                                           java.lang.String attributeName,
                                                           @NotNull
                                                           java.lang.String assertionValue)
```
    Creates a new approximate match search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this approximate match filter. It must not be null.
    
    assertionValue - The assertion value for this approximate match filter. It must not be null.
    
    Returns:
    
    The created approximate match search filter.
  - createApproximateMatchFilter
```
@NotNull
public static Filter createApproximateMatchFilter(@NotNull
                                                           java.lang.String attributeName,
                                                           @NotNull
                                                           byte[] assertionValue)
```
    Creates a new approximate match search filter with the provided information.
    
    Parameters:
    
    attributeName - The attribute name for this approximate match filter. It must not be null.
    
    assertionValue - The assertion value for this approximate match filter. It must not be null.
    
    Returns:
    
    The created approximate match search filter.
  - extensibleMatch
```
@NotNull
public static Filter extensibleMatch(@Nullable
                                              java.lang.String attributeName,
                                              @Nullable
                                              java.lang.String matchingRuleID,
                                              boolean dnAttributes,
                                              @NotNull
                                              java.lang.String assertionValue)
```
    Creates a new extensible match search filter with the provided information. At least one of the attribute name and matching rule ID must be specified, and the assertion value must always be present.
    
    This method does exactly the same thing as createExtensibleMatchFilter(String,String,boolean,String), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this extensible match filter.
    
    matchingRuleID - The matching rule ID for this extensible match filter.
    
    dnAttributes - Indicates whether the match should be performed against attributes in the target entry's DN.
    
    assertionValue - The assertion value for this extensible match filter. It must not be null.
    
    Returns:
    
    The created extensible match search filter.
  - extensibleMatch
```
@NotNull
public static Filter extensibleMatch(@Nullable
                                              java.lang.String attributeName,
                                              @Nullable
                                              java.lang.String matchingRuleID,
                                              boolean dnAttributes,
                                              @NotNull
                                              byte[] assertionValue)
```
    Creates a new extensible match search filter with the provided information. At least one of the attribute name and matching rule ID must be specified, and the assertion value must always be present.
    
    This method does exactly the same thing as createExtensibleMatchFilter(String,String,boolean,byte[]), but with a shorter method name for convenience.
    
    Parameters:
    
    attributeName - The attribute name for this extensible match filter.
    
    matchingRuleID - The matching rule ID for this extensible match filter.
    
    dnAttributes - Indicates whether the match should be performed against attributes in the target entry's DN.
    
    assertionValue - The assertion value for this extensible match filter. It must not be null.
    
    Returns:
    
    The created extensible match search filter.
  - createExtensibleMatchFilter
```
@NotNull
public static Filter createExtensibleMatchFilter(@Nullable
                                                          java.lang.String attributeName,
                                                          @Nullable
                                                          java.lang.String matchingRuleID,
                                                          boolean dnAttributes,
                                                          @NotNull
                                                          java.lang.String assertionValue)
```
    Creates a new extensible match search filter with the provided information. At least one of the attribute name and matching rule ID must be specified, and the assertion value must always be present.
    
    Parameters:
    
    attributeName - The attribute name for this extensible match filter.
    
    matchingRuleID - The matching rule ID for this extensible match filter.
    
    dnAttributes - Indicates whether the match should be performed against attributes in the target entry's DN.
    
    assertionValue - The assertion value for this extensible match filter. It must not be null.
    
    Returns:
    
    The created extensible match search filter.
  - createExtensibleMatchFilter
```
@NotNull
public static Filter createExtensibleMatchFilter(@Nullable
                                                          java.lang.String attributeName,
                                                          @Nullable
                                                          java.lang.String matchingRuleID,
                                                          boolean dnAttributes,
                                                          @NotNull
                                                          byte[] assertionValue)
```
    Creates a new extensible match search filter with the provided information. At least one of the attribute name and matching rule ID must be specified, and the assertion value must always be present.
    
    Parameters:
    
    attributeName - The attribute name for this extensible match filter.
    
    matchingRuleID - The matching rule ID for this extensible match filter.
    
    dnAttributes - Indicates whether the match should be performed against attributes in the target entry's DN.
    
    assertionValue - The assertion value for this extensible match filter. It must not be null.
    
    Returns:
    
    The created extensible match search filter.
  - create
```
@NotNull
public static Filter create(@NotNull
                                     java.lang.String filterString)
                              throws LDAPException
```
    Creates a new search filter from the provided string representation.
    
    Parameters:
    
    filterString - The string representation of the filter to create. It must not be null.
    
    Returns:
    
    The search filter decoded from the provided filter string.
    
    Throws:
    
    LDAPException - If the provided string cannot be decoded as a valid LDAP search filter.
  - writeTo
```
public void writeTo(@NotNull
                    ASN1Buffer buffer)
```
    Writes an ASN.1-encoded representation of this filter to the provided ASN.1 buffer.
    
    Parameters:
    
    buffer - The ASN.1 buffer to which the encoded representation should be written.
  - encode
```
@NotNull
public ASN1Element encode()
```
    Encodes this search filter to an ASN.1 element suitable for inclusion in an LDAP search request protocol op.
    
    Returns:
    
    An ASN.1 element containing the encoded search filter.
  - readFrom
```
@NotNull
public static Filter readFrom(@NotNull
                                       ASN1StreamReader reader)
                                throws LDAPException
```
    Reads and decodes a search filter from the provided ASN.1 stream reader.
    
    Parameters:
    
    reader - The ASN.1 stream reader from which to read the filter.
    
    Returns:
    
    The decoded search filter.
    
    Throws:
    
    LDAPException - If an error occurs while reading or parsing the search filter.
  - decode
```
@NotNull
public static Filter decode(@NotNull
                                     ASN1Element filterElement)
                              throws LDAPException
```
    Decodes the provided ASN.1 element as a search filter.
    
    Parameters:
    
    filterElement - The ASN.1 element containing the encoded search filter.
    
    Returns:
    
    The decoded search filter.
    
    Throws:
    
    LDAPException - If the provided ASN.1 element cannot be decoded as a search filter.
  - getFilterType
```
public byte getFilterType()
```
    Retrieves the filter type for this filter.
    
    Returns:
    
    The filter type for this filter.
  - getComponents
```
@NotNull
public Filter[] getComponents()
```
    Retrieves the set of filter components used in this AND or OR filter. This is not applicable for any other filter type.
    
    Returns:
    
    The set of filter components used in this AND or OR filter, or an empty array if this is some other type of filter or if there are no components (i.e., as in an LDAP TRUE or LDAP FALSE filter).
  - getNOTComponent
```
@Nullable
public Filter getNOTComponent()
```
    Retrieves the filter component used in this NOT filter. This is not applicable for any other filter type.
    
    Returns:
    
    The filter component used in this NOT filter, or null if this is some other type of filter.
  - getAttributeName
```
@Nullable
public java.lang.String getAttributeName()
```
    Retrieves the name of the attribute type for this search filter. This is applicable for the following types of filters:
    - Equality
    - Substring
    - Greater or Equal
    - Less or Equal
    - Presence
    - Approximate Match
    - Extensible Match
    Returns:
    
    The name of the attribute type for this search filter, or null if it is not applicable for this type of filter.
  - getAssertionValue
```
@Nullable
public java.lang.String getAssertionValue()
```
    Retrieves the string representation of the assertion value for this search filter. This is applicable for the following types of filters:
    - Equality
    - Greater or Equal
    - Less or Equal
    - Approximate Match
    - Extensible Match
    Returns:
    
    The string representation of the assertion value for this search filter, or null if it is not applicable for this type of filter.
  - getAssertionValueBytes
```
@Nullable
public byte[] getAssertionValueBytes()
```
    Retrieves the binary representation of the assertion value for this search filter. This is applicable for the following types of filters:
    - Equality
    - Greater or Equal
    - Less or Equal
    - Approximate Match
    - Extensible Match
    Returns:
    
    The binary representation of the assertion value for this search filter, or null if it is not applicable for this type of filter.
  - getRawAssertionValue
```
@Nullable
public ASN1OctetString getRawAssertionValue()
```
    Retrieves the raw assertion value for this search filter as an ASN.1 octet string. This is applicable for the following types of filters:
    - Equality
    - Greater or Equal
    - Less or Equal
    - Approximate Match
    - Extensible Match
    Returns:
    
    The raw assertion value for this search filter as an ASN.1 octet string, or null if it is not applicable for this type of filter.
  - getSubInitialString
```
@Nullable
public java.lang.String getSubInitialString()
```
    Retrieves the string representation of the subInitial element for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The string representation of the subInitial element for this substring filter, or null if this is some other type of filter, or if it is a substring filter with no subInitial element.
  - getSubInitialBytes
```
@Nullable
public byte[] getSubInitialBytes()
```
    Retrieves the binary representation of the subInitial element for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The binary representation of the subInitial element for this substring filter, or null if this is some other type of filter, or if it is a substring filter with no subInitial element.
  - getRawSubInitialValue
```
@Nullable
public ASN1OctetString getRawSubInitialValue()
```
    Retrieves the raw subInitial element for this filter as an ASN.1 octet string. This is not applicable for any other filter type.
    
    Returns:
    
    The raw subInitial element for this filter as an ASN.1 octet string, or null if this is not a substring filter, or if it is a substring filter with no subInitial element.
  - getSubAnyStrings
```
@NotNull
public java.lang.String[] getSubAnyStrings()
```
    Retrieves the string representations of the subAny elements for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The string representations of the subAny elements for this substring filter, or an empty array if this is some other type of filter, or if it is a substring filter with no subFinal element.
  - getSubAnyBytes
```
@NotNull
public byte[][] getSubAnyBytes()
```
    Retrieves the binary representations of the subAny elements for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The binary representations of the subAny elements for this substring filter, or an empty array if this is some other type of filter, or if it is a substring filter with no subFinal element.
  - getRawSubAnyValues
```
@NotNull
public ASN1OctetString[] getRawSubAnyValues()
```
    Retrieves the raw subAny values for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The raw subAny values for this substring filter, or an empty array if this is some other type of filter, or if it is a substring filter with no subFinal element.
  - getSubFinalString
```
@Nullable
public java.lang.String getSubFinalString()
```
    Retrieves the string representation of the subFinal element for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The string representation of the subFinal element for this substring filter, or null if this is some other type of filter, or if it is a substring filter with no subFinal element.
  - getSubFinalBytes
```
@Nullable
public byte[] getSubFinalBytes()
```
    Retrieves the binary representation of the subFinal element for this substring filter. This is not applicable for any other filter type.
    
    Returns:
    
    The binary representation of the subFinal element for this substring filter, or null if this is some other type of filter, or if it is a substring filter with no subFinal element.
  - getRawSubFinalValue
```
@Nullable
public ASN1OctetString getRawSubFinalValue()
```
    Retrieves the raw subFinal element for this filter as an ASN.1 octet string. This is not applicable for any other filter type.
    
    Returns:
    
    The raw subFinal element for this filter as an ASN.1 octet string, or null if this is not a substring filter, or if it is a substring filter with no subFinal element.
  - getMatchingRuleID
```
@Nullable
public java.lang.String getMatchingRuleID()
```
    Retrieves the matching rule ID for this extensible match filter. This is not applicable for any other filter type.
    
    Returns:
    
    The matching rule ID for this extensible match filter, or null if this is some other type of filter, or if this extensible match filter does not have a matching rule ID.
  - getDNAttributes
```
public boolean getDNAttributes()
```
    Retrieves the dnAttributes flag for this extensible match filter. This is not applicable for any other filter type.
    
    Returns:
    
    The dnAttributes flag for this extensible match filter.
  - matchesEntry
```
public boolean matchesEntry(@NotNull
                            Entry entry)
                     throws LDAPException
```
    Indicates whether this filter matches the provided entry. Note that this is a best-guess effort and may not be completely accurate in all cases. All matching will be performed using case-ignore string matching, which may yield an unexpected result for values that should not be treated as simple strings. For example:
    - Two DN values which are logically equivalent may not be considered matches if they have different spacing.
    - Ordering comparisons against numeric values may yield unexpected results (e.g., "2" will be considered greater than "10" because the character "2" has a larger ASCII value than the character "1").
    In addition to the above constraints, it should be noted that neither approximate matching nor extensible matching are currently supported.
    Parameters:
    
    entry - The entry for which to make the determination. It must not be null.
    
    Returns:
    
    true if this filter appears to match the provided entry, or false if not.
    
    Throws:
    
    LDAPException - If a problem occurs while trying to make the determination.
  - matchesEntry
```
public boolean matchesEntry(@NotNull
                            Entry entry,
                            @Nullable
                            Schema schema)
                     throws LDAPException
```
    Indicates whether this filter matches the provided entry. Note that this is a best-guess effort and may not be completely accurate in all cases. If provided, the given schema will be used in an attempt to determine the appropriate matching rule for making the determinations, but some corner cases may not be handled accurately. Neither approximate matching nor extensible matching are currently supported.
    
    Parameters:
    
    entry - The entry for which to make the determination. It must not be null.
    
    schema - The schema to use when making the determination. If this is null, then all matching will be performed using a case-ignore matching rule.
    
    Returns:
    
    true if this filter appears to match the provided entry, or false if not.
    
    Throws:
    
    LDAPException - If a problem occurs while trying to make the determination.
  - simplifyFilter
```
@NotNull
public static Filter simplifyFilter(@NotNull
                                             Filter filter,
                                             boolean reOrderElements)
```
    Attempts to simplify the provided filter to allow it to be more efficiently processed by the server. The simplifications it will make include:
    - Any AND or OR filter that contains only a single filter component will be converted to just that embedded filter component to eliminate the unnecessary AND or OR wrapper. For example, the filter "(&(uid=john.doe))" will be converted to just "(uid=john.doe)".
    - Any AND components inside of an AND filter will be merged into the outer AND filter. Any OR components inside of an OR filter will be merged into the outer OR filter. For example, the filter "(&(objectClass=person)(&(givenName=John)(sn=Doe)))" will be converted to "(&(objectClass=person)(givenName=John)(sn=Doe))".
    - Any AND filter that contains an LDAP false filter will be converted to just an LDAP false filter.
    - Any OR filter that contains an LDAP true filter will be converted to just an LDAP true filter.
    - If reOrderElements is true, then this method will attempt to re-order the elements inside AND and OR filters in an attempt to ensure that the components which are likely to be the most efficient come earlier than those which are likely to be the least efficient. This can speed up processing in servers that process filter components in a left-to-right order.
    The simplification will happen recursively, in an attempt to generate a filter that is as simple and efficient as possible.
    Parameters:
    
    filter - The filter to attempt to simplify.
    
    reOrderElements - Indicates whether this method may re-order the elements in the filter so that, in a server that evaluates the components in a left-to-right order, the components which are likely to be more efficient to process will be listed before those which are likely to be less efficient.
    
    Returns:
    
    The simplified filter, or the original filter if the provided filter is not one that can be simplified any further.
  - hashCode
```
public int hashCode()
```
    Generates a hash code for this search filter.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    
    The generated hash code for this search filter.
  - equals
```
public boolean equals(@Nullable
                      java.lang.Object o)
```
    Indicates whether the provided object is equal to this search filter.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    o - The object for which to make the determination.
    
    Returns:
    
    true if the provided object can be considered equal to this search filter, or false if not.
  - toString
```
@NotNull
public java.lang.String toString()
```
    Retrieves a string representation of this search filter.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    A string representation of this search filter.
  - toString
```
public void toString(@NotNull
                     java.lang.StringBuilder buffer)
```
    Appends a string representation of this search filter to the provided buffer.
    
    Parameters:
    
    buffer - The buffer to which to append a string representation of this search filter.
  - toNormalizedString
```
@NotNull
public java.lang.String toNormalizedString()
```
    Retrieves a normalized string representation of this search filter.
    
    Returns:
    
    A normalized string representation of this search filter.
  - toNormalizedString
```
public void toNormalizedString(@NotNull
                               java.lang.StringBuilder buffer)
```
    Appends a normalized string representation of this search filter to the provided buffer.
    
    Parameters:
    
    buffer - The buffer to which to append a normalized string representation of this search filter.
  - encodeValue
```
@NotNull
public static java.lang.String encodeValue(@NotNull
                                                    java.lang.String value)
```
    Encodes the provided value into a form suitable for use as the assertion value in the string representation of a search filter. Parentheses, asterisks, backslashes, null characters, and any non-ASCII characters will be escaped using a backslash before the hexadecimal representation of each byte in the character to escape.
    
    Parameters:
    
    value - The value to be encoded. It must not be null.
    
    Returns:
    
    The encoded representation of the provided string.
  - createSubstringAssertion
```
@NotNull
public static java.lang.String createSubstringAssertion(@Nullable
                                                                 java.lang.String subInitial,
                                                                 @Nullable
                                                                 java.lang.String[] subAny,
                                                                 @Nullable
                                                                 java.lang.String subFinal)
```
    Creates the string representation of a substring assertion with the provided components.
    
    Parameters:
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The string representation of a substring assertion with the provided components.
  - createSubstringAssertion
```
@NotNull
public static java.lang.String createSubstringAssertion(@Nullable
                                                                 byte[] subInitial,
                                                                 @Nullable
                                                                 byte[][] subAny,
                                                                 @Nullable
                                                                 byte[] subFinal)
```
    Creates the string representation of a substring assertion with the provided components.
    
    Parameters:
    
    subInitial - The subInitial component for this substring filter. It may be null if there is no subInitial component, but it must not be empty.
    
    subAny - The set of subAny components for this substring filter. It may be null or empty if there are no subAny components.
    
    subFinal - The subFinal component for this substring filter. It may be null if there is no subFinal component, but it must not be empty.
    
    Returns:
    
    The string representation of a substring assertion with the provided components.
  - encodeValue
```
@NotNull
public static java.lang.String encodeValue(@NotNull
                                                    byte[] value)
```
    Encodes the provided value into a form suitable for use as the assertion value in the string representation of a search filter. Parentheses, asterisks, backslashes, null characters, and any non-ASCII characters will be escaped using a backslash before the hexadecimal representation of each byte in the character to escape.
    
    Parameters:
    
    value - The value to be encoded. It must not be null.
    
    Returns:
    
    The encoded representation of the provided string.
  - encodeValue
```
public static void encodeValue(@NotNull
                               ASN1OctetString value,
                               @NotNull
                               java.lang.StringBuilder buffer)
```
    Appends the assertion value for this filter to the provided buffer, encoding any special characters as necessary.
    
    Parameters:
    
    value - The value to be encoded.
    
    buffer - The buffer to which the assertion value should be appended.
  - toCode
```
public void toCode(@NotNull
                   java.util.List<java.lang.String> lineList,
                   int indentSpaces,
                   @Nullable
                   java.lang.String firstLinePrefix,
                   @Nullable
                   java.lang.String lastLineSuffix)
```
    Appends a number of lines comprising the Java source code that can be used to recreate this filter to the given list. Note that unless a first line prefix and/or last line suffix are provided, this will just include the code for the static method used to create the filter, starting with "Filter.createXFilter(" and ending with the closing parenthesis for that method call.
    
    Parameters:
    
    lineList - The list to which the source code lines should be added.
    
    indentSpaces - The number of spaces that should be used to indent the generated code. It must not be negative.
    
    firstLinePrefix - An optional string that should precede the static method call (e.g., it could be used for an attribute assignment, like "Filter f = "). It may be null or empty if there should be no first line prefix.
    
    lastLineSuffix - An optional suffix that should follow the closing parenthesis of the static method call (e.g., it could be a semicolon to represent the end of a Java statement). It may be null or empty if there should be no last line suffix.

Class Filter

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FILTER_TYPE_AND

FILTER_TYPE_OR

FILTER_TYPE_NOT

FILTER_TYPE_EQUALITY

FILTER_TYPE_SUBSTRING

FILTER_TYPE_GREATER_OR_EQUAL

FILTER_TYPE_LESS_OR_EQUAL

FILTER_TYPE_PRESENCE

FILTER_TYPE_APPROXIMATE_MATCH

FILTER_TYPE_EXTENSIBLE_MATCH

Method Detail

and

and

createANDFilter

createANDFilter

createANDFilter

or

or

createORFilter

createORFilter

createORFilter

not

createNOTFilter

equals

equals

createEqualityFilter

createEqualityFilter

substring

substring

createSubstringFilter

createSubstringFilter

subInitial

subInitial

createSubInitialFilter

createSubInitialFilter

subAny

subAny

createSubAnyFilter

createSubAnyFilter

subFinal

subFinal

createSubFinalFilter

createSubFinalFilter

greaterOrEqual

greaterOrEqual

createGreaterOrEqualFilter

createGreaterOrEqualFilter

lessOrEqual

lessOrEqual

createLessOrEqualFilter

createLessOrEqualFilter

present

createPresenceFilter

approximateMatch

approximateMatch

createApproximateMatchFilter

createApproximateMatchFilter

extensibleMatch

extensibleMatch

createExtensibleMatchFilter

createExtensibleMatchFilter

create

writeTo

encode

readFrom

decode

getFilterType

getComponents

getNOTComponent

getAttributeName

getAssertionValue

getAssertionValueBytes

getRawAssertionValue

getSubInitialString

getSubInitialBytes