RTActorRef.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 __RTActorRef_h__
#define __RTActorRef_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTConfig_h__
#include <RTConfig.h>
#endif
 
class  RTActor;
struct RTActorClass;
class  RTActorFactoryInterface;
class  RTActorFactory;
class  RTActorId;
class  RTActorRefProbe;
struct RTBindingEnd;
struct RTComponentDescriptor;
class  RTController;
class  RTDataObject;
union  RTImportList;
struct RTObject_class;
 
class RTActorRef
{
private:
    const RTComponentDescriptor   * _info;
    void                          * _contents;
 
#if USE_THREADS
    friend class RTActor;
 
    static void                 lock( void );
    static void                 unlock( void );
#endif
 
    RTActor                  ** access( int ) const;
    int                         reserve( int & );
    void                        unreserve( int );
    void                        add( RTActor *, int );
    void                        remove( int );
 
public:
#if OBSERVABLE
    RTActorRefProbe           * probe;
#endif
 
    RTS_INLINE RTActor        * getOwner( void ) const;
 
    RTS_INLINE int              size( void ) const;
 
    RTS_INLINE int              getId( void ) const;
 
    RTS_INLINE const char     * getName( void ) const;
 
    RTS_INLINE const RTComponentDescriptor * getInfo( void ) const;
 
    RTS_INLINE RTController   * context( void );
 
    void                        incarnateAll( void );
 
    void                        initializeAll( void );
 
    RTActor                   * incarnate( const RTActorClass   & cap,
                                           const void           * data,
                                           const RTObject_class * type,
                                           RTController         * controller,
                                           int                    index,
                                           RTActorFactory       * factory = nullptr);
 
    int                         destroy( void );
 
    int                         destroy( RTActor * i );
 
    int                         import( RTActor * i, int index);
 
    void                        deport( void );
 
    int                         deport( RTActor * i);
 
    int                         deport( RTActor *, RTImportList *, RTController * initiator );
 
    RTS_INLINE int              isFixed( void ) const;
 
    RTS_INLINE int              isOptional( void ) const;
 
    RTS_INLINE int              isImported( void ) const;
 
    RTS_INLINE RTActor        * operator[]( int index) const;
 
    RTS_INLINE RTActor        * at( int index) const;
 
    int                         indexOf( const RTActor * i) const;
 
    RTS_INLINE                  RTActorRef( void );
                                ~RTActorRef( void );
 
    RTS_INLINE int              operator==( const RTActorId & ) const;
    RTS_INLINE int              operator!=( const RTActorId & ) const;
 
    void                        init( const RTComponentDescriptor * info );
 
    int                         _followIn( RTBindingEnd & end,
                                           int            portId,
                                           int            portIndex );
    int                         _followOut( RTBindingEnd & end,
                                            RTActor      * member,
                                            int            portId,
                                            int            portIndex );
 
private:
    int                         bind_ports( RTActor    * member,
                                            int          index,
                                            RTActorRef * importer );
 
    RTActor                   * incarnate2( const RTActorClass *,
                                            RTController       *,
                                            int                          index,
                                            RTActorFactoryInterface    * factory = nullptr );
 
    // unavailable methods
    RTActorRef( const RTActorRef & );
    RTActorRef & operator=( const RTActorRef & );
};
 
#if RTS_INLINES
#include <RTActorRef.inl>
#endif
 
#endif // __RTActorRef_h__