nsComponentManagerUtils.h
上传用户:goldcmy89
上传日期:2017-12-03
资源大小:2246k
文件大小:10k
源码类别:

PlugIns编程

开发平台:

Visual C++

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org Code.
  16.  *
  17.  * The Initial Developer of the Original Code is
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37. #ifndef nsComponentManagerUtils_h__
  38. #define nsComponentManagerUtils_h__
  39. #ifndef nscore_h__
  40. #include "nscore.h"
  41. #endif
  42. #ifndef nsCOMPtr_h__
  43. #include "nsCOMPtr.h"
  44. #endif
  45. #include "nsIFactory.h"
  46. NS_COM_GLUE nsresult
  47. CallCreateInstance
  48.   (const nsCID &aClass, nsISupports *aDelegate, const nsIID &aIID,
  49.    void **aResult);
  50. NS_COM_GLUE nsresult
  51. CallCreateInstance
  52.   (const char *aContractID, nsISupports *aDelegate, const nsIID &aIID,
  53.    void **aResult);
  54. NS_COM_GLUE nsresult
  55. CallGetClassObject
  56.   (const nsCID &aClass, const nsIID &aIID, void **aResult);
  57. NS_COM_GLUE nsresult
  58. CallGetClassObject
  59.   (const char *aContractID, const nsIID &aIID, void **aResult);
  60. class NS_COM_GLUE nsCreateInstanceByCID : public nsCOMPtr_helper
  61. {
  62. public:
  63.     nsCreateInstanceByCID( const nsCID& aCID, nsISupports* aOuter, nsresult* aErrorPtr )
  64.         : mCID(aCID),
  65.           mOuter(aOuter),
  66.           mErrorPtr(aErrorPtr)
  67.     {
  68.         // nothing else to do here
  69.     }
  70.     
  71.     virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
  72.     
  73. private:
  74.     const nsCID&    mCID;
  75.     nsISupports*    mOuter;
  76.     nsresult*       mErrorPtr;
  77. };
  78. class NS_COM_GLUE nsCreateInstanceByContractID : public nsCOMPtr_helper
  79. {
  80. public:
  81.     nsCreateInstanceByContractID( const char* aContractID, nsISupports* aOuter, nsresult* aErrorPtr )
  82.         : mContractID(aContractID),
  83.           mOuter(aOuter),
  84.           mErrorPtr(aErrorPtr)
  85.     {
  86.         // nothing else to do here
  87.     }
  88.     
  89.     virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
  90.     
  91. private:
  92.     const char*   mContractID;
  93.     nsISupports*  mOuter;
  94.     nsresult*     mErrorPtr;
  95. };
  96. class NS_COM_GLUE nsCreateInstanceFromFactory : public nsCOMPtr_helper
  97. {
  98. public:
  99.     nsCreateInstanceFromFactory( nsIFactory* aFactory, nsISupports* aOuter, nsresult* aErrorPtr )
  100.         : mFactory(aFactory),
  101.           mOuter(aOuter),
  102.           mErrorPtr(aErrorPtr)
  103.     {
  104.         // nothing else to do here
  105.     }
  106.     
  107.     virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
  108.     
  109. private:
  110.     nsIFactory*   mFactory;
  111.     nsISupports*  mOuter;
  112.     nsresult*     mErrorPtr;
  113. };
  114. inline
  115. const nsCreateInstanceByCID
  116. do_CreateInstance( const nsCID& aCID, nsresult* error = 0 )
  117. {
  118.     return nsCreateInstanceByCID(aCID, 0, error);
  119. }
  120. inline
  121. const nsCreateInstanceByCID
  122. do_CreateInstance( const nsCID& aCID, nsISupports* aOuter, nsresult* error = 0 )
  123. {
  124.     return nsCreateInstanceByCID(aCID, aOuter, error);
  125. }
  126. inline
  127. const nsCreateInstanceByContractID
  128. do_CreateInstance( const char* aContractID, nsresult* error = 0 )
  129. {
  130.     return nsCreateInstanceByContractID(aContractID, 0, error);
  131. }
  132. inline
  133. const nsCreateInstanceByContractID
  134. do_CreateInstance( const char* aContractID, nsISupports* aOuter, nsresult* error = 0 )
  135. {
  136.     return nsCreateInstanceByContractID(aContractID, aOuter, error);
  137. }
  138. inline
  139. const nsCreateInstanceFromFactory
  140. do_CreateInstance( nsIFactory* aFactory, nsresult* error = 0 )
  141. {
  142.     return nsCreateInstanceFromFactory(aFactory, 0, error);
  143. }
  144. inline
  145. const nsCreateInstanceFromFactory
  146. do_CreateInstance( nsIFactory* aFactory, nsISupports* aOuter, nsresult* error = 0 )
  147. {
  148.     return nsCreateInstanceFromFactory(aFactory, aOuter, error);
  149. }
  150. class NS_COM_GLUE nsGetClassObjectByCID : public nsCOMPtr_helper
  151. {
  152. public:
  153.     nsGetClassObjectByCID( const nsCID& aCID, nsresult* aErrorPtr )
  154.         : mCID(aCID),
  155.           mErrorPtr(aErrorPtr)
  156.     {
  157.         // nothing else to do here
  158.     }
  159.     
  160.     virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
  161.     
  162. private:
  163.     const nsCID&    mCID;
  164.     nsresult*       mErrorPtr;
  165. };
  166. class NS_COM_GLUE nsGetClassObjectByContractID : public nsCOMPtr_helper
  167. {
  168. public:
  169.     nsGetClassObjectByContractID( const char* aContractID, nsresult* aErrorPtr )
  170.         : mContractID(aContractID),
  171.           mErrorPtr(aErrorPtr)
  172.     {
  173.         // nothing else to do here
  174.     }
  175.     
  176.     virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
  177.     
  178. private:
  179.     const char*   mContractID;
  180.     nsresult*     mErrorPtr;
  181. };
  182. /**
  183.  * do_GetClassObject can be used to improve performance of callers 
  184.  * that call |CreateInstance| many times.  They can cache the factory
  185.  * and call do_CreateInstance or CallCreateInstance with the cached
  186.  * factory rather than having the component manager retrieve it every
  187.  * time.
  188.  */
  189. inline const nsGetClassObjectByCID
  190. do_GetClassObject( const nsCID& aCID, nsresult* error = 0 )
  191. {
  192.     return nsGetClassObjectByCID(aCID, error);
  193. }
  194. inline const nsGetClassObjectByContractID
  195. do_GetClassObject( const char* aContractID, nsresult* error = 0 )
  196. {
  197.     return nsGetClassObjectByContractID(aContractID, error);
  198. }
  199. // type-safe shortcuts for calling |CreateInstance|
  200. template <class DestinationType>
  201. inline
  202. nsresult
  203. CallCreateInstance( const nsCID &aClass,
  204.                     nsISupports *aDelegate,
  205.                     DestinationType** aDestination )
  206. {
  207.     NS_PRECONDITION(aDestination, "null parameter");
  208.     
  209.     return CallCreateInstance(aClass, aDelegate,
  210.                               NS_GET_IID(DestinationType),
  211.                               NS_REINTERPRET_CAST(void**, aDestination));
  212. }
  213. template <class DestinationType>
  214. inline
  215. nsresult
  216. CallCreateInstance( const nsCID &aClass,
  217.                     DestinationType** aDestination )
  218. {
  219.     NS_PRECONDITION(aDestination, "null parameter");
  220.     
  221.     return CallCreateInstance(aClass, nsnull,
  222.                               NS_GET_IID(DestinationType),
  223.                               NS_REINTERPRET_CAST(void**, aDestination));
  224. }
  225. template <class DestinationType>
  226. inline
  227. nsresult
  228. CallCreateInstance( const char *aContractID,
  229.                     nsISupports *aDelegate,
  230.                     DestinationType** aDestination )
  231. {
  232.     NS_PRECONDITION(aContractID, "null parameter");
  233.     NS_PRECONDITION(aDestination, "null parameter");
  234.     
  235.     return CallCreateInstance(aContractID, 
  236.                               aDelegate,
  237.                               NS_GET_IID(DestinationType),
  238.                               NS_REINTERPRET_CAST(void**, aDestination));
  239. }
  240. template <class DestinationType>
  241. inline
  242. nsresult
  243. CallCreateInstance( const char *aContractID,
  244.                     DestinationType** aDestination )
  245. {
  246.     NS_PRECONDITION(aContractID, "null parameter");
  247.     NS_PRECONDITION(aDestination, "null parameter");
  248.     
  249.     return CallCreateInstance(aContractID, nsnull,
  250.                               NS_GET_IID(DestinationType),
  251.                               NS_REINTERPRET_CAST(void**, aDestination));
  252. }
  253. template <class DestinationType>
  254. inline
  255. nsresult
  256. CallCreateInstance( nsIFactory *aFactory,
  257.                     nsISupports *aDelegate,
  258.                     DestinationType** aDestination )
  259. {
  260.     NS_PRECONDITION(aFactory, "null parameter");
  261.     NS_PRECONDITION(aDestination, "null parameter");
  262.     
  263.     return aFactory->CreateInstance(aDelegate,
  264.                                     NS_GET_IID(DestinationType),
  265.                                     NS_REINTERPRET_CAST(void**, aDestination));
  266. }
  267. template <class DestinationType>
  268. inline
  269. nsresult
  270. CallCreateInstance( nsIFactory *aFactory,
  271.                     DestinationType** aDestination )
  272. {
  273.     NS_PRECONDITION(aFactory, "null parameter");
  274.     NS_PRECONDITION(aDestination, "null parameter");
  275.     
  276.     return aFactory->CreateInstance(nsnull,
  277.                                     NS_GET_IID(DestinationType),
  278.                                     NS_REINTERPRET_CAST(void**, aDestination));
  279. }
  280. template <class DestinationType>
  281. inline
  282. nsresult
  283. CallGetClassObject( const nsCID &aClass,
  284.                     DestinationType** aDestination )
  285. {
  286.     NS_PRECONDITION(aDestination, "null parameter");
  287.     
  288.     return CallGetClassObject(aClass,
  289.         NS_GET_IID(DestinationType), NS_REINTERPRET_CAST(void**, aDestination));
  290. }
  291. template <class DestinationType>
  292. inline
  293. nsresult
  294. CallGetClassObject( const char* aContractID,
  295.                     DestinationType** aDestination )
  296. {
  297.     NS_PRECONDITION(aDestination, "null parameter");
  298.     
  299.     return CallGetClassObject(aContractID,
  300.         NS_GET_IID(DestinationType), NS_REINTERPRET_CAST(void**, aDestination));
  301. }
  302. #endif /* nsComponentManagerUtils_h__ */