Hi Jean-Louis,
overlooked the "send" question: in ooRexx the defined methods and the
messages (represented by the tilde/twiddle/"~") are represented in their
own ooRexx classes.
So if in a Rexx program the "~" is encountered a message object (an
instance of the class "Message") is created. However, the creation of a
message does not yet cause that message to be dispatched to the object.
In order to dispatch a message object (which actually carries out the
message) one has to send it either the mssage "send" or "start".
* Using the "send" method causes the execution to halt until the
message has been carried out in full and allows one to fetch
directly a result value, if any.
* Using the "start" method cuases the execution to go on, the
message is carried out concurrently and returns an object, which
can be interrogated for the status of the asynchroneous execution
of the started message. Eventually, when the asynchroneous message
finished, one can learn that and even fetch the result.
Cf. the reference documentation of the class "Message".
HTH,
---rony
On 08.08.2011 11:39, Rony G. Flatscher wrote:
> Hi Jean-Louis,
>
> it seems that Rick is currently not online, so I try to give some
> shots, hoping they may help a little bit.
>
> [One problem in OO is the terminology, which sometimes comes into ones
> way (instead of clarifying concepts, sometimes they obfuscate them,
> unfortunately). There are quite a few synonyms, like "object" ==
> "instance" == "value" etc. or "class" == "type" etc.]
>
> On 08.08.2011 10:23, Jean-Louis Faucher wrote:
>> I try to understand the underlying model for object, class, metaclass
>> (source excerpt at the end of the mail). Not easy...
>
> ooRexx has been quite influenced by Smalltalk, so some of the concepts
> are directly from there.
>
> In general there are no class methods!
> (This means among other things that all methods are instance methods!)
> :)
>
> ---
>
> * There is simply a "class" that allows one to define methods and
> attributes the methods of a class can have direct access to.
> o A '"method" is a function/procedure that is only available
> for instances of the class in which the methods are defined.
> * An "object" is just an instance of a class. The object possesses
> the functionality/"behaviour" of the methods of its class.
> * There is a "class hierarchy" which is used when method
> resolution takes place with the concept that all methods (not
> attributes!) of all the superclasses (shortest path to root
> class) get inherited. (This is also the area where scope becomes
> important w.r.t. method resolution, but also access to
> attributes, i.e. concurrency issues and the like.)
> o The class hierarchy allows an object to have more methods
> (functionality/behaviour) than defined in its own class,
> by means of inheritance.
> * The root of a class hierarchy is usually calld "Object", which
> is a class, as it defines methods. As all other classes in
> ooRexx are derived directly (by default) or indirectly from this
> root class, its methods (functionality/behaviour) is inherited
> by all other classes (and its instances)!
>
> ---
>
> In dynamic languages the class definitions (the name, the methods) are
> represented in objects as well. The class used for creating objects
> that keep the definition of a class in ooRexx (and many other
> languages) is called "Class". As instances of this class describe the
> structure and behaviour of individual classes the term "metaclass" is
> used for it. So the ooRexx class "Class" is the metaclass of ooRexx.
> Of course, if one subclasses "Class" it inherits all abilities of
> "Class" and as such keeps on being able to maintain the definition of
> classes. An instance of "Class" or one of its subclasses (hence of any
> metaclass) is called "class object".
>
> The instance methods of metaclasses (i.e. "class objects") are called
> "class methods", indicating that these methods belong to the class object.
>
> ---
>
> When ooRexx starts up the class hierarchy is created in native code
> and from the image. I.e. all ooRexx supplied classes build (and are
> represented in) the ooRexx class hierarchy in the form of class
> objects. Each of these class objects maintains e.g. the name of the
> class and the methods, instances of this class should get assigned to
> at creation time (which is done in the 'new' method of "Class").
>
> At runtime one can access these class objects with their environment
> symbol, which is the name of the class preceeded by a dot, e.g.:
> ".object", ".class", ".array" and the like.
>
> ---
>
> One speciality (and very powerful feature) of ooRexx is its ability to
> add/remove methods from instances ("one-off-objects")! Cf. e.g. the
> "Object"'s methods "setMethod" and "unsetMethod", but also the "Class"
> method "enhanced" to create instances of a class which get additional
> methods (hence "one-off").
>
> It is also possible to change the set of methods instances of a class
> get assigned to, when they get created. Cf. the "Class" methods
> "method", "methods", "define" and "delete", which allow to maintain
> the methods instances of a class should get assigned to at the time
> they got created.
>
> Note: the method "instanceMethod" and "instanceMethods" in the root
> class "Object" allow one to fetch the actual instance method(s) of an
> object (ie. also from one-off objects).
>
> ---
>
> Finally ad methods of a class object: all methods of a class object
> are "instance methods", sometimes dubbed "class methods", because they
> are the instance methods of a metclass/class object. A class object is
> just a normal ooRexx object and as such it is possible to add/remove
> instance methods to/from it!
>
> When an ooRexx class defines methods with the subkeyword "class" then
> these methods will be added to the class object (as instance methods
> of the class object).
>
> ---
>
> Hope that helps clarify a few of your questions.
>
> Ad ooRexx native code and implementation, this is something that
> probably Rick is the only one who can answer at the moment.
>
> ---rony
>
>
>>
>> I can't find a suitable definition for the ??? below.
>>
>> Extracted from rexxref :
>>
>> 5.1.1
>> The Object class is the root of the class hierarchy.
>> The instance methods of the Object class are, therefore, available on
>> all objects.
>> [JLF] The class methods of the Object class are ???
>>
>> 5.1.2
>> 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.
>> [JLF] The class methods of the Class class are ???
>>
>> 4.1.4
>> A metaclass is a class you can use to create another class. The only
>> metaclass that Rexx provides is .Class, the Class class. The Class
>> class is the metaclass of all the classes Rexx provides. This means
>> that instances of .Class are themselves classes.
>> [JLF] The instance methods of a metaclass are ??? : [proposition] the
>> class methods of all the classes associated to this metaclass.
>> [JLF] The class methods of a metaclass are ???
>
>
>
>
>>
>>
>> What is a scope ? (I see scopes and metaClassScopes in the source
>> excerpt).
>>
>> Is there any publication that gives a big picture of this data model ?
>> In particular, I try to put in words the actions done by these methods :
>> ~instanceMethods
>> ~methods
>> ~send
>>
>>
>> Source excerpt :
>>
>> ObjectClass.hpp
>> class RexxInternalObject : public RexxVirtualBase{
>> inline RexxBehaviour *getObjectType() { return behaviour; }
>> -----
>> RexxBehaviour *behaviour; /* the object's
>> behaviour */
>>
>> class RexxObject : public RexxInternalObject {
>> inline RexxBehaviour *behaviourObject() { return this->behaviour; }
>>
>>
>> RexxBehavious.hpp
>> class RexxBehaviour : public RexxInternalObject
>> {
>> inline RexxTable *getMethodDictionary() { return
>> this->methodDictionary; };
>> RexxIdentityTable *scopes; /* scopes
>> table */
>> RexxTable *methodDictionary; /* method
>> dictionary */
>> RexxClass *owningClass; /* class that created this
>> object */
>> RexxTable *instanceMethodDictionary; /* methods added via
>> SETMETHOD */
>>
>>
>> ClassClass.hpp
>> class RexxClass : public RexxObject {
>> RexxTable *classMethodDictionary; // class methods
>> specific to this class
>> RexxBehaviour *instanceBehaviour; // instances of this class
>> inherit this behaviour
>> RexxTable *instanceMethodDictionary; // methods added to
>> this class
>> ---------
>> RexxClass *baseClass; // Baseclass of this class
>> RexxArray *metaClass; // Metaclass of this class
>> RexxArray *metaClassMethodDictionary; // Metaclass mdict
>> RexxIdentityTable *metaClassScopes; // Metaclass scopes
>> ---------
>> RexxArray *classSuperClasses; // The superclass and any
>> inherited mixins for class behaviour
>> RexxArray *instanceSuperClasses; // The superclass and
>> any inherited mixins for instance behaviour
>> ---------
>> RexxList *subClasses; // our list of weak
>> referenced subclasses
>>
>>
>> Jean Louis
------------------------------------------------------------------------------
BlackBerry® DevCon Americas, Oct. 18-20, San Francisco, CA
The must-attend event for mobile developers. Connect with experts.
Get tools for creating Super Apps. See the latest technologies.
Sessions, hands-on labs, demos & much more. Register early & save!
http://p.sf.net/sfu/rim-blackberry-1
_______________________________________________
Oorexx-devel mailing list
Oorexx-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/oorexx-devel
