// ------------------------------------------------------------------------------------------------ #include "Routine.hpp" #include "Base/Stack.hpp" #include "Library/Chrono.hpp" // ------------------------------------------------------------------------------------------------ #include // ------------------------------------------------------------------------------------------------ namespace SqMod { // ------------------------------------------------------------------------------------------------ bool Routine::s_Lock = false; Routine::Time Routine::s_Last = 0; Routine::Time Routine::s_Prev = 0; Routine::Queue Routine::s_Queue; Routine::Buckets Routine::s_Buckets; Routine::Objects Routine::s_Objects; // ------------------------------------------------------------------------------------------------ SQInteger Routine::Typename(HSQUIRRELVM vm) { static SQChar name[] = _SC("SqRoutine"); sq_pushstring(vm, name, sizeof(name)); return 1; } // ------------------------------------------------------------------------------------------------ void Routine::Attach(Routine * routine, Interval interval) { // Do we have a valid routine and interval bucket to attach? if (!routine || !interval) { return; } // Attempt to locate the bucket with the specified interval Buckets::iterator itr = std::find_if(s_Buckets.begin(), s_Buckets.end(), IntrvFunc(interval)); // Does this bucket exist? if (itr == s_Buckets.end()) { // Then create it s_Buckets.emplace_back(interval); // And attach this routine s_Buckets.back().mRoutines.push_back(routine); } // Is this routine already attached to this bucket? else if (std::find(itr->mRoutines.begin(), itr->mRoutines.end(), routine) == itr->mRoutines.end()) { itr->mRoutines.push_back(routine); // Then let's attach it now } } // ------------------------------------------------------------------------------------------------ void Routine::Detach(Routine * routine, Interval interval) { // Do we have a valid routine and interval to detach? if (!routine || !interval) { return; } // Attempt to locate the bucket with this interval Buckets::iterator bitr = std::find_if(s_Buckets.begin(), s_Buckets.end(), IntrvFunc(interval)); // Was there a bucket with this interval? if (bitr == s_Buckets.end()) { return; // Nothing to detach from! } // Attempt to find this routine in the associated bucket Routines::iterator ritr = std::find(bitr->mRoutines.begin(), bitr->mRoutines.end(), routine); // Was this routine even attached? if (ritr != bitr->mRoutines.end()) { bitr->mRoutines.erase(ritr); // Then erase it and move on } // Any reason to keep this bucket? (don't immediate routines with interval of 1) if (interval != 1 && bitr->mRoutines.empty()) { s_Buckets.erase(bitr); // Remove the bucket as well } } // ------------------------------------------------------------------------------------------------ Object Routine::Associate(Routine * routine) { // Attempt to see if this instance already exists in the pool Objects::iterator itr = s_Objects.find(routine); // Is this routine remembered for the first time? if (itr == s_Objects.end()) { // Obtain the initial stack size const StackGuard sg; // Push this instance on the stack ClassType< Routine >::PushInstance(DefaultVM::Get(), routine); // Initialize this element into the pool itr = s_Objects.emplace(routine, Var< Object >(DefaultVM::Get(), -1).value).first; // If the iterator still points to a null element then we failed if (itr == s_Objects.end()) { // NOTE: Routine instance is destroyed by the script object if necessary! STHROWF("Unable to remember routine instance"); } } // Does this routine still keep a strong reference to it self? else if (itr->second.IsNull()) { // Obtain the initial stack size const StackGuard sg; // Push this instance on the stack ClassType< Routine >::PushInstance(DefaultVM::Get(), routine); // Obtain a strong reference to it itr->second = Var< Object >(DefaultVM::Get(), -1).value; } // Return the object that we have return itr->second; } // ------------------------------------------------------------------------------------------------ void Routine::Dissociate(Routine * routine) { // Attempt to see if this instance already exists in the pool Objects::iterator itr = s_Objects.find(routine); // Was this routine even stored in the pool? if (itr != s_Objects.end() && !itr->second.IsNull()) { itr->second.Release(); // Release the reference to self } } // ------------------------------------------------------------------------------------------------ bool Routine::Associated(Routine * routine) { // Attempt to see if this instance already exists in the pool Objects::iterator itr = s_Objects.find(routine); // Return whether this routine is pooled and references itself return (itr != s_Objects.end() && !itr->second.IsNull()); } // ------------------------------------------------------------------------------------------------ void Routine::Forget(Routine * routine) { s_Objects.erase(routine); } // ------------------------------------------------------------------------------------------------ void Routine::ProcQueue() { // Do we have any queued commands that must be performed when unlocked? if (s_Queue.empty() || s_Lock) { return; // We're done here! } // Process all commands in the queue for (const auto & cmd : s_Queue) { // Are we supposed to detach the associated routine? if (cmd.mCommand == CMD_DETACH) { // Detach the routine from it's associated bucket first Detach(cmd.mRoutine, cmd.mInterval); // Break association to allow the instance to be destroyed Dissociate(cmd.mRoutine); } // Are we supposed to attach the associated routine? else if (cmd.mCommand == CMD_ATTACH) { // Attach the routine to it's associated bucket first Attach(cmd.mRoutine, cmd.mInterval); // Prevent destruction of this routine while buckets are locked Associate(cmd.mRoutine); } } // Clear processed commands s_Queue.clear(); } // ------------------------------------------------------------------------------------------------ void Routine::Process() { // In case an exception prevented the unlock last time s_Lock = false; // Normally there shouldn't be any but just in case the above happened ProcQueue(); // Is this the first call? if (s_Last == 0) { s_Last = GetCurrentSysTime(); // We'll do it text time return; } // Lock the buckets s_Lock = true; // Backup the last known time-stamp s_Prev = s_Last; // Get the current time-stamp s_Last = GetCurrentSysTime(); // Calculate the elapsed time Int32 delta = Int32((s_Last - s_Prev) / 1000L); // Process all available buckets for (auto & bucket : s_Buckets) { // Update the bucket elapsed time bucket.mElapsed += delta; // Have we completed the bucket interval? if (bucket.mElapsed < bucket.mInterval) { continue; // Move to the next one } // Attempt to execute bucket routines, if any for (auto & routine : bucket.mRoutines) { routine->Execute(); } // Reset the bucket elapsed time bucket.mElapsed = 0; } // Unlock the buckets s_Lock = false; // Process operations that couldn't be performed while buckets were locked ProcQueue(); } // ------------------------------------------------------------------------------------------------ void Routine::TerminateAll() { // Let's make sure no pending commands are left ProcQueue(); // Process all buckets for (auto & bucket : s_Buckets) { // Process all routines in this bucket for (auto & routine : bucket.mRoutines) { // Release all resources routine->Release(); // Mark it as terminated routine->m_Terminated = true; } } // Clear all references to routines s_Buckets.clear(); // Clear all routine instance associations s_Objects.clear(); // Clear the last time-stamp in case of a reload s_Last = 0; } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval) : m_Iterations(0) , m_Interval(interval) , m_Arguments(0) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() { Create(); } Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(0) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() { Create(); } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(1) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() , m_Arg1(a1) { Create(); } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(2) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() , m_Arg1(a1), m_Arg2(a2) { Create(); } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(3) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() , m_Arg1(a1), m_Arg2(a2), m_Arg3(a3) { Create(); } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3, Object & a4) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(4) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() , m_Arg1(a1), m_Arg2(a2), m_Arg3(a3), m_Arg4(a4) { Create(); } // ------------------------------------------------------------------------------------------------ Routine::Routine(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3, Object & a4, Object & a5) : m_Iterations(iterations) , m_Interval(interval) , m_Arguments(5) , m_Suspended(false) , m_Terminated(false) , m_Callback(env.GetVM(), env, func.GetFunc()) , m_Tag(_SC("")) , m_Data() , m_Arg1(a1), m_Arg2(a2), m_Arg3(a3), m_Arg4(a4), m_Arg5(a5) { Create(); } // ------------------------------------------------------------------------------------------------ Routine::~Routine() { // Remove this instance from the pool Forget(this); // Was the routine already terminated? if (m_Terminated) { return; // Nothing to release! } // Detach from the associated bucket Detach(); // Release script resources Release(); } // ------------------------------------------------------------------------------------------------ Int32 Routine::Cmp(const Routine & o) const { if (m_Interval == o.m_Interval) return 0; else if (m_Interval > o.m_Interval) return 1; else return -1; } // ------------------------------------------------------------------------------------------------ CSStr Routine::ToString() const { return ToStrF(_PRINT_INT_FMT, m_Interval); } // ------------------------------------------------------------------------------------------------ const String & Routine::GetTag() const { return m_Tag; } // ------------------------------------------------------------------------------------------------ void Routine::SetTag(CSStr tag) { m_Tag.assign(tag ? tag : _SC("")); } // ------------------------------------------------------------------------------------------------ Object & Routine::GetData() { // Validate the routine lifetime Validate(); // Return the requested information return m_Data; } // ------------------------------------------------------------------------------------------------ void Routine::SetData(Object & data) { // Validate the routine lifetime Validate(); // Apply the specified value m_Data = data; } // ------------------------------------------------------------------------------------------------ Routine & Routine::ApplyTag(CSStr tag) { m_Tag.assign(tag ? tag : _SC("")); // Allow chaining return *this; } // ------------------------------------------------------------------------------------------------ Routine & Routine::ApplyData(Object & data) { // Validate the routine lifetime Validate(); // Apply the specified value m_Data = data; // Allow chaining return *this; } // ------------------------------------------------------------------------------------------------ void Routine::Terminate() { // Was the routine already terminated? if (m_Terminated) { STHROWF("Routine was already terminated"); } // Detach from the associated bucket Detach(); // Release script resources and mark it as terminated Release(); } // ------------------------------------------------------------------------------------------------ Routine & Routine::SetArg(Uint8 num, Object & val) { // Validate the routine lifetime Validate(); // Identify which argument was requested switch (num) { case 1: m_Arg1 = val; break; case 2: m_Arg2 = val; break; case 3: m_Arg3 = val; break; case 4: m_Arg4 = val; break; case 5: m_Arg5 = val; break; case 6: m_Arg6 = val; break; case 7: m_Arg7 = val; break; case 8: m_Arg8 = val; break; case 9: m_Arg9 = val; break; case 10: m_Arg10 = val; break; case 11: m_Arg11 = val; break; case 12: m_Arg12 = val; break; case 13: m_Arg13 = val; break; case 14: m_Arg14 = val; break; default: STHROWF("Argument is out of range: %d", num); } // Allow chaining return *this; } // ------------------------------------------------------------------------------------------------ Object & Routine::GetArg(Uint8 num) { // Validate the routine lifetime Validate(); // Identify which argument was requested switch (num) { case 1: return m_Arg1; case 2: return m_Arg2; case 3: return m_Arg3; case 4: return m_Arg4; case 5: return m_Arg5; case 6: return m_Arg6; case 7: return m_Arg7; case 8: return m_Arg8; case 9: return m_Arg9; case 10: return m_Arg10; case 11: return m_Arg11; case 12: return m_Arg12; case 13: return m_Arg13; case 14: return m_Arg14; default: STHROWF("Argument is out of range: %d", num); } // Shouldn't really reach this point return NullObject(); } // ------------------------------------------------------------------------------------------------ Routine::Interval Routine::GetInterval() const { return m_Interval; } // ------------------------------------------------------------------------------------------------ void Routine::SetInterval(Interval interval) { // Validate the routine lifetime Validate(); // Is the specified interval valid? if (!interval) { STHROWF("Invalid routine interval"); } // Detach from the current bucket Detach(); // Update the interval m_Interval = interval; // Attach to the new bucket Attach(); } // ------------------------------------------------------------------------------------------------ Routine::Iterate Routine::GetIterations() const { return m_Iterations; } // ------------------------------------------------------------------------------------------------ void Routine::SetIterations(Iterate iterations) { // Validate the routine lifetime Validate(); // Perform the requested operation m_Iterations = iterations; } // ------------------------------------------------------------------------------------------------ Uint8 Routine::GetArguments() const { return m_Arguments; } void Routine::SetArguments(Uint8 num) { // Validate the routine lifetime Validate(); // Is the specified argument count valid? if (num > 14) { STHROWF("Argument is out of range: %d", num); } // Perform the requested operation m_Arguments = num; } // ------------------------------------------------------------------------------------------------ bool Routine::GetSuspended() const { return m_Suspended; } // ------------------------------------------------------------------------------------------------ void Routine::SetSuspended(bool toggle) { // Validate the routine lifetime Validate(); // Perform the requested operation m_Suspended = toggle; } // ------------------------------------------------------------------------------------------------ bool Routine::GetTerminated() const { return m_Terminated; } // ------------------------------------------------------------------------------------------------ Function & Routine::GetCallback() { // Validate the routine lifetime Validate(); // Return the requested information return m_Callback; } // ------------------------------------------------------------------------------------------------ void Routine::SetCallback(Object & env, Function & func) { // Validate the routine lifetime Validate(); // Perform the requested operation m_Callback = Function(env.GetVM(), env, func.GetFunc()); } // ------------------------------------------------------------------------------------------------ void Routine::Release() { // Was the routine already terminated? if (m_Terminated) { return; // Nothing to release! } // Mark it as terminated m_Terminated = true; // Release the callback m_Callback.ReleaseGently(); // Release the arguments m_Arg1.Release(); m_Arg2.Release(); m_Arg3.Release(); m_Arg4.Release(); m_Arg5.Release(); m_Arg6.Release(); m_Arg7.Release(); m_Arg8.Release(); m_Arg9.Release(); m_Arg10.Release(); m_Arg11.Release(); m_Arg12.Release(); m_Arg13.Release(); m_Arg14.Release(); } // ------------------------------------------------------------------------------------------------ void Routine::Create() { // Do we even have a valid interval? if (!m_Interval) { STHROWF("Invalid routine interval"); } // Is the specified callback even valid? else if (m_Callback.IsNull()) { STHROWF("Invalid routine callback"); } // Always use the command queue to attach the routine when created s_Queue.emplace_back(this, m_Interval, CMD_ATTACH); } // ------------------------------------------------------------------------------------------------ void Routine::Attach() { // Do we have a valid interval? if (!m_Interval) { return; // Nothing to attach to! } // Are the buckets locked? else if (s_Lock) { // Queue a command to attach this routine when the bucket is unlocked s_Queue.emplace_back(this, m_Interval, CMD_ATTACH); } // Attempt to attach the the routine now else { // Attach to the associated bucket Attach(this, m_Interval); // Associate the instance with it's script object to prevent unexpected release Associate(this); } } // ------------------------------------------------------------------------------------------------ void Routine::Detach() { // Do we have a valid interval? if (!m_Interval) { return; // Nothing to detach from! } // Are the buckets locked? else if (s_Lock) { // Queue a command to detach this routine when the bucket is unlocked s_Queue.emplace_back(this, m_Interval, CMD_DETACH); } // Attempt to detach the the routine now else { // Detach from the associated bucket Detach(this, m_Interval); // Break association to allow the instance to be released Dissociate(this); } } // ------------------------------------------------------------------------------------------------ void Routine::Execute() { // Is this routine suspended or has nothing to call? if (m_Suspended || m_Callback.IsNull()) { return; // We're done here! } // Make sure that we have a known number of arguments else if (m_Arguments > 14) { STHROWF("Routine [%s] => Out of range argument count [%d]", m_Tag.c_str(), m_Arguments); } // Attempt to forward the call try { switch (m_Arguments) { // Attempt to identify how many arguments should be passed case 0: m_Callback.Execute(); break; case 1: m_Callback.Execute(m_Arg1); break; case 2: m_Callback.Execute(m_Arg1, m_Arg2); break; case 3: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3); break; case 4: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4); break; case 5: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5); break; case 6: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6); break; case 7: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7); break; case 8: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8); break; case 9: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9); break; case 10: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9, m_Arg10); break; case 11: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9, m_Arg10, m_Arg11); break; case 12: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9, m_Arg10, m_Arg11, m_Arg12); break; case 13: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9, m_Arg10, m_Arg11, m_Arg12, m_Arg13); break; case 14: m_Callback.Execute(m_Arg1, m_Arg2, m_Arg3, m_Arg4, m_Arg5, m_Arg6, m_Arg7, m_Arg8, m_Arg9, m_Arg10, m_Arg11, m_Arg12, m_Arg13, m_Arg14); break; } } catch (const Sqrat::Exception & e) { LogErr("Routine [%s] => Squirrel error [%s]", m_Tag.c_str(), e.Message().c_str()); } catch (const std::exception & e) { LogErr("Routine [%s] => Program error [%s]", m_Tag.c_str(), e.what()); } catch (...) { LogErr("Routine [%s] => Unknown error", m_Tag.c_str()); } // Decrease the number of iterations if necessary if (m_Iterations && (--m_Iterations) == 0) { Terminate(); // This routine reached the end of it's life } } /* ------------------------------------------------------------------------------------------------ * Forward the call to process routines. */ void ProcessRoutine() { Routine::Process(); } /* ------------------------------------------------------------------------------------------------ * Forward the call to terminate routines. */ void TerminateRoutine() { Routine::TerminateAll(); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval) { return Associate(new Routine(env, func, interval)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations) { return Associate(new Routine(env, func, interval, iterations)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1) { return Associate(new Routine(env, func, interval, iterations, a1)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2) { return Associate(new Routine(env, func, interval, iterations, a1, a2)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3) { return Associate(new Routine(env, func, interval, iterations, a1, a2, a3)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3, Object & a4) { return Associate(new Routine(env, func, interval, iterations, a1, a2, a3, a4)); } // ------------------------------------------------------------------------------------------------ Object Routine::Create(Object & env, Function & func, Interval interval, Iterate iterations , Object & a1, Object & a2, Object & a3, Object & a4, Object & a5) { return Associate(new Routine(env, func, interval, iterations, a1, a2, a3, a4, a5)); } // ------------------------------------------------------------------------------------------------ void Routine::Flush() { // Make sure the buckets are not locked if (s_Lock) { STHROWF("Buckets are under active lock"); } // Process commands in queue ProcQueue(); } // ------------------------------------------------------------------------------------------------ Uint32 Routine::QueueSize() { return static_cast< Uint32 >(s_Queue.size()); } // ------------------------------------------------------------------------------------------------ Uint32 Routine::GetCount() { return static_cast< Uint32 >(s_Objects.size()); } // ------------------------------------------------------------------------------------------------ Uint32 Routine::GetBuckets() { return static_cast< Uint32 >(s_Buckets.size()); } // ------------------------------------------------------------------------------------------------ Uint32 Routine::GetInBucket(Interval interval) { // Attempt to locate the bucket with the specified interval Buckets::iterator itr = std::find_if(s_Buckets.begin(), s_Buckets.end(), IntrvFunc(interval)); // Does this bucket exist? if (itr == s_Buckets.end()) { return 0; // This bucket doesn't exist! } // Return the number of elements in this bucket return static_cast< Uint32 >(itr->mRoutines.size()); } // ------------------------------------------------------------------------------------------------ Array Routine::GetBucketsList() { // Allocate an array large enough to hold the number of active buckets Array arr(DefaultVM::Get(), s_Buckets.size()); // The index where the bucket interval should be inserted SQInteger idx = 0; // Insert the interval and size of each active bucket for (const auto & bucket : s_Buckets) { arr.SetValue(idx++, bucket.mInterval); } // Return the resulted array return arr; } // ------------------------------------------------------------------------------------------------ Table Routine::GetBucketsTable() { // Create a table to hold the number of active buckets Table tbl(DefaultVM::Get()); // Insert the interval of each active bucket for (const auto & bucket : s_Buckets) { tbl.SetValue(bucket.mInterval, bucket.mRoutines.size()); } // Return the resulted table return tbl; } // ------------------------------------------------------------------------------------------------ Object Routine::FindByTag(CSStr tag) { // Perform a validity check on the specified tag if (!tag || *tag == '\0') { STHROWF("The specified routine tag is invalid: null/empty"); } // Process each routine in the pool for (const auto & elem : s_Objects) { // Is this routine valid (should always be) and does the tag match the specified one? if (elem.first != nullptr && elem.first->m_Tag.compare(tag) == 0) { // Do we need to obtain the script object again? if (elem.second.IsNull()) { // Obtain the initial stack size const StackGuard sg; // Push this instance on the stack ClassType< Routine >::PushInstance(DefaultVM::Get(), elem.first); // Obtain a strong reference to it and return it return Var< Object >(DefaultVM::Get(), -1).value; } // Stop searching and return this routine return elem.second; } } // Unable to locate a routine matching the specified tag return NullObject(); } // ================================================================================================ void Register_Routine(HSQUIRRELVM vm) { RootTable(vm).Bind(_SC("SqRoutine"), Class< Routine, NoConstructor< Routine > >(vm, _SC("SqRoutine")) /* Metamethods */ .Func(_SC("_cmp"), &Routine::Cmp) .SquirrelFunc(_SC("_typename"), &Routine::Typename) .Func(_SC("_tostring"), &Routine::ToString) /* Properties */ .Prop(_SC("Tag"), &Routine::GetTag, &Routine::SetTag) .Prop(_SC("Data"), &Routine::GetData, &Routine::SetData) .Prop(_SC("Interval"), &Routine::GetInterval, &Routine::SetInterval) .Prop(_SC("Iterations"), &Routine::GetIterations, &Routine::SetIterations) .Prop(_SC("Arguments"), &Routine::GetArguments, &Routine::SetArguments) .Prop(_SC("Suspended"), &Routine::GetSuspended, &Routine::SetSuspended) .Prop(_SC("Terminated"), &Routine::GetTerminated) .Prop(_SC("Callback"), &Routine::GetCallback) /* Functions */ .Func(_SC("SetTag"), &Routine::ApplyTag) .Func(_SC("SetData"), &Routine::ApplyData) .Func(_SC("Terminate"), &Routine::Terminate) .Func(_SC("Bind"), &Routine::SetCallback) .Func(_SC("GetArg"), &Routine::GetArg) .Func(_SC("SetArg"), &Routine::SetArg) // Static Functions .StaticFunc(_SC("Flush"), &Routine::Flush) .StaticFunc(_SC("QueueSize"), &Routine::QueueSize) .StaticFunc(_SC("Count"), &Routine::GetCount) .StaticFunc(_SC("Buckets"), &Routine::GetBuckets) .StaticFunc(_SC("InBucket"), &Routine::GetInBucket) .StaticFunc(_SC("BucketsList"), &Routine::GetBucketsList) .StaticFunc(_SC("BucketsTable"), &Routine::GetBucketsTable) .StaticFunc(_SC("FindByTag"), &Routine::FindByTag) // Static Overloads .StaticOverload< Object (*)(Object &, Function &, Routine::Interval) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate, Object &) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate, Object &, Object &) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate, Object &, Object &, Object &) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate, Object &, Object &, Object &, Object &) > (_SC("Create"), &Routine::Create) .StaticOverload< Object (*)(Object &, Function &, Routine::Interval, Routine::Iterate, Object &, Object &, Object &, Object &, Object &) > (_SC("Create"), &Routine::Create) ); } } // Namespace:: SqMod