Read Me - Common Public License V1.0 - Copyright Notice(©)
The Object Class The Object class is the root of the class hierarchy. The instance methods of the Object class are, therefore, available on all objects.
The Class Class The Class class is like a factory that produces the factories that produce objects. It is a subclass of the Object class (). The instance methods of the Class class are also the class methods of all classes.
The String Class String objects represent character-string data values. A character string value can have any length and contain any characters.
The Method Class The Method class creates method objects from Rexx source code. It is a subclass of the Object class ().
The Routine Class The Routine class creates routine objects from Rexx source code. It is a subclass of the Object class ().
The Package Class The Package class contains the source code for a package of Rexx code. A package instance holds all of the routines, classes, and methods created from a source code unit and also manages external dependencies referenced by ::REQUIRES directives. The files loaded by ::REQUIRES are also contained in Package class instances. It is a subclass of the Object class (.
The Message Class A message object provides for the deferred or asynchronous sending of a message. You can create a message object by using the new method of the Message class or the start () method of the Object class.
The InputStream Class This class is defined as an abstract mixin class. It must be implemented by subclassing it or inheriting from it as a mixin. Many of the methods in this class are abstract and must be overridden or they will throw a syntax error when invoked.
The OutputStream Class This class is defined as an abstract mixin class. It must be implemented by subclassing it or inheriting from it as a mixin. Many of the methods in this class are abstract and must be overridden or they will throw a syntax error when invoked.
The InputOutputStream Class This class is defined as an abstract mixin class. It must be implemented by subclassing it or inheriting from it as a mixin. Many of the methods in this class are abstract and must be overridden or they will throw a syntax error when invoked.
The Stream Class A stream object allows external communication from Rexx. (See for a discussion of Rexx input and output.)
The Collection Class The Collection class is a MIXIN class that defines the basic set of methods implemented by all Collections. Many of the Collection class methods are abstract and must be implemented the inheriting subclasses.
The MapCollection Class The MapCollection class is a MIXIN class that defines the basic set of methods implemented by all collections that use create a mapping from an index object to a value.
The OrderedCollection Class The OrderedCollection class is a MIXIN class that defines the basic set of methods implemented by all collections that have an inherent index ordering, such as an array or a list.
The SetCollection Class This is a tagging mixin class only and does not define any methods of its own. Collections that implement SetCollection are MapCollections that constrain the index and item to be be the same object.
The Array Class An array is a possibly sparse collection with indexes that are positive whole numbers. You can reference array items by using one or more indexes. The number of indexes is the same as the number of dimensions of the array. This number is called the dimensionality of the array.
The Bag Class A bag is a non-sparse collection that restricts the elements to having an item that is the same as the index. Any object can be placed in a bag, and the same object can be placed in a bag several times.
The CircularQueue Class The CircularQueue class allows for storing objects in a circular queue of a predefined size. Once the end of the queue has been reached, new item objects are inserted from the beginning, replacing earlier entries. Any object can be placed in the queue and the same object can occupy more than one position in the queue.
The Directory Class A Directory is a MapCollection using unique character string indexes. The items of the collection can be any valid Rexx object.
The List Class A list is a non-sparse sequenced collection similar to the Arrat class () to which you can add new items at any position in the sequence. The List creates a new index value whenever an item is added to the list and the associated index value remains valid for that item regardless of other additions or removals. Only indexes the list object generates are valid i.e. the list is never a sparse list and the list object will not modify indexes for items in the list.
The Properties Class A properties object is a collection with unique indexes that are character strings representing names and items that are also restricted to character string values. Properties objects are useful for processing bundles of application option values.
The Queue Class A queue is a non-sparse sequenced collection with whole-number indexes. The indexes specify the position of an item relative to the head (first item) of the queue. Adding or removing an item changes the association of an index to its queue item. You can add items at either the tail or the head of the queue.
The Relation Class A relation is a collection with indexes that can be any object. In a relation, each item is associated with a single index, but there can be more than one item with the same index (unlike a table, which can contain only one item for any index).
The Set Class A Set is a collection containing member items where the index is the same as the item (similar to a Bag collection). Any object can be placed in a set. There can be only one occurrence of any object in a set (unlike a Bag collection). Item equality is determined by using the == method.
The Stem Class A stem object is a collection with unique indexes that are character strings.
The Table Class A table is a collection with indexes that can be any object. In a table, each item is associated with a single index, and there can be only one item for each index (unlike a relation, which can contain more than one item with the same index). Index equality is determined by using the == method.
The IdentityTable Class An identity table is a collection with indexes that can be any object. In an identity table, each item is associated with a single index, and there can be only one item for each index. Index and item matches in an identity table are made using an object identity comparison. That is, an index will only match if the same instance is used in the collection.
The DateTime Class A DateTime object represents a point in between 1 January 0001 at 00:00.000000 and 31 December 9999 at 23:59:59.999999. A DateTime object has methods to allow formatting a date or time in various formats, as well as allowing arithmetic operations between dates.
The Alarm Class An alarm object provides timing and notification capability by supplying a facility to send any message to any object at a given time. You can cancel an alarm before it sends its message.
The TimeSpan Class A TimeSpan object represents a point in between 1 January 0001 at 00:00.000000 and 31 December 9999 at 23:59:59.999999. A TimeSpan object has methods to allow formatting a date or time in various formats, as well as allowing arithmetic operations between dates.
The Comparable Class This class is defined as a mixin class.
The Orderable Class The Orderable class can be inherited by classes which wish to provide each of the comparison operator methods without needing to implement each of the individual methods. The inheriting class need only implement the Comparable compareTo() method (). This class is defined as a mixin class.
The Comparator Class The Comparator class is the base class for implementing Comparator objects that can be used with the Array sortWith() () or stableSortWith() method (). The compare() method implements some form of comparison that determines the relative ordering of two objects. Many Comparator implementations are specific to particular object types.
The CaselessComparator Class The CaselessComparator class performs caseless orderings of String objects.
The ColumnComparator Class The ColumnComparator class performs orderings based on specific substrings of String objects.
The CaselessColumnComparator Class The CaselessColumnComparator class performs caseless orderings of specific substrings of String objects.
The DescendingComparator Class The DescendingComparator class performs sort orderings in descending order. This is the inverse of a Comparator () sort order.
The CaselessDescendingComparator Class The CaselessDescendingComparator class performs caseless string sort orderings in descending order. This is the inverse of a CaselessComparator () sort order.
The InvertingComparator Class The InvertingComparator class inverts the comparison results of another Comparator object to reverse the resulting sort order.
The Monitor Class The Monitor class acts as a proxy for other objects. Messages sent to the Monitor object are forwarded to a different target object. The message target can be changed dynamically.
The MutableBuffer Class The MutableBuffer class is a buffer on which certain string operations such as concatenation can be performed very efficiently. Unlike String objects, MutableBuffers can be altered without requiring a new object allocation. A MutableBuffer object can provide better performance for algorithms that involve frequent concatenations to build up longer string objects because it creates fewer intermediate objects.
The RegularExpression Class This class provides support for regular expressions. A regular expression is a pattern you can use to match strings.
The RexxQueue Class The RexxQueue class provides object-style access to Rexx external data queues.
The Supplier Class You can use a supplier object to iterate over items of a collection. Supplier objects are created from a snapshot of a collection. The iteration results are not affected by later changes to the source collection object.
The StreamSupplier Class A subclass of the Supplier class () that will provided stream lines using supplier semantics. This allows the programmer to iterate over the remaining lines in a stream. A StreamSupplier object provides a snapshot of the stream at the point in time it is created, including the current line read position. In general, the iteration is not effected by later changes to the read and write positioning of the stream. However, forces external to the iteration may change the content of the remaining lines as the itertion progresses.
The RexxContext Class The RexxContext class gives access to context information about the currently executing Rexx code. Instances of the RexxContext class can only be obtained via the .CONTEXT environment symbol. They cannot be directly created by the user. It is a subclass of the Object class ().
The WeakReference Class A WeakReference instance maintains a non-pinning reference to another object. A non-pinning reference does not prevent an object from getting garbage collected or having its uninit method run when there are no longer normal references maintained to the object. Once the referenced object is eligible for garbage collection, the reference inside the WeakReference instance will be cleared and the VALUE method will return .nil on all subsequent calls. WeakReferences are useful for maintaining caches of objects without preventing the objects from being reclaimed by the garbage collector when needed.
The Pointer Class A Pointer instance is a wrapper around a native pointer value. This class is designed primarily for writing methods and functions in native code and can only be created using the native code application programming interfaces. The Pointer class new method will raise an error if invoked.
The Buffer Class A Buffer instance is a Rexx interpreter managed block of storage. This class is designed primarily for writing methods and functions in native code and can only be created using the native code application programming interfaces. The Buffer class new method will raise an error if invoked.
The File Class The File class provides services which are common to all the filesystems supported by ooRexx. A File object represents a path to a file or directory. The path can be relative or absolute.

Read Me - Common Public License V1.0 - Copyright Notice(©)