diff --git a/Moose Development/Moose/Core/Base.lua b/Moose Development/Moose/Core/Base.lua index 307047859..d20f068ee 100644 --- a/Moose Development/Moose/Core/Base.lua +++ b/Moose Development/Moose/Core/Base.lua @@ -764,9 +764,7 @@ do -- Scheduling if not self.Scheduler then self.Scheduler = SCHEDULER:New( self ) end - - self.Scheduler.SchedulerObject = self.Scheduler - + local ScheduleID = _SCHEDULEDISPATCHER:AddSchedule( self, SchedulerFunction, @@ -804,9 +802,6 @@ do -- Scheduling self.Scheduler = SCHEDULER:New( self ) end - self.Scheduler.SchedulerObject = self.Scheduler - --self.MasterObject = self - local ScheduleID = self.Scheduler:Schedule( self, SchedulerFunction, diff --git a/Moose Development/Moose/Core/Event.lua b/Moose Development/Moose/Core/Event.lua index 4a6b96448..4ef56c8ea 100644 --- a/Moose Development/Moose/Core/Event.lua +++ b/Moose Development/Moose/Core/Event.lua @@ -488,6 +488,9 @@ local _EVENTMETA = { -- @type EVENT.Events -- @field #number IniUnit +--- Create new event handler. +-- @param #EVENT self +-- @return #EVENT self function EVENT:New() local self = BASE:Inherit( self, BASE:New() ) self:F2() @@ -1223,7 +1226,7 @@ EVENTHANDLER = { --- The EVENTHANDLER constructor -- @param #EVENTHANDLER self --- @return #EVENTHANDLER +-- @return #EVENTHANDLER self function EVENTHANDLER:New() self = BASE:Inherit( self, BASE:New() ) -- #EVENTHANDLER return self diff --git a/Moose Development/Moose/Core/ScheduleDispatcher.lua b/Moose Development/Moose/Core/ScheduleDispatcher.lua index 2fb596fd8..c85943d75 100644 --- a/Moose Development/Moose/Core/ScheduleDispatcher.lua +++ b/Moose Development/Moose/Core/ScheduleDispatcher.lua @@ -4,7 +4,7 @@ -- -- Takes care of the creation and dispatching of scheduled functions for SCHEDULER objects. -- --- This class is tricky and needs some thorought explanation. +-- This class is tricky and needs some thorough explanation. -- SCHEDULE classes are used to schedule functions for objects, or as persistent objects. -- The SCHEDULEDISPATCHER class ensures that: -- @@ -13,9 +13,10 @@ -- - Scheduled functions are automatically removed when the schedule is finished, according the SCHEDULER object parameters. -- -- The SCHEDULEDISPATCHER class will manage SCHEDULER object in memory during garbage collection: --- - When a SCHEDULER object is not attached to another object (that is, it's first :Schedule() parameter is nil), then the SCHEDULER --- object is _persistent_ within memory. +-- +-- - When a SCHEDULER object is not attached to another object (that is, it's first :Schedule() parameter is nil), then the SCHEDULER object is _persistent_ within memory. -- - When a SCHEDULER object *is* attached to another object, then the SCHEDULER object is _not persistent_ within memory after a garbage collection! +-- -- The none persistency of SCHEDULERS attached to objects is required to allow SCHEDULER objects to be garbage collectged, when the parent object is also desroyed or nillified and garbage collected. -- Even when there are pending timer scheduled functions to be executed for the SCHEDULER object, -- these will not be executed anymore when the SCHEDULER object has been destroyed. @@ -33,13 +34,28 @@ -- @module Core.ScheduleDispatcher -- @image Core_Schedule_Dispatcher.JPG +--- SCHEDULEDISPATCHER class. +-- @type SCHEDULEDISPATCHER +-- @field #string ClassName Name of the class. +-- @field #number CallID Call ID counter. +-- @field #table PersistentSchedulers Persistant schedulers. +-- @field #table ObjectSchedulers Schedulers that only exist as long as the master object exists. +-- @field #table Schedule Meta table setmetatable( {}, { __mode = "k" } ). +-- @extends Core.Base#BASE + --- The SCHEDULEDISPATCHER structure -- @type SCHEDULEDISPATCHER SCHEDULEDISPATCHER = { - ClassName = "SCHEDULEDISPATCHER", - CallID = 0, + ClassName = "SCHEDULEDISPATCHER", + CallID = 0, + PersistentSchedulers = {}, + ObjectSchedulers = {}, + Schedule = nil, } +--- Create a new schedule dispatcher object. +-- @param #SCHEDULEDISPATCHER self +-- @return #SCHEDULEDISPATCHER self function SCHEDULEDISPATCHER:New() local self = BASE:Inherit( self, BASE:New() ) self:F3() @@ -51,11 +67,23 @@ end -- It is constructed as such that a garbage collection is executed on the weak tables, when the Scheduler is nillified. -- Nothing of this code should be modified without testing it thoroughly. -- @param #SCHEDULEDISPATCHER self --- @param Core.Scheduler#SCHEDULER Scheduler +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +-- @param #function ScheduleFunction Scheduler function. +-- @param #table ScheduleArguments Table of arguments passed to the ScheduleFunction. +-- @param #number Start Start time in seconds. +-- @param #number Repeat Repeat interval in seconds. +-- @param #number Randomize Radomization factor [0,1]. +-- @param #number Stop Stop time in seconds. +-- @param #number TraceLevel Trace level [0,3]. +-- @param Core.Fsm#FSM Fsm Finite state model. +-- @return #table Call ID or nil. function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleArguments, Start, Repeat, Randomize, Stop, TraceLevel, Fsm ) - self:F2( { Scheduler, ScheduleFunction, ScheduleArguments, Start, Repeat, Randomize, Stop, TraceLevel } ) + self:F2( { Scheduler, ScheduleFunction, ScheduleArguments, Start, Repeat, Randomize, Stop, TraceLevel, Fsm } ) + -- Increase counter. self.CallID = self.CallID + 1 + + -- Create ID. local CallID = self.CallID .. "#" .. ( Scheduler.MasterObject and Scheduler.MasterObject.GetClassNameAndID and Scheduler.MasterObject:GetClassNameAndID() or "" ) or "" -- Initialize the ObjectSchedulers array, which is a weakly coupled table. @@ -118,7 +146,6 @@ function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleAr if name_fsm then Info.name = name_fsm end - --env.info( debug.traceback() ) end self:T3( self.Schedule[Scheduler][CallID] ) @@ -126,7 +153,7 @@ function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleAr self.Schedule[Scheduler][CallID].CallHandler = function( Params ) local CallID = Params.CallID - local Info = Params.Info + local Info = Params.Info or {} local Source = Info.source or "?" local Line = Info.currentline or "?" local Name = Info.name or "?" @@ -153,10 +180,9 @@ function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleAr --self:T3( { Schedule = Schedule } ) - local SchedulerObject = Scheduler.SchedulerObject - --local ScheduleObjectName = Scheduler.SchedulerObject:GetNameAndClassID() + local SchedulerObject = Scheduler.MasterObject --Scheduler.SchedulerObject Now is this the Maste or Scheduler object? local ScheduleFunction = Schedule.Function - local ScheduleArguments = Schedule.Arguments + local ScheduleArguments = Schedule.Arguments or {} local Start = Schedule.Start local Repeat = Schedule.Repeat or 0 local Randomize = Schedule.Randomize or 0 @@ -201,7 +227,7 @@ function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleAr - ( Randomize * Repeat / 2 ), ( Randomize * Repeat / 2 ) ) + - 0.01 + 0.0001 -- Accuracy --self:T3( { Repeat = CallID, CurrentTime, ScheduleTime, ScheduleArguments } ) return ScheduleTime -- returns the next time the function needs to be called. else @@ -222,6 +248,10 @@ function SCHEDULEDISPATCHER:AddSchedule( Scheduler, ScheduleFunction, ScheduleAr return CallID end +--- Remove schedule. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +-- @param #table CallID Call ID. function SCHEDULEDISPATCHER:RemoveSchedule( Scheduler, CallID ) self:F2( { Remove = CallID, Scheduler = Scheduler } ) @@ -231,11 +261,19 @@ function SCHEDULEDISPATCHER:RemoveSchedule( Scheduler, CallID ) end end +--- Start dispatcher. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +-- @param #table CallID (Optional) Call ID. +-- @param #table CallID Call ID. +-- @param #string Info (Optional) Debug info. function SCHEDULEDISPATCHER:Start( Scheduler, CallID, Info ) self:F2( { Start = CallID, Scheduler = Scheduler } ) - + if CallID then + local Schedule = self.Schedule[Scheduler] + -- Only start when there is no ScheduleID defined! -- This prevents to "Start" the scheduler twice with the same CallID... if not Schedule[CallID].ScheduleID then @@ -246,31 +284,46 @@ function SCHEDULEDISPATCHER:Start( Scheduler, CallID, Info ) timer.getTime() + Schedule[CallID].Start ) end + else + + -- Recursive. for CallID, Schedule in pairs( self.Schedule[Scheduler] or {} ) do self:Start( Scheduler, CallID, Info ) -- Recursive end + end end +--- Stop dispatcher. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +-- @param #table CallID Call ID. function SCHEDULEDISPATCHER:Stop( Scheduler, CallID ) self:F2( { Stop = CallID, Scheduler = Scheduler } ) if CallID then + local Schedule = self.Schedule[Scheduler] - -- Only stop when there is a ScheduleID defined for the CallID. - -- So, when the scheduler was stopped before, do nothing. + + -- Only stop when there is a ScheduleID defined for the CallID. So, when the scheduler was stopped before, do nothing. if Schedule[CallID].ScheduleID then timer.removeFunction( Schedule[CallID].ScheduleID ) Schedule[CallID].ScheduleID = nil end + else + for CallID, Schedule in pairs( self.Schedule[Scheduler] or {} ) do self:Stop( Scheduler, CallID ) -- Recursive end + end end +--- Clear all schedules by stopping all dispatchers. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. function SCHEDULEDISPATCHER:Clear( Scheduler ) self:F2( { Scheduler = Scheduler } ) @@ -279,9 +332,19 @@ function SCHEDULEDISPATCHER:Clear( Scheduler ) end end -function SCHEDULEDISPATCHER:NoTrace( Scheduler ) +--- Shopw tracing info. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +function SCHEDULEDISPATCHER:ShowTrace( Scheduler ) self:F2( { Scheduler = Scheduler } ) - - Scheduler.ShowTrace = nil + Scheduler.ShowTrace = true +end + +--- No tracing info. +-- @param #SCHEDULEDISPATCHER self +-- @param Core.Scheduler#SCHEDULER Scheduler Scheduler object. +function SCHEDULEDISPATCHER:NoTrace( Scheduler ) + self:F2( { Scheduler = Scheduler } ) + Scheduler.ShowTrace = false end diff --git a/Moose Development/Moose/Core/Scheduler.lua b/Moose Development/Moose/Core/Scheduler.lua index c5f796185..e5ef5960f 100644 --- a/Moose Development/Moose/Core/Scheduler.lua +++ b/Moose Development/Moose/Core/Scheduler.lua @@ -43,7 +43,9 @@ --- The SCHEDULER class -- @type SCHEDULER --- @field #number ScheduleID the ID of the scheduler. +-- @field #table Schedules Table of schedules. +-- @field #table MasterObject Master object. +-- @field #boolean ShowTrace Trace info if true. -- @extends Core.Base#BASE @@ -69,53 +71,53 @@ -- -- * @{#SCHEDULER.New}( nil ): Setup a new SCHEDULER object, which is persistently executed after garbage collection. -- --- SchedulerObject = SCHEDULER:New() --- SchedulerID = SchedulerObject:Schedule( nil, ScheduleFunction, {} ) +-- MasterObject = SCHEDULER:New() +-- SchedulerID = MasterObject:Schedule( nil, ScheduleFunction, {} ) -- --- The above example creates a new SchedulerObject, but does not schedule anything. --- A separate schedule is created by using the SchedulerObject using the method :Schedule..., which returns a ScheduleID +-- The above example creates a new MasterObject, but does not schedule anything. +-- A separate schedule is created by using the MasterObject using the method :Schedule..., which returns a ScheduleID -- -- ### Construct a SCHEDULER object without a volatile schedule, but volatile to the Object existence... -- -- * @{#SCHEDULER.New}( Object ): Setup a new SCHEDULER object, which is linked to the Object. When the Object is nillified or destroyed, the SCHEDULER object will also be destroyed and stopped after garbage collection. -- -- ZoneObject = ZONE:New( "ZoneName" ) --- SchedulerObject = SCHEDULER:New( ZoneObject ) --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} ) +-- MasterObject = SCHEDULER:New( ZoneObject ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {} ) -- ... -- ZoneObject = nil -- garbagecollect() -- --- The above example creates a new SchedulerObject, but does not schedule anything, and is bound to the existence of ZoneObject, which is a ZONE. --- A separate schedule is created by using the SchedulerObject using the method :Schedule()..., which returns a ScheduleID +-- The above example creates a new MasterObject, but does not schedule anything, and is bound to the existence of ZoneObject, which is a ZONE. +-- A separate schedule is created by using the MasterObject using the method :Schedule()..., which returns a ScheduleID -- Later in the logic, the ZoneObject is put to nil, and garbage is collected. --- As a result, the ScheduleObject will cancel any planned schedule. +-- As a result, the MasterObject will cancel any planned schedule. -- -- ### Construct a SCHEDULER object with a persistent schedule. -- -- * @{#SCHEDULER.New}( nil, Function, FunctionArguments, Start, ... ): Setup a new persistent SCHEDULER object, and start a new schedule for the Function with the defined FunctionArguments according the Start and sequent parameters. -- --- SchedulerObject, SchedulerID = SCHEDULER:New( nil, ScheduleFunction, {} ) +-- MasterObject, SchedulerID = SCHEDULER:New( nil, ScheduleFunction, {} ) -- --- The above example creates a new SchedulerObject, and does schedule the first schedule as part of the call. --- Note that 2 variables are returned here: SchedulerObject, ScheduleID... +-- The above example creates a new MasterObject, and does schedule the first schedule as part of the call. +-- Note that 2 variables are returned here: MasterObject, ScheduleID... -- -- ### Construct a SCHEDULER object without a schedule, but volatile to the Object existence... -- -- * @{#SCHEDULER.New}( Object, Function, FunctionArguments, Start, ... ): Setup a new SCHEDULER object, linked to Object, and start a new schedule for the Function with the defined FunctionArguments according the Start and sequent parameters. -- -- ZoneObject = ZONE:New( "ZoneName" ) --- SchedulerObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} ) +-- MasterObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {} ) -- ... -- ZoneObject = nil -- garbagecollect() -- --- The above example creates a new SchedulerObject, and schedules a method call (ScheduleFunction), +-- The above example creates a new MasterObject, and schedules a method call (ScheduleFunction), -- and is bound to the existence of ZoneObject, which is a ZONE object (ZoneObject). --- Both a ScheduleObject and a SchedulerID variable are returned. +-- Both a MasterObject and a SchedulerID variable are returned. -- Later in the logic, the ZoneObject is put to nil, and garbage is collected. --- As a result, the ScheduleObject will cancel the planned schedule. +-- As a result, the MasterObject will cancel the planned schedule. -- -- ## SCHEDULER timer stopping and (re-)starting. -- @@ -125,15 +127,15 @@ -- * @{#SCHEDULER.Stop}(): Stop the schedules within the SCHEDULER object. If a CallID is provided to :Stop(), then only the schedule referenced by CallID will be stopped. -- -- ZoneObject = ZONE:New( "ZoneName" ) --- SchedulerObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 10 ) +-- MasterObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 10 ) -- ... --- SchedulerObject:Stop( SchedulerID ) +-- MasterObject:Stop( SchedulerID ) -- ... --- SchedulerObject:Start( SchedulerID ) +-- MasterObject:Start( SchedulerID ) -- --- The above example creates a new SchedulerObject, and does schedule the first schedule as part of the call. --- Note that 2 variables are returned here: SchedulerObject, ScheduleID... +-- The above example creates a new MasterObject, and does schedule the first schedule as part of the call. +-- Note that 2 variables are returned here: MasterObject, ScheduleID... -- Later in the logic, the repeating schedule with SchedulerID is stopped. -- A bit later, the repeating schedule with SchedulerId is (re)-started. -- @@ -145,32 +147,32 @@ -- Consider the following code fragment of the SCHEDULER object creation. -- -- ZoneObject = ZONE:New( "ZoneName" ) --- SchedulerObject = SCHEDULER:New( ZoneObject ) +-- MasterObject = SCHEDULER:New( ZoneObject ) -- -- Several parameters can be specified that influence the behaviour of a Schedule. -- -- ### A single schedule, immediately executed -- --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {} ) -- -- The above example schedules a new ScheduleFunction call to be executed asynchronously, within milleseconds ... -- -- ### A single schedule, planned over time -- --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10 ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {}, 10 ) -- -- The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds ... -- -- ### A schedule with a repeating time interval, planned over time -- --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60 ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60 ) -- -- The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, -- and repeating 60 every seconds ... -- -- ### A schedule with a repeating time interval, planned over time, with time interval randomization -- --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5 ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5 ) -- -- The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, -- and repeating 60 seconds, with a 50% time interval randomization ... @@ -180,7 +182,7 @@ -- -- ### A schedule with a repeating time interval, planned over time, with time interval randomization, and stop after a time interval -- --- SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5, 300 ) +-- SchedulerID = MasterObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5, 300 ) -- -- The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, -- The schedule will repeat every 60 seconds. @@ -191,13 +193,15 @@ -- -- @field #SCHEDULER SCHEDULER = { - ClassName = "SCHEDULER", - Schedules = {}, + ClassName = "SCHEDULER", + Schedules = {}, + MasterObject = nil, + ShowTrace = nil, } --- SCHEDULER constructor. -- @param #SCHEDULER self --- @param #table SchedulerObject Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference. +-- @param #table MasterObject Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference. -- @param #function SchedulerFunction The event function to be called when a timer event occurs. The event function needs to accept the parameters specified in SchedulerArguments. -- @param #table SchedulerArguments Optional arguments that can be given as part of scheduler. The arguments need to be given as a table { param1, param 2, ... }. -- @param #number Start Specifies the amount of seconds that will be waited before the scheduling is started, and the event function is called. @@ -205,50 +209,46 @@ SCHEDULER = { -- @param #number RandomizeFactor Specifies a randomization factor between 0 and 1 to randomize the Repeat. -- @param #number Stop Specifies the amount of seconds when the scheduler will be stopped. -- @return #SCHEDULER self. --- @return #number The ScheduleID of the planned schedule. -function SCHEDULER:New( SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop ) +-- @return #table The ScheduleID of the planned schedule. +function SCHEDULER:New( MasterObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop ) local self = BASE:Inherit( self, BASE:New() ) -- #SCHEDULER self:F2( { Start, Repeat, RandomizeFactor, Stop } ) local ScheduleID = nil - self.MasterObject = SchedulerObject - self.ShowTrace = true + self.MasterObject = MasterObject + self.ShowTrace = false if SchedulerFunction then - ScheduleID = self:Schedule( SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop, 4 ) + ScheduleID = self:Schedule( MasterObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop, 4 ) end return self, ScheduleID end ---function SCHEDULER:_Destructor() --- --self:E("_Destructor") --- --- _SCHEDULEDISPATCHER:RemoveSchedule( self.CallID ) ---end - --- Schedule a new time event. Note that the schedule will only take place if the scheduler is *started*. Even for a single schedule event, the scheduler needs to be started also. -- @param #SCHEDULER self --- @param #table SchedulerObject Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference. +-- @param #table MasterObject Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference. -- @param #function SchedulerFunction The event function to be called when a timer event occurs. The event function needs to accept the parameters specified in SchedulerArguments. -- @param #table SchedulerArguments Optional arguments that can be given as part of scheduler. The arguments need to be given as a table { param1, param 2, ... }. -- @param #number Start Specifies the amount of seconds that will be waited before the scheduling is started, and the event function is called. --- @param #number Repeat Specifies the interval in seconds when the scheduler will call the event function. +-- @param #number Repeat Specifies the time interval in seconds when the scheduler will call the event function. -- @param #number RandomizeFactor Specifies a randomization factor between 0 and 1 to randomize the Repeat. --- @param #number Stop Specifies the amount of seconds when the scheduler will be stopped. --- @return #number The ScheduleID of the planned schedule. -function SCHEDULER:Schedule( SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop, TraceLevel, Fsm ) +-- @param #number Stop Time interval in seconds after which the scheduler will be stoppe. +-- @param #number TraceLevel Trace level [0,3]. Default 3. +-- @param Core.Fsm#FSM Fsm Finite state model. +-- @return #table The ScheduleID of the planned schedule. +function SCHEDULER:Schedule( MasterObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop, TraceLevel, Fsm ) self:F2( { Start, Repeat, RandomizeFactor, Stop } ) self:T3( { SchedulerArguments } ) local ObjectName = "-" - if SchedulerObject and SchedulerObject.ClassName and SchedulerObject.ClassID then - ObjectName = SchedulerObject.ClassName .. SchedulerObject.ClassID + if MasterObject and MasterObject.ClassName and MasterObject.ClassID then + ObjectName = MasterObject.ClassName .. MasterObject.ClassID end - self:F3( { "Schedule :", ObjectName, tostring( SchedulerObject ), Start, Repeat, RandomizeFactor, Stop } ) - self.SchedulerObject = SchedulerObject + self:F3( { "Schedule :", ObjectName, tostring( MasterObject ), Start, Repeat, RandomizeFactor, Stop } ) + self.MasterObject = MasterObject local ScheduleID = _SCHEDULEDISPATCHER:AddSchedule( self, @@ -269,19 +269,17 @@ end --- (Re-)Starts the schedules or a specific schedule if a valid ScheduleID is provided. -- @param #SCHEDULER self --- @param #number ScheduleID (optional) The ScheduleID of the planned (repeating) schedule. +-- @param #table ScheduleID (Optional) The ScheduleID of the planned (repeating) schedule. function SCHEDULER:Start( ScheduleID ) self:F3( { ScheduleID } ) - _SCHEDULEDISPATCHER:Start( self, ScheduleID ) end --- Stops the schedules or a specific schedule if a valid ScheduleID is provided. -- @param #SCHEDULER self --- @param #number ScheduleID (optional) The ScheduleID of the planned (repeating) schedule. +-- @param #table ScheduleID (Optional) The ScheduleID of the planned (repeating) schedule. function SCHEDULER:Stop( ScheduleID ) self:F3( { ScheduleID } ) - _SCHEDULEDISPATCHER:Stop( self, ScheduleID ) end @@ -290,7 +288,6 @@ end -- @param #number ScheduleID (optional) The ScheduleID of the planned (repeating) schedule. function SCHEDULER:Remove( ScheduleID ) self:F3( { ScheduleID } ) - _SCHEDULEDISPATCHER:Remove( self, ScheduleID ) end @@ -298,28 +295,17 @@ end -- @param #SCHEDULER self function SCHEDULER:Clear() self:F3( ) - _SCHEDULEDISPATCHER:Clear( self ) end +--- Show tracing for this scheduler. +-- @param #SCHEDULER self +function SCHEDULER:ShowTrace() + _SCHEDULEDISPATCHER:ShowTrace( self ) +end + --- No tracing for this scheduler. -- @param #SCHEDULER self --- @param #number ScheduleID (optional) The ScheduleID of the planned (repeating) schedule. function SCHEDULER:NoTrace() - _SCHEDULEDISPATCHER:NoTrace( self ) end - - - - - - - - - - - - - - diff --git a/Moose Development/Moose/Globals.lua b/Moose Development/Moose/Globals.lua index 05f3b8cf3..bdde44b6d 100644 --- a/Moose Development/Moose/Globals.lua +++ b/Moose Development/Moose/Globals.lua @@ -5,7 +5,7 @@ _EVENTDISPATCHER = EVENT:New() -- Core.Event#EVENT --- Declare the timer dispatcher based on the SCHEDULEDISPATCHER class -_SCHEDULEDISPATCHER = SCHEDULEDISPATCHER:New() -- Core.Timer#SCHEDULEDISPATCHER +_SCHEDULEDISPATCHER = SCHEDULEDISPATCHER:New() -- Core.ScheduleDispatcher#SCHEDULEDISPATCHER --- Declare the main database object, which is used internally by the MOOSE classes. _DATABASE = DATABASE:New() -- Core.Database#DATABASE