datacls.cpp

/*
 *  This file was generated by the SOM Compiler.
 *  Generated using:
 *     SOM incremental update: 2.47
 */


/*
 *  This file was generated by the SOM Compiler and Emitter Framework.
 *  Generated using template emitter:
 *      SOM Emitter emitxtm: 2.23.1.9
 */

#ifndef SOM_Module_datacls_Source
#define SOM_Module_datacls_Source
#endif
#define ProductObject_Class_Source

#define _RETAIL /* to completely eliminate the ...MethodDebug(...) debugging output to SOMOutCharRoutine (default:stdout) */
#include "datacls.xih"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#define INCL_BASE
#include <os2.h>

#define UNKNOWN_VEND "unknown vendor"
#define UNKNOWN_PROD "unknown device"



SOM_Scope void SOMLINK key_somDefaultInit(KeyObject *somSelf, 
                                          som3InitCtrl* ctrl)
{
    KeyObjectData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    KeyObjectMethodDebug("KeyObject","somDefaultInit");
    KeyObject_BeginInitializer_somDefaultInit;

    KeyObject_Init_somf_TCollectibleLong_somDefaultInit(somSelf, ctrl);

    /*
     * local KeyObject initialization code added by programmer
     */
}


SOM_Scope void SOMLINK key_somDestruct(KeyObject *somSelf, octet doFree, 
                                       som3DestructCtrl* ctrl)
{
    KeyObjectData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    KeyObjectMethodDebug("KeyObject","key_somDestruct");
    KeyObject_BeginDestructor;

    /*
     * local KeyObject deinitialization code added by programmer
     */

    KeyObject_EndDestructor;
}


SOM_Scope boolean  SOMLINK key_somfIsSame(KeyObject *somSelf, 
                                           Environment *ev, somf_MCollectible* obj)
{
    /* KeyObjectData *somThis = KeyObjectGetData(somSelf); */
    KeyObjectMethodDebug("KeyObject","key_somfIsSame");
    KeyObject *somOther = (KeyObject *)obj;

    return (somSelf->somfGetValue(ev) == somOther->somfGetValue(ev));
}


/*
 *Method from the IDL attribute statement:
 *"attribute string productName"
 */

SOM_Scope string  SOMLINK product__get_productName(ProductObject *somSelf, 
                                                    Environment *ev)
{
    ProductObjectData *somThis = ProductObjectGetData(somSelf);
    ProductObjectMethodDebug("ProductObject","product__get_productName");

    return somThis->productName;
}

/*
 *Method from the IDL attribute statement:
 *"attribute string productName"
 */

SOM_Scope void  SOMLINK product__set_productName(ProductObject *somSelf, 
                                                  Environment *ev, 
                                                 string productName)
{
    ProductObjectData *somThis = ProductObjectGetData(somSelf);
    ProductObjectMethodDebug("ProductObject","product__set_productName");
    size_t len = strlen(productName);

    if (somThis->productName) {
       SOMFree(somThis->productName);
    } /* endif */
    somThis->productName = (string)SOMMalloc(len+1);
    if (somThis->productName) {
       strcpy(somThis->productName,productName);
       somThis->productName[len] = '\0';
    } /* endif */
}

SOM_Scope void SOMLINK product_somDefaultInit(ProductObject *somSelf, 
                                              som3InitCtrl* ctrl)
{
    ProductObjectData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    ProductObjectMethodDebug("ProductObject","somDefaultInit");
    ProductObject_BeginInitializer_somDefaultInit;

    ProductObject_Init_somf_MCollectible_somDefaultInit(somSelf, ctrl);

    /*
     * local ProductObject initialization code added by programmer
     */
}


SOM_Scope void SOMLINK product_somDestruct(ProductObject *somSelf, 
                                           octet doFree, som3DestructCtrl* ctrl)
{
    ProductObjectData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    ProductObjectMethodDebug("ProductObject","product_somDestruct");
    ProductObject_BeginDestructor;

    /*
     * local ProductObject deinitialization code added by programmer
     */
    if (somThis->productName) {
       SOMFree(somThis->productName);
    } /* endif */

    ProductObject_EndDestructor;
}



/*
 *Method from the IDL attribute statement:
 *"attribute string vendorName"
 */

SOM_Scope string  SOMLINK vendor__get_vendorName(VendorObject *somSelf, 
                                                  Environment *ev)
{
    VendorObjectData *somThis = VendorObjectGetData(somSelf);
    VendorObjectMethodDebug("VendorObject","vendor__get_vendorName");

    return somThis->vendorName;
}

/*
 *Method from the IDL attribute statement:
 *"attribute string vendorName"
 */

SOM_Scope void  SOMLINK vendor__set_vendorName(VendorObject *somSelf, 
                                                Environment *ev, 
                                               string vendorName)
{
    VendorObjectData *somThis = VendorObjectGetData(somSelf);
    VendorObjectMethodDebug("VendorObject","vendor__set_vendorName");
    size_t len = strlen(vendorName);

    if (somThis->vendorName) {
       SOMFree(somThis->vendorName);
    } /* endif */
    somThis->vendorName = (string)SOMMalloc(len+1);
    if (somThis->vendorName) {
       strcpy(somThis->vendorName,vendorName);
       somThis->vendorName[len] = '\0';
    } /* endif */
}



SOM_Scope ProductObject*  SOMLINK vendor_addProduct(VendorObject *somSelf, 
                                                     Environment *ev, 
                                                    long key, 
                                                    string productName)
{
    VendorObjectData *somThis = VendorObjectGetData(somSelf);
    VendorObjectMethodDebug("VendorObject","vendor_addProduct");
    KeyObject *pKey       = new KeyObject;
    ProductObject *pProduct = new ProductObject;

    if (somThis->products && pKey && pProduct) {
       pKey->somfSetValue(ev,key);
       pProduct->_set_productName(ev,productName);
       somThis->products->somfAddMM(ev,pKey,pProduct);
       return pProduct;
    } else {
       if (pKey) {
          delete pKey;
       } /* endif */
       if (pProduct) {
          delete pProduct;
       } /* endif */
       return SOMF_NIL;
    } /* endif */
}


SOM_Scope ProductObject*  SOMLINK vendor_findProduct(VendorObject *somSelf, 
                                                      Environment *ev, 
                                                     long key)
{
    VendorObjectData *somThis = VendorObjectGetData(somSelf);
    VendorObjectMethodDebug("VendorObject","vendor_findProduct");
    KeyObject *pKey       = new KeyObject;
    ProductObject *pProduct = SOMF_NIL;

    if (somThis->products) {
       pKey->somfSetValue(ev,key);
       pProduct = (ProductObject *)somThis->products->somfRetrieve(ev,pKey);
    }
    delete pKey;
    if (pProduct == SOMF_NIL) {
       pProduct = somThis->defaultProduct;
    } /* endif */

    return pProduct;
}

SOM_Scope void SOMLINK vendor_somDefaultInit(VendorObject *somSelf, 
                                             som3InitCtrl* ctrl)
{
    VendorObjectData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    VendorObjectMethodDebug("VendorObject","somDefaultInit");
    VendorObject_BeginInitializer_somDefaultInit;

    VendorObject_Init_somf_MCollectible_somDefaultInit(somSelf, ctrl);

    /*
     * local VendorObject initialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();

    somThis->products = new somf_THashTable;

    somThis->defaultProduct = new ProductObject;
    if (somThis->defaultProduct) {
       somThis->defaultProduct->_set_productName(ev,UNKNOWN_PROD);
    } /* endif */
}


SOM_Scope void SOMLINK vendor_somDestruct(VendorObject *somSelf, 
                                          octet doFree, som3DestructCtrl* ctrl)
{
    VendorObjectData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    VendorObjectMethodDebug("VendorObject","vendor_somDestruct");
    VendorObject_BeginDestructor;

    /*
     * local VendorObject deinitialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();

    if (somThis->products) {
       somThis->products->somfDeleteAll(ev);
       delete somThis->products;
    } /* endif */

    if (somThis->vendorName) {
       SOMFree(somThis->vendorName);
    } /* endif */

    if (somThis->defaultProduct) {
       delete somThis->defaultProduct;
    } /* endif */

    VendorObject_EndDestructor;
}


SOM_Scope VendorObject*  SOMLINK USB_addVendor(USBDeviceCollection *somSelf, 
                                                Environment *ev, 
                                               long key, string vendorName)
{
    /* USBDeviceCollectionData *somThis = USBDeviceCollectionGetData(somSelf); */
    USBDeviceCollectionMethodDebug("USBDeviceCollection","USB_addVendor");
    KeyObject *pKey       = new KeyObject;
    VendorObject *pVendor = new VendorObject;

    if (pKey && pVendor) {
       pKey->somfSetValue(ev,key);
       pVendor->_set_vendorName(ev,vendorName);

       somSelf->somfAddMM(ev,pKey,pVendor);
       return pVendor;
    } /* endif */
    else
    {
       if (pKey) {
          delete pKey;
       } /* endif */
       if (pVendor) {
          delete pVendor;
       } /* endif */
       return SOMF_NIL;
    }
}

SOM_Scope VendorObject*  SOMLINK USB_findVendor(USBDeviceCollection *somSelf, 
                                                Environment *ev, 
                                                long key)
{
    USBDeviceCollectionData *somThis = USBDeviceCollectionGetData(somSelf);
    USBDeviceCollectionMethodDebug("USBDeviceCollection","USB_findVendor");
    KeyObject *pKey       = new KeyObject;
    VendorObject *pVendor = SOMF_NIL;

    pKey->somfSetValue(ev,key);
    pVendor = (VendorObject *)somSelf->somfRetrieve(ev,pKey);
    delete pKey;
    if (pVendor == SOMF_NIL) {
       pVendor = somThis->defaultVendor;
    } /* endif */
    return pVendor;
}

SOM_Scope void SOMLINK USB_somDefaultInit(USBDeviceCollection *somSelf, 
                                          som3InitCtrl* ctrl)
{
    USBDeviceCollectionData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    USBDeviceCollectionMethodDebug("USBDeviceCollection","somDefaultInit");
    USBDeviceCollection_BeginInitializer_somDefaultInit;

    USBDeviceCollection_Init_somf_THashTable_somDefaultInit(somSelf, ctrl);

    /*
     * local USBDeviceCollection initialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();
    char szFileName[CCHMAXPATH+4] = {0};
    char strCurrLine[256];
    char strCurrString[256];
    FILE *f = NULL;
    int numFields;
    unsigned short idCurrId;
    VendorObject *pV = NULL;


    somThis->defaultVendor = new VendorObject;
    if (somThis->defaultVendor) {
       somThis->defaultVendor->_set_vendorName(ev,UNKNOWN_VEND);
    } /* endif */

    // what we do here is looking for file "usb.ids", parsing its content
    // and building up a database with vendor and product strings
    // identified by vendor id and device id
    _searchenv("usb.ids","ETC",szFileName);
    if (0 == szFileName[0]) {
       _searchenv("usb.ids","PATH",szFileName);
    } /* endif */
    if (0 == szFileName[0]) {
       _searchenv("usb.ids","DPATH",szFileName);
    } /* endif */
    if (0 != szFileName[0]) {
       f = fopen(szFileName,"r");
       if (f) {
          while (!feof(f)) {
             fgets(strCurrLine,sizeof(strCurrLine)-1,f);
             // we quit the parsing loop as soon as we find
             // the sections in file "usb.ids" that follow
             // the vendor/device block
             // we detect this by looking at a specific comment line
             if (strstr(strCurrLine,"# List of known device classes, subclasses and protocols")) {
                break;
             } /* endif */
             numFields = sscanf(strCurrLine,"%hx %[^\n]",&idCurrId,strCurrString);
             if (numFields == 2) {
                if (strCurrLine[0] != '\t') { // we found a vendor description
                   pV = somSelf->addVendor(ev,idCurrId,strCurrString);
                } else if (strCurrLine[1] != '\t') {  // we found a device description
                   if (pV) {
                      pV->addProduct(ev,idCurrId,strCurrString);
                   } /* endif */
                } /* endif */
             } /* endif */
          } /* endwhile */
          fclose(f);
       } /* endif */
    } /* endif */
}


SOM_Scope void SOMLINK USB_somDestruct(USBDeviceCollection *somSelf, 
                                       octet doFree, som3DestructCtrl* ctrl)
{
    USBDeviceCollectionData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    USBDeviceCollectionMethodDebug("USBDeviceCollection","USB_somDestruct");
    USBDeviceCollection_BeginDestructor;

    /*
     * local USBDeviceCollection deinitialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();
    somSelf->somfDeleteAll(ev);

    if (somThis->defaultVendor) {
       delete somThis->defaultVendor;
    } /* endif */

    USBDeviceCollection_EndDestructor;
}



SOM_Scope void SOMLINK device_somDefaultInit(RMDeviceObject *somSelf, 
                                             som3InitCtrl* ctrl)
{
    RMDeviceObjectData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    RMDeviceObjectMethodDebug("RMDeviceObject","somDefaultInit");
    RMDeviceObject_BeginInitializer_somDefaultInit;

    RMDeviceObject_Init_somf_MCollectible_somDefaultInit(somSelf, ctrl);

    /*
     * local RMDeviceObject initialization code added by programmer
     */
}


SOM_Scope void SOMLINK device_somDestruct(RMDeviceObject *somSelf, 
                                          octet doFree, som3DestructCtrl* ctrl)
{
    RMDeviceObjectData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    RMDeviceObjectMethodDebug("RMDeviceObject","device_somDestruct");
    RMDeviceObject_BeginDestructor;

    /*
     * local RMDeviceObject deinitialization code added by programmer
     */

    RMDeviceObject_EndDestructor;
}




SOM_Scope RMDeviceObject*  SOMLINK RM_addRMDevice(RMDeviceCollection *somSelf, 
                                                   Environment *ev, 
                                                  long key, long idVendor, 
                                                  long idProduct)
{
    /* RMDeviceCollectionData *somThis = RMDeviceCollectionGetData(somSelf); */
    RMDeviceCollectionMethodDebug("RMDeviceCollection","RM_addRMDevice");

    KeyObject *pKey       = new KeyObject;
    RMDeviceObject *pRMDevice = new RMDeviceObject;

    if (pKey && pRMDevice) {
       pKey->somfSetValue(ev,key);
       pRMDevice->_set_idVendor(ev,idVendor);
       pRMDevice->_set_idProduct(ev,idProduct);

       somSelf->somfAddMM(ev,pKey,pRMDevice);
       return pRMDevice;
    } /* endif */
    else
    {
       if (pKey) {
          delete pKey;
       } /* endif */
       if (pRMDevice) {
          delete pRMDevice;
       } /* endif */
       return SOMF_NIL;
    }
}

SOM_Scope RMDeviceObject*  SOMLINK RM_findRMDevice(RMDeviceCollection *somSelf, 
                                                    Environment *ev, 
                                                   long key)
{
    /* RMDeviceCollectionData *somThis = RMDeviceCollectionGetData(somSelf); */
    RMDeviceCollectionMethodDebug("RMDeviceCollection","RM_findRMDevice");

    KeyObject *pKey       = new KeyObject;
    RMDeviceObject *pRMDevice = SOMF_NIL;

    pKey->somfSetValue(ev,key);
    pRMDevice = (RMDeviceObject *)somSelf->somfRetrieve(ev,pKey);
    delete pKey;
    return pRMDevice;
}

SOM_Scope void  SOMLINK RM_deleteRMDevice(RMDeviceCollection *somSelf, 
                                           Environment *ev, long key)
{
    /* RMDeviceCollectionData *somThis = RMDeviceCollectionGetData(somSelf); */
    RMDeviceCollectionMethodDebug("RMDeviceCollection","RM_deleteRMDevice");
    RMDeviceObject *pR;
    KeyObject *pKey       = new KeyObject;

    pKey->somfSetValue(ev,key);
    pR = (RMDeviceObject *)somSelf->somfDelete(ev,pKey);
    delete pKey;
    if (pR) {
       delete pR;
    } /* endif */
}

SOM_Scope void SOMLINK RM_somDefaultInit(RMDeviceCollection *somSelf, 
                                         som3InitCtrl* ctrl)
{
    RMDeviceCollectionData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    RMDeviceCollectionMethodDebug("RMDeviceCollection","somDefaultInit");
    RMDeviceCollection_BeginInitializer_somDefaultInit;

    RMDeviceCollection_Init_somf_THashTable_somDefaultInit(somSelf, ctrl);

    /*
     * local RMDeviceCollection initialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();

    ULONG ulNumDevices = 0UL;
    ULONG ulDevNumber  = 0UL;
    ULONG ulBufLen     = 0UL;
    ULONG i=0;
 
    DeviceDescriptor   desc;
    GETDEVINFODATA     info;

    M_RMDeviceCollectionData *somMThis              = M_RMDeviceCollectionGetData(_RMDeviceCollection);
    HMODULE hUSBMod                                 = somMThis->hUSBMod;
    PFNUsbQueryNumberDevices UsbQueryNumberDevices  = somMThis->UsbQueryNumberDevices;
    PFNUsbQueryDeviceInfo UsbQueryDeviceInfo        = somMThis->UsbQueryDeviceInfo;
    PFNUsbQueryDeviceReport UsbQueryDeviceReport    = somMThis->UsbQueryDeviceReport;

    if (hUSBMod && UsbQueryNumberDevices && UsbQueryDeviceInfo && UsbQueryDeviceReport) {
       // whenever a RMDeviceCollection is created (new RMDeviceCollection)
       // we query the list of RM devices nodes that are related to USB devices
       // then we query the vendor and product id for that USB device
       // we finally build up a relation between RM device node and USB vendor and product id
       // that will ultimately allow us to query vendor and product string from the RM device node
       APIRET rc = UsbQueryNumberDevices(&ulNumDevices);
       for (i=1;i<=ulNumDevices;i++) {
    
          ulBufLen = sizeof(info);
          APIRET rc1 = LOUCHAR(UsbQueryDeviceInfo(i,&ulBufLen,&info));
          ulBufLen = sizeof(desc);
          APIRET rc2 = LOUCHAR(UsbQueryDeviceReport(i,&ulBufLen,&desc));
          if ((NO_ERROR == rc1) &&
              ((NO_ERROR == rc2) || (ERROR_MORE_DATA == rc2))
             ) {
            somSelf->addRMDevice(ev,info.rmDevHandle,desc.idVendor,desc.idProduct);
          } /* endif */
       } /* endfor */
    } /* endif */
}


SOM_Scope void SOMLINK RM_somDestruct(RMDeviceCollection *somSelf, 
                                      octet doFree, som3DestructCtrl* ctrl)
{
    RMDeviceCollectionData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    RMDeviceCollectionMethodDebug("RMDeviceCollection","RM_somDestruct");
    RMDeviceCollection_BeginDestructor;

    /*
     * local RMDeviceCollection deinitialization code added by programmer
     */
    Environment *ev = somGetGlobalEnvironment();

    somSelf->somfDeleteAll(ev);

    RMDeviceCollection_EndDestructor;
}



SOM_Scope void SOMLINK M_RM_somDefaultInit(M_RMDeviceCollection *somSelf, 
                                           som3InitCtrl* ctrl)
{
    M_RMDeviceCollectionData *somThis; /* set in BeginInitializer */
    somInitCtrl globalCtrl;
    somBooleanVector myMask;
    M_RMDeviceCollectionMethodDebug("M_RMDeviceCollection","somDefaultInit");
    M_RMDeviceCollection_BeginInitializer_somDefaultInit;

    M_RMDeviceCollection_Init_SOMClass_somDefaultInit(somSelf, ctrl);

    /*
     * local M_RMDeviceCollection initialization code added by programmer
     */

    if (NULLHANDLE == somThis->hUSBMod)
    {
       if (NO_ERROR == DosLoadModule(NULL,0,"USBCALLS",&somThis->hUSBMod))
       {
          DosQueryProcAddr(somThis->hUSBMod,2,NULL,(PFN *)&somThis->UsbQueryNumberDevices);
          DosQueryProcAddr(somThis->hUSBMod,4,NULL,(PFN *)&somThis->UsbQueryDeviceInfo);
          DosQueryProcAddr(somThis->hUSBMod,1,NULL,(PFN *)&somThis->UsbQueryDeviceReport);
       }
       else
       {
          somThis->hUSBMod = NULLHANDLE;
       }
    }
}

SOM_Scope void SOMLINK M_RM_somDestruct(M_RMDeviceCollection *somSelf, 
                                        octet doFree, som3DestructCtrl* ctrl)
{
    M_RMDeviceCollectionData *somThis; /* set in BeginDestructor */
    somDestructCtrl globalCtrl;
    somBooleanVector myMask;
    M_RMDeviceCollectionMethodDebug("M_RMDeviceCollection","M_RM_somDestruct");
    M_RMDeviceCollection_BeginDestructor;

    /*
     * local M_RMDeviceCollection deinitialization code added by programmer
     */

    if (somThis->hUSBMod) {
       DosFreeModule(somThis->hUSBMod);
       somThis->hUSBMod               = NULLHANDLE;
       somThis->UsbQueryNumberDevices = NULL;
       somThis->UsbQueryDeviceInfo    = NULL;
       somThis->UsbQueryDeviceReport  = NULL;
    } /* endif */

    M_RMDeviceCollection_EndDestructor;
}