action.hh

#ifndef _DRAMA2_ACTION_INC
#define _DRAMA2_ACTION_INC
 
/*
 *+                     a c t i o n . h h
 
 * Include File name:
      drama/action.hh
 
 * Function:
       DRAMA 2 include file - Action Implementation class definition.
 
 * Description:
      The drama::Action class is used to manage the implementation of
      actions in the Drama2 system. 
 
       Internal support class - not to be used by user code.
 
 * Language:
      C++   
 
 * Support: Tony Farrell, AAO
 
 *-
 
 * "@(#) $Id$"
 
 * History:
     31-Jan-2014 - TJF - Original version
 
 *  Copyright (c) Australian Astronomical Observatory, 2014.
    Not to be used for commercial purposes without permission.
    No warranty of any form unless subject to a specific agreement.
 
 */
#include "drama/task.hh"
#include "drama/action.hh"
#include "drama/messagehandler.hh"
//#include "util/heaptracked.hh"
#include "drama/entryinfo.hh"
#include "drama/request.hh"
#include "status.h"
#include <memory>
namespace drama { 
 
    class Task;   // Needed by Action below.
    class Action;
    class ActionHandler;
    class Spawnable;
 
    using ActionHandlerPtr = std::shared_ptr<ActionHandler> ;
 
    class ActionHandler {
        friend class drama::Action; // Action is allow to call our private methods.
        friend class drama::Spawnable;
    private:
 
        /* MessageEvent is invoked when a message is received. Must invoke
         *  the sub-class's method.
         */
        virtual Request MessageEvent(std::weak_ptr<Task> task, Action *action) = 0;
        /* This is invoked when the action ends.  Invokes the user overideable 
         *   method ActionEnd().
         */
        virtual void InvokeActionEnd(std::weak_ptr<Task> task, Action *action,
                                     bool taskExiting, 
                                     StatusType actionEndStatus) = 0;
 
        /*
         * The action we are part of.
         */
        Action *_actionPtr = nullptr;
    public:
 
 
        /*
         * Destructor.
         */
        virtual ~ActionHandler();
        void SetAction( Action *action);
  
    };
 
 
    class Action {
    private:
 
       // We store the valid ID_CODE in every object we create.  This
        // is to allow us to check in static handlers invoked by DRAMA
        // code that we have the right type of object.  Not a perfect thing,
        // but helps find issues.  
        static const long int ID_CODE = 0x2398434;
        const long int _checkIdCode = ID_CODE;
 
        friend class drama::Task; // Task is allow to call some functions here.
        friend class drama::Spawnable; // Spawnable is allow to create these.
        
        /*
         * Pointer to the DRAMA task this action is part of.
         */
        std::weak_ptr<Task> _theTask;
        /*
         * Name of this action.  Never changed, so is const.
         */
        const std::string _actionName;  
 
        /* Non-static obey, kick and action end handlers */
        virtual void ObeyHandler(StatusType *status);
        virtual void KickHandler(StatusType *status);
 
        /*
         * ActionHandlerPtr is typedef-ed to "std::shared_ptr<ActionHandler>".
         */
 
        /*
         * Object specified by the user to be invoked to  implement the action.
         */
        ActionHandlerPtr _origActionHandler=nullptr;     
        /*
         * Object specified by the user to implement the next Obey reschedule event.
         * Can be changed.
         */ 
        ActionHandlerPtr _currentObeyHandler=nullptr;   
        /*
         * Object specified by the user to implement the next Kick event.
         * Can be changed.
         */ 
        ActionHandlerPtr _currentKickHandler=nullptr;  
 
        /*
         * We need to know if we are currently in an obey or kick 
         */
        bool _runningAction=false;
 
        // *************
        // Methods that drama::Task is allowed to access.
 
 
 
 
        // Static routines invoked by drama::Task for Obey and Kick messages.
        //  DitsGetCode() should point to the object.
        static void ObeyHandlerStatic(StatusType *status);
        static void KickHandlerStatic(StatusType *status);
 
 
        // Invoked when the action object is deleted as the task shuts down.
        static void Cleanup(long int code, StatusType * const status);
 
 
        // Invoked when the action ends.
        static void ActEndHandlerStatic(DVOIDP client_data,
                                        int taskExit,
                                        StatusType exitStatus,
                                        StatusType *status);
 
 
        // Invoke the obey method.
        Request InvokeCurrentObey();
 
    protected:
        virtual ~Action();
 
        Action(ActionHandlerPtr obj, std::weak_ptr<Task> task, const std::string &name) :
            _theTask(task),
            _actionName(name),
            _origActionHandler(obj),
            _currentObeyHandler(obj)
        {
            obj->SetAction(this);
        }
 
        // End of methods drama::Task is allowed to access
        // *************
 
        virtual void ActEndHandler(bool taskExit,
                                   StatusType exitStatus,
                                   StatusType *status);
 
    public:
        void PutObeyHandler(ActionHandlerPtr obj) {
            if (!_runningAction)
                DramaTHROW(DRAMA2__INV_CALL_FRM_NONACT,
                           "Tried to change Obey handler when not in action.");
            _currentObeyHandler = obj;
        }
        void PutKickHandler(ActionHandlerPtr obj) {
            if (!_runningAction)
                DramaTHROW(DRAMA2__INV_CALL_FRM_NONACT,
                           "Tried to change Kick handler when not in action.");
            _currentKickHandler = obj;
        }
 
 
        /*
         * Used by ~ActionHandler to indicate the  action handler object
         * has been destroyed.
         */
        void _HandlerGone() {
#if 0
            fprintf(stderr,"Action:_HandlerGone - %p\n", (void *)(this));
#endif
            _origActionHandler = nullptr;
        }
 
        /*
         * Get Name
         */
        std::string GetActionName() const {
            return _actionName;
        }
    };
 
 
} // namespace drama
 
#endif