llservice.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:6k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llservice.h
  3.  * @author Phoenix
  4.  * @date 2004-11-21
  5.  * @brief Declaration file for LLService and related classes.
  6.  *
  7.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2004-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. #ifndef LL_LLSERVICE_H
  35. #define LL_LLSERVICE_H
  36. #include <string>
  37. #include <map>
  38. //#include <boost/intrusive_ptr.hpp>
  39. //#include <boost/shared_ptr.hpp>
  40. //#include "llframetimer.h"
  41. #include "lliopipe.h"
  42. #include "llchainio.h"
  43. #if 0
  44. class LLServiceCreator;
  45. /**
  46.  * intrusive pointer support
  47.  */
  48. namespace boost
  49. {
  50. void intrusive_ptr_add_ref(LLServiceCreator* p);
  51. void intrusive_ptr_release(LLServiceCreator* p);
  52. };
  53. #endif
  54. /** 
  55.  * @class LLServiceCreator
  56.  * @brief This class is an abstract base class for classes which create
  57.  * new <code>LLService</code> instances.
  58.  *
  59.  * Derive classes from this class which appropriately implement the
  60.  * <code>operator()</code> and destructor.
  61.  * @see LLService
  62.  */
  63. #if 0
  64. class LLServiceCreator
  65. {
  66. public:
  67. typedef boost::intrusive_ptr<LLService> service_t;
  68. virtual ~LLServiceCreator() {}
  69. virtual service_t activate() = 0;
  70. virtual void discard() = 0;
  71. protected:
  72. LLServiceCreator() : mReferenceCount(0)
  73. {
  74. }
  75. private:
  76. friend void boost::intrusive_ptr_add_ref(LLServiceCreator* p);
  77. friend void boost::intrusive_ptr_release(LLServiceCreator* p);
  78. U32 mReferenceCount;
  79. };
  80. #endif
  81. #if 0
  82. namespace boost
  83. {
  84. inline void intrusive_ptr_add_ref(LLServiceCreator* p)
  85. {
  86. ++p->mReferenceCount;
  87. }
  88. inline void intrusive_ptr_release(LLServiceCreator* p)
  89. {
  90. if(p && 0 == --p->mReferenceCount)
  91. {
  92. delete p;
  93. }
  94. }
  95. };
  96. #endif
  97. /** 
  98.  * @class LLService
  99.  * @brief This class is the base class for the service classes.
  100.  * @see LLIOPipe
  101.  *
  102.  * The services map a string to a chain factory with a known interface
  103.  * at the front of the chain. So, to activate a service, call
  104.  * <code>activate()</code> with the name of the service needed which
  105.  * will call the associated factory, and return a pointer to the
  106.  * known interface.
  107.  * <b>NOTE:</b> If you are implementing a service factory, it is
  108.  * vitally important that the service pipe is at the front of the
  109.  * chain.
  110.  */
  111. class LLService : public LLIOPipe
  112. {
  113. public:
  114. //typedef boost::intrusive_ptr<LLServiceCreator> creator_t;
  115. //typedef boost::intrusive_ptr<LLService> service_t;
  116. typedef boost::shared_ptr<LLChainIOFactory> creator_t;
  117. /** 
  118.  * @brief This method is used to register a protocol name with a
  119.  * a functor that creates the service.
  120.  *
  121.  * THOROUGH_DESCRIPTION
  122.  * @param aParameter A brief description of aParameter.
  123.  * @return Returns true if a service was successfully registered.
  124.  */
  125. static bool registerCreator(const std::string& name, creator_t fn);
  126. /** 
  127.  * @brief This method connects to a service by name.
  128.  *
  129.  * @param name The name of the service to connect to.
  130.  * @param chain The constructed chain including the service instance.
  131.  * @param context Context for the activation.
  132.  * @return An instance of the service for use or NULL on failure.
  133.  */
  134. static LLIOPipe* activate(
  135. const std::string& name,
  136. LLPumpIO::chain_t& chain,
  137. LLSD context);
  138. /** 
  139.  * @brief 
  140.  *
  141.  * @param name The name of the service to discard.
  142.  * @return true if service creator was found and discarded.
  143.  */
  144. static bool discard(const std::string& name);
  145. protected:
  146. // The creation factory static data.
  147. typedef std::map<std::string, creator_t> creators_t;
  148. static creators_t sCreatorFunctors;
  149. protected:
  150. // construction & destruction. since this class is an abstract
  151. // base class, it is up to Service implementations to actually
  152. // deal with construction and not a public method. How that
  153. // construction takes place will be handled by the service
  154. // creators.
  155. LLService();
  156. virtual ~LLService();
  157. protected:
  158. // This frame timer records how long this service has
  159. // existed. Useful for derived services to give themselves a
  160. // lifetime and expiration.
  161. // *NOTE: Phoenix - This functionaity has been moved to the
  162. // pump. 2005-12-13
  163. //LLFrameTimer mTimer;
  164. // Since services are designed in an 'ask now, respond later'
  165. // idiom which probably crosses thread boundaries, almost all
  166. // services will need a handle to a response pipe. It will usually
  167. // be the job of the service author to derive a useful
  168. // implementation of response, and up to the service subscriber to
  169. // further derive that class to do something useful when the
  170. // response comes in.
  171. LLIOPipe::ptr_t mResponse;
  172. };
  173. #endif // LL_LLSERVICE_H