ITK 中的智能指针与对象工厂演示-2

 

6.对象工厂基类

  //MyObjectFactoryBase.h
#pragma once

#include "MyCreateObjectFunction.h"

#include <list>
#include <vector>
#include <string>

//
//关于对象工厂,参考上面给出的文章,写得很不错,关于泛化对象工厂的原理阐述的很清晰.
//泛化对象工厂: http://blog.youkuaiyun.com/azure1987/archive/2009/10/27/4732355.aspx
//

//一个 multimap, 用来存储识别对象工厂的信息,及其可以创建的对象的版本信息
class OverRideMap;

//
//MyObjectFactoryBase: 工厂基类, ITK 中几乎所有对象都是通过相应的对象工厂创建
//MyObjectFactoryBase 中包含一个静态方法 CreateInstance(), 该方法通过已注册的对象工厂创建对象
//第一次调用 CreateInstance(), ITK 环境变量路径中所有的 dll 或者 静态库都被加载到当前进程
//为了加载环境变量中的动态或静态库到当前进程, ITK 中又使用了其它库, 我将这部分省略掉
//
//1.对象工厂能够在运行时进行版本替换
//  在程序中通过变量 m_EnabledFlag 进行控制是否可能创建特定版本的对象实例.
//2.使用 multimap 存储识别对象工厂的信息, 这样一个对象工厂中可以有相同 key 的对象
//  我们在程序中演示了如何通过设置 m_EnabledFlag 创建不同版本的对象
//3.代码中的一些方法如 GetDescription 是用来输出对象工厂信息的
//  SetEnableFlag 等是用来控制创建对象的哪一个版本
//
class MyObjectFactoryBase : public MyObject
{
public:  
	typedef MyObjectFactoryBase				Self;
	typedef MyObject						Superclass;
	typedef MySmartPointer<Self>			Pointer;
	typedef MySmartPointer<const Self>		ConstPointer;

	//virtual const char* GetNameOfClass() const;
	MyTypeMacro(MyObjectFactoryBase, MyObject);

	//返回一个名为 classname 的类对象实例
	//每个被加载的 MyObjectFactoryBase 都会按环境变量中的顺序被询问
	//一旦有一个工厂成功创建对象并返回, 其余工厂便不再被询问.
	static MyObject::Pointer CreateInstance(const char* classname);

	/
	//注册/注销 对象工厂
	static void RegisterFactory(MyObjectFactoryBase* );
	static void UnRegisterFactory(MyObjectFactoryBase*);
	static void UnRegisterAllFactories();

	
	//返回包含所有已注册的对象工厂的链表
	static std::list<MyObjectFactoryBase*> GetRegisteredFactories();
	virtual const char* GetDescription(void) const = 0; //描述该对象工厂

	//描述对象工厂及其能够创建的对象
	virtual std::list<std::string> GetClassOverrideNames();
	virtual std::list<std::string> GetClassOverrideWithNames();
	virtual std::list<std::string> GetClassOverrideDescriptions();

	/
	//m_EnabledFlag:用来控制使用哪一个版本的类来创建对象, 以达到动态替换的目标
	virtual std::list<bool> GetEnableFlags();
	//设置/取得 指定版本类的 m_EnabledFlag 标志.
	virtual void SetEnableFlag(bool flag, 
		const char* className, const char* subclassName);
	virtual bool GetEnableFlag(const char* className, const char* subclassName);
	//Disable: 将使对象工厂不能创建该类的任何版本实例
	virtual void Disable(const char* className);

	//OverrideInformation: 工厂及对象的版本信息, 及是否可以创建
	struct OverrideInformation
	{
		std::string m_Description;			//类的描述
		std::string m_OverrideWithName;		//重载的版本
		bool m_EnabledFlag;					//指示是否可以创建该版本的对象实例.
		MyCreateObjectFunctionBase::Pointer m_CreateObject;
	};
protected:
	MyObjectFactoryBase();
	virtual ~MyObjectFactoryBase();

	//注册对象工厂, 以及其可以创建的对象版本的信息
	void RegisterOverride(
		const char* classOverride,
		const char* overrideClassName,
		const char* description,
		bool enableFlag,
		MyCreateObjectFunctionBase* createFunction);  //

	//对象工厂的子类实现 CreateObject 并返回创建的对象的指针，若不支持则返回 0
	virtual MyObject::Pointer CreateObject(const char* classname );
private:
	MyObjectFactoryBase(const Self&);
	void operator=(const Self&);

	static void Initialize();			//初始化

	//一个 multimap: 存储对象工厂及其可以创建的对象的版本信息
	OverRideMap* m_OverrideMap;

	//对象工厂列表, 包含指向已经注册的对象工厂的指针
	static std::list<MyObjectFactoryBase*>* m_RegisteredFactories; 
};
 

7.Helper 类

  //MyObjectFactory.h
#pragma once
#include "MyObjectFactoryBase.h"

//MyObjectFactory:
//是一个帮助类(a helper class), 实现 Create() 方法, 用于创建一个对象实例.
//对象工厂允许在运行时进行替换.
//对象工厂通过运行时类型识别 RTTI 实现.
template <class T>
class MyObjectFactory : public MyObjectFactoryBase
{
public:
	static typename T::Pointer Create()
	{
		MyObject::Pointer ret = MyObjectFactory::CreateInstance(typeid(T).name());

		//ObjectType *GetPointer () const { return m_Pointer; }
		//取得原始指针, 将其向下类型转换为 T*
		return dynamic_cast<T*>(ret.GetPointer());
	}
};
  

 

8.临界区类实现

  //MyFastMutexLock.h
#pragma once

//不同的平台需要定义不同的类型,这里只给出 windows32 例子
//不同平台在处理时有相应的优化策略, 以保证操作的原子性.
#if defined(_WIN32)
	#include "Windows.h"
	#include <winbase.h>
	typedef CRITICAL_SECTION FastMutexType;
#endif

//为了演示, 完全可以只使用 int 即可, 但无法提供真正的加锁功能
#ifndef _WIN32
	typedef int FastMutexType;	
#endif

//临界区锁类: 在修改临界值时, 对其加锁, 以保证修改的唯一原子性.
class MyFastMutexLock
{
public:
	typedef MyFastMutexLock   Self;

	//可以在栈上创建临界区对象, 所以将构造函数与析构函数设为 pubilc.
	MyFastMutexLock();
	~MyFastMutexLock();

	//Lock, 加锁, 使其它任何对象都不能修改被加锁的对象
	void Lock() const;

	//Unlock, 解锁
	void Unlock() const;

protected:
	mutable FastMutexType   m_FastMutexLock;
};
  

9.MyObject 类的方法实现

   //MyObject.h
#pragma once

#include "MyMacro.h"
#include "MyFastMutexLock.h"
#include "MySmartPointer.h"

#if defined(_WIN32)
  //To get LONG defined
  #include "Windows.h"
#endif

//MyObject 几乎是所有对象的基类, 实现引用计数功能, 
//代码基本来 ITK 中的 LightObject 类, LightObject 在 ITK 中是最顶层的类.
class MyObject
{
public:
	typedef MyObject					Self;
	typedef MySmartPointer<Self>        Pointer;		//包装为智能指针
	typedef MySmartPointer<const Self>  ConstPointer;

	//通过对象工厂创建对象的实例
	static Pointer New();

	//根据已存在的对象创建一新的对象实例，允许用户创建一个完全相同的对象
	//这在需要向上类型转换时非常有用***
	virtual Pointer CreateAnother() const;

	//使用 New() 的对象, 应该使用 Delete()
	//Delete() 会调用 UnRegister 减少引用计数
	//只有当该对象的引用计数减为 0 时才会真正删除对象
	virtual void Delete();

	//运行时类型识别, 返回某对象的具体类名.
	virtual const char *GetNameOfClass() const 
	{return "MyObject";}

	//Used to avoid dll boundary problems.
	void* operator new(size_t);
	void* operator new[](size_t);
	void operator delete(void*);
	void operator delete[](void*, size_t);

	//增加与减少引用计数
	virtual void Register() const;
	virtual void UnRegister() const;

	//返回该类对象实例的引用计数
	virtual int GetReferenceCount() const 
	{	return static_cast<int>(m_ReferenceCount);	}

	//设置该类对象的引用计数值.
	virtual void SetReferenceCount(int);

protected:
	MyObject() : m_ReferenceCount(1) {	}
	virtual ~MyObject(); 
		
	//不同的平台, 需要定义不同的类型, 这里只简单使用 int 型. 引用计数.
#if (defined(WIN32) || defined(_WIN32))
	typedef LONG InternalReferenceCountType;
#else
	typedef int InternalReferenceCountType;
#endif
	//引用计数
	mutable InternalReferenceCountType m_ReferenceCount;
	//mutable int	m_ReferenceCount;	

	//临界区锁, 用于对临界区变量加锁
	mutable MyFastMutexLock			m_ReferenceCountLock;
private:
	MyObject(const Self&);		         
	void operator=(const Self&); 
};
 

10.对象工厂基类实现

  #if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "MyObjectFactoryBase.h"

#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <algorithm>
#include <map>

//
//该类用于清除所有已经注册的对象工厂.
class CleanUpObjectFactory
{
public:
	inline void Use(){	}
	~CleanUpObjectFactory()
	{
		MyObjectFactoryBase::UnRegisterAllFactories();
	}  
};
//定义一全局静态变量, 在程序生命周期结束时析构, 用于注销所有对象工厂
static CleanUpObjectFactory CleanUpObjectFactoryGlobal;


//StringOverMap, 使用 typedef 进行类型定义, 避免出现名字过长的警告.
typedef std::multimap<std::string, 
MyObjectFactoryBase::OverrideInformation>  StringOverMapType;

//用于存储 <classID, facotoryInfo>
//classID     对象工厂的标识
//factoryInfo 该对象工厂的信息, 包含其可以创建的对象的所有版本信息
class OverRideMap : public StringOverMapType
{
};

/
//静态变量初始化, 已注册的对象工厂链表.
std::list<MyObjectFactoryBase*>* 
MyObjectFactoryBase::m_RegisteredFactories = 0;

//构造函数
MyObjectFactoryBase::MyObjectFactoryBase()
{
	m_OverrideMap = new OverRideMap;
}

//析构, 卸载已加载的对象工厂.
MyObjectFactoryBase::~MyObjectFactoryBase()
{
	m_OverrideMap->erase(m_OverrideMap->begin(), m_OverrideMap->end());
	delete m_OverrideMap;
}

//使用已注册的对象工厂创建类名为 classname 的对象实例.
MyObject::Pointer 
MyObjectFactoryBase::CreateInstance(const char* classname)
{
	if( !MyObjectFactoryBase::m_RegisteredFactories )
	{
		MyObjectFactoryBase::Initialize();
	}

	for( std::list<MyObjectFactoryBase*>::iterator 
		i = m_RegisteredFactories->begin();
		i != m_RegisteredFactories->end(); ++i )
	{
		//遍历已注册的对象列表, 如果某个对象工厂成功创建对象, 则返回
		MyObject::Pointer newobject = (*i)->CreateObject(classname);
		if(newobject)
		{
			newobject->Register();
			return newobject;
		}
	}
	return 0;
}

//初始化
void MyObjectFactoryBase::Initialize()
{
	//全局静态变量, 用于最后注销所有的对象工厂
	CleanUpObjectFactoryGlobal.Use();

	//已经初始化过了, 返回
	if( MyObjectFactoryBase::m_RegisteredFactories )
	{
		return;
	}

	MyObjectFactoryBase::m_RegisteredFactories =
		new std::list<MyObjectFactoryBase*>;
}

//注册对象工厂, 添加至链表中.
void MyObjectFactoryBase::RegisterFactory(MyObjectFactoryBase* factory)
{
	//先进行初始化，然后将该对象工厂加入到对象工厂链表中
	MyObjectFactoryBase::Initialize();
	MyObjectFactoryBase::m_RegisteredFactories->push_back(factory);
	factory->Register();
}

//清除已经清册的名为 factory 的对象工厂
void MyObjectFactoryBase::UnRegisterFactory(MyObjectFactoryBase* factory)
{ 
	if( !MyObjectFactoryBase::m_RegisteredFactories )
		return;

	for ( std::list<MyObjectFactoryBase*>::iterator 
		i = m_RegisteredFactories->begin();
		i != m_RegisteredFactories->end(); ++i )
	{
		if ( factory == *i )
		{
			factory->UnRegister();
			m_RegisteredFactories->remove(factory);
			return;
		}
	}
}

//清除所有已注册的对象工厂, 并删除对象工厂列表
void MyObjectFactoryBase::UnRegisterAllFactories()
{
	if ( MyObjectFactoryBase::m_RegisteredFactories )
	{
		for ( std::list<MyObjectFactoryBase*>::iterator
			f = m_RegisteredFactories->begin();
			f != m_RegisteredFactories->end(); ++f )
		{
			(*f)->UnRegister();
		}
		//删除对象工厂链表...
		delete MyObjectFactoryBase::m_RegisteredFactories;
		MyObjectFactoryBase::m_RegisteredFactories = 0;
	}
}

//返回包含所有已注册的对象工厂的链表...
std::list<MyObjectFactoryBase*> 
MyObjectFactoryBase::GetRegisteredFactories()
{
	return *MyObjectFactoryBase::m_RegisteredFactories;
}

///
//描述对象工厂及其能够创建的对象
std::list<std::string> 
MyObjectFactoryBase::GetClassOverrideNames()
{
	std::list<std::string> ret;
	for ( OverRideMap::iterator i = m_OverrideMap->begin();
		i != m_OverrideMap->end(); ++i )
	{
		ret.push_back((*i).first);
	}
	return ret;
}
std::list<std::string> 
MyObjectFactoryBase::GetClassOverrideWithNames()
{
	std::list<std::string> ret;
	for ( OverRideMap::iterator i = m_OverrideMap->begin();
		i != m_OverrideMap->end(); ++i )
	{
		ret.push_back((*i).second.m_OverrideWithName);
	}
	return ret;
}
std::list<std::string> 
MyObjectFactoryBase::GetClassOverrideDescriptions()
{ 
	std::list<std::string> ret;
	for ( OverRideMap::iterator i = m_OverrideMap->begin();
		i != m_OverrideMap->end(); ++i )
	{
		ret.push_back((*i).second.m_Description);
	}
	return ret;
}

//注册对象工厂, 以及其可以创建的对象的版本信息
void MyObjectFactoryBase::RegisterOverride(
	const char* classOverride,
	const char* subclass,
	const char* description,
	bool enableFlag,
	MyCreateObjectFunctionBase* createFunction)
{
	MyObjectFactoryBase::OverrideInformation info;

	info.m_Description		= description;
	info.m_OverrideWithName = subclass;			//具体的子类
	info.m_EnabledFlag		= enableFlag;		//是否使用该子类版本
	info.m_CreateObject		= createFunction;

	m_OverrideMap->insert(OverRideMap::value_type(classOverride, info));
}

//
MyObject::Pointer 
MyObjectFactoryBase::CreateObject(const char* classname)
{
	OverRideMap::iterator start = m_OverrideMap->lower_bound(classname);
	OverRideMap::iterator end = m_OverrideMap->upper_bound(classname);

	int m = 0;
	for ( OverRideMap::iterator i = start; i != end; ++i )
	{
		//(*i).second.m_EnabledFlag = true; 则使用该工厂创建该版本的对象实例
		if ( i != m_OverrideMap->end() && (*i).second.m_EnabledFlag)
		{
			//调用了 MyCreateObjectFunction::CreateObject();
			//MyCreateObjectFunction 是用于创建对象的回调函数
			return (*i).second.m_CreateObject->CreateObject();
		}
	}
	return 0;
}

///
//m_EnabledFlag: 控制对象工厂可以创建的对象版本
void MyObjectFactoryBase::SetEnableFlag(bool flag,
				const char* className,const char* subclassName)
{
	OverRideMap::iterator start = m_OverrideMap->lower_bound(className);
	OverRideMap::iterator end = m_OverrideMap->upper_bound(className);
	for ( OverRideMap::iterator i = start; i != end; ++i )
	{
		if ( (*i).second.m_OverrideWithName == subclassName )
		{
			(*i).second.m_EnabledFlag = flag;
		}
	}
}
bool MyObjectFactoryBase
::GetEnableFlag(const char* className, const char* subclassName)
{
	OverRideMap::iterator start = m_OverrideMap->lower_bound(className);
	OverRideMap::iterator end = m_OverrideMap->upper_bound(className);
	for ( OverRideMap::iterator i = start; i != end; ++i )
	{
		if ( (*i).second.m_OverrideWithName == subclassName )
		{
			return (*i).second.m_EnabledFlag;
		}
	}
	return 0;
}
void MyObjectFactoryBase::Disable(const char* className)
{
	OverRideMap::iterator start = m_OverrideMap->lower_bound(className);
	OverRideMap::iterator end = m_OverrideMap->upper_bound(className);
	for ( OverRideMap::iterator i = start; i != end; ++i )
	{
		(*i).second.m_EnabledFlag = 0;
	}
}
std::list<bool> 
MyObjectFactoryBase::GetEnableFlags()
{
	std::list<bool> ret;
	for( OverRideMap::iterator i = m_OverrideMap->begin();
		 i != m_OverrideMap->end(); ++i)
	{
		ret.push_back((*i).second.m_EnabledFlag);
	}
	return ret;
}