rom/oop/unused/interfaceclass.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Class for interface objects.
   6     Lang: english
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <exec/memory.h>
  11 #include <proto/utility.h>
  12 #include <proto/oop.h>
  13 #include <oop/oop.h>
  14
  15 #include "private.h"
  16
  17 #include "intern.h"
  18
  19 #undef SDEBUG
  20 #undef DEBUG
  21 #define DEBUG 0
  22 #define SDEBUG 0
  23 #include <aros/debug.h>
  24
  25 #define OOPBase ((struct Library *)cl->UserData)
  26
  27 static IPTR StdCallIF(OOP_Interface *iface, OOP_Msg msg);
  28
  29 struct interface_data
  30 {
  31     /* First part of the interface object's instance data is
  32        public, and may be accesesd directly.
  33     */
  34     OOP_Interface public;
  35
  36     /* The pointer to the interface's methods should indeed not
  37        be public.
  38     */
  39     struct IFMethod     *methodtable;
  40 };
  41
  42
  43 struct interface_object
  44 {
  45     /* All objects has a pointer to their class at ((VOID **)o)[-1] */
  46     OOP_Class *oclass;
  47
  48     /* When getting a interface ojject, you will get a pointer to
  49        &(intifobject->Inst.PublicPart)
  50     */
  51     struct interface_data data;
  52
  53 };
  54
  55 /***********************
  56 **  Interface::New()  **
  57 ***********************/
  58 static OOP_Object *interface_new(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  59 {
  60
  61
  62     STRPTR if_id = NULL;
  63     struct IFMethod *if_mtab;
  64     OOP_Object *if_obj;
  65     struct interface_object *ifo;
  66
  67     /* Parse parameters */
  68
  69     /* What target object does the user want an interface object for ? */
  70     if_obj = (OOP_Object *)GetTagData(aInterface_TargetObject, NULL, msg->attrList);
  71
  72     /* What interface does he want from the object ? */
  73     if_id  = (STRPTR)GetTagData(aInterface_InterfaceID,  NULL,  msg->attrList);
  74
  75     EnterFunc(bug("Interface::New(if_obj=%p, if_id=%s)\n", if_obj, if_id));
  76
  77     /* We MUST have those two parameters, to be able to
  78        create an interface object */
  79     if ( !(if_obj && if_id ) )
  80         ReturnPtr("Interface::New", Object *, NULL);
  81
  82
  83     D(bug("Trying to find interface: %s\n", if_id));
  84
  85     /* Try to find interface in the target object's class*/
  86     if_mtab = findinterface(OOP_OCLASS(if_obj), if_id);
  87
  88     if (!if_mtab)
  89         /* Not supported. Failed. */
  90         ReturnPtr("Interface::New", OOP_Object *, NULL);
  91
  92     D(bug("mtab found: %p\n", if_mtab));
  93
  94     /* Allocate mem for the interface object */
  95     ifo = AllocMem( sizeof (struct interface_object), MEMF_ANY );
  96     if (ifo)
  97     {
  98
  99         D(bug("obj alloced\n"));
 100
 101         /* The interface object remebers it's target object.
 102            Convenience for the user + he can store interface
 103            objects instead of a pointer to the object itself.
 104            (He doesn't have to store both)
 105         */
 106
 107         ifo->data.public.targetObject = if_obj;
 108
 109
 110         /* Function for calling a method on an interface obect.
 111            Just use a standard one, but we could add support
 112            for letting the user override the function with his own.
 113         */
 114         ifo->data.public.callMethod = StdCallIF;
 115
 116         /* The interface object must have some methods to call :-) */
 117         ifo->data.methodtable = if_mtab;
 118
 119         /* Initialize OCLASS(interfaceobject) */
 120         ifo->oclass     = cl;
 121
 122         ReturnPtr ("Interface::New", OOP_Object *, (OOP_Object *)&(ifo->data.public));
 123     }
 124     ReturnPtr ("Interface::New", OOP_Object *, NULL);
 125
 126 }
 127
 128 /****************
 129 **  Dispose()  **
 130 ****************/
 131 static VOID interface_dispose(OOP_Class *cl, OOP_Interface  *ifobj, OOP_Msg msg )
 132 {
 133     EnterFunc(bug("Interface::Dispose()\n"));
 134
 135     /* Just free the thing */
 136     FreeMem(_OOP_OBJECT(ifobj), sizeof (struct interface_object));
 137
 138     ReturnVoid("Interface::Dispose");
 139 }
 140
 141
 142 /************************
 143 **  Support functions  **
 144 ************************/
 145
 146
 147 /* Default way to call a interface objects' method.
 148    (Inserted into the Interface struct's CallIF() field
 149 */
 150 static IPTR StdCallIF(OOP_Interface *iface, OOP_Msg msg)
 151 {
 152     /* Mask off the method offset */
 153     register ULONG midx = msg->MID & METHOD_MASK;
 154
 155     register struct IFMethod *method;
 156
 157     /* Get the correct method from the correct offset */
 158     method = &( ((struct interface_data *)iface)->methodtable[midx] );
 159
 160     /* ... and call the method on the interface object's target object */
 161     return ( method->MethodFunc(method->mClass, iface->targetObject, msg) );
 162
 163 }
 164
 165 #undef OOPBase
 166
 167 /* Well, initalize the interface class. Self explainatory */
 168 OOP_Class *init_interfaceclass(struct Library *OOPBase)
 169 {
 170
 171     struct OOP_MethodDescr methods[] =
 172     {
 173         {(IPTR (*)())interface_new,             moRoot_New},
 174         {(IPTR (*)())interface_dispose,         moRoot_Dispose},
 175         { NULL, 0UL }
 176     };
 177
 178     struct OOP_InterfaceDescr ifdescr[] =
 179     {
 180         { methods, IID_Root, 2},
 181         { NULL, 0UL, 0UL}
 182     };
 183
 184     struct TagItem tags[] =
 185     {
 186         {aMeta_SuperID,         (IPTR)NULL},
 187         {aMeta_InterfaceDescr,          (IPTR)ifdescr},
 188         {aMeta_ID,                      (IPTR)CLID_Interface},
 189         {aMeta_InstSize,                (IPTR)sizeof (struct interface_data)},
 190         {TAG_DONE, 0UL}
 191     };
 192
 193
 194     OOP_Class *cl;
 195
 196     EnterFunc(bug("init_interfaceclass()\n"));
 197
 198     cl = (OOP_Class *)OOP_NewObject(NULL, CLID_MIMeta, tags);
 199     if (cl)
 200     {
 201         cl->UserData = OOPBase;
 202         OOP_AddClass(cl);
 203     }
 204
 205     ReturnPtr ("init_interfaceclass", OOP_Class *, cl);
 206 }