RTLayerConnector.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 __RTLayerConnector_h__
#define __RTLayerConnector_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTCachedString_h__
#include <RTCachedString.h>
#endif
 
#ifndef __RTDictionary_h__
#include <RTDictionary.h>
#endif
 
#ifndef __RTLayerData_h__
#include <RTLayerData.h>
#endif
 
struct RTBindingEnd;
class  RTProtocol;
class  RTQueue;
 
class RTLayerConnector
{
public:
    // static features
 
    struct NameBuffer
    {
    RTS_INLINE        NameBuffer( void );
              NameBuffer( const NameBuffer & );
    RTS_INLINE        ~NameBuffer( void );
    NameBuffer      & operator=( const NameBuffer & );
 
    const char      * value;
    char            * large_buffer;
    char              small_buffer[ 80 ];
    };
 
    static const char    defaultService[];
    static void          parseService( const char *, NameBuffer & );
    static const char  * parseName( const char * );
 
    static void          lock( void );
    static void          unlock( void );
 
    static void          showSAPs( void );
 
    static RTLayerData  * registerSAP( RTController *,
                       RTProtocol   *,
                       const char   * );
 
    static RTLayerData  * registerSPP( RTController *,
                       RTProtocol   *,
                       const char   * );
 
    static void          cleanup( void );
 
    enum CheckOption { CheckNow, CheckedAlready };
 
    static void          bind  ( RTController *, RTBindingEnd &,
                         RTBindingEnd &,
                         CheckOption = CheckNow );
    static void          unbind( RTController *, RTBindingEnd & );
    static void          unbind( RTController *, RTProtocol   & );
 
    // instance features
 
             RTLayerConnector( void );
    virtual              ~RTLayerConnector( void );
 
    int                  install  ( RTController *, const char * name );
    int                  uninstall( RTController *, const char * name );
 
    virtual RTLayerData * _registerSAP( RTController *,
                    RTProtocol   *,
                    const char   * ) = 0;
 
    virtual RTLayerData * _registerSPP( RTController *,
                    RTProtocol   *,
                    const char   * ) = 0;
 
    virtual void         _enumerate( void ) const = 0;
 
private:
    class Pending : public RTLayerData
    {
    public:
         Pending( RTQueue *, RTProtocol *, const char * );
    virtual  ~Pending( void );
 
    virtual const char * getRegisteredName( void ) const override;
 
    virtual void         resize( RTController * context, int old_size ) override;
 
    virtual void         deregister( RTController * context ) override;
 
    int                  size( void ) const;
 
    RTQueue            * queue;
    RTProtocol         * port;
    RTCachedString       name;
    }; //lint !e1712
 
    static RTDictionary connectors;
    static RTDictionary pendingSAPs;
    static RTDictionary pendingSPPs;
 
    static int total_replication( const RTQueue * queue );
 
    // unavailable methods
    RTLayerConnector( const RTLayerConnector & );
    RTLayerConnector & operator=( const RTLayerConnector & );
}; //lint !e1712
 
#if RTS_INLINES
#include <RTLayerConnector.inl>
#endif
 
#endif // __RTLayerConnector_h__