RTFrame.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 __RTFrame_h__
#define __RTFrame_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTActorId_h__
#include <RTActorId.h>
#endif
 
#ifndef __RTController_h__
#include <RTController.h>
#endif
 
#ifndef __RTProtocol_h__
#include <RTProtocol.h>
#endif
 
struct RTActorClass;
class  RTActorRef;
class  RTController;
struct RTTypedValue;
 
struct Frame
{
    class Base : public RTProtocol
    {
    public:
        RTS_INLINE      Base( void );
        RTS_INLINE      ~Base( void );
 
        static const RTProtocolDescriptor rt_class;
 
        RTActorId       incarnate( RTActorRef & cp);
 
        RTActorId       incarnate( RTActorRef & cp, const RTActorClass & cap);
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const void * data,
                                   const RTObject_class * type,
                                   RTController * controller,
                                   int index );
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const RTActorClass & cap,
                                   const void * data,
                                   const RTObject_class * type,
                                   RTController * controller,
                                   int index );
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const RTDataObject & data,
                                   RTController * controller = nullptr,
                                   int index = -1 );
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const RTActorClass & cap,
                                   const RTDataObject & data,
                                   RTController * controller = nullptr,
                                   int index = -1 );
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const RTTypedValue & info,
                                   RTController * controller = nullptr,
                                   int index = -1 );
 
        RTActorId       incarnate( RTActorRef & cp,
                                   const RTActorClass & cap,
                                   const RTTypedValue & info,
                                   RTController * controller = nullptr,
                                   int index = -1 );
#if RTUseCPP11
        RTActorId       incarnateCustom( RTActorRef & cp,
                                         RTActorFactory& factory,
                                         int index = -1);
 
        RTActorId       incarnateCustom( RTActorRef & cp,
                                         RTActorFactory&& factory, // To allow temporary factory objects
                                         int index = -1);
 
        RTActorId       incarnateCustom( RTActorRef & cp,
                                         const void * data,
                                         const RTObject_class * type,
                                         RTActorFactory& factory,
                                         int index = -1);
 
        RTActorId       incarnateCustom( RTActorRef & cp,
                                         const void * data,
                                         const RTObject_class * type,
                                         RTActorFactory&& factory, // To allow temporary factory objects
                                         int index = -1);
#endif
 
        int             destroy( RTActorId  & i);
 
        int             destroy( RTActorRef & cp);
 
        int             import( const RTActorId & i,
                                RTActorRef & cp_dest,
                                int index = -1 );
 
        int             import( RTActorRef & cp_src,
                                RTActorRef & cp_dest,
                                int index = -1 );
 
        int             deport( const RTActorId & i,
                                RTActorRef & cp);
 
        RTActorId    ** incarnationsOf( const RTActorRef & cp );
 
        RTActorId       incarnationAt ( const RTActorRef & cp,
                                        int index );
 
        RTActorId       me( void );
 
        const RTActorClass & myClass( void );
 
        const RTActorClass & classOf( const RTActorId & instance );
 
        int classIsKindOf( const RTActorClass & subClass,
                           const RTActorClass & superClass );
 
        const char * className( const RTActorClass & );
 
    private:
#if RTFRAME_CHECKING != RTFRAME_CHECK_NONE
        int             permissionCheck( RTController::Primitive,
                                         RTActorRef *,
                                         int trace );
#endif
 
        // unavailable methods
        Base( const Base & );
        Base & operator=( const Base & );
    };
};
 
#if RTS_INLINES
#include <RTFrame.inl>
#endif
 
#endif // __RTFrame_h__