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 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.

  [[OS2 API:SOMObject|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 [[OS2 API:somGetClassName();
  // Return the name of the receiver's class.

  long [[OS2 API:somGetSize();
  // Return the size of the receiver.

  //### Testing Group

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

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

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

  //### Dynamic

  boolean [[OS2 API: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 [[OS2 API: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 [[OS2 API:somCastObj(in [[OS2 API:SOMClass cls);
  // cast the receiving object to cls (which must be an ancestor of the
  // objects true class. Returns true on success.

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


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

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

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

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

  //### Development Support

  [[OS2 API:SOMObject [[OS2 API: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 [[OS2 API: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 [[OS2 API: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__ */
};