关于Loki库的命令模式的简化版

最新推荐文章于 2024-04-30 15:51:33 发布
最新推荐文章于 2024-04-30 15:51:33 发布
阅读量758 收藏 1
点赞数
分类专栏： 软件工程 文章标签： class fun functor null cmd delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaodan007/article/details/7021632
版权 
/******************************************************************** 
 file name : Policy.h 
 author  :   Clark/陈泽丹 
 created :   2011-11-30
 工具包:
 *********************************************************************/ 


#ifndef __CLK_POLICY_H__
#define __CLK_POLICY_H__

#define TYPELIST_1(T1) \
	POLICY::Typelist<T1, ::POLICY::NullType>

#define TYPELIST_2(T1, T2) \
	POLICY::Typelist<T1, TYPELIST_1(T2) >

#define TYPELIST_3(T1, T2, T3) \
	POLICY::Typelist<T1, TYPELIST_2(T2, T3) >

#define TYPELIST_4(T1, T2, T3, T4) \
	POLICY::Typelist<T1, TYPELIST_3(T2, T3, T4) >

#define TYPELIST_5(T1, T2, T3, T4, T5) \
	POLICY::Typelist<T1, TYPELIST_4(T2, T3, T4, T5) >

#define TYPELIST_6(T1, T2, T3, T4, T5, T6) \
	POLICY::Typelist<T1, TYPELIST_5(T2, T3, T4, T5, T6) >

#define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
	POLICY::Typelist<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) >

#define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
	POLICY::Typelist<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >

#define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
	POLICY::Typelist<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >

#define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
	POLICY::Typelist<T1, TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >

#define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
	POLICY::Typelist<T1, TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >

#define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
	POLICY::Typelist<T1, TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) >

#define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
	POLICY::Typelist<T1, TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) >

#define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) \
	POLICY::Typelist<T1, TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) >

#define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) \
	POLICY::Typelist<T1, TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) >


namespace POLICY
{
	class NullType {};
	template <class T, class U>
	struct Typelist
	{
		typedef T Head;
		typedef U Tail;
	};

	//线程类_为多线程情况的扩展做准备
	class DEFAULT_THREADING{};

	//内存分配器_子类通过继承获得其new和delete功能
	template< class ThreadingModel = DEFAULT_THREADING>
	class SmallObject: public ThreadingModel
	{
	public:
		static void* operator new(unsigned int size)
		{
			++m_iCount;
			return ::operator new(size);
		}
		static void operator delete(void* p, unsigned int size)
		{
			--m_iCount;
			delete p;
		}
		static int GetCount(){ return m_iCount; }
		virtual ~SmallObject(){}
	private:
		static int m_iCount;
	};
	template<class ThreadingModel> 
	int SmallObject<ThreadingModel>::m_iCount = 0;

	namespace Private
	{
		//指令器
		template <class R>
		struct FunctorImplBase: public SmallObject<DEFAULT_THREADING> 
		{
			typedef R ResultType;
			typedef NullType Parm1;
			typedef NullType Parm2;
			typedef NullType Parm3;
			typedef NullType Parm4;
			typedef NullType Parm5;
			typedef NullType Parm6;
			typedef NullType Parm7;
			typedef NullType Parm8;
			typedef NullType Parm9;
			typedef NullType Parm10;
			typedef NullType Parm11;
			typedef NullType Parm12;
			typedef NullType Parm13;
			typedef NullType Parm14;
			typedef NullType Parm15;
			virtual ~FunctorImplBase(){}
		};

		template <class R, class TList>
		class FunctorImpl;

		template <class R>
		class FunctorImpl<R, NullType>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			virtual R operator()() = 0;
		};

		template <class R, class P1>
		class FunctorImpl<R, TYPELIST_1(P1)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			virtual R operator()(Parm1) = 0;
		};
		template <class R, class P1, class P2>
		class FunctorImpl<R, TYPELIST_2(P1, P2)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			virtual R operator()(Parm1, Parm2) = 0;
		};
		template <class R, class P1, class P2, class P3>
		class FunctorImpl<R, TYPELIST_3(P1, P2, P3)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			virtual R operator()(Parm1, Parm2, Parm3) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4>
		class FunctorImpl<R, TYPELIST_4(P1, P2, P3, P4) >: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4, class P5>
		class FunctorImpl<R, TYPELIST_5(P1, P2, P3, P4, P5)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,class P5, class P6>
		class FunctorImpl<R, TYPELIST_6(P1, P2, P3, P4, P5, P6)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7>
		class FunctorImpl<R, TYPELIST_7(P1, P2, P3, P4, P5, P6, P7)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8>
		class FunctorImpl<R, TYPELIST_8(P1, P2, P3, P4, P5, P6, P7, P8)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9>
		class FunctorImpl<R, TYPELIST_9(P1, P2, P3, P4, P5, P6, P7, P8, P9)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10>
		class FunctorImpl<R, TYPELIST_10(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10, class P11>
		class FunctorImpl<R,
			TYPELIST_11(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			typedef P11 Parm11;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10, Parm11) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10, class P11, class P12>
		class FunctorImpl<R,
			TYPELIST_12(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			typedef P11 Parm11;
			typedef P12 Parm12;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10, class P11, class P12, class P13>
		class FunctorImpl<R,
			TYPELIST_13(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			typedef P11 Parm11;
			typedef P12 Parm12;
			typedef P13 Parm13;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10, class P11, class P12, class P13, class P14>
		class FunctorImpl<R,
			TYPELIST_14(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
			P14)>
			: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			typedef P11 Parm11;
			typedef P12 Parm12;
			typedef P13 Parm13;
			typedef P14 Parm14;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0;
		};
		template <class R, class P1, class P2, class P3, class P4,
			class P5, class P6, class P7, class P8, class P9,
			class P10, class P11, class P12, class P13, class P14,
			class P15>
		class FunctorImpl<R,
			TYPELIST_15(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
			P14, P15)>
			: public FunctorImplBase<R>
		{
		public:
			typedef R ResultType;
			typedef P1 Parm1;
			typedef P2 Parm2;
			typedef P3 Parm3;
			typedef P4 Parm4;
			typedef P5 Parm5;
			typedef P6 Parm6;
			typedef P7 Parm7;
			typedef P8 Parm8;
			typedef P9 Parm9;
			typedef P10 Parm10;
			typedef P11 Parm11;
			typedef P12 Parm12;
			typedef P13 Parm13;
			typedef P14 Parm14;
			typedef P15 Parm15;
			virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, 
				Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14,
				Parm15) = 0;
		};


		//普通函数和仿函数的对外接口
		template <class Impl, class Fun>
		class FunctorHandler: public Impl
		{
		private:
			typedef typename Impl Base;
			typedef typename Base::ResultType ResultType;
			typedef typename Base::Parm1 Parm1;
			typedef typename Base::Parm2 Parm2;
			typedef typename Base::Parm3 Parm3;
			typedef typename Base::Parm4 Parm4;
			typedef typename Base::Parm5 Parm5;
			typedef typename Base::Parm6 Parm6;
			typedef typename Base::Parm7 Parm7;
			typedef typename Base::Parm8 Parm8;
			typedef typename Base::Parm9 Parm9;
			typedef typename Base::Parm10 Parm10;
			typedef typename Base::Parm11 Parm11;
			typedef typename Base::Parm12 Parm12;
			typedef typename Base::Parm13 Parm13;
			typedef typename Base::Parm14 Parm14;
			typedef typename Base::Parm15 Parm15;
			Fun m_fun;

		public:
			FunctorHandler(const Fun& fun) : m_fun(fun) {}
			ResultType operator()(){ return m_fun(); }
			ResultType operator()(Parm1 p1){ return m_fun(p1); }
			ResultType operator()(Parm1 p1, Parm2 p2){ return m_fun(p1, p2); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3){ return m_fun(p1, p2, p3); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4){ return m_fun(p1, p2, p3, p4); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5){ return m_fun(p1, p2, p3, p4, p5); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6){ return m_fun(p1, p2, p3, p4, p5, p6); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7){ return m_fun(p1, p2, p3, p4, p5, p6, p7); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13, Parm14 p14){return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);}
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15){ return m_fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);}
		};

		//成员函数的对外接口
		template <class Impl, class PointerToObj, class PointerToMemFn>
		class MemFunHandler : public Impl
		{
		private:
			typedef typename Impl Base;
			typedef typename Base::ResultType ResultType;
			typedef typename Base::Parm1 Parm1;
			typedef typename Base::Parm2 Parm2;
			typedef typename Base::Parm3 Parm3;
			typedef typename Base::Parm4 Parm4;
			typedef typename Base::Parm5 Parm5;
			typedef typename Base::Parm6 Parm6;
			typedef typename Base::Parm7 Parm7;
			typedef typename Base::Parm8 Parm8;
			typedef typename Base::Parm9 Parm9;
			typedef typename Base::Parm10 Parm10;
			typedef typename Base::Parm11 Parm11;
			typedef typename Base::Parm12 Parm12;
			typedef typename Base::Parm13 Parm13;
			typedef typename Base::Parm14 Parm14;
			typedef typename Base::Parm15 Parm15;
			PointerToObj m_pObj;
			PointerToMemFn m_pMemFn;

		public:
			MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn): m_pObj(pObj), m_pMemFn(pMemFn){}
			ResultType operator()(){ return ((*m_pObj).*m_pMemFn)(); }
			ResultType operator()(Parm1 p1){ return ((*m_pObj).*m_pMemFn)(p1); }
			ResultType operator()(Parm1 p1, Parm2 p2){ return ((*m_pObj).*m_pMemFn)(p1, p2); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11){return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);}
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12){ return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);}
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13){return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);}
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13, Parm14 p14){return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);}
			ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15){return ((*m_pObj).*m_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);}
		};
	}

	//指令封装
	//将普通函数，仿函数和成员函数的对外接口整合在一起
	template <class R, class TList = NullType>
	class Functor
	{
	private:
		typedef Private::FunctorImpl<R, TList> Impl;
		typedef R ResultType;
		typedef TList ParmList;
		typedef typename Impl::Parm1 Parm1;
		typedef typename Impl::Parm2 Parm2;
		typedef typename Impl::Parm3 Parm3;
		typedef typename Impl::Parm4 Parm4;
		typedef typename Impl::Parm5 Parm5;
		typedef typename Impl::Parm6 Parm6;
		typedef typename Impl::Parm7 Parm7;
		typedef typename Impl::Parm8 Parm8;
		typedef typename Impl::Parm9 Parm9;
		typedef typename Impl::Parm10 Parm10;
		typedef typename Impl::Parm11 Parm11;
		typedef typename Impl::Parm12 Parm12;
		typedef typename Impl::Parm13 Parm13;
		typedef typename Impl::Parm14 Parm14;
		typedef typename Impl::Parm15 Parm15;

		Impl* m_spImpl;
		//不提供拷贝构造
		Functor(const Functor& other){}
		//不提供赋值语句
		Functor& operator=(const Functor& other){}

	public:
		template <class Fun>
		Functor(Fun fun):m_spImpl(NULL)
		{
			m_spImpl = new Private::FunctorHandler<Impl, Fun>(fun);
			if( NULL == m_spImpl){ /*Log语句*/ }
		}
		template <class PtrObj, class MemFn>
		Functor(const PtrObj& p, MemFn memFn):m_spImpl(NULL)
		{
			m_spImpl = new Private::MemFunHandler<Impl, PtrObj, MemFn>(p, memFn);
			if( NULL == m_spImpl){ /*Log语句*/ }
		}
		virtual ~Functor()
		{ 
			if( NULL != m_spImpl) 
			{ 
				delete m_spImpl; 
				m_spImpl = NULL; 
			} 
		}
		ResultType operator()(){ return (*m_spImpl)(); }
		ResultType operator()(Parm1 p1){ return (*m_spImpl)(p1); }
		ResultType operator()(Parm1 p1, Parm2 p2){ return (*m_spImpl)(p1, p2); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3){ return (*m_spImpl)(p1, p2, p3); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4){ return (*m_spImpl)(p1, p2, p3, p4); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5){ return (*m_spImpl)(p1, p2, p3, p4, p5); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);}
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,p12, p13);}
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);}
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15){ return (*m_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);}
	};

	//回滚操作
	//回滚的触发条件：本个体操作已成功执行，但群体操作未成功,导致本个体操作回滚
	/*
	使用：
	TOOL::Rall<void> r2; DataBase db;
	if( db.doDB(true)) 
	r2.SetRall(&db,&DataBase::UndoDB);
	else return;

	TOOL::Rall<void> r1;
	if( doFun(true)) 
	r1.SetRall(UndoFun);
	else return;

	r1.OK();
	r2.OK();
	*/
	template <class R>
	class Rall
	{
	public:
		Rall():cmd(NULL),m_bIsOK(false){}
		~Rall()
		{
			if( NULL != cmd)
			{
				if( !m_bIsOK )
				{ 
					(*cmd)();
				}
				delete cmd;
				cmd = NULL;
			}
		}

		template <class Fun>
		void SetRall(Fun fun)
		{ 
			if( NULL != cmd){ delete cmd; cmd = NULL; }
			cmd = new Functor<R>(fun); 
		}
		template <class PtrObj, class MemFn>
		void SetRall(const PtrObj& p, MemFn memFn)
		{
			if( NULL != cmd){ delete cmd; cmd = NULL; }
			cmd = new Functor<R>(p, memFn);
		}
		void OK(){ m_bIsOK = true; }
	private:
		bool m_bIsOK;
		Functor<R>* cmd;
	};
}

#endif //__CLK_POLICY_H__


 

xiaodan007
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
apscheduler三种定时触发方式
sdsdvsdvs的博客
03-05 657
day_of_week (int|str) – number or name of weekday (0-6 or mon,tue,wed,thu,fri,sat,sun) - （表示一周中的第几天，既可以用0-6表示也可以用其英语缩写表示）# week (int|str) – ISO week (1-53) -（格里历2006年12月31日可以写成2006年-W52-7（扩展形式）或2006W527（紧凑形式））# start_date (datetime|str) – 开始日期。
轻量级日志管理系统-loki 简单部署
wx__wx的博客
04-26 1848
使用grafana开发的loki工具，10分钟手动搭建一个轻量级日志管理系统
定时触发器
xiaodan007的专栏
11-08 1818
--[[ file name : 技能模块第一版 author : Clark/陈泽丹 created : 2012-11-07 purpose : --]] module("程序", package.seeall) PACK_GameAPI = require"系统接口" --时间触发器管理者 function new_timer_manager(
Java—Loki日志收集
最新发布
ClancyLv的博客
04-30 713
Loki 是一个受 Prometheus 启发的水平可扩展、高度可用的多租户日志聚合系统。它的设计非常具有成本效益且易于操作。它不索引日志的内容，而是为每个日志流编制一组标签。。
mysql触发器如果某个字段被修改_Mysql event时间触发器，实现定时修改某些符合某一条件的某一字段...
weixin_42471237的博客
01-18 1302
我最近做项目遇到一个问题就是数据库的的订单需要定时检查自己的订单状态，如果到了endtime字段的时间订单状态还是2，就将订单状态修改为4在网上找到类似的解决方法。定时的关键是要结合MySQL的某些时间函数。如下文：mysql可以实现定时触发功能，比如说定于某某时间mysql数据库做什么工作，或每隔多长时间做什么工作。第二种情况应用还是比较广的，比如说我希望每天检查一下我的数据信息，超过一个月的无...
嵌入式计算机系统设计第二次实验报告
qq_49327751的博客
03-16 6407
实验题目：STC-BSP 余下API函数及综合运用 实验时间：2022.3.7（第3周周一）～2022.3.20（第4周周日） 实验地点：在规定时间中自主寻找合适实验地点并在规定时间内完成 实验条件： 1.STC-B学习板（2021暑假小学期每个学生自己做的） 2.个人电脑：自备 3.Keil、ISP、CH340驱动软件：自备 4.STC-BSP及Demo 程序：教师提供 5.“STC_B学习板”软件支持包使用说明：教师提供 6.C51语言语法：课程提供参考电子书籍，或自找自学 7.Demo1～Demo5源
Loki库源码(泛型模式C++库)
09-14
Loki is the name of a C++ software library written by Andrei Alexandrescu as part of his book Modern C++ Design. 　The library makes extensive use of C++ template metaprogramming and implements ...
loki 库 源码 策略设计模式
12-21
《洛基库（Loki）源码解析：策略设计模式的深度探究》 洛基库（Loki）是一个由C++编程语言实现的开源库，它以其强大的模板设计能力而闻名，尤其在策略设计模式的应用上表现突出。该库不仅为开发者提供了多种实用的...
LOKI库文件
02-14
大师之作。美德作品。
loki库v0.1.6
12-13
Loki是由Andrei编写的一个与《Modern C++ Design》（C++设计新思维）一书配套发行的C++代码库。 它不仅把C++模板的功能发挥到了极致，而且把类似设计模式这样思想层面的东西通过库来提供。
stl和loki库
02-16
Loki库是另一款C++的库，由Sutter创建，它扩展了STL的功能，特别是对于智能指针、安全的多线程编程、工厂模式和单例模式等设计模式的实现。Loki库包含以下模块： 1. `SmartPtr`：提供各种类型的智能指针，如`...
定时任务（在选定的时间点触发）
10-16
在规定好的$(function(){ $(".orderEdits").hide(); setInterval(orderTimer, 1000);//倒计时为1000为1秒间隔，每秒倒计时，动态秒数 orderTimer(); });时间点触发
Loki安装部署
YIYIYI
11-30 3796
Loki安装部署
日志之Loki详细讲解
上善若泪
01-30 2153
下、创建的端口号是3100，就需要填写为http://loki:3100，这里为什么不写IP地址而写成服务的名字，是因为在k8s集群里面有个dns服务器会自动解析这个地址。另外也可以用上面提到的其他日志收集工具来收取，这篇文章在结尾处会附上其他工具的配置方式。改为1，是因为这个设置不正确造成的。收集起来的日志信息对于业务来说是至关重要的，因此需要在容器重启的时候日志能够保留下来。如果是裸机部署的情况下，需要对上面的配置文件做一下稍微的改动，更改。从上面的图中我们可以看到，它在解析日志的时候是以。
JAVA 定时任务实现方式
qq_41482600的博客
07-29 7104
定时任务
loki+promtail+rsyslog+gafana日志收集
weixin_43741408的博客
07-17 1584
是日志文件的名字，表示主机名+发送源主机IP；514为rsyslog 日志接收端口）pormtail需要对这些日志文件有读取、写入权限，以便传递至loki。配置Grafana（添加数据源、导入数据）配置交换机、防火墙 发送日志到Loki。再查看此套日志系统性能占用率（很轻量级）关闭防火墙、selinux。配置Promtail。
mysql 定时触发器
彦彦专栏
07-29 8286
mysql可以实现定时触发功能，比如说定于某某时间mysql数据库做什么工作，或每隔多长时间做什么工作。 第二种情况应用还是比较广的，比如说我希望每天检查一下我的数据信息，超过一个月的无用信息清除以腾出空间供其他存储数据使用；或者相隔一段时间更新一下数据等等。 下面讨论下这种情况，给出一个例子供大家参考： 1.首先定义一个存储过程取名为e_test，注意竖线（“|”）一定不能丢 DELIM
java定时触发器_【引用】Java定时触发器
weixin_39870664的博客
03-08 245
首先添加所需要的类包：quartz-1.5.2.jar，quartz-all-1.5.2.jar，quartz-jboss-1.5.2.jar//设置定时作业public void startScheduler(HttpServletRequest requests)throws SchedulerException{try{//建立作业调度器Scheduler scheduler = StdSc...
loki使用超详细说明
热门推荐
李文良的博客
10-08 6万+
前言：小伙伴们是用什么看日志的呢？我是用的loki，今天我跟大家分享下loki的使用，喜欢的话一键三连点收藏哦！ loki使用超详细说明一、loki简介二、Loki 使用三、Loki语法说明四、Loki错误信息查看五、范围查询六、集合运算七、Loki Url 表达式编写八、Loki api使用 一、loki简介 Loki是 Grafana Labs 团队最新的开源项目，是一个水平可扩展，高可用性，多租户的日志聚合系统。它的设计非常经济高效且易于操作，因为它不会为日志内容编制索引，而是为每个日志流编制一组标签
现代C++设计新突破：模板技巧与Loki库探索
第二部分（第2篇）则深入介绍了Loki库的设计与实现，这是作者精心构造的一套实用工具集合。其中包括小型对象分配（Small-Object Allocation）、泛化函数（Generalization Functors）、单例模式（Singleton）、智能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值