Re: [Oorexx-devel] Just a "little" info needed

OK, there's obviously something I'm not grasping here.  Guess the bug I just entered would explain 
better my "obvious" mis-conception of how compareTo would work.

I'll table my testUnit until I have a better grasp.

Lee

Rick McGuire wrote:
> Not completely sure I understand your question.  Not everything in 
> ooRexx is a string, everything is an object, and a string is just one 
> type of object.   Which really has absolutely nothing to do with 
> Comparable, etc :-). 
> 
> So, let's do a quick tutorial on how these are used.  Let's start with 
> Comparable.  The Comparable mixin consists of a single abstract method, 
> compareTo().  So any class that inherits from Comparable is expected to 
> implement a compareTo() method.  A compareTo() method is for doing an 
> ordered comparison of two "compatible" objects ( e.g., two strings).  
> This is used by the array sort() method to determining when elements 
> within the array should be swapped.  So,
> 
>     a = .array~of("Rick", "David", "Lee")
>     a~sort
>     do name over a
>          say name
>     end
> 
> Will display "David", "Lee", "Rick" because the sort method made calls 
> to the string compareTo() method whenever two string objects needed to 
> be compared. 
> 
> Any object can inherit from Comparable and provide a compareTo() 
> method.  In fact, you should be quite familiar with two of them at this 
> point, DateTime and TimeSpan.  The compareTo() method allows you to sort 
> arrays of DateTime or TimeSpan objects, just as you can sort arrays of 
> strings.  The sort works because a DateTime knows how to compare itself 
> to another DateTime object and determine which is the bigger of the two.
> 
> Now Comparators serve multiple purposes.  To start with, you might be 
> working with object instances where the original author never considered 
> the possibility that you might want to sort these, so there's no 
> compareTo() method.  For example, you might be sorting a bunch of 
> OLEObject instances you got from a spreadsheet. 
> 
> A Comparator object implements a single method compare() that will 
> compare two different compatible objects with each other to produce an 
> ordering.  For example, consider the following simple class:
> 
> ::class dog
> ::attribute breed
> ::attribute name
> ::attribute weight
> 
> There are multiple ways I might want to sort an array of dogs.  By 
> breed, by name, or by weight.  I can do all of these by writing some 
> simple Comparator classes.
> 
> ::class BreedSorter subclass Comparator
> ::method compare
> use strict arg left, right
> return left~breed~compareTo(right~breed)   -- Compares the string names 
> of the breeds.
> 
> A name sorter and a weight sorter would be similarly simple to create.  
> Then, to sort using one of these, you'd just do
> 
> dogs~sortWith(.breedComparator~new)
> 
> The BreedComparator instance is used to compare pairs of dogs during the 
> sorting process.
> 
> The core class set includes a number of simple Comparators for 
> performing different common sort operations. 
> 
> DescendingCompartor -- This just does a "-left~compareTo(right)".  By 
> negating the result of the compareTo, the sort is performed in the 
> opposite direction. 
> 
> CaselessComparator -- This one is specific to the string class, which 
> also implements a caselessCompareTo() method.  This calls 
> caselessCompareTo() instead of compareTo(), resulting in a case 
> insensitive sort.
> 
> CaselessDescendingComparator -- Just a combination of the two above.
> 
> ColumnComparator -- Another one specific to the string class.  This 
> compares specific column positions within the pairs of strings for the 
> sort.
> 
> CaselessColumnComparator -- You should be spotting the pattern by now :-)
> 
> InvertingComparator -- This one is very useful.  It's initialized with 
> another comparator instance, and just inverts the compare result.  So, 
> to do a descending sort of my dogs by breed, I can do:
> 
> dogs~sortWith(.InvertingComparator~new(.BreedComparator~new))
> 
> Rick
> 
> 
>    
> 
> 
> 
> On 10/10/07, *Lee Peedin* < le...@sa... 
> <mailto:le...@sa...>> wrote:
> 
>     Getting prepared (by reading the documentation) to write testUnits
>     for the following:
> 
>     Comparable Class
>     Comparator Class
>     CaseLessColumnComparator Class
>     etc.
> 
>     and got one question.
> 
>     What limitation, if any, is there on the "receiving object"?  Since
>     "everything in Rexx" is a string
>     and a string is an object, does that basically mean "anything" can
>     be the receiver?
> 
>     Lee
> 
>     -------------------------------------------------------------------------
>     This SF.net email is sponsored by: Splunk Inc.
>     Still grepping through log files to find problems?  Stop.
>     Now Search log events and configuration files using AJAX and a browser.
>     Download your FREE copy of Splunk now >> http://get.splunk.com/
>     <http://get.splunk.com/>
>     _______________________________________________
>     Oorexx-devel mailing list
>     Oor...@li...
>     <mailto:Oor...@li...>
>     https://lists.sourceforge.net/lists/listinfo/oorexx-devel
> 
> 
> 
> ------------------------------------------------------------------------
> 
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Oorexx-devel mailing list
> Oor...@li...
> https://lists.sourceforge.net/lists/listinfo/oorexx-devel