⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 functor.h

📁 loki库的源代码。loki库是以模板技术和面向对象技术为基础的c++类库。
💻 H
📖 第 1 页 / 共 5 页
字号:
🔍
12345 

		FunctorBase(const FunctorBase& rhs) 
			: spImpl_(Impl::Clone(rhs.spImpl_.get()))
        {}
		
		// Ctor for user defined impl-classes
		FunctorBase(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl)
        {}

		template <class PtrObj, typename MemFn, class MyFunctor>
		FunctorBase(const PtrObj& p, MemFn memFn, Loki::Type2Type<MyFunctor>)
        : spImpl_(new MemFunHandler<MyFunctor, PtrObj, MemFn>(p, memFn))
        {}

		ResultType operator()()
        { return (*spImpl_)(); }

		ResultType operator()(Parm1 p1)
        { return (*spImpl_)(p1); }
        
        ResultType operator()(Parm1 p1, Parm2 p2)
        { return (*spImpl_)(p1, p2); }
        
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
        { return (*spImpl_)(p1, p2, p3); }

        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
        { return (*spImpl_)(p1, p2, p3, p4); }
        
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
        { return (*spImpl_)(p1, p2, p3, p4, p5); }
        
        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6)
        { return (*spImpl_)(p1, p2, p3, p4, p5, p6); }
        
        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7)
        { return (*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 (*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 (*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 (*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 (*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 (*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 (*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 (*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 (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
                p12, p13, p14, p15);
        }	
		protected:
			std::auto_ptr<Impl> spImpl_;
			~FunctorBase() {}
	};

	// implementation class for Functor with return type = void
	template <class Impl>
	class FunctorVoidBase
	{
		typedef void ResultType;
	public:
		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;

		FunctorVoidBase() : spImpl_() {}
		
		template <class Fun, class MyFunctor>
		FunctorVoidBase(const Fun& fun, Loki::Type2Type<MyFunctor>) 
			: spImpl_(new FunctorHandler<MyFunctor, Fun>(fun))
		{}

		FunctorVoidBase(const FunctorVoidBase& rhs) 
			: spImpl_(Impl::Clone(rhs.spImpl_.get()))
        {}
		
		// Ctor for user defined impl-classes
		FunctorVoidBase(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl)
        {}

		template <class PtrObj, typename MemFn, class MyFunctor>
		FunctorVoidBase(const PtrObj& p, MemFn memFn, Loki::Type2Type<MyFunctor>)
        : spImpl_(new MemFunHandler<MyFunctor, PtrObj, MemFn>(p, memFn))
        {}
		
		
		ResultType operator()()
        { (*spImpl_)(); }

		ResultType operator()(Parm1 p1)
        { (*spImpl_)(p1); }
        
        ResultType operator()(Parm1 p1, Parm2 p2)
        { (*spImpl_)(p1, p2); }
        
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
        { (*spImpl_)(p1, p2, p3); }

        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
        { (*spImpl_)(p1, p2, p3, p4); }
        
		ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
        { (*spImpl_)(p1, p2, p3, p4, p5); }
        
        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6)
        { (*spImpl_)(p1, p2, p3, p4, p5, p6); }
        
        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7)
        { (*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)
        { (*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)
        { (*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)
        { (*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)
        { (*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)
        {
            (*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)
        {
            (*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)
        {
            (*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)
        {
            (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
                p12, p13, p14, p15);
        }	
		protected:
			std::auto_ptr<Impl> spImpl_;
			~FunctorVoidBase() {}
	};
}


////////////////////////////////////////////////////////////////////////////////
// class template Functor
// A generalized functor implementation with value semantics
////////////////////////////////////////////////////////////////////////////////
    template<typename R, class TList = NullType,
			class ThreadingModel = DEFAULT_THREADING>
	class Functor : public Select<
						IsEqualType<R, void>::value,
						Private::FunctorVoidBase<FunctorImpl<R, TList, ThreadingModel> >,
						Private::FunctorBase<R, FunctorImpl<R, TList, ThreadingModel> >
						>::Result
    {
    typedef typename Select<
			IsEqualType<R, void>::value,
			Private::FunctorVoidBase<FunctorImpl<R, TList, ThreadingModel> >,
			Private::FunctorBase<R, FunctorImpl<R, TList, ThreadingModel> >
			>::Result ImplBase;
	public:
        
		// Handy type definitions for the body type
        typedef FunctorImpl<R, TList, ThreadingModel> Impl;
        typedef R               ResultType;
        typedef TList           ParmList;
        typedef ThreadingModel	ThreadModel;
        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;
	public:
        
		// Member functions
		Functor() : ImplBase()
        {}
		        
		// we can't use loki's original ctor with VC 6 because
		// this compiler will not recognize the copy-ctor 
		// if this template-ctor is present.
		//template <typename Fun>
        //Functor(Fun fun)
        //: spImpl_(new FunctorHandler<Functor, Fun>(fun))
        //{}
		// The Loki::Disambiguate parameters makes this ctor distingushable
		// from the copy-ctor. 
		template <class Fun>
		Functor(Fun fun, Loki::Disambiguate) 
			: ImplBase(fun, Type2Type<Functor>())
		{}

		Functor(const Functor& rhs) : ImplBase(rhs)
        {}
		
		// Ctor for user defined impl-classes
		Functor(std::auto_ptr<Impl> spImpl) : ImplBase(spImpl) 
        {}
		
		// ctors for functions with up to 15 arguments.
		template <class Ret>
		Functor(Ret (*p)()) : ImplBase(p, Type2Type<Functor>())
		{}
        
		template <class Ret, class A0>
		Functor(Ret (*p)(A0)) 
			: ImplBase(p, Type2Type<Functor>())
		{}

		template <class Ret, class A0, class A1>
		Functor(Ret (*p)(A0, A1)) 
			: ImplBase(p, Type2Type<Functor>())
		{}

		template <class Ret, class A0, class A1, class A2>
		Functor(Ret (*p)(A0, A1, A2)) 
			: ImplBase(p, Type2Type<Functor>())
		{}

		template <class Ret,
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -