OpenJDK 27 · com.sun.jndi.ldap.AbstractLdapNamingEnumeration

Modifier and Type	Field and Description
private boolean	cleaned
private Continuation	cont
private Vector<LdapEntry>	entries
private LdapClient	enumClnt
private NamingException	errEx
private boolean	hasMoreCalled
protected LdapCtx	homeCtx
private int	limit
protected Name	listArg
private boolean	more
private int	posn
private LdapReferralException	refEx
private LdapResult	res

Access	Constructor and Description
pack-priv	AbstractLdapNamingEnumeration(LdapCtx homeCtx, LdapResult answer, Name listArg, Continuation cont)

Method Summary

Modifier and Type	Method and Description
public void	appendUnprocessedReferrals(LdapReferralException ex) Implements com.sun.jndi.ldap.ReferralEnumeration.appendUnprocessedReferrals.
protected final void	cleanup()
public final void	close() Implements javax.naming.NamingEnumeration.close. Closes this enumeration.
protected abstract T	createItem(String dn, Attributes attrs, Vector<Control> respCtls)
protected final void	finalize() Overrides java.lang.Object.finalize. Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
protected final String	getAtom(String dn)
private void	getNextBatch()
protected abstract AbstractLdapNamingEnumeration<? extends NameClassPair>	getReferredResults(LdapReferralContext refCtx)
public final boolean	hasMore() Implements javax.naming.NamingEnumeration.hasMore. Determines whether there are any more elements in the enumeration.
public final boolean	hasMoreElements() Implements java.util.Enumeration.hasMoreElements. Tests if this enumeration contains more elements.
private boolean	hasMoreImpl()
protected final boolean	hasMoreReferrals()
public final T	next() Implements javax.naming.NamingEnumeration.next. Retrieves the next element in the enumeration.
private T	nextAux()
public final T	nextElement() Implements java.util.Enumeration.nextElement. Returns the next element of this enumeration if this enumeration object has at least one more element to provide.
private T	nextImpl()
pack-priv final void	setNamingException(NamingException e)
protected void	update(AbstractLdapNamingEnumeration<? extends NameClassPair> ne)

Inherited from java.lang.Object:: clone equals getClass hashCode notify notifyAll toString wait wait wait

cleaned	back to summary
private boolean cleaned

cont	back to summary
private Continuation cont

entries	back to summary
private Vector<LdapEntry> entries

enumClnt	back to summary
private LdapClient enumClnt

errEx	back to summary
private NamingException errEx

hasMoreCalled	back to summary
private boolean hasMoreCalled

homeCtx	back to summary
protected LdapCtx homeCtx

limit	back to summary
private int limit

listArg	back to summary
protected Name listArg

more	back to summary
private boolean more

posn	back to summary
private int posn

refEx	back to summary
private LdapReferralException refEx

res	back to summary
private LdapResult res

AbstractLdapNamingEnumeration	back to summary
pack-priv AbstractLdapNamingEnumeration(LdapCtx homeCtx, LdapResult answer, Name listArg, Continuation cont) throws NamingException

Method Detail

appendUnprocessedReferrals	back to summary
public void appendUnprocessedReferrals(LdapReferralException ex) Implements com.sun.jndi.ldap.ReferralEnumeration.appendUnprocessedReferrals. Annotations @Override

appendUnprocessedReferrals

back to summary

public void appendUnprocessedReferrals(LdapReferralException ex)

Implements com.sun.jndi.ldap.ReferralEnumeration.appendUnprocessedReferrals.

Annotations

@Override

cleanup	back to summary
protected final void cleanup()

close back to summary

close	back to summary
public final void close() Implements javax.naming.NamingEnumeration.close. Doc from javax.naming.NamingEnumeration.close. Closes this enumeration. After this method has been invoked on this enumeration, the enumeration becomes invalid and subsequent invocation of any of its methods will yield undefined results. This method is intended for aborting an enumeration to free up resources. If an enumeration proceeds to the end--that is, until `hasMoreElements()` or `hasMore()` returns `false`-- resources will be freed up automatically and there is no need to explicitly call `close()`. This method indicates to the service provider that it is free to release resources associated with the enumeration, and can notify servers to cancel any outstanding requests. The `close()` method is a hint to implementations for managing their resources. Implementations are encouraged to use appropriate algorithms to manage their resources when client omits the `close()` calls. Annotations @Override

public final void close()

Implements javax.naming.NamingEnumeration.close.

Doc from javax.naming.NamingEnumeration.close.

Closes this enumeration. After this method has been invoked on this enumeration, the enumeration becomes invalid and subsequent invocation of any of its methods will yield undefined results. This method is intended for aborting an enumeration to free up resources. If an enumeration proceeds to the end--that is, until hasMoreElements() or hasMore() returns false-- resources will be freed up automatically and there is no need to explicitly call close().

This method indicates to the service provider that it is free to release resources associated with the enumeration, and can notify servers to cancel any outstanding requests. The close() method is a hint to implementations for managing their resources. Implementations are encouraged to use appropriate algorithms to manage their resources when client omits the close() calls.

Annotations

@Override

createItem	back to summary
protected abstract T createItem(String dn, Attributes attrs, Vector<Control> respCtls) throws NamingException

finalize back to summary

finalize	back to summary
protected final void finalize() Overrides java.lang.Object.finalize. Doc from java.lang.Object.finalize. Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the `finalize` method to dispose of system resources or to perform other cleanup. When running in a Java virtual machine in which finalization has been disabled or removed, the garbage collector will never call `finalize()`. In a Java virtual machine in which finalization is enabled, the garbage collector might call `finalize` only after an indefinite delay. The general contract of `finalize` is that it is invoked if and when the Java virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The `finalize` method may take any action, including making this object available again to other threads; the usual purpose of `finalize`, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded. The `finalize` method of class `Object` performs no special action; it simply returns normally. Subclasses of `Object` may override this definition. The Java programming language does not guarantee which thread will invoke the `finalize` method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates. After the `finalize` method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded. The `finalize` method is never invoked more than once by a Java virtual machine for any given object. Any exception thrown by the `finalize` method causes the finalization of this object to be halted, but is otherwise ignored. Annotations @SuppressWarnings:removal

protected final void finalize()

Overrides java.lang.Object.finalize.

Doc from java.lang.Object.finalize.

Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.

When running in a Java virtual machine in which finalization has been disabled or removed, the garbage collector will never call finalize(). In a Java virtual machine in which finalization is enabled, the garbage collector might call finalize only after an indefinite delay.

The general contract of finalize is that it is invoked if and when the Java virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

The Java programming language does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java virtual machine for any given object.

Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.

Annotations

@SuppressWarnings:removal

getAtom	back to summary
protected final String getAtom(String dn)

getNextBatch	back to summary
private void getNextBatch() throws NamingException

getReferredResults	back to summary
protected abstract AbstractLdapNamingEnumeration<? extends NameClassPair> getReferredResults(LdapReferralContext refCtx) throws NamingException

hasMore	back to summary
public final boolean hasMore() throws NamingException Implements javax.naming.NamingEnumeration.hasMore. Doc from javax.naming.NamingEnumeration.hasMore. Determines whether there are any more elements in the enumeration. This method allows naming exceptions encountered while determining whether there are more elements to be caught and handled by the application. Annotations @Override Exceptions NamingException: If a naming exception is encountered while attempting to determine whether there is another element in the enumeration. See NamingException and its subclasses for the possible naming exceptions.

hasMore

back to summary

public final boolean hasMore() throws NamingException

Implements javax.naming.NamingEnumeration.hasMore.

Doc from javax.naming.NamingEnumeration.hasMore.

Determines whether there are any more elements in the enumeration. This method allows naming exceptions encountered while determining whether there are more elements to be caught and handled by the application.

Annotations

@Override

Exceptions

NamingException:: If a naming exception is encountered while attempting to determine whether there is another element in the enumeration. See NamingException and its subclasses for the possible naming exceptions.

hasMoreElements	back to summary
public final boolean hasMoreElements() Implements java.util.Enumeration.hasMoreElements. Doc from java.util.Enumeration.hasMoreElements. Tests if this enumeration contains more elements. Annotations @Override

hasMoreElements

back to summary

public final boolean hasMoreElements()

Implements java.util.Enumeration.hasMoreElements.

Doc from java.util.Enumeration.hasMoreElements.

Tests if this enumeration contains more elements.

Annotations

@Override

hasMoreImpl	back to summary
private boolean hasMoreImpl() throws NamingException

hasMoreReferrals	back to summary
protected final boolean hasMoreReferrals() throws NamingException

next back to summary

next	back to summary
public final T next() throws NamingException Implements javax.naming.NamingEnumeration.next. Doc from javax.naming.NamingEnumeration.next. Retrieves the next element in the enumeration. This method allows naming exceptions encountered while retrieving the next element to be caught and handled by the application. Note that `next()` can also throw the runtime exception NoSuchElementException to indicate that the caller is attempting to enumerate beyond the end of the enumeration. This is different from a NamingException, which indicates that there was a problem in obtaining the next element, for example, due to a referral or server unavailability, etc. Annotations @Override Exceptions NamingException: If a naming exception is encountered while attempting to retrieve the next element. See NamingException and its subclasses for the possible naming exceptions.

public final T next() throws NamingException

Implements javax.naming.NamingEnumeration.next.

Doc from javax.naming.NamingEnumeration.next.

Retrieves the next element in the enumeration. This method allows naming exceptions encountered while retrieving the next element to be caught and handled by the application.

Note that next() can also throw the runtime exception NoSuchElementException to indicate that the caller is attempting to enumerate beyond the end of the enumeration. This is different from a NamingException, which indicates that there was a problem in obtaining the next element, for example, due to a referral or server unavailability, etc.

Annotations

@Override

Exceptions

NamingException:: If a naming exception is encountered while attempting to retrieve the next element. See NamingException and its subclasses for the possible naming exceptions.

nextAux	back to summary
private T nextAux() throws NamingException

nextElement	back to summary
public final T nextElement() Implements java.util.Enumeration.nextElement. Doc from java.util.Enumeration.nextElement. Returns the next element of this enumeration if this enumeration object has at least one more element to provide. Annotations @Override

nextElement

back to summary

public final T nextElement()

Implements java.util.Enumeration.nextElement.

Doc from java.util.Enumeration.nextElement.

Returns the next element of this enumeration if this enumeration object has at least one more element to provide.

Annotations

@Override

nextImpl	back to summary
private T nextImpl() throws NamingException

setNamingException	back to summary
pack-priv final void setNamingException(NamingException e)

update	back to summary
protected void update(AbstractLdapNamingEnumeration<? extends NameClassPair> ne)

pack-priv abstract Class AbstractLdapNamingEnumeration<T extends NameClassPair>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail