SOMObject

From EDM2
Jump to: navigation, search
SOMObjectChart.png

SOMObject is the root class for all SOM classes. That is, all SOM classes must be subclasses of SOMObject or of some other class derived from SOMObject. SOMObject introduces no instance data, so objects whose classes inherit from SOMObject incur no size increase. They do inherit a suite of methods that provide the behaviour required of all SOM objects. Three of these methods are typically overridden by any subclass that has instance data- somDefaultInit, somDestruct, and somDumpSelfInt. See the descriptions of these methods for further information.

SOMObject defines the behaviour common to all SOM objects.

  • File stem: somobj
  • Base: None.
  • Metaclass : SOMClass
  • Ancestor Classes: None
  • Class definition file: somobj.idl

Methods

The following list shows all the SOMObject methods.

Group - Initialization/Termination
Group - Access
Group - Testing
Group - Dynamic
Group - Developer Support

Overridden methods

There are currently no overridden methods defined for the SOMObject class.

Interface SOMObject

interface SOMObject
// This is the SOM root class, all SOM classes must be descended from
// <SOMObject>. <SOMObject> has no instance data so there is no
// per-instance cost to being descended from it.

{
  //### Typedefs

  typedef sequence <SOMObject> SOMObjectSequence;
  // a sequence of SOM Objects

  typedef sequence <octet> BooleanSequence;
  // a sequence of booleans.

  struct somObjectOffset {
     SOMObject obj;
     long     offset;
  };
  // a structure to describe an object-related offset
  typedef sequence <somObjectOffset> somObjectOffsets;
  // a sequence of object-related offsets

  //###  Initialization / Termination

  void somDefaultInit(in som3InitCtrl *ctrl);
  // A default initializer for a SOM object. Passing a null ctrl
  // indicates to the receiver that its class is the class of the
  // object being initialized, whereby the initializer will determine
  // an appropriate control structure.

  void somDestruct(in octet doFree, in som3DestructCtrl *ctrl);
  // The default destructor for a SOM object. A nonzero <doFree>
  // indicates that the object storage should be freed by the
  // object's class (via somDeallocate) after uninitialization.
  // As with somDefaultInit, a null ctrl can be passed.

  void somDefaultCopyInit(in som3InitCtrl *ctrl, in SOMObject fromObj);
  // A default copy constructor. Use this to make copies of objects for
  // calling methods with "by-value" argument semantics.

  SOMObject somDefaultAssign(in som3AssignCtrl  *ctrl, in SOMObject fromObj);
  // A default assignment operator. Use this to "assign" the state of one
  // object to another.

  //### etc.

  void somDefaultConstCopyInit(in som3InitCtrl *ctrl, in SOMObject fromObj);
  // A default copy constructor that uses a const fromObj.

  void somDefaultVCopyInit(in som3InitCtrl *ctrl, in SOMObject fromObj);
  // A default copy constructor that uses a volatile fromObj.

  void somDefaultConstVCopyInit(in som3InitCtrl *ctrl, in SOMObject fromObj);
  // A default copy constructor that uses a const volatile fromObj.

  SOMObject somDefaultConstAssign(in som3AssignCtrl *ctrl,
                                  in SOMObject fromObj);
  // A default assignment operator that uses a const fromObj.

  SOMObject somDefaultVAssign(in som3AssignCtrl *ctrl, in SOMObject fromObj);
  // A default assignment operator that uses a volatile fromObj.

  SOMObject somDefaultConstVAssign(in som3AssignCtrl *ctrl,
                                   in SOMObject fromObj);
  // A default assignment operator that uses a const volatile fromObj.

  void somInit();
  // Obsolete but still supported. Override somDefaultInit instead of somInit.

  void somFree();
  // Use as directed by framework implementations.

  void somUninit();
  // Obsolete but still supported. Override somDestruct instead of somUninit.

  //### Access

  SOMClass somGetClass();
  // Return the receiver's class.

  string somGetClassName();
  // Return the name of the receiver's class.

  long somGetSize();
  // Return the size of the receiver.

  //### Testing Group

  boolean somIsA(in SOMClass aClassObj);
  // Returns 1 (true) if the receiver responds to methods
  // introduced by <aClassObj>, and 0 (false) otherwise.

  boolean somIsInstanceOf(in SOMClass aClassObj);
  // Returns 1 (true) if the receiver is an instance of
  // <aClassObj> and 0 (false) otherwise.

  boolean somRespondsTo(in somId mId);
  // Returns 1 (true) if the indicated method can be invoked
  // on the receiver and 0 (false) otherwise.

  //### Dynamic

  boolean somDispatch(out somToken retValue,
                   in somId methodId,
                   in va_list ap);
  // This method provides a generic, class-specific dispatch mechanism.
  // It accepts as input <retValue> a pointer to the memory area to be
  // loaded with the result of dispatching the method indicated by
  // <methodId> using the arguments in <ap>. <ap> contains the object
  // on which the method is to be invoked as the first argument.

  boolean somClassDispatch(in SOMClass clsObj,
                        out somToken retValue,
                        in somId methodId,
                        in va_list ap);
  // Like somDispatch, but method resolution for static methods is done
  // according to the clsObj instance method table.

  boolean somCastObj(in SOMClass cls);
  // cast the receiving object to cls (which must be an ancestor of the
  // objects true class. Returns true on success.

  boolean somResetObj();
  // reset an object to its true class. Returns true always.

  void somDispatchV(in somId methodId,
                    in somId descriptor,
                    in va_list ap);
  // Obsolete. Use somDispatch instead.

  long somDispatchL(in somId methodId,
                    in somId descriptor,
                    in va_list ap);
  // Obsolete. Use somDispatch instead.

  void* somDispatchA(in somId methodId,
                     in somId descriptor,
                     in va_list ap);
  // Obsolete. Use somDispatch instead.

  double somDispatchD(in somId methodId,
                      in somId descriptor,
                      in va_list ap);
  // Obsolete. Use somDispatch instead.

  //### Development Support

  SOMObject somPrintSelf();
  // Uses <SOMOutCharRoutine> to write a brief string with identifying
  // information about this object.  The default implementation just gives
  // the object's class name and its address in memory.
  // <self> is returned.

  void somDumpSelf(in long level);
  // Uses <SOMOutCharRoutine> to write a detailed description of this object
  // and its current state.
  //
  // <level> indicates the nesting level for describing compound objects
  // it must be greater than or equal to zero.  All lines in the
  // description will be preceeded by <2*level> spaces.
  //
  // This routine only actually writes the data that concerns the object
  // as a whole, such as class, and uses <somDumpSelfInt> to describe
  // the object's current state.  This approach allows readable
  // descriptions of compound objects to be constructed.
  //
  // Generally it is not necessary to override this method, if it is
  // overriden it generally must be completely replaced.

  void somDumpSelfInt(in long level);
  // Uses <SOMOutCharRoutine> to write in the current state of this object.
  // Generally this method will need to be overridden.  When overriding
  // it, begin by calling the parent class form of this method and then
  // write in a description of your class's instance data. This will
  // result in a description of all the object's instance data going
  // from its root ancestor class to its specific class.

#ifdef __SOMIDL__
  implementation {
    releaseorder: somInit,somUninit,somFree,somDefaultVCopyInit,
                  somGetClassName,somGetClass,somIsA,somRespondsTo,
                  somIsInstanceOf,somGetSize,somDumpSelf,somDumpSelfInt,
                  somPrintSelf,somDefaultConstVCopyInit,somDispatchV,
                  somDispatchL,somDispatchA,
                  somDispatchD,somDispatch,somClassDispatch,
                  somCastObj, somResetObj, somDefaultInit, somDestruct,
                  somPrivate1, somPrivate2,
                  somDefaultCopyInit, somDefaultConstCopyInit, somDefaultAssign,
                  somDefaultConstAssign, somDefaultVAssign,
                  somDefaultConstVAssign;

    // Class Modifiers
    callstyle = oidl;
    externalstem = somob;
    majorversion = 1;
#ifndef SOMPCALL
    minorversion = 5; // for som2.5 kernel
#else
    minorversion = 6; // for som2.5 kernel with pcall
#endif
    filestem = somobj;
    dllname = "som.dll";

    // Public Method Modifiers
    somDefaultInit: init;
    somDefaultCopyInit: init;
    somDefaultConstCopyInit: init;
    somDefaultVCopyInit: init;
    somDefaultConstVCopyInit: init;

    somDefaultInit: caller_owns_parameters = "ctrl";
    somDestruct: caller_owns_parameters = "ctrl";
    somDefaultCopyInit: caller_owns_parameters = "ctrl";
    somDefaultAssign: caller_owns_parameters = "ctrl";
    somDefaultConstCopyInit: caller_owns_parameters = "ctrl";
    somDefaultVCopyInit: caller_owns_parameters = "ctrl";
    somDefaultConstVCopyInit: caller_owns_parameters = "ctrl";
    somDefaultConstAssign: caller_owns_parameters = "ctrl";
    somDefaultVAssign: caller_owns_parameters = "ctrl";
    somDefaultConstVAssign: caller_owns_parameters = "ctrl";
    somRespondsTo: caller_owns_parameters = "mId";
    somDispatch: caller_owns_parameters = "methodId, ap";
    somClassDispatch: caller_owns_parameters = "methodId, ap";
    somDispatchV: caller_owns_parameters = "methodId, descriptor, ap";
    somDispatchL: caller_owns_parameters = "methodId, descriptor, ap";
    somDispatchA: caller_owns_parameters = "methodId, descriptor, ap";
    somDispatchD: caller_owns_parameters = "methodId, descriptor, ap";
  };
#endif /* __SOMIDL__ */
};