Simulated Com (ex 24a)

Windows NT Systems Programming: Spring 2000

[ Home | Syllabus | Course Notes | Assignments | Search]

Exercise 24a: simulated COM object

Description of desired object:

Spaceship object with a number of distinct "interfaces"
- Motion: is used to simulate motion in the spaceship
- Visual: used to display position of the spaceship
- OTHERS?: crew, life support,

Interfaces to spaceship component.

We will build this one by hand - as simulated COM object
Here is interface.h (relevant parts)

// here is the stuff that we really want
struct IMotion : public IUnknown
{
    IMotion() {  }
    virtual void Fly() = 0; // pure
    virtual int& GetPosition() = 0;
};

struct IVisual : public IUnknown
{
    IVisual() { }
    virtual void Display() = 0;
};

// here is the stuff needed for creating and managing components
struct IUnknown 
// manages component - returns interface vtables and controls lifetime
{
    IUnknown() {  }
    virtual BOOL QueryInterface(int nIid, void** ppvObj) = 0;
    virtual DWORD Release() = 0;
    virtual DWORD AddRef() = 0;
};

struct IClassFactory : public IUnknown
// used to create components
{
    IClassFactory( )  { }
    virtual BOOL CreateInstance(int nIid, void** ppvObj) = 0;
};

Client Program

#include "interface.h"


int main( ) // simulates OLE client program
{
    IUnknown* pUnk; // If you declare these void*, you lose type-safety
    IMotion* pMot;
    IVisual* pVis;
    IClassFactory* pClf; 
    
    GetClassObject(CLSID_CSpaceship, IID_IClassFactory,
                  (void**) &pClf); 

    pClf->CreateInstance(IID_IUnknown, (void**) &pUnk); 
    pUnk->QueryInterface(IID_IMotion, (void**) &pMot);  
    pMot->QueryInterface(IID_IVisual, (void**) &pVis); 
    
    // next three lines are the "real" program
    pMot->Fly(); // fly to next position
    int nPos = pMot->GetPosition();
    pVis->Display(); // and display spaceship

    pClf->Release(); // clean up
    pUnk->Release();
    pMot->Release();
    pVis->Release();
    return 0;
}

This creates the ClassFactory object for the component,
Used to create instances of the component as needed.
First argument is UUID of component, Second is UUID of desired interface
Returns vtable to class factory member functions
This is the "constructor" for the component, returns vtable to its IUnknown interface (every COM object has one)
Gets vtable to "motion" interface, next line gets vtable to Visual interface

Implementation Class Definition

class CSpaceship
{
private:
    int m_nPosition;
    int m_nAcceleration;
    int m_nColor;
public:
    CSpaceship() {   m_nPosition = 100;    m_nAcceleration = 101;   m_nColor = 102;  }
    ~CSpaceship( )      { }
    class XMotion : public IMotion // inherits interface class
// nested classes
    {
    public:
        XMotion( )      { }
        virtual void Fly();
        virtual int& GetPosition();
    } m_xMotion;
    
    class XVisual : public IVisual
    {
    public:
        XVisual( ) { }
        virtual void Display();
    } m_xVisual;

    friend class XVisual;  // These must be at the bottom!
    friend class XMotion;
};

Tracing the Client Program (GetClassObject)

Purpose: generate a classfactory object for creating Spaceship objects.
See previous notes on com servers and com registry

CSpaceshipFactory g_factory;

//----------simulates COM component ----------------------------------
// In real COM, this would be DllGetClassObject, which would be called
// whenever a client called CoGetClassObject    
    
BOOL GetClassObject(int nClsid, int nIid, void** ppvObj)
{
    ASSERT(nClsid == CLSID_CSpaceship);
    ASSERT((nIid == IID_IUnknown) || (nIid == IID_IClassFactory));
    return g_factory.ExternalQueryInterface(nIid, ppvObj);
    // refcount is 2, which prevents accidental deletion
}

BOOL CSpaceshipFactory::ExternalQueryInterface(int nIid,
                                               void** ppvObj) {
 switch (nIid) {
    case IID_IUnknown:
    case IID_IClassFactory:
      *ppvObj = &m_xClassFactory; 
      break;
    default:
      *ppvObj = NULL;
      return FALSE;
    }
    ExternalAddRef( );
    return TRUE;
}

Only works for the spaceship component (in reality need a classfactory for each component) which we get from DDL from the registry
Only works for IUnknown and the classfactory interfaces.
classfactory object already exists, in reality would have to create an instance of this object at this time.
call its queryinterface to return a pointer to the vtable
address of a vtable
add one to the reference count

CreateInstance

Purpose: to create an instance of the space ship object using the class factory object

BOOL CSpaceshipFactory::XClassFactory::CreateInstance(int nIid,
                                                      void** ppvObj) {
    CSpaceship* pObj = new CSpaceship(); 
    if (pObj->ExternalQueryInterface(nIid, ppvObj)) {
        pObj->ExternalRelease(); // balance reference count
        return TRUE;
    }
    return FALSE;
}

BOOL CSpaceship::ExternalQueryInterface(int nIid, void** ppvObj) {
    switch (nIid) {
    case IID_IUnknown:
    case IID_IMotion:
      *ppvObj = &m_xMotion; // Both IMotion and IVisual are derived
      break;                //  from IUnknown, so either pointer will do
    case IID_IVisual:
      *ppvObj = &m_xVisual;
      break;
    default:
      *ppvObj = NULL;
      return FALSE;
    }
    ExternalAddRef();
    return TRUE;
}

Nested scope resolution operators
Here is the "new" operator which we knew was hidden in here somewhere
get the vtable of the interface required.
IUnknown vtable is always the first three function pointers of any other interface's vtable

Releasing Components

DWORD ExternalRelease() {
        if (m_dwRef == 0)
          return 0;
        if(--m_dwRef == 0L) {
          delete this; // delete when reference count become 0
          return 0;
        }
        return m_dwRef;
    }