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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llrun.h
  3.  * @author Phoenix
  4.  * @date 2006-02-16
  5.  * @brief Declaration of LLRunner and LLRunnable classes.
  6.  *
  7.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2006-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_LLRUN_H
  35. #define LL_LLRUN_H
  36. #include <vector>
  37. #include <boost/shared_ptr.hpp>
  38. class LLRunnable;
  39. /** 
  40.  * @class LLRunner
  41.  * @brief This class manages a set of LLRunnable objects.
  42.  *
  43.  * An instance of this class has a collection of LLRunnable objects
  44.  * which are scheduled to run on a repeating or one time basis.
  45.  * @see LLRunnable
  46.  */
  47. class LL_COMMON_API LLRunner
  48. {
  49. public:
  50. /**
  51.  * @brief The pointer to a runnable.
  52.  */
  53. typedef boost::shared_ptr<LLRunnable> run_ptr_t;
  54. /**
  55.  * @brief The handle for use in the API.
  56.  */
  57. typedef S64 run_handle_t;
  58. /**
  59.  * @brief Constructor.
  60.  */
  61. LLRunner();
  62. /**
  63.  * @brief Destructor.
  64.  */
  65. ~LLRunner();
  66. /** 
  67.  * @brief Enumeration which specifies when to run.
  68.  */
  69. enum ERunSchedule
  70. {
  71. // The runnable will run in N seconds
  72. RUN_IN,
  73. // The run every N seconds
  74. RUN_EVERY,
  75. // A count of the run types
  76. RUN_SCHEDULE_COUNT
  77. };
  78. /**
  79.  * @brief Run the runnables which are scheduled to run
  80.  *
  81.  * @return Returns the number of runnables run.
  82.  */
  83. S32 run();
  84. /** 
  85.  * @brief Add a runnable to the run list.
  86.  *
  87.  * The handle of the runnable is unique to each addition. If the
  88.  * same runnable is added a second time with the same or different
  89.  * schedule, this method will return a new handle.
  90.  * @param runnable The runnable to run() on schedule.
  91.  * @param schedule Specifies the run schedule.
  92.  * @param seconds When to run the runnable as interpreted by schedule.
  93.  * @return Returns the handle to the runnable. handle == 0 means failure.
  94.  */
  95. run_handle_t addRunnable(
  96. run_ptr_t runnable,
  97. ERunSchedule schedule,
  98. F64 seconds);
  99. /**
  100.  * @brief Remove the specified runnable.
  101.  *
  102.  * @param handle The handle of the runnable to remove.
  103.  * @return Returns the pointer to the runnable removed which may
  104.  * be empty.
  105.  */
  106. run_ptr_t removeRunnable(run_handle_t handle);
  107. protected:
  108. struct LLRunInfo
  109. {
  110. run_handle_t mHandle;
  111. run_ptr_t mRunnable;
  112. ERunSchedule mSchedule;
  113. F64 mNextRunAt;
  114. F64 mIncrement;
  115. LLRunInfo(
  116. run_handle_t handle,
  117. run_ptr_t runnable,
  118. ERunSchedule schedule,
  119. F64 next_run_at,
  120. F64 increment);
  121. };
  122. typedef std::vector<LLRunInfo> run_list_t;
  123. run_list_t mRunOnce;
  124. run_list_t mRunEvery;
  125. run_handle_t mNextHandle;
  126. };
  127. /** 
  128.  * @class LLRunnable
  129.  * @brief Abstract base class for running some scheduled process.
  130.  *
  131.  * Users of the LLRunner class are expected to derive a concrete
  132.  * implementation of this class which overrides the run() method to do
  133.  * something useful.
  134.  * @see LLRunner
  135.  */
  136. class LL_COMMON_API LLRunnable
  137. {
  138. public:
  139. LLRunnable();
  140. virtual ~LLRunnable();
  141. /** 
  142.  * @brief Do the process.
  143.  *
  144.  * This method will be called from the LLRunner according to 
  145.  * @param runner The Runner which call run().
  146.  * @param handle The handle this run instance is run under.
  147.  */
  148. virtual void run(LLRunner* runner, S64 handle) = 0;
  149. };
  150. #endif // LL_LLRUN_H