chxavcommand.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:7k
源码类别:

Symbian

开发平台:

C/C++

  1. /************************************************************************
  2.  * chxavcommand.h
  3.  * --------------
  4.  *
  5.  * Synopsis:
  6.  * abstract interface for command objects, CHXAvCommand
  7.  * concrete wrappers for calls to class member function:
  8.  * no-arg class member function object 
  9.  * one-arg class member function object
  10.  *
  11.  *  Example:
  12.  *
  13.  *  class Music
  14.  *  {
  15.  *  public:
  16.  * void SetEventAction(EventType type, const CHXAvCommand& cmd);
  17.  * ...
  18.  *  };
  19.  *
  20.  *  class Dancer
  21.  *  { ... };
  22.  *
  23.  *  void DoBreakDance() {...} // no args
  24.  *  void Bow(TInt count) {...} // one arg
  25.  *
  26.  *  void Dancer::Init(Music* pMusic)
  27.  *  {
  28.  * //
  29.  * // start break dancing when music begins,
  30.  * // bow three times when music ends
  31.  * //
  32.  * const CHXAvCommand& cmdStart = MakeCommand(this, &Dancer::DoBreakDance);
  33.  * const CHXAvCommand& cmdEnd = MakeCommand(this, &Dancer::Bow, 3);
  34.  * pMusic->SetEventAction(Music::OnBegin, cmdStart);
  35.  * pMusic->SetEventAction(Music::OnEnd, cmdEnd);
  36.  *  }
  37.  *
  38.  * 
  39.  * Target:
  40.  * Symbian OS
  41.  *
  42.  *
  43.  * (c) 1995-2003 RealNetworks, Inc. Patents pending. All rights reserved.
  44.  *
  45.  ************************************************************************/
  46. #ifndef _chxavcommand_h_
  47. #define _chxavcommand_h_
  48. // Includes from this project...
  49. #include "chxavrefptr.h"
  50. //
  51. // class CHXAvCommand_
  52. //
  53. // command base class
  54. template<typename ReturnType>
  55. class CHXAvCommand_ 
  56. {
  57. public:
  58.     virtual ReturnType Execute() = 0;
  59.     virtual CHXAvCommand_* CloneL() const = 0;
  60.     virtual ~CHXAvCommand_() {};
  61. };
  62. // class CHXAvCommand
  63. typedef CHXAvCommand_<void> CHXAvCommand;
  64. typedef refptr<CHXAvCommand> CHXAvCommandPtr;
  65. // class CHXAvBoolCommand
  66. typedef CHXAvCommand_<bool> CHXAvBoolCommand;
  67. typedef refptr<CHXAvBoolCommand> CHXAvBoolCommandPtr;
  68. //
  69. // class CHXAvCommand0_
  70. //
  71. // call to member func that takes no args, has a return val
  72. template< typename ClassType, typename ReturnType >
  73. class CHXAvCommand0_ : public CHXAvCommand_<ReturnType>
  74. {
  75. public:
  76.     typedef ReturnType (ClassType::*PCMFN)();
  77.     CHXAvCommand0_(ClassType* pObject, PCMFN pMethod) : m_pObject(pObject), m_pMethod(pMethod) {}
  78.     ReturnType Execute()
  79.     {
  80.         return (m_pObject->*m_pMethod)();
  81.     }
  82.     CHXAvCommand_<ReturnType>* CloneL() const 
  83.     {
  84.         return new (ELeave) CHXAvCommand0_(*this);
  85.     }
  86. private:
  87.     ClassType* m_pObject;
  88.     PCMFN m_pMethod;
  89. };
  90. //
  91. // class CHXAvCommand1_
  92. //
  93. // call to member func that takes one arg, has a return val
  94. template< typename ClassType, typename ReturnType, typename ArgType >
  95. class CHXAvCommand1_ : public CHXAvCommand_<ReturnType>
  96. {
  97. public:
  98.     typedef ReturnType (ClassType::*PCMFN)(ArgType arg);
  99.     CHXAvCommand1_(ClassType* pObject, PCMFN pMethod, ArgType arg) 
  100.     : m_pObject(pObject), m_pMethod(pMethod), m_arg(arg) {}
  101.     ReturnType Execute()
  102.     {
  103.         return (m_pObject->*m_pMethod)(m_arg);
  104.     }
  105.     CHXAvCommand_<ReturnType>* CloneL() const
  106.     {
  107.         return new (ELeave) CHXAvCommand1_(*this);
  108.     }
  109. private:
  110.     ClassType* m_pObject;
  111.     PCMFN m_pMethod;
  112.     ArgType m_arg;
  113. };
  114. //
  115. // class CHXAvCommand0
  116. //
  117. // call to member func that takes no args, no return val
  118. template< typename ClassType>
  119. class CHXAvCommand0 : public CHXAvCommand
  120. {
  121. public:
  122.     typedef void (ClassType::*PCMFN)();
  123.     CHXAvCommand0(ClassType* pObject, PCMFN pMethod) 
  124.         : m_pObject(pObject), m_pMethod(pMethod) {}
  125.     void Execute()
  126.     {
  127.         (m_pObject->*m_pMethod)();
  128.     }
  129.     CHXAvCommand* CloneL() const 
  130.     {
  131.         return new (ELeave) CHXAvCommand0(*this);
  132.     }
  133. private:
  134.     ClassType* m_pObject;
  135.     PCMFN m_pMethod;
  136. };
  137. //
  138. // class CHXAvCommand1
  139. //
  140. // call to member func that takes one arg, no return val
  141. template< typename ClassType, typename ArgType >
  142. class CHXAvCommand1 : public CHXAvCommand
  143. {
  144. public:
  145.     typedef void (ClassType::*PCMFN)(ArgType arg);
  146.     CHXAvCommand1(ClassType* pObject, PCMFN pMethod, ArgType arg) 
  147.     : m_pObject(pObject), m_pMethod(pMethod), m_arg(arg) {}
  148.     void Execute()
  149.     {
  150.         (m_pObject->*m_pMethod)(m_arg);
  151.     }
  152.     CHXAvCommand* CloneL() const
  153.     {
  154.         return new (ELeave) CHXAvCommand1(*this);
  155.     }
  156. private:
  157.     ClassType* m_pObject;
  158.     PCMFN m_pMethod;
  159.     ArgType m_arg;
  160. };
  161. //
  162. // convenience helpers
  163. //
  164. // these save a few keystrokes (so you don't have to explicity
  165. // type out template args) and enhance readability
  166. //
  167. // MakeCommand(pMyClass, &MyClass::Dance, value)
  168. //
  169. // vs.
  170. //
  171. // CHXAvCommand0<MyClass, int>(pMyClass, &MyClass::Dance, value);
  172. //
  173. // *** note use of long-hand for handling void return; we assume recent C++ 
  174. // features (partial specializations, member fun templates, return void) 
  175. // not likely to be supported
  176. //
  177. // *** with return value ***
  178. //
  179. template< typename ClassType, typename ReturnType >
  180. inline
  181. CHXAvCommand0_ <ClassType, ReturnType> 
  182. MakeCommand_(  ClassType* pClass, ReturnType (ClassType::*pcmfn)() )
  183. {
  184.     return CHXAvCommand0_<ClassType, ReturnType>(pClass, pcmfn);
  185. }
  186. template< typename ClassType, typename ReturnType, typename ArgType>
  187. inline
  188. CHXAvCommand1_<ClassType, ReturnType, ArgType> 
  189. MakeCommand_(  ClassType* pClass, ReturnType (ClassType::*pcmfn)(ArgType), ArgType arg )
  190. {
  191.     return CHXAvCommand1_<ClassType, ReturnType, ArgType>(pClass, pcmfn, arg);
  192. }
  193. template< typename ClassType, typename ReturnType >
  194. inline
  195. CHXAvCommand0_ <ClassType, ReturnType> *
  196. AllocCommandL_(  ClassType* pClass, ReturnType (ClassType::*pcmfn)() )
  197. {
  198.     return new CHXAvCommand0_<ClassType, ReturnType>(pClass, pcmfn);
  199. }
  200. template< typename ClassType, typename ReturnType, typename ArgType>
  201. inline
  202. CHXAvCommand1_<ClassType, ReturnType, ArgType> *
  203. AllocCommandL_(  ClassType* pClass, ReturnType (ClassType::*pcmfn)(ArgType), ArgType arg )
  204. {
  205.     return new CHXAvCommand1_<ClassType, ReturnType, ArgType>(pClass, pcmfn, arg);
  206. }
  207. //
  208. // *** no return (void) ***
  209. //
  210. template< typename ClassType>
  211. inline
  212. CHXAvCommand0 <ClassType> 
  213. MakeCommand(  ClassType* pClass, void (ClassType::*pcmfn)() )
  214. {
  215.     return CHXAvCommand0<ClassType>(pClass, pcmfn);
  216. }
  217. template< typename ClassType,  typename ArgType>
  218. inline
  219. CHXAvCommand1<ClassType, ArgType> 
  220. MakeCommand(  ClassType* pClass, void (ClassType::*pcmfn)(ArgType), ArgType arg )
  221. {
  222.     return CHXAvCommand1<ClassType, ArgType>(pClass, pcmfn, arg);
  223. }
  224. template< typename ClassType>
  225. inline
  226. CHXAvCommand0 <ClassType> *
  227. AllocCommandL(  ClassType* pClass, void (ClassType::*pcmfn)() )
  228. {
  229.     return new (ELeave) CHXAvCommand0<ClassType>(pClass, pcmfn);
  230. }
  231. template< typename ClassType,  typename ArgType>
  232. inline
  233. CHXAvCommand1<ClassType, ArgType> *
  234. AllocCommandL(  ClassType* pClass, void (ClassType::*pcmfn)(ArgType), ArgType arg )
  235. {
  236.     return new (ELeave) CHXAvCommand1<ClassType, ArgType>(pClass, pcmfn, arg);
  237. }
  238. #endif // _chxavcommand_h_