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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llrun.cpp
  3.  * @author Phoenix
  4.  * @date 2006-02-16
  5.  * @brief Implementation of the LLRunner and related 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. #include "linden_common.h"
  35. #include "llrun.h"
  36. #include "llframetimer.h"
  37. static const LLRunner::run_handle_t INVALID_RUN_HANDLE = 0;
  38. /** 
  39.  * LLRunner
  40.  */
  41. LLRunner::LLRunner() :
  42. mNextHandle(1)
  43. {
  44. }
  45. LLRunner::~LLRunner()
  46. {
  47. mRunOnce.clear();
  48. mRunEvery.clear();
  49. }
  50. S32 LLRunner::run()
  51. {
  52. // We collect all of the runnables which should be run. Since the
  53. // runnables are allowed to adjust the run list, we need to copy
  54. // them into a temporary structure which then iterates over them
  55. // to call out of this method into the runnables.
  56. F64 now = LLFrameTimer::getTotalSeconds();
  57. run_list_t run_now;
  58. // Collect the run once. We erase the matching ones now because
  59. // it's easier. If we find a reason to keep them around for a
  60. // while, we can restructure this method.
  61. LLRunner::run_list_t::iterator iter = mRunOnce.begin();
  62. for( ; iter != mRunOnce.end(); )
  63. {
  64. if(now > (*iter).mNextRunAt)
  65. {
  66. run_now.push_back(*iter);
  67. iter = mRunOnce.erase(iter);
  68. }
  69. else
  70. {
  71. ++iter;
  72. }
  73. }
  74. // Collect the ones that repeat.
  75. iter = mRunEvery.begin();
  76. LLRunner::run_list_t::iterator end = mRunEvery.end();
  77. for( ; iter != end; ++iter )
  78. {
  79. if(now > (*iter).mNextRunAt)
  80. {
  81. (*iter).mNextRunAt = now + (*iter).mIncrement;
  82. run_now.push_back(*iter);
  83. }
  84. }
  85. // Now, run them.
  86. iter = run_now.begin();
  87. end = run_now.end();
  88. for( ; iter != end; ++iter )
  89. {
  90. (*iter).mRunnable->run(this, (*iter).mHandle);
  91. }
  92. return run_now.size();
  93. }
  94. LLRunner::run_handle_t LLRunner::addRunnable(
  95. run_ptr_t runnable,
  96. ERunSchedule schedule,
  97. F64 seconds)
  98. {
  99. if(!runnable) return INVALID_RUN_HANDLE;
  100. run_handle_t handle = mNextHandle++;
  101. F64 next_run = LLFrameTimer::getTotalSeconds() + seconds;
  102. LLRunInfo info(handle, runnable, schedule, next_run, seconds);
  103. switch(schedule)
  104. {
  105. case RUN_IN:
  106. // We could optimize this a bit by sorting this on entry.
  107. mRunOnce.push_back(info);
  108. break;
  109. case RUN_EVERY:
  110. mRunEvery.push_back(info);
  111. break;
  112. default:
  113. handle = INVALID_RUN_HANDLE;
  114. break;
  115. }
  116. return handle;
  117. }
  118. LLRunner::run_ptr_t LLRunner::removeRunnable(LLRunner::run_handle_t handle)
  119. {
  120. LLRunner::run_ptr_t rv;
  121. LLRunner::run_list_t::iterator iter = mRunOnce.begin();
  122. LLRunner::run_list_t::iterator end = mRunOnce.end();
  123. for( ; iter != end; ++iter)
  124. {
  125. if((*iter).mHandle == handle)
  126. {
  127. rv = (*iter).mRunnable;
  128. mRunOnce.erase(iter);
  129. return rv;
  130. }
  131. }
  132. iter = mRunEvery.begin();
  133. end = mRunEvery.end();
  134. for( ; iter != end; ++iter)
  135. {
  136. if((*iter).mHandle == handle)
  137. {
  138. rv = (*iter).mRunnable;
  139. mRunEvery.erase(iter);
  140. return rv;
  141. }
  142. }
  143. return rv;
  144. }
  145. /** 
  146.  * LLRunner::LLRunInfo
  147.  */
  148. LLRunner::LLRunInfo::LLRunInfo(
  149. run_handle_t handle,
  150. run_ptr_t runnable,
  151. ERunSchedule schedule,
  152. F64 next_run_after,
  153. F64 increment) :
  154. mHandle(handle),
  155. mRunnable(runnable),
  156. mSchedule(schedule),
  157. mNextRunAt(next_run_after),
  158. mIncrement(increment)
  159. {
  160. }
  161. LLRunnable::LLRunnable()
  162. { }
  163. // virtual
  164. LLRunnable::~LLRunnable()
  165. { }