Class MockableLDAPConnection

    • Constructor Detail

      • MockableLDAPConnection

        public MockableLDAPConnection​(@NotNull
                                      LDAPConnection connection)
        Creates a new mockable LDAP connection from the provided connection. All non-overridden methods will simply be delegated to the provided connection.
        Parameters:
        connection - The connection to which all non-overridden method calls will be delegated.
    • Method Detail

      • getWrappedConnection

        @NotNull
        public final LDAPConnection getWrappedConnection()
        Retrieves the connection that has been wrapped by this mockable LDAP connection, and to which all non-overridden method calls will be delegated.
        Returns:
        The connection that has been wrapped by this mockable LDAP connection, and to which all non-overridden method calls will be delegated.
      • close

        public void close()
        Closes the associated interface and frees any resources associated with it. This method may be safely called multiple times, but the associated interface should not be used after it has been closed.
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Specified by:
        close in interface FullLDAPInterface
      • getSchema

        @Nullable
        public Schema getSchema()
                         throws LDAPException
        Retrieves the directory server schema definitions, using the subschema subentry DN contained in the server's root DSE. For directory servers containing a single schema, this should be sufficient for all purposes. For servers with multiple schemas, it may be necessary to specify the DN of the target entry for which to obtain the associated schema.
        Specified by:
        getSchema in interface LDAPInterface
        Returns:
        The directory server schema definitions, or null if the schema information could not be retrieved (e.g, the client does not have permission to read the server schema).
        Throws:
        LDAPException - If a problem occurs while attempting to retrieve the server schema.
      • getSchema

        @Nullable
        public Schema getSchema​(@Nullable
                                java.lang.String entryDN)
                         throws LDAPException
        Retrieves the directory server schema definitions that govern the specified entry. The subschemaSubentry attribute will be retrieved from the target entry, and then the appropriate schema definitions will be loaded from the entry referenced by that attribute. This may be necessary to ensure correct behavior in servers that support multiple schemas.
        Specified by:
        getSchema in interface LDAPInterface
        Parameters:
        entryDN - The DN of the entry for which to retrieve the associated schema definitions. It may be null or an empty string if the subschemaSubentry attribute should be retrieved from the server's root DSE.
        Returns:
        The directory server schema definitions, or null if the schema information could not be retrieved (e.g, the client does not have permission to read the server schema).
        Throws:
        LDAPException - If a problem occurs while attempting to retrieve the server schema.
      • getEntry

        @Nullable
        public SearchResultEntry getEntry​(@NotNull
                                          java.lang.String dn)
                                   throws LDAPException
        Retrieves the entry with the specified DN. All user attributes will be requested in the entry to return.
        Specified by:
        getEntry in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to retrieve. It must not be null.
        Returns:
        The requested entry, or null if the target entry does not exist or no entry was returned (e.g., if the authenticated user does not have permission to read the target entry).
        Throws:
        LDAPException - If a problem occurs while sending the request or reading the response.
      • getEntry

        @Nullable
        public SearchResultEntry getEntry​(@NotNull
                                          java.lang.String dn,
                                          @Nullable
                                          java.lang.String... attributes)
                                   throws LDAPException
        Retrieves the entry with the specified DN.
        Specified by:
        getEntry in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to retrieve. It must not be null.
        attributes - The set of attributes to request for the target entry. If it is null, then all user attributes will be requested.
        Returns:
        The requested entry, or null if the target entry does not exist or no entry was returned (e.g., if the authenticated user does not have permission to read the target entry).
        Throws:
        LDAPException - If a problem occurs while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              java.lang.String dn,
                              @NotNull
                              Attribute... attributes)
                       throws LDAPException
        Processes an add operation with the provided information.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to add. It must not be null.
        attributes - The set of attributes to include in the entry to add. It must not be null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              java.lang.String dn,
                              @NotNull
                              java.util.Collection<Attribute> attributes)
                       throws LDAPException
        Processes an add operation with the provided information.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to add. It must not be null.
        attributes - The set of attributes to include in the entry to add. It must not be null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              Entry entry)
                       throws LDAPException
        Processes an add operation with the provided information.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        entry - The entry to add. It must not be null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              java.lang.String... ldifLines)
                       throws LDIFException,
                              LDAPException
        Processes an add operation with the provided information.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        ldifLines - The lines that comprise an LDIF representation of the entry to add. It must not be empty or null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDIFException - If the provided entry lines cannot be decoded as an entry in LDIF form.
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              AddRequest addRequest)
                       throws LDAPException
        Processes the provided add request.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        addRequest - The add request to be processed. It must not be null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • add

        @NotNull
        public LDAPResult add​(@NotNull
                              ReadOnlyAddRequest addRequest)
                       throws LDAPException
        Processes the provided add request.
        Specified by:
        add in interface LDAPInterface
        Parameters:
        addRequest - The add request to be processed. It must not be null.
        Returns:
        The result of processing the add operation.
        Throws:
        LDAPException - If the server rejects the add request, or if a problem is encountered while sending the request or reading the response.
      • bind

        @NotNull
        public BindResult bind​(@Nullable
                               java.lang.String bindDN,
                               @Nullable
                               java.lang.String password)
                        throws LDAPException
        Processes a simple bind request with the provided DN and password.
        Specified by:
        bind in interface FullLDAPInterface
        Parameters:
        bindDN - The bind DN for the bind operation.
        password - The password for the simple bind operation.
        Returns:
        The result of processing the bind operation.
        Throws:
        LDAPException - If the server rejects the bind request, or if a problem occurs while sending the request or reading the response.
      • bind

        @NotNull
        public BindResult bind​(@NotNull
                               BindRequest bindRequest)
                        throws LDAPException
        Processes the provided bind request.
        Specified by:
        bind in interface FullLDAPInterface
        Parameters:
        bindRequest - The bind request to be processed. It must not be null.
        Returns:
        The result of processing the bind operation.
        Throws:
        LDAPException - If the server rejects the bind request, or if a problem occurs while sending the request or reading the response.
      • compare

        @NotNull
        public CompareResult compare​(@NotNull
                                     java.lang.String dn,
                                     @NotNull
                                     java.lang.String attributeName,
                                     @NotNull
                                     java.lang.String assertionValue)
                              throws LDAPException
        Processes a compare operation with the provided information.
        Specified by:
        compare in interface LDAPInterface
        Parameters:
        dn - The DN of the entry in which to make the comparison. It must not be null.
        attributeName - The attribute name for which to make the comparison. It must not be null.
        assertionValue - The assertion value to verify in the target entry. It must not be null.
        Returns:
        The result of processing the compare operation.
        Throws:
        LDAPException - If the server rejects the compare request, or if a problem is encountered while sending the request or reading the response.
      • compare

        @NotNull
        public CompareResult compare​(@NotNull
                                     CompareRequest compareRequest)
                              throws LDAPException
        Processes the provided compare request.
        Specified by:
        compare in interface LDAPInterface
        Parameters:
        compareRequest - The compare request to be processed. It must not be null.
        Returns:
        The result of processing the compare operation.
        Throws:
        LDAPException - If the server rejects the compare request, or if a problem is encountered while sending the request or reading the response.
      • delete

        @NotNull
        public LDAPResult delete​(@NotNull
                                 java.lang.String dn)
                          throws LDAPException
        Deletes the entry with the specified DN.
        Specified by:
        delete in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to delete. It must not be null.
        Returns:
        The result of processing the delete operation.
        Throws:
        LDAPException - If the server rejects the delete request, or if a problem is encountered while sending the request or reading the response.
      • delete

        @NotNull
        public LDAPResult delete​(@NotNull
                                 DeleteRequest deleteRequest)
                          throws LDAPException
        Processes the provided delete request.
        Specified by:
        delete in interface LDAPInterface
        Parameters:
        deleteRequest - The delete request to be processed. It must not be null.
        Returns:
        The result of processing the delete operation.
        Throws:
        LDAPException - If the server rejects the delete request, or if a problem is encountered while sending the request or reading the response.
      • delete

        @NotNull
        public LDAPResult delete​(@NotNull
                                 ReadOnlyDeleteRequest deleteRequest)
                          throws LDAPException
        Processes the provided delete request.
        Specified by:
        delete in interface LDAPInterface
        Parameters:
        deleteRequest - The delete request to be processed. It must not be null.
        Returns:
        The result of processing the delete operation.
        Throws:
        LDAPException - If the server rejects the delete request, or if a problem is encountered while sending the request or reading the response.
      • processExtendedOperation

        @NotNull
        public ExtendedResult processExtendedOperation​(@NotNull
                                                       java.lang.String requestOID,
                                                       @Nullable
                                                       ASN1OctetString requestValue)
                                                throws LDAPException
        Processes an extended operation with the provided request OID and value.
        Specified by:
        processExtendedOperation in interface FullLDAPInterface
        Parameters:
        requestOID - The OID for the extended request to process. It must not be null.
        requestValue - The encoded value for the extended request to process. It may be null if there does not need to be a value for the requested operation.
        Returns:
        The extended result object that provides information about the result of the request processing.
        Throws:
        LDAPException - If a problem occurs while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 java.lang.String dn,
                                 @NotNull
                                 Modification mod)
                          throws LDAPException
        Applies the provided modification to the specified entry.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to modify. It must not be null.
        mod - The modification to apply to the target entry. It must not be null.
        Returns:
        The result of processing the modify operation.
        Throws:
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 java.lang.String dn,
                                 @NotNull
                                 Modification... mods)
                          throws LDAPException
        Applies the provided set of modifications to the specified entry.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to modify. It must not be null.
        mods - The set of modifications to apply to the target entry. It must not be null or empty. *
        Returns:
        The result of processing the modify operation.
        Throws:
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 java.lang.String dn,
                                 @NotNull
                                 java.util.List<Modification> mods)
                          throws LDAPException
        Applies the provided set of modifications to the specified entry.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        dn - The DN of the entry to modify. It must not be null.
        mods - The set of modifications to apply to the target entry. It must not be null or empty.
        Returns:
        The result of processing the modify operation.
        Throws:
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 java.lang.String... ldifModificationLines)
                          throws LDIFException,
                                 LDAPException
        Processes a modify request from the provided LDIF representation of the changes.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        ldifModificationLines - The lines that comprise an LDIF representation of a modify change record. It must not be null or empty.
        Returns:
        The result of processing the modify operation.
        Throws:
        LDIFException - If the provided set of lines cannot be parsed as an LDIF modify change record.
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 ModifyRequest modifyRequest)
                          throws LDAPException
        Processes the provided modify request.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        modifyRequest - The modify request to be processed. It must not be null.
        Returns:
        The result of processing the modify operation.
        Throws:
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modify

        @NotNull
        public LDAPResult modify​(@NotNull
                                 ReadOnlyModifyRequest modifyRequest)
                          throws LDAPException
        Processes the provided modify request.
        Specified by:
        modify in interface LDAPInterface
        Parameters:
        modifyRequest - The modify request to be processed. It must not be null.
        Returns:
        The result of processing the modify operation.
        Throws:
        LDAPException - If the server rejects the modify request, or if a problem is encountered while sending the request or reading the response.
      • modifyDN

        @NotNull
        public LDAPResult modifyDN​(@NotNull
                                   java.lang.String dn,
                                   @NotNull
                                   java.lang.String newRDN,
                                   boolean deleteOldRDN)
                            throws LDAPException
        Performs a modify DN operation with the provided information.
        Specified by:
        modifyDN in interface LDAPInterface
        Parameters:
        dn - The current DN for the entry to rename. It must not be null.
        newRDN - The new RDN to use for the entry. It must not be null.
        deleteOldRDN - Indicates whether to delete the current RDN value from the entry.
        Returns:
        The result of processing the modify DN operation.
        Throws:
        LDAPException - If the server rejects the modify DN request, or if a problem is encountered while sending the request or reading the response.
      • modifyDN

        @NotNull
        public LDAPResult modifyDN​(@NotNull
                                   java.lang.String dn,
                                   @NotNull
                                   java.lang.String newRDN,
                                   boolean deleteOldRDN,
                                   @Nullable
                                   java.lang.String newSuperiorDN)
                            throws LDAPException
        Performs a modify DN operation with the provided information.
        Specified by:
        modifyDN in interface LDAPInterface
        Parameters:
        dn - The current DN for the entry to rename. It must not be null.
        newRDN - The new RDN to use for the entry. It must not be null.
        deleteOldRDN - Indicates whether to delete the current RDN value from the entry.
        newSuperiorDN - The new superior DN for the entry. It may be null if the entry is not to be moved below a new parent.
        Returns:
        The result of processing the modify DN operation.
        Throws:
        LDAPException - If the server rejects the modify DN request, or if a problem is encountered while sending the request or reading the response.
      • modifyDN

        @NotNull
        public LDAPResult modifyDN​(@NotNull
                                   ModifyDNRequest modifyDNRequest)
                            throws LDAPException
        Processes the provided modify DN request.
        Specified by:
        modifyDN in interface LDAPInterface
        Parameters:
        modifyDNRequest - The modify DN request to be processed. It must not be null.
        Returns:
        The result of processing the modify DN operation.
        Throws:
        LDAPException - If the server rejects the modify DN request, or if a problem is encountered while sending the request or reading the response.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   java.lang.String filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information. The search result entries and references will be collected internally and included in the SearchResult object that is returned.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        search in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   Filter filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information. The search result entries and references will be collected internally and included in the SearchResult object that is returned.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        search in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@Nullable
                                   SearchResultListener searchResultListener,
                                   @NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   java.lang.String filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchResultListener - The search result listener that should be used to return results to the client. It may be null if the search results should be collected internally and returned in the SearchResult object.
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@Nullable
                                   SearchResultListener searchResultListener,
                                   @NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   Filter filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchResultListener - The search result listener that should be used to return results to the client. It may be null if the search results should be collected internally and returned in the SearchResult object.
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   DereferencePolicy derefPolicy,
                                   int sizeLimit,
                                   int timeLimit,
                                   boolean typesOnly,
                                   @NotNull
                                   java.lang.String filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information. The search result entries and references will be collected internally and included in the SearchResult object that is returned.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        search in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        sizeLimit - The maximum number of entries that the server should return for the search. A value of zero indicates that there should be no limit.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   DereferencePolicy derefPolicy,
                                   int sizeLimit,
                                   int timeLimit,
                                   boolean typesOnly,
                                   @NotNull
                                   Filter filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information. The search result entries and references will be collected internally and included in the SearchResult object that is returned.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        search in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        sizeLimit - The maximum number of entries that the server should return for the search. A value of zero indicates that there should be no limit.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@Nullable
                                   SearchResultListener searchResultListener,
                                   @NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   DereferencePolicy derefPolicy,
                                   int sizeLimit,
                                   int timeLimit,
                                   boolean typesOnly,
                                   @NotNull
                                   java.lang.String filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchResultListener - The search result listener that should be used to return results to the client. It may be null if the search results should be collected internally and returned in the SearchResult object.
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        sizeLimit - The maximum number of entries that the server should return for the search. A value of zero indicates that there should be no limit.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@Nullable
                                   SearchResultListener searchResultListener,
                                   @NotNull
                                   java.lang.String baseDN,
                                   @NotNull
                                   SearchScope scope,
                                   @NotNull
                                   DereferencePolicy derefPolicy,
                                   int sizeLimit,
                                   int timeLimit,
                                   boolean typesOnly,
                                   @NotNull
                                   Filter filter,
                                   @Nullable
                                   java.lang.String... attributes)
                            throws LDAPSearchException
        Processes a search operation with the provided information.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchResultListener - The search result listener that should be used to return results to the client. It may be null if the search results should be collected internally and returned in the SearchResult object.
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        sizeLimit - The maximum number of entries that the server should return for the search. A value of zero indicates that there should be no limit.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   SearchRequest searchRequest)
                            throws LDAPSearchException
        Processes the provided search request.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchRequest - The search request to be processed. It must not be null.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • search

        @NotNull
        public SearchResult search​(@NotNull
                                   ReadOnlySearchRequest searchRequest)
                            throws LDAPSearchException
        Processes the provided search request.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references (although if a search result listener was provided, then it will have been used to make any entries and references available, and they will not be available through the getSearchEntries and getSearchReferences methods).
        Specified by:
        search in interface LDAPInterface
        Parameters:
        searchRequest - The search request to be processed. It must not be null.
        Returns:
        A search result object that provides information about the processing of the search, potentially including the set of matching entries and search references returned by the server.
        Throws:
        LDAPSearchException - If the search does not complete successfully, or if a problem is encountered while sending the request or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                java.lang.String baseDN,
                                                @NotNull
                                                SearchScope scope,
                                                @NotNull
                                                java.lang.String filter,
                                                @Nullable
                                                java.lang.String... attributes)
                                         throws LDAPSearchException
        Processes a search operation with the provided information. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                java.lang.String baseDN,
                                                @NotNull
                                                SearchScope scope,
                                                @NotNull
                                                Filter filter,
                                                @Nullable
                                                java.lang.String... attributes)
                                         throws LDAPSearchException
        Processes a search operation with the provided information. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                java.lang.String baseDN,
                                                @NotNull
                                                SearchScope scope,
                                                @NotNull
                                                DereferencePolicy derefPolicy,
                                                int timeLimit,
                                                boolean typesOnly,
                                                @NotNull
                                                java.lang.String filter,
                                                @Nullable
                                                java.lang.String... attributes)
                                         throws LDAPSearchException
        Processes a search operation with the provided information. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The string representation of the filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                java.lang.String baseDN,
                                                @NotNull
                                                SearchScope scope,
                                                @NotNull
                                                DereferencePolicy derefPolicy,
                                                int timeLimit,
                                                boolean typesOnly,
                                                @NotNull
                                                Filter filter,
                                                @Nullable
                                                java.lang.String... attributes)
                                         throws LDAPSearchException
        Processes a search operation with the provided information. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        baseDN - The base DN for the search request. It must not be null.
        scope - The scope that specifies the range of entries that should be examined for the search.
        derefPolicy - The dereference policy the server should use for any aliases encountered while processing the search.
        timeLimit - The maximum length of time in seconds that the server should spend processing this search request. A value of zero indicates that there should be no limit.
        typesOnly - Indicates whether to return only attribute names in matching entries, or both attribute names and values.
        filter - The filter to use to identify matching entries. It must not be null.
        attributes - The set of attributes that should be returned in matching entries. It may be null or empty if the default attribute set (all user attributes) is to be requested.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                SearchRequest searchRequest)
                                         throws LDAPSearchException
        Processes the provided search request. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        searchRequest - The search request to be processed. If it is configured with a search result listener or a size limit other than one, then the provided request will be duplicated with the appropriate settings.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.
      • searchForEntry

        @Nullable
        public SearchResultEntry searchForEntry​(@NotNull
                                                ReadOnlySearchRequest searchRequest)
                                         throws LDAPSearchException
        Processes the provided search request. It is expected that at most one entry will be returned from the search, and that no additional content from the successful search result (e.g., diagnostic message or response controls) are needed.

        Note that if the search does not complete successfully, an LDAPSearchException will be thrown In some cases, one or more search result entries or references may have been returned before the failure response is received. In this case, the LDAPSearchException methods like getEntryCount, getSearchEntries, getReferenceCount, and getSearchReferences may be used to obtain information about those entries and references.
        Specified by:
        searchForEntry in interface LDAPInterface
        Parameters:
        searchRequest - The search request to be processed. If it is configured with a search result listener or a size limit other than one, then the provided request will be duplicated with the appropriate settings.
        Returns:
        The entry that was returned from the search, or null if no entry was returned or the base entry does not exist.
        Throws:
        LDAPSearchException - If the search does not complete successfully, if more than a single entry is returned, or if a problem is encountered while parsing the provided filter string, sending the request, or reading the response. If one or more entries or references were returned before the failure was encountered, then the LDAPSearchException object may be examined to obtain information about those entries and/or references.