RTActor.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTActor_h__
#define __RTActor_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTController_h__
#include <RTController.h>
#endif
 
#ifndef __RTVersionId_h__
#include <RTVersionId.h>
#endif
 
struct RTActorClass;
class  RTActorProbe;
class  RTActorRef;
struct RTActor_class;
struct RTBindingEnd;
struct RTComponentDescriptor;
class  RTDebugger;
union  RTImportList;
class  RTMessage;
struct RTObject_class;
class  RTProtocol;
class  RTRelayPort;
 
class RTActor
{
    friend class RTActorRef;
    friend class RTController;
    friend class RTDebugger;
    friend class RTMessage;
    friend class RTProtocol;
 
private: // instance data
    RTController      * rts;
    RTActorRef        * homeReference;
    int                 homeIndex;
    RTRelayPort       * relays;
#if DEFER_IN_ACTOR
    RTMessageQ          deferredQ;
#endif
#if SUSPEND
    RTMessage         * suspendMsgs; // stack of messages which arrived while the actor was suspended
#endif
 
    RTImportList      * importList;
 
    struct State
    {
        RTStateId          current;
#if RTStateId_MaxSize > 1
        unsigned char      idShift; // log2( log256( getNumStates() ) )
#endif
        union
        {
            unsigned char  s1[ 1 ];
#if RTStateId_MaxSize > 1
            unsigned short s2[ 1 ];
#endif
#if RTStateId_MaxSize > 2
            unsigned int   s4[ 1 ];
#endif
        } history;
    };
 
    State             * state;
 
public: // instance data
 
    const RTMessage   * msg;
 
#if OBSERVABLE
    RTActorProbe      * probe;
#endif
 
protected: // functions
 
    RTS_INLINE void         saveHistory( void );
 
    RTS_INLINE void         setCurrentState( int s);
 
    virtual void            unhandledMessage( void );
 
    virtual void            unexpectedMessage( void );
 
    virtual void            messageReceivedBeforeInitialized( void );
 
    void                    unexpectedState( void );
 
#if ! OBSERVABLE
    RTS_INLINE
#endif
    void                    rtgChainBegin( int origin, const char * trans );
 
#if ! OBSERVABLE
    RTS_INLINE
#endif
    void                    rtgTransitionBegin( void );
 
#if ! OBSERVABLE
    RTS_INLINE
#endif
    void                    rtgTransitionEnd( void );
 
    void                    enterState( int );
    virtual void            enterStateV( void );
 
    virtual void            rtgStateEntry( void );
 
    void                    exitState( const RTStateId parent[] );
    virtual void            exitStateV( void );
    void                    processHistory( void );
    void                    exitToChainState( int, const RTStateId parent[] );
 
    void                    initializeAll( void );
 
    int                     removeImport( RTActorRef * ,RTController * initiator );
    void                    removeAllImports( RTController * initiator );
 
    int                     _followIn( RTBindingEnd & end,
                                       int portId,
                                       int repIndex,
                                       RTActorRef * importer );
 
    int                     _followOut( RTBindingEnd & end,
                                        int portId,
                                        int repIndex );
 
    void                    _unbind( RTActorRef * importer  ,RTController* initiator);
    virtual void            _predestroy( void );
 
public: // functions
 
    RTActor( RTController *, RTActorRef * );
 
    virtual ~RTActor( void );
 
    RTS_INLINE int          getIndex( void ) const;
 
    RTS_INLINE int          index( void ) const;
 
    RTS_INLINE int          getId( void ) const;
 
    const char            * getName( void ) const;
 
    RTS_INLINE RTActorRef * getReference( void ) const;
 
    RTS_INLINE const RTMessage * getMsg( void );
 
    RTS_INLINE int          sendCopyToMe ( const RTMessage* msg );
 
    virtual void            rtsBehavior( int signal, int port ) = 0;
 
#if LOG_MESSAGE
    virtual void            logMsg( void );
#endif
 
    RTS_INLINE RTController * context( void ) const;
 
    RTS_INLINE int          isActive( void ) const;
 
    virtual int             designLevel( void ) const;
 
    RTS_INLINE const char * getTypeName( void ) const;
 
    RTS_INLINE RTVersionId  getVersion( void ) const;
 
    RTS_INLINE int          isSameType( const RTActorClass * cap) const;
 
    int                     isType( const char * str) const;
 
#if SUSPEND
    void                    suspend( void );
    void                    resume( void );
    RTS_INLINE int          isSuspended( void ) const;
#endif
 
    virtual const RTActor_class  * getActorData( void ) const = 0;
 
    int                     getNumStates( void ) const;
 
    const char            * getStateString( int s) const;
 
    const char            * getCurrentStateString( void ) const;
 
    RTS_INLINE int          getCurrentState( void ) const;
 
    RTS_INLINE int          getHistory( int ) const;
 
    int                     _numComponents( void ) const;
    RTActorRef            * _component( int compId );
 
    void                    _preinitialize( int _homeIndex,
                                            const RTComponentDescriptor * );
    int                     initMe( const void           * data,
                                    const RTObject_class * type,
                                    RTController         * sender );
 
#if RTIMPORT_ISREFERENCEDBY_CHECK
    int                     isReferencedBy( const RTActor * ) const;
#endif
 
    virtual const RTActorClass * defaultClass( RTActorRef & component,
                                               int          repIndex );
 
    virtual RTController  * defaultController( RTActorRef & component,
                                               int          repIndex );
 
    void                    _incarnateAllFixed( void );
 
    // The functions below are generated by the toolset.
    virtual int             _followOutV( RTBindingEnd & end,
                                         int            compId,
                                         int            portId,
                                         int            portIndex );
 
    // This function is simply inherited unless the actor has additional
    // (interface) ports or has excluded ports of its superclass.
    virtual int             _followInV( RTBindingEnd & end,
                                        int            portId,
                                        int            repIndex );
 
protected:
    RTS_INLINE RTController::Error getError( void ) const;
 
private:
    // unavailable methods
    RTActor( const RTActor & );
    RTActor & operator=( const RTActor & );
}; //lint !e1712
 
#if RTS_INLINES
#include <RTActor.inl>
#endif
 
#endif // __RTActor_h__