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

 

6.对象工厂基类

  //MyObjectFactoryBase.h
#pragma once

#include "MyCreateObjectFunction.h"

#include 
#include 
#include 

//
//关于对象工厂,参考上面给出的文章,写得很不错,关于泛化对象工厂的原理阐述的很清晰.
//泛化对象工厂: http://blog.csdn.net/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			Pointer;
	typedef MySmartPointer		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 GetRegisteredFactories();
	virtual const char* GetDescription(void) const = 0; //描述该对象工厂

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

	/////////////////////////////
	//m_EnabledFlag:用来控制使用哪一个版本的类来创建对象, 以达到动态替换的目标
	virtual std::list 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* m_RegisteredFactories; 
};

7.Helper 类

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

//MyObjectFactory:
//是一个帮助类(a helper class), 实现 Create() 方法, 用于创建一个对象实例.
//对象工厂允许在运行时进行替换.
//对象工厂通过运行时类型识别 RTTI 实现.
template 
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(ret.GetPointer());
	}
};
 

 

8.临界区类实现

  //MyFastMutexLock.h
#pragma once

//不同的平台需要定义不同的类型,这里只给出 windows32 例子
//不同平台在处理时有相应的优化策略, 以保证操作的原子性.
#if defined(_WIN32)
	#include "Windows.h"
	#include 
	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        Pointer;		//包装为智能指针
	typedef MySmartPointer  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(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 
#include 
#include 
#include 
#include