COM原理与实现之一

COM原理与实现之一

COM组件其实是一种特殊的对象体系，遵循一个统一的标准，使到各个软件都可以通过某种方法访问这个对象的方法，也就可以做到组件调用。COM就是统一的标准——通过接口来调用COM组件。接口是COM组件能被外界所感知的唯一的东西。 

所有接口的接口都继承自IUnknown，实现了“接口查询”和“引用计数”。包含3个方法：

interface IUnknown
{
virtual HRESULT _stdcall QueryInterface([in]REFIID iid, [out] void **ppv)=0;
virtual ULONG _stdcall AddRef(void)=0;
virtual ULONG _stdcall Release(void)=0;
}QueryInterface负责得到该组件的其他接口的指针。
AddRef/Release负责管理该组件的生存期——引用计数+1/-1。

我实现的跨平台COM，也定义了类似IUnknown的接口，我称之为：IUniversal，定义如下：
/**
* IUniversal.h
* IUniversal is a variant from IUnknown
*
* Refer:
* <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef IUNIVERSAL_H
#define IUNIVERSAL_H

#include "Platform.h"

#define iid_IUniversal ((iid_t)(-1))

interface IUniversal
{
static const iid_t IID = ((iid_t) (-1));

virtual lresult_t query(iid_t iid, void **ppvOut) = 0;
virtual unsigned long retain(void) = 0;
virtual unsigned long release(void) = 0;
};

class UniversalImpl
{
private:

refcount_t _refc;

public:
UniversalImpl() : _refc(1) {
}

virtual ~UniversalImpl() {
}

//
// IUniversal
//
virtual lresult_t query(iid_t iid, void **ppv) = 0;

virtual unsigned long retain(void) {
return __interlock_inc(&_refc);
}

virtual unsigned long release(void) {
if (__interlock_dec(&_refc) == 0) {
delete this;
return 0;
}
return _refc;
}
};

#endif /* IUNIVERSAL_H */
其中Platform.h 定义如下：
/**
* Platform.h
*
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef PLATFORM_H
#define PLATFORM_H

#if defined _MSC_VER || WIN32
#ifndef OS_PLATFORM_WIN
#define OS_PLATFORM_WIN
#endif
#endif

#ifdef OS_PLATFORM_WIN
#include <windows.h>
#include <process.h>
#else
#include <pthread.h>
#include <unistd.h>
#endif

#ifndef interface
#define interface struct
#endif

/**
* interface iid
*/
typedef unsigned int iid_t;

/**
* long result
*/
typedef long lresult_t;

#define lres_success 0
#define lres_error (-1)
#define lres_e_outmemory (-4)
#define lres_e_nointerface (-11)

/**
* ref count type
*/
#ifdef OS_PLATFORM_WIN
typedef volatile unsigned long refcount_t;
#define __interlock_inc(add) InterlockedIncrement(add)
#define __interlock_dec(sub) InterlockedDecrement(sub)
#else
typedef volatile size_t refcount_t;
#define __interlock_inc(add) __sync_add_and_fetch(add, 1)
#define __interlock_dec(sub) __sync_sub_and_fetch(sub, 1)
#endif

#endif /* PLATFORM_H */
任何一个C++对象想要成为COM，必须从IUniversal继承，并且由于 UniversalImpl 实现了一个默认的 IUniversal，所以可以直接从UniversalImpl继承过来。
例如我们定义下面一个组件Entity，其接口定义如下：
interface EntityInterface : IUniversal
{
static const iid_t IID = ((iid_t) 0x00F001);

virtual void addComponent(AbstractComponent * component) = 0;

virtual void removeComponent(AbstractComponent * component) = 0;

virtual void removeAllComponents() = 0;
};
组件 Entity 的实现如下：
/**
* Entity.h
*
* Refer:
* http://www.richardlord.net/blog/what-is-an-entity-framework * http://blog.csdn.net/i_dovelemon/article/details/30250049 * http://blog.csdn.net/zhao_92221/article/details/46629553 * http://blog.csdn.net/ubuntu64fan/article/details/8839778 *
* Init Created: 2016-05-30
* Last Updated: 2016-06-08
*/
#ifndef ENTITY_H
#define ENTITY_H

#include "../EntityInterface.h"

#include "../ComponentManager.h"

#include <stdio.h>
#include <assert.h>

#include "../../../common/hashmap.h"
#include "../../../common/dhlist.h"

#include <memory>
#include <vector>
using namespace std;

namespace ecs {

class EntityManager;

class Entity :
public UniversalImpl,
public EntityInterface
{
friend class EntityManager;

static const int COMPS_HASHSIZE = 0x10;

Entity() {
printf("Entity\n");

INIT_LIST_HEAD(&list1_comps);

for (int hash = 0; hash <= COMPS_HASHSIZE; hash++) {
INIT_HLIST_HEAD(&hlist_comps[hash]);
}
}

public:

virtual ~Entity() {
printf("~Entity\n");

removeAllComponents();
}

public:

// Create function
//
static lresult_t createInstance(EntityInterface **ppv) {
EntityInterface * p = (EntityInterface *) new Entity();
if (p) {
*ppv = p;
return lres_success;
} else {
*ppv = 0;
return lres_e_outmemory;
}
}

// IUniversal
//
virtual lresult_t query(iid_t iid, void **ppv) {
if (iid == IUniversal::IID || iid == EntityInterface::IID) {
*ppv = static_cast<EntityInterface *> (this);
} else {
*ppv = 0;
return lres_e_nointerface;
}
reinterpret_cast<IUniversal*>(*ppv)->retain();
return lres_success;
}

virtual unsigned long retain(void) {
return UniversalImpl::retain();
}

virtual unsigned long release(void) {
return UniversalImpl::release();
}

// EntityInterface
//
virtual void addComponent(AbstractComponent * component) {
COMPONENT_TYPE compType = component->getComponentType();

list_add(&component->i_list, &list1_comps);
}

virtual void removeComponent(AbstractComponent * component) {

}

virtual void removeAllComponents() {
struct list_head *list, *node;

list_for_each_safe(list, node, &list1_comps) {
class AbstractComponent * p = list_entry(list, class AbstractComponent, i_list);
list_del(list);
delete (p);
}
}

private:

struct list_head i_list;
struct hlist_node i_hash;

/*
* components list and hlist
*/
struct list_head list1_comps;
struct hlist_head hlist_comps[COMPS_HASHSIZE + 1];
};

}; /* namespace ecs */

#endif /* ENTITY_H */
这样一个COM系统就初具雏形。使用的时候我们还需要一个智能指针对象，辅助我们使用组件对象。我定义这个智能接口指针如下：
/**
* SIPtr.h
* Smart Interface Pointer
*
* Use: SIPtr<IX, iidIX> spIX;
* Do not use with IUniversal; SIPtr<IUniversal, iidIUniversal>
* will not compile. Instead, use IUniversalSPtr.
*
* Refer:
* <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef SIPTR_H
#define SIPTR_H

#include "IUniversal.h"

#include <assert.h>

template <class T> class SIPtr
{
public:

// Constructors
SIPtr() {
m_pI = 0;
}

SIPtr(T* lp) {
m_pI = lp;
if ( m_pI ) {
m_pI->retain();
}
}

SIPtr(IUniversal* pI) {
m_pI = 0;
if ( pI ) {
pI->query(T::IID, (void **) & m_pI);
}
}

// Destructor
~SIPtr() {
release();
}

// Reset
void release() {
if ( m_pI ) {
T* pOld = m_pI;
m_pI = 0;
pOld->release();
}
}

// Attach to an existing interface (does not retain)
void attach(T * pI) {
if (m_pI != pI) {
IUniversal* pOld = m_pI;

m_pI = pI;

if (pOld) {
// Release the old interface
pOld->release();
}
}
}

// Detach the interface (does not release)
T* detach() {
T* pOld = m_pI;
m_pI = 0;
return pOld;
}

// Conversion
operator T*() {
return m_pI;
}

// Pointer operations
T& operator*() {
assert(m_pI);
return * m_pI;
}

T** operator&() {
assert(!m_pI);
return &m_pI;
}

T* operator->() {
assert(m_pI);
return m_pI;
}

// Assignment from the same interface
T* operator=(T* pI) {
if (m_pI != pI) {
// Save current value
IUniversal* pOld = (IUniversal *) m_pI;

// Assign new value
m_pI = pI;

if (m_pI) {
m_pI->retain();
}

if (pOld) {
// Release the old interface
pOld->release();
}
}
return m_pI;
}

// Assignment from another interface
T* operator=(IUniversal* pI) {
// Save current value
IUniversal* pOld = m_pI;
m_pI = 0;

// Query for correct interface
if ( pI ) {
lresult_t hr = pI->query(T::iid_interface, (void**) & m_pI);
assert(hr == lres_success && m_pI);
}

if ( pOld ) {
// Release old pointer
pOld->release();
}
return m_pI ;
}

// bool functions
bool operator!() {
return m_pI ? false : true;
}

// Requires a compiler that supports BOOL
operator bool() const {
return m_pI ? true : false;
}

// Interface ID
iid_t iid() {
return T::IID;
}

private:
// Pointer variable
T* m_pI;
};

/**
* IUniversalPtr is a smart interface for IUniversal
*/
class IUniversalPtr
{
public:
// Constructors
IUniversalPtr() {
m_pI = 0;
}

IUniversalPtr(IUniversal* lp) {
m_pI = lp;
if ( m_pI ) {
m_pI->retain();
}
}

// Destructor
~IUniversalPtr() {
release();
}

// Reset
void release() {
if (m_pI) {
IUniversal* pOld = m_pI;
m_pI = 0;
pOld->release();
}
}

// Conversion
operator IUniversal*() {
return (IUniversal*) m_pI;
}

// Pointer operations
IUniversal& operator*() {
assert(m_pI);
return *m_pI;
}

IUniversal** operator&() {
assert(!m_pI);
return &m_pI;
}

IUniversal* operator->() {
assert(m_pI);
return m_pI;
}

// Assignment
IUniversal* operator=(IUniversal* pI) {
if (m_pI != pI) {
// Save current value
IUniversal* pOld = m_pI;

// Assign new value
m_pI = pI;

if ( m_pI ) {
m_pI->retain();
}

if ( pOld ) {
// Release the old interface
pOld->release();
}
}
return m_pI;
}

// Boolean functions
bool operator!() {
return m_pI ? false : true;
}

operator bool() const {
return m_pI ? true : false;
}

private:
// Pointer variable
IUniversal* m_pI;
};

#endif /* SIPTR_H */

使用 Entity 很简单：
void testEntityInterface()
{
SIPtr<EntityInterface>spEntity;

Entity::createInstance(&spEntity);

spEntity->addComponent(...);
}