comobjlib.h

VXWORKS源代码

/* comObjLib.h - template-based COM-object construction library (VxCOM) */

/* Copyright (c) 1999 Wind River Systems, Inc. */

/*

modification history
--------------------
02n,04oct01,dbs  add macros to export coclasses in shlibs
02m,24sep01,nel  SPR#70528. Fix memory leak in CComBSTR.
02l,31jul01,dbs  allow override of InternalAddRef/Release methods
02k,28jun01,dbs  use safe inc/dec funcs, remove VxMutex dependency
02j,21jun01,dbs  make use of VxMutex class
02i,09apr01,nel  SPR#65606. Correct minor formating errors.
02h,28feb01,nel  SPR#35792. Add more ATL defs to bring into line with T2.
02g,16aug00,nel  Add CComBSTR(char *) to CComStr to make MathDemo example work
                 under vxworks.
02f,30may00,nel  Add more variant support
02e,28feb00,nel  Remove VxComTrack dependency on hard coded idl stuff
02d,01feb00,nel  Added VxComTrack code and Fix for singleton operation
02c,15oct99,dbs  fix comments to refer to proper classnames
02b,18aug99,dbs  remove extraneous ptr-conversion operator in CComPtr
02a,13aug99,drm  Bux fix.
01z,13aug99,dbs  fix copy-ctor in CComPtr
01y,29jul99,aim  changed mutex types to void*
01x,28jul99,drm  Changing g_defaultServerPriority to g_defaultServerPriority.
01w,28jul99,dbs  remove PS_CLNT_ASSIGNED enum value
01v,26jul99,dbs  fix typo in COM_INTERFACE_ENTRY macros
01u,30jun99,dbs  add const operator-> to CComPtr
01t,28jun99,dbs  remove obsolete ptrAssign function
01s,04jun99,dbs  fix registry calls
01r,03jun99,dbs  remove comSyncLib and VxMutex class
01q,26may99,dbs  add further ATL compatibility
01p,20may99,dbs  move class-object functionality into CComCoClass
                 class so explicit template instantiation works
01o,04may99,dbs  check return value of alloc in CreateInstance
01n,03may99,drm  adding priority scheme support
01m,27apr99,dbs  add alloc helper funcs
01l,23apr99,dbs  make mutex publically available thru CComObject methods
01k,23apr99,dbs  improve QI implementation, remove virtualness,
                 enforce locking in CComObject class
01j,22apr99,dbs  remove potential leaks, remove extraneous debugging
                 code (will be replaced with official DEBUG-lib in
		 future), simplify locking strategy (we don't need to
		 provide a VxNoLock class at all).
01i,14apr99,dbs  put incr and decr methods into VxMutex class
01h,31mar99,dbs  add CComPtr and CComBSTR classes
01g,03feb99,dbs  use STDMETHOD macros
01f,20jan99,dbs  fix file names - vxcom becomes com
01e,11jan99,dbs  change classnames to be ATL compatible
01d,21dec98,dbs  changes for VXCOM
01c,15dec98,dbs  add singleton support
01b,11dec98,dbs  simplify registry
01a,17nov98,dbs  created

*/

/*

  DESCRIPTION:

  This file contains template classes for creating COM objects using
  multiple inheritance to implement multiple interfaces. Classes
  created with these templates feature class-factories, thread-safe
  reference counting, etc...

  They are source-level compatible with ATL, and use the same
  COM_MAP() style of interface mapping, although the implementation is
  somewhat different.
  */


#ifndef __INCcomObjLib_h__
#define __INCcomObjLib_h__

#include "comCoreLib.h"
#include "comLib.h"
#include <stdio.h>

#define DECLARE_CLASSFACTORY_SINGLETON() enum {singleton=1};

#define DECLARE_REGISTRY_RESOURCE(x)
#define DECLARE_REGISTRY(class, pid, vpid, nid, flags)

#ifndef VXDCOM_COMTRACK_LEVEL
#define VXDCOM_COMTRACK_LEVEL 0
#endif

#if (VXDCOM_COMTRACK_LEVEL == 0)
#define COMTRACK_ADD_CLS(c)
#define COMTRACK_ADD_IID(c) 
#define COMTRACK_UPDATE()
#else
#include "comShow.h"
#define COMTRACK_ADD_CLS(c) if (VxComTrack::theInstance()->addClassInstance ((void *)this, (char *)vxcomGUID2String (GetObjectCLSID ()), #c, m_dwRefCount, GetObjectCLSID ()) != NULL) _qi_impl (IID_IUnknown, NULL)
#define COMTRACK_ADD_IID(c) VxComTrack::theInstance()->addInterface ((void *)this, (char *)vxcomGUID2String (IID_##c), "IID_"#c, IID_##c)
#define COMTRACK_UPDATE() VxComTrack::theInstance()->updateClassInstance (this, m_dwRefCount)
#endif

//////////////////////////////////////////////////////////////////////////
//
// CComObjectRoot - the base class of all the VxDCOM classes. It
// provides basic IUnknown support, plus support for COM aggregation
// and reference-counting...
//

class CComObjectRoot
    {

  public:
    enum { singleton=0 };

    CComObjectRoot (IUnknown *punk=0)
      : m_dwRefCount (0),
	m_pUnkOuter (punk)
	{
	}

    virtual ~CComObjectRoot ()
	{
	}

    // IUnknown implementation support - these methods provide the
    // basis upon which the IUnknown methods are built...

    ULONG InternalAddRef ()
	{
        ULONG n = comSafeInc (&m_dwRefCount);
	return n;
	}

    ULONG InternalRelease ()
	{
        ULONG n = comSafeDec (&m_dwRefCount);

	COMTRACK_UPDATE ();

	if (n)
	    return n;

	// Must delete this object, so we temporarily set its
	// ref-count to 1 so we don't get circular destruction
	// chains...
	m_dwRefCount = 1;

	delete this;
	return 0;
	}
    
  protected:
    long		m_dwRefCount;	// reference-count
    IUnknown*		m_pUnkOuter;	// aggregating outer

    };

//////////////////////////////////////////////////////////////////////////
//
// CComClassFactory - implements IClassFactory to allow objects to
// be created at runtime...
//

template <class T> class CComClassFactory
    : public CComObjectRoot,
      public IClassFactory
    
    {

    enum { singleton_factory=T::singleton };
    
  public:

    CComClassFactory () {}
    
    // IUnknown implementation for class-factory

    ULONG STDMETHODCALLTYPE AddRef ()
        { return InternalAddRef (); }

    ULONG STDMETHODCALLTYPE Release ()
        { 
        ULONG result = InternalRelease ();
        return result;
        }

    HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void ** ppv)
	{
        if (! ppv)
            return E_POINTER;

        if ((riid == IID_IClassFactory) || (riid == IID_IUnknown))
            {
            *ppv = static_cast<IClassFactory*> (this);
            InternalAddRef ();
            return S_OK;
            }

	*ppv = 0;
        return E_NOINTERFACE;
        }


    // IClassFactory implementation
    HRESULT STDMETHODCALLTYPE CreateInstance
	(
	IUnknown*	pUnkOuter,
	REFIID		riid,
	void**		ppv
	);
        
    HRESULT STDMETHODCALLTYPE LockServer (BOOL bLock)
        { return S_OK; }

    };

//////////////////////////////////////////////////////////////////////////
//
// CComCoClass - represents the 'coclass' or component-object
// itself. The 'coclass' represents the whole object, not any
// particular one of its exposed interfaces, and is only required when
// an object/class must be 'externally' createable via
// CoCreateinstance(). Hence, the functions required by
// CComClassFactory and the registration mechanism are wrapped in this
// template-class. It should be mixed in with the user's class when
// this functionality is required.
//

template <class T, const CLSID* pclsid> class CComCoClass
    {
    typedef CComClassFactory<T> ClassFactory_t;

  public:

    static const CLSID& GetObjectCLSID () { return *pclsid; }
    
    // classObjectGet - gets the class' class-object (factory)...
    static HRESULT classObjectGet
	(
	REFCLSID	clsid,
	REFIID		iid,
	void**		ppv
	)
	
        {

	// Validate CLSID
	if (*pclsid != clsid)
	    return CLASS_E_CLASSNOTAVAILABLE;

	// Create new factory...	    
        ClassFactory_t* pCF = new ClassFactory_t;

	// Bump up CF ref count to 1
	pCF->AddRef ();

	// QI for requested interface - if successful it will leave
	// ref-count at 2, if not, then it will be 1 still...
	HRESULT hr = pCF->QueryInterface (iid, ppv);

	// release one reference - if QI failed this will destroy the
	// factory, but if successful will leave it around...
	pCF->Release ();
	
	return hr;
        }

    // classRegister - this function is used by the auto-registration
    // macro AUTOREGISTER_COCLASS to add the CLSID to the Registry
    static HRESULT classRegister 
        (
        VXDCOMPRIORITYSCHEME scheme, // priority scheme to use
        int priority		     // priority - not used by all schemes 
        )
	{
        int priorityToRegister;	// prio to register is determined by sheme

        switch (scheme)
            {
            case PS_DEFAULT:
                // Set priority to system default; ignore priority argument
                priorityToRegister = g_defaultServerPriority;
                break;
            
            case PS_SVR_ASSIGNED:
                // Set priority to given priority
                priorityToRegister = priority;
                break;

            case PS_CLNT_PROPAGATED:
                // Set priority to given priority for cases where the priority
                // is not provided by the client (as in Win32).  If the
                // provided priority is < 0, then use the default system
                // priority.
                if (priority < 0)
                    priorityToRegister = g_defaultServerPriority;
                else
                    {
                    if ((priority >=0) && (priority <=255))
                        priorityToRegister = priority;
                    else
                        priorityToRegister = g_defaultServerPriority;
                    }
                break;

            default:
                // Unknown or unsupported priority scheme.  Return an error.
                return E_UNEXPECTED;
                break;
            }

        // Register the structure against the CLSID
	return comClassRegister (*pclsid,
                                 CLSCTX_INPROC_SERVER,
                                 &classObjectGet,
                                 scheme,
                                 priorityToRegister);
        }

    };


//////////////////////////////////////////////////////////////////////////
//
// wotlQIHelper -- templated on the same implementation class as 
// CComObject, this function provides a type-safe way of invoking
// the class' _qi_impl() method.
//

template <class T>
HRESULT wotlQIHelper (T* pThis, REFIID riid, void** ppv)
    {
    return pThis->_qi_impl (riid, ppv);
    }

//////////////////////////////////////////////////////////////////////////
//
// CComObject - the main class for creating objects. The class 'T'
// must derive from CComObjectRoot (in order to gain an IUnknown
// implementation and other support functionality).
//

template <class T> class CComObject : public T
    {
  public:

    // CreateInstance() creates a single instance, no aggregation, no
    // specific COM interface...
    static HRESULT CreateInstance (CComObject<T>** pp);

    // CreateInstance - does the business of creating an instance of
    // the class, and finding the requested interface on it...
    static HRESULT CreateInstance
	(
	IUnknown*	punkOuter,
	REFIID		riid,
	void** 		ppv
	)
        {
	// Validate args
        if (!ppv)
            return E_POINTER;

	// Create an instance (refcount will be zero)
        CComObject* pObj = new CComObject;
	if (! pObj)
	    return E_OUTOFMEMORY;

	// preset return value in case we fail to QI
	*ppv = 0;

	// save aggregate IUnknown ptr
	pObj->m_pUnkOuter = punkOuter;

	// QI for desired interface - if it fails, we must get rid of
	// the recently-allocated instance before returning. If it
	// succeeds, returned interface-ptr will have one ref...
        HRESULT hr = pObj->_qi_impl (riid, ppv);
	if (FAILED (hr))
	    delete pObj;

	return hr;
        }
    
    // over-ride the base-class 'internal_qi' method so we can
    // implement QI via the COM_MAP macros...
    HRESULT internal_qi (REFIID riid, void** ppv)
	{
	return _qi_impl (riid, ppv);
	}

    // IUnknown implementation - these methods are used by each of the
    // multiply-inherited base interfaces as their own IUnknown
    // methods.
    
    ULONG STDMETHODCALLTYPE AddRef ()
	{
	if (m_pUnkOuter)
	    return m_pUnkOuter->AddRef ();
	return InternalAddRef ();
	}
    
    ULONG STDMETHODCALLTYPE Release ()
	{
	if (m_pUnkOuter)
	    return m_pUnkOuter->Release ();
        return InternalRelease ();
	}
    
    HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void ** ppv)
        {
	if (m_pUnkOuter)
	    return m_pUnkOuter->QueryInterface (riid, ppv);
	return wotlQIHelper<T> (this, riid, ppv);
	}

  private:
    static DWORD		m_dwRegToken;
    
    };

template <class T>
HRESULT CComObject<T>::CreateInstance (CComObject<T>** pp)
    {
    if (0 != pp)
        {
        *pp = new CComObject<T> ();
        if (0 != *pp)
            return S_OK;

        return E_OUTOFMEMORY;
        }

    return E_POINTER;
    }

template <class T> DWORD CComObject<T>::m_dwRegToken;

template <class T>
HRESULT CComClassFactory<T>::CreateInstance
    (
    IUnknown*		pUnkOuter,
    REFIID		riid,
    void**		ppv
    )
    {
    HRESULT		hr;
    static IUnknown*	m_punkTheInstance = 0;

    if (singleton_factory)
	{
	if (pUnkOuter)
	    return CLASS_E_NOAGGREGATION;
	
	if (! m_punkTheInstance)
	    {
	    hr = CComObject<T>::CreateInstance
		 (0, IID_IUnknown, (void**) &m_punkTheInstance);
	    if (FAILED (hr))
		return hr;
		// This is a singleton so we will never want to delete it, 
		// therefore we increment the ref count.
        AddRef ();
	    }

	return m_punkTheInstance->QueryInterface (riid, ppv);
	}
    
    return CComObject<T>::CreateInstance (pUnkOuter, riid, ppv);
    }


//////////////////////////////////////////////////////////////////////////
//
// CComPtr --  a smart-ptr class (like that of ATL) for holding COM
// interface pointers, and performing automatic ref-counting. We don't 
// provide the CComQIPtr class.
//