RTMessage.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 __RTMessage_h__
#define __RTMessage_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTTimespec_h__
#include <RTTimespec.h>
#endif
 
class  RTActor;
class  RTController;
class  RTDataObject;
struct RTObject_class;
class  RTProtocol;
struct RTTypedValue;
 
class RTMessage
{
public: // these really should be private
    RTMessage             * next;
 
#if OTRTSDEBUG != DEBUG_NONE
    int                     _sendPortId;
    int                     _sendPortIndex;
    int                     _sendProbeId;
    RTTimespec              _sendTime;
#endif
 
public:
    union
    {
        void              * data;
        const void        * const_data;
    };
    short                   signal;
    unsigned char           priority;
 
protected:
    unsigned char           _flags;
    RTActor               * _receiver;
    RTProtocol            * _port;
    int                     _portIndex;
    const RTObject_class  * _type;
 
#if RTMESSAGE_PAYLOAD_SIZE != 0
    // space for a small amount of data
    union
    {
        char                _data_area[ RTMESSAGE_PAYLOAD_SIZE ];
        RTAlignment         _alignment;
    };
#endif
 
    void                    _internData( bool moveData );
 
    enum
    {
        MaskDeferred  = 1,
        MaskDataOwned = 2
    };
 
public:
    RTS_INLINE void         clear( void );
 
    RTS_INLINE              RTMessage( void );
                            RTMessage( const RTMessage & );
 
    RTS_INLINE              ~RTMessage( void );
 
    RTS_INLINE int          isRTData( void ) const;
 
    RTS_INLINE void         setDeferred( void );
 
    RTS_INLINE void         resetDeferred( void );
 
    RTS_INLINE int          isDeferred( void ) const;
 
    RTS_INLINE void         setInvalid( void );
 
    RTS_INLINE int          isValid( void ) const;
 
    RTS_INLINE void         setSignal( int id);
 
    RTS_INLINE int          getSignal( void ) const;
 
    const char            * getSignalName( void ) const;
 
    RTS_INLINE void         setPriority( int prio);
 
    RTS_INLINE int          getPriority( void ) const;
 
    RTS_INLINE void       * getData( void ) const;
 
    RTS_INLINE void         setData( const void * data, const RTObject_class * type);
 
    RTS_INLINE void         setData( const RTDataObject & data);
 
    RTS_INLINE void         internData( bool moveData = false );
 
    RTS_INLINE const RTObject_class * getType( void ) const;
 
    RTS_INLINE RTProtocol * sap( void ) const;
 
    int                     sapId( void ) const;
 
    RTS_INLINE int          sapIndex0( void ) const;
 
    RTS_INLINE int          sapIndex( void ) const;
 
    enum DeliverResult
    {
        Accepted
      , Deferred
      , Rejected // signal or type invalid
    };
 
    DeliverResult           deliver( void );
 
    RTMessage             & operator=( const RTMessage & );
 
    int                     defer( void ) const;
 
    RTS_INLINE void         setDestination( RTActor * cap, RTProtocol * port, int index);
 
    RTS_INLINE RTActor    * receiver( void ) const;
 
    RTS_INLINE RTController * context( void ) const;
};
 
#if RTS_INLINES
#include <RTMessage.inl>
#endif
 
#endif // __RTMessage_h__