The Fundamental Classes
|
|
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 Stream Classes
|
|
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 Classes
|
|
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 Utility Classes
|
|
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.
|