RTProtocol.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 __RTProtocol_h__
#define __RTProtocol_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTPriority_h_
#include <RTPriority.h>
#endif
 
#ifndef __RTProtocolDescriptor_h__
#include <RTProtocolDescriptor.h>
#endif
 
class  RTActor;
class  RTActorProbe;
struct RTBindingEnd;
class  RTController;
class  RTDebugger;
struct RTExceptionSignal;
struct RTInSignal;
class  RTLayerConnector;
class  RTLayerData;
class  RTMessage;
struct RTObject_class;
struct RTOutSignal;
struct RTPortDescriptor;
struct RTSymmetricSignal;
struct RTTypedValue;
 
class RTProtocol
{
public:
    RTS_INLINE RTProtocol( void );
               ~RTProtocol( void );
 
    RTController * context( void ) const;
 
    RTS_INLINE int getId( void ) const;
 
    const RTPortDescriptor * getInfo( void ) const;
 
    RTS_INLINE const char * getName( void ) const;
 
    RTS_INLINE RTActor * getOwner( void ) const;
 
    RTS_INLINE int size( void ) const;
 
    int resize( int new_size );
 
    RTS_INLINE int registerSAP( const char * service);
 
    RTS_INLINE int deregisterSAP( void );
 
    RTS_INLINE int registerSPP( const char * service);
 
    RTS_INLINE int deregisterSPP( void );
 
    const char * defaultLayerName( void ) const;
 
    RTS_INLINE int isRegistered( void ) const;
 
    const char * getRegisteredName( void ) const;
 
#if RTS_COMPATIBLE <= 520
    int registerAs( const char * service);
#endif
 
    int deregister( void );
 
    int isBoundAt( int index ) const;
 
    int isIndexTo( int index, RTActor * capsule) const;
 
    int indexTo( RTActor * capsule) const;
 
    // Managing the defer queue: These functions match any signal.
 
    int purge( void );
 
    int purgeAt( int index );
 
    int recall( void );
 
    int recallFront( void );
 
    int recallAt( int index, int front = 0 );
 
    int recallAll( void );
 
    int recallAllFront( void );
 
    int recallAllAt( int index, int front = 0 );
 
    void bindingNotification( int on_off );
 
    RTS_INLINE int bindingNotificationRequested( void ) const;
 
    void sendTypeCheckEnable( int on_off );
 
    RTS_INLINE int sendTypeCheckEnabled( void ) const;
 
    RTProtocolDescriptor::Status sendCheck( int signal, const RTObject_class * type ) const;
 
    void receiveTypeCheckEnable( int on_off );
 
    RTS_INLINE int receiveTypeCheckEnabled( void ) const;
 
    RTProtocolDescriptor::Status receiveCheck( int signal, const RTObject_class * type ) const;
 
protected:
    enum
    {
        BindingNotification     =  1
          , RegisteredAsSAP     =  2
          , SendTypeCheck       =  4
          , ReceiveTypeCheck    =  8
          , Resized             = 16
    };
 
    void                     init( const RTPortDescriptor * );
 
    RTS_INLINE int           getFlags( void ) const;
    void                     setFlag( int );
    void                     resetFlag( int );
 
    void                     bindAt( int, RTBindingEnd &, RTController * );
    int                      peerAt( int, RTBindingEnd & );
    void                     unbindAt( int, RTController * );
 
    void                     notifyInit( RTController * );
    void                     notifyBoundAt( int, RTController * );
 
    // Derived classes define additional incoming signals starting
    // with ( rtiLast_{BASE} + 1 ) and will define rtiLast_{CLASS}
    // as its last signal.
    enum
    {
        rtiLast_RTProtocol = 0
    };
 
private:
    // Represents a port instance
    struct End
    {
        enum State
        {
            Unbound,
            Bound,
            BoundXThread
        };
 
        State           state;
        RTProtocol    * remote;
        int             remoteIndex;
        const int     * signalMap;
 
        // these are only called after the priority and type are checked
 
        int send( RTController         * sender,
                  RTProtocol           * port,
                  int                    index,
                  int                    signal,
                  const void           * data,
                  const RTObject_class * type,
                  int                    prio,
                  bool                   moveData );
 
        int invoke( RTMessage            * replyBuffer,
                    RTController         * invoker,
                    RTProtocol           * port,
                    int                    index,
                    int                    signal,
                    const void           * data,
                    const RTObject_class * type,
                    bool implicitReply);
    };
 
    End                    * _ends;
    const RTPortDescriptor * _info;
    int                      _flags;
    RTLayerData            * _layer;
 
    // unavailable methods
    RTProtocol( const RTProtocol & );
    RTProtocol & operator=( const RTProtocol & );
 
    friend struct End;
    friend class  RTActor;
    friend class  RTActorProbe;
    friend class  RTDebugger;
    friend class  RTLayerConnector;
 
    enum CallStyle { Programmatic, Automatic };
 
    int registerSAP( const char *, CallStyle );
    int deregisterSAP( CallStyle );
 
    int registerSPP( const char *, CallStyle );
    int deregisterSPP( CallStyle );
 
    // These classes must have access to the methods below.
    friend struct RTExceptionSignal;
    friend struct RTInSignal;
    friend struct RTOutSignal;
    friend struct RTSymmetricSignal;
 
    // support for "in" signals
 
    int purge      ( int signal );
    int purgeAt    ( int signal, int index );
 
    int recall     ( int signal,            int front );
    int recallAt   ( int signal, int index, int front );
 
    int recallAll  ( int signal,            int front );
    int recallAllAt( int signal, int index, int front );
 
public:
    // support for "out" signals
    // These need to be public to support programmatic invoke, reply and send on a general port based on descriptor info
 
    int invoke( RTMessage            * replyBuffer,
                int                    signal,
                const void           * data,
                const RTObject_class * type,
                bool implicitReply);
 
    int invokeAt( int                    index,
                  RTMessage            * replyBuffer,
                  int                    signal,
                  const void           * data,
                  const RTObject_class * type,
                  bool implicitReply);
 
    int reply( int                    signal,
               const void           * data,
               const RTObject_class * type );
 
    int send( int                    signal,
              const void           * data,
              const RTObject_class * type,
              int                    priority,
              bool                   moveData = false);
 
    int sendAt( int                    index,
                int                    signal,
                const void           * data,
                const RTObject_class * type,
                int                    priority,
                bool                   moveData = false);
 
private:
    // support for "exception" signals
    int raise( int                    signal,
               const void           * data,
               const RTObject_class * type );
};
 
#if RTS_INLINES
#include <RTProtocol.inl>
#endif
 
#endif // __RTProtocol_h__