[Date Prev][Date Next] [Chronological] [Thread] [Top]
Re: [ldapext] Java LDAP API, sorting

To: Steve Sonntag <vtag@novell.com>, ldapext@ietf.org
Subject: Re: [ldapext] Java LDAP API, sorting
From: Rob Weltman <robw@worldspot.com>
Date: Sun, 21 Apr 2002 10:47:50 -0700
References: <scbd87fb.045@prv-mail20.provo.novell.com> <3CC2F3EA.313B92FA@worldspot.com>
  Also, please explain how LDAPAttribute and LDAPEntry will implement compareTo.

Rob


Rob Weltman wrote:
> 
> Steve,
> 
>   Your second message on this topic (below) is very difficult to parse. Could you rewrite it to just include what you are proposing?
> 
> Thanks,
> Rob
> 
> Steve Sonntag wrote:
> >
> > Rob,
> >
> > I realize I overlooked something in the discussion on sorting,
> > specifically
> > the two classes TreeSet and TreeMap that order objects as they are
> > added into the to the Tree object.  Objects are sorted either by
> > their natural order or as specified by a Comparator object.
> >
> > With that information, the following changes are in order.
> >
> > >>> "Steve Sonntag" <vtag@novell.com> 15-Apr-02 4:20:35 PM >>>
> >
> > > Rob,
> > >
> > > I have been reviewing the changes associated
> > > with the addition of the Java Collections
> > > Framework.  I believe the specification is
> > > incomplete relative to the use of this framework.
> > >
> > > Specifically I am looking at how one performs sorts
> > > using the collections framework and have reviewed
> > > the statements in Appendix 9.2 that relate to sorting.
> > >
> > > >  LDAPAttributeSet
> > > >
> > > >          Implements Cloneable and java.util.Set. Removed the
> > methods
> > >
> > > >          made redundant by implementing Set: add(LDAPAttribute
> > attr),
> > >
> > > >          elementAt(), getAttributes(), remove(String name),
> > > >          removeElementAt(), and size().
> > > >
> > > >  LDAPCompareAttrNames
> > > >
> > > >          Implements java.util.Comparator instead of
> > > LDAPEntryComparator.
> > > >
> > > >  LDAPSearchResults
> > > >
> > > >          Does not implement Enumeration.
> > > >
> > > >          Removed nextElement().
> > > >
> > > >          Renamed hasMoreElements() to hasMore().
> > > >
> > > >          Removed sort() (sorting can now be done with
> > > classes/interfaces
> > > >          of the Collections framework now that LDAPAttributeSet
> > > >          implements Set).
> > >
> > > The collections framework has two interfaces and two classes
> >         Four Classes
> > > that facilitate sorting.  These are:
> > >
> > > -  The Comparable interface - an implementing
> > >     object can be compared with another implementing
> > >     object, determining the natural ordering of
> > >     the objects.
> > > -  The Comparator interface - implementers can
> > >     compare and order two objects, called specific ordering.
> > > -  The Arrays class - allows sorting of objects
> > >     contained in an array using either natural
> > >     or specific ordering.
> > > -  The Collections class - allows sorting of
> > >     objects contained in a class that implements the
> > >     List interface using natural or specific ordering.
> >
> > -       The TreeSet class, an implementation of the SortedSet interface
> >         sorts objects as they are added to the object, and
> >         uses natural or specific ordering.
> > -       The TreeMap class, an implementation of the SortedMap interface
> >         sorts objects by keys as they are added to the object, and
> >         uses natural or specific ordering.
> > >
> > > There seem to be three obvious kinds of data
> > > that one might consider sorting:
> > >
> > > 1)    Values of a multi-valued attribute.
> > > 2)    Attribute Names
> > > 3)    Search Entries
> > >
> > > Let's see how the Collections Framework
> > > can be used to sort these items:
> > >
> > > Sort values from a multivalued binary attribute:
> > >
> > >       byte[][] values = attr.getByteValueArray( )
> > >       Arrays.sort( values[]);      // Order by byte values
> > >       Arrays.sort( values[], myComparator) // Specific ordering
> > >
> >     TreeSet can be used to order values by looping through
> >         values and adding them to the set using natural ordering
> >         or a specific comparator.
> >
> > > Sort values from a multivalued String attribute:
> > >
> > >       String[] values = attr.getStringValueArray();
> > >       Arrays.sort(values);              // Natural ordering
> > >       Arrays.sort(values, myComparator);  // Specific Ordering
> > >
> >     TreeSet can be used to order values by looping through
> >         values and adding them to the set using natural ordering
> >         or a specific comparator.
> >
> > > Sort Attribute objects
> > >
> > >       LDAPEntry entry = results.next();
> > >       LDAPAttributeSet aset = entry.getAttributeSet()
> > >       LDAPAttribute[] attrs = new LDAPAttribute[20];
> > >       attrs = aset.toArray(attrs);            // from Set
> > >       Arrays.sort(attrs);                           // Natural
> > > ordering by attribute name
> > >       Arrays.sort(attrs, myComparator); // Specific ordering
> > >
> > >     Note: Currently natural ordering between
> > >     LDAPAttribute objects is undefined since
> > >     LDAPAttribute does not implement the Comparable
> > >     interface.  I suggest that LDAPAttribute implement
> > >     the Comparable interface with natural ordering
> > >     based on attribute name.
> > >
> >
> >     TreeSet can be used to order attributes by looping
> >         through the name and adding each to the set using natural
> >         ordering or a specific comparator.
> >
> >         If LDAPAttribute objects implement Comparable as I
> >         suggest, one can simply say "new TreeSet(attributeSet)"
> >         to create a naturally sorted collection of attributes.
> >
> > > Sort LDAPEntry objects
> > >
> > >     It is not possible to sort Entries, since
> > >     there is no way to get either a List or an
> > >     Array from LDAPSearchResults.  I suggest
> > >     that LDAPEntry implement the Comparable
> > >     interface with natural ordering based on the
> > >     dn, and that LDAPSearchResults implement
> > >     a nextArray() method (see below).  If this
> > >     were done, sorting of LDAPEntry objects
> > >     could be done as follows:
> > >
> > >     LDAPEntry[] entries = results.nextArray();
> > >     Arrays.sort(entries);                           // Sort by dn
> > >     Arrays.sort(entries, myComparator);       // Specific ordering.
> > >
> > >     Note: myComparator is probably of type LDAPCompareAttrNames,
> > >     but an application could implement their own Comparator class.
> >
> >         Using TreeSet, Entries can be sorted by adding the Entries
> >         to the TreeSet object.  This has the advantage over nextArray()
> >         in that no fiddling need be done with batchsize.  It is up
> >         to the application to determine which Entries are sorted and
> >         how to deal with ensuring adequate memory for large sorts.
> >
> >         I see no need for the above described nextArray method.
> >
> > >
> > >
> > -----------------------------------------------------------------------------
> > > Suggested changes to the draft:
> > >
> > > 2.1 public class LDAPAttribute
> > >         implements Cloneable, Serializable, Comparable
> > >   ------------------------
> > > 2.2.2 compareTo
> > >
> > >       public int compareTo(Object obj)
> > >
> > >     Compares this object with the specified object for
> > >     order.  Ordering is determined by comparing attribute
> > >     names (see getName()) using the compareTo() method of
> > >     the String class. Returns a negative integer, zero, or
> > >     a positive integer as this object is less than, equal
> > >     to, or greater than the specified object.
> > >
> > >      obj              The object to be compared to this object.
> > >   ------------------------
> > >
> > > 2.14 public classs LDAPEntry
> > >         implements Serializable, Comparable
> > >   ------------------------
> > > 2.14.2 compareTo
> > >
> > >       public int compareTo(Object obj)
> > >
> > >     Compares this object with the specified object for
> > >     order.  Ordering is determined by comparing dn values
> > >     (see getDN) using the compareTo() method of the
> > StringaringValueArray();
> > >       Array
> > >     class.  Returns a negative integer, zero, or a
> > >     positive integer as this object is less than, equal
> > >     to, or greater than the specified object.
> > >
> > >      obj              The object to be compared to this object.
> > >
> > >   ------------------------
> > > (in class LDAPSearchResults)
> > >
> > > 2.35.5 nextArray
> > >
> > >       public LDAPEntry[] nextArray() throws LDAPException
> > >
> > > Returns an array containing all LDAPEntries in the
> > > order they were received. If automatic referral
> > > following is disabled or a referral was not
> > > followed, nextArray() will throw an
> > > LDAPReferralException when the referral is received.
> > >
> > > It should be noted that only those Entries which
> > > have been received and not retrieved via next()
> > > or nextArray() are placed in the array.  This will
> > > generally be the number of entries specified by
> > > batchsize. The size of the array returned will
> > > equal the number of entries returned. If all
> > > entries have already been returned, nextArray()
> > > throws NoSuchElementException.  If a sort of all
> > > entries returned by a search is desired, batchsize
> > > should be set to zero so that all entries are received
> > > by the API before control is returned to the application.
> > > (see LDAPSearchConstraints.setBatchSize()).  Sorting
> > > can be performed using the sort method of the Arrays class.
> > >   ------------------------
> >
> > Eliminate nextArray, but do have LDAPEntry and LDAPAttribute
> > implement Comparable.
> >
> > The description of LDAPCompareAttrNames should be clarified to
> > something like the following:
> >
> > 2.7 public class LDAPCompareaAttrNames
> >                         implements Comparator
> >
> >    An object of this class defines the ordering when sorting
> >    search results. LDAPEntry objects are sorted by the value
> >    of the specified attribute name(s) in ascending or descending
> >    order.  This object is typically supplied to an implementation
> >    of the collection interfaces like TreeSet which performs the sort.
> >
> >  -----------------------------------------------
> >
> > In summary what I suggest is,
> >
> >  add "implement Comparable" for classes LDAPAttribute and LDAPEntry
> >    (with appropriate description of natural compare mechanism)
> >
> >  Clarify description for LDAPCompareAttrNames
> >
> > -Steve
> > >
> > >
> > > -Steve
> > >
> > >
> > >
> > > ------------------------
> > > Steven Sonntag
> > > Novell, Inc., The leading provider of Net business solutions
> > > http://www.novell.com
> > >
> > >
> > > _______________________________________________
> > > Ldapext mailing list
> > > Ldapext@ietf.org
> > > https://www1.ietf.org/mailman/listinfo/ldapext

_______________________________________________
Ldapext mailing list
Ldapext@ietf.org
https://www1.ietf.org/mailman/listinfo/ldapext
References:
- Re: [ldapext] Java LDAP API, sorting
  - From: Rob Weltman <robw@worldspot.com>
Prev by Date: Re: [ldapext] Java LDAP API, sorting
Next by Date: RE: [ldapext] LDAP and subtree specification and subentries
Index(es):
- Chronological
- Thread