models/samples/ComputerSystem/expected_src/ResourceManager.cc

#include "ResourceManager.hh"

#include "Resource.hh"
#include "USBDeviceDriver.hh"
#include "umlrtcommsportrole.hh"
#include "umlrtmessage.hh"
#include "umlrtslot.hh"
#include "umlrttimerprotocol.hh"
#include <cstddef>
#include "umlrtcapsuleclass.hh"
#include "umlrtcapsulepart.hh"
#include "umlrtcapsulerole.hh"
#include "umlrtframeservice.hh"
class UMLRTRtsInterface;
struct UMLRTCommsPort;

Capsule_ResourceManager::Capsule_ResourceManager( const UMLRTCapsuleClass * cd, UMLRTSlot * st, const UMLRTCommsPort * * border, const UMLRTCommsPort * * internal, bool isStat )
: UMLRTCapsule( NULL, cd, st, border, internal, isStat )
, appPort( borderPorts[borderport_appPort] )
, frame( borderPorts[borderport_frame] )
, resMgr( borderPorts[borderport_resMgr] )
, timer( borderPorts[borderport_timer] )
, usbPrinterDriver( &slot->parts[part_usbPrinterDriver] )
, usbStorageDriver( &slot->parts[part_usbStorageDriver] )
, printerRequestCount( 0 )
, storageRequestCount( 0 )
, currentState( SPECIAL_INTERNAL_STATE_UNVISITED )
{
    stateNames[top__InitFail] = "top__InitFail";
    stateNames[top__WaitingForRequest] = "top__WaitingForRequest";
    stateNames[top__WaitInitTimeout] = "top__WaitInitTimeout";
    stateNames[SPECIAL_INTERNAL_STATE_UNVISITED] = "<uninitialized>";
}










void Capsule_ResourceManager::bindPort( bool isBorder, int portId, int index )
{
    if( isBorder )
        switch( portId )
        {
        case borderport_appPort:
            UMLRTFrameService::sendBoundUnbound( borderPorts, borderport_appPort, index, true );
            break;
        case borderport_resMgr:
            UMLRTFrameService::sendBoundUnbound( borderPorts, borderport_resMgr, index, true );
            break;
        }
}

void Capsule_ResourceManager::unbindPort( bool isBorder, int portId, int index )
{
    if( isBorder )
        switch( portId )
        {
        case borderport_appPort:
            UMLRTFrameService::sendBoundUnbound( borderPorts, borderport_appPort, index, false );
            UMLRTFrameService::disconnectPort( borderPorts[borderport_appPort], index );
            break;
        case borderport_resMgr:
            UMLRTFrameService::sendBoundUnbound( borderPorts, borderport_resMgr, index, false );
            UMLRTFrameService::disconnectPort( borderPorts[borderport_resMgr], index );
            break;
        }
}









void Capsule_ResourceManager::inject( const UMLRTMessage & message )
{
    msg = &message;
    switch( currentState )
    {
    case top__WaitingForRequest:
        currentState = state_____top__WaitingForRequest( &message );
        break;
    case top__InitFail:
        currentState = state_____top__InitFail( &message );
        break;
    case top__WaitInitTimeout:
        currentState = state_____top__WaitInitTimeout( &message );
        break;
    default:
        break;
    }
}

void Capsule_ResourceManager::initialize( const UMLRTMessage & message )
{
    msg = &message;
    actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__initialize( &message );
    currentState = choice_____top__instantiateOK( &message );
}

const char * Capsule_ResourceManager::getCurrentStateString() const
{
    return stateNames[currentState];
}




void Capsule_ResourceManager::entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__InitFail__initFailState( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_QH-LUA7dEeWWHqV5N_7gJQ */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    std::cout << "[" << this->getName() << "] is in state {InitFail}" << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitInitTimeout__waitOnTimeout( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_5nGcIA48EeWfxoP9jGN4_w */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] is in state {WaitInitTimeout}" << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_YOXT8O0NEeSzlZWHZcnPXA */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] is in state {WaitingForRequest},  waiting for a request" << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::exitaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__requestReceived( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_m4LMsA7dEeWWHqV5N_7gJQ */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] received a request!" << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK__InitiFailed( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_jXgVEPBOEeSy0dZlYL7EHw */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] FAILed to initialize!" << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK__InstantiateSuccess( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_qLX1kPBOEeSy0dZlYL7EHw */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] drivers instantiated." << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__initialize__Initialize( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_NM_EQMXIEeSsD5C2f30z-g */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] initializing";
    /**
    * In this version, we will initialize just the resources that are required for the demo.
    * This capsule could be made more intelligent by implemented managed pools.
    */
    bool localPrinterStatus;
    bool localStorageStatus;
    bool localTimerStatus;
    printerID = frame.incarnate(usbPrinterDriver, USBPrinterDriver);
    localPrinterStatus = printerID.isValid();
    if ( localPrinterStatus ) {
    std::cout << " - printer driver ready" << std::endl;
    } else {
    std::cout << " - ERROR instantiating printer driver" << std::endl;
    }
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] initializing";
    storageID = frame.incarnate(usbStorageDriver, USBStorageDriver);
    localStorageStatus = storageID.isValid();
    if ( localStorageStatus ) {
    std::cout << " - storage driver ready" << std::endl;
    } else {
    std::cout << " - ERROR instantiating storage driver" << std::endl;
    }
    status = ( localPrinterStatus && localStorageStatus);
    if (status) {
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] initializing - ";
    numSec = 10;
    timerID = timer.informIn(UMLRTTimespec(numSec,0));
    localTimerStatus = timerID.isValid();
    if ( ! localTimerStatus ) {
    std::cout << "FAILED to ";
    }
    std::cout << "set a " << numSec << " seconds timer for drivers initialization." << std::endl;
    }
    status = ( localPrinterStatus && localStorageStatus && localTimerStatus);
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPortStorageRequest__sendAppPortStorageResource( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_fybTYA8cEeWl7ddVi7dGGQ */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] storage resource requested by App,";
    if ( storageID.isValid() ) {
    if ( appPort.resourceID( storageID ).send() ) {
    std::cout << " and sent." << std::endl;
    } else {
    std::cout << " but ERROR sending storage resource!" << std::endl;
    }
    } else {
    if ( appPort.resNotAvail().send() ) {
    std::cout << " but storage resource not available sent." << std::endl;
    } else {
    std::cout << "but ERROR sending storage resource not available!" << std::endl;
    }
    }
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPrinterRequest__sendAppPortPrinterResource( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_BXI1oA8cEeWl7ddVi7dGGQ */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] printer resource requested by App,";
    if ( printerID.isValid() ) {
    if ( resMgr.resourceID( printerID ).send() ) {
    std::cout << " and sent." << std::endl;
    } else {
    std::cout << " but got an ERROR sending!" << std::endl;
    }
    } else {
    if ( resMgr.resNotAvail().send() ) {
    std::cout << "[ but printer resource is not available sent" << std::endl;
    } else {
    std::cout << "but ERROR sending printer resource not available" << std::endl;
    }
    }
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrPrinterRequest__sendResMgrPrinterResource( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_iA5vkMX-EeSsD5C2f30z-g */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] printer resource requested by computer,";
    if ( printerID.isValid() ) {
    if ( resMgr.resourceID( printerID ).send() ) {
    std::cout << " and sent." << std::endl;
    } else {
    std::cout << " but ERROR sending printer resource!" << std::endl;
    }
    } else {
    if ( resMgr.resNotAvail().send() ) {
    std::cout << " but printer resource not available sent." << std::endl;
    } else {
    std::cout << " but ERROR sending printer resource not available!" << std::endl;
    }
    }
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrStorageRequest__sendResMgrStorageResource( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_095lEMX-EeSsD5C2f30z-g */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    std::cout << "[" << this->getName() << "] storage resource requested by Computer,";
    if ( storageID.isValid() ) {
    if ( resMgr.resourceID( storageID ).send() ) {
    std::cout << " and sent." << std::endl;
    } else {
    std::cout << " but ERROR sending storage resource!" << std::endl;
    }
    } else {
    if ( resMgr.resNotAvail().send() ) {
    std::cout << " but storage resource not available sent." << std::endl;
    } else {
    std::cout << " but ERROR sending storage resource not available" << std::endl;
    }
    }
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onTimeout__broadcastReady( const UMLRTMessage * msg )
{
    // the following code has been generated
    /* UMLRT-CODEGEN:platform:/resource/ComputerSystem/ComputerSystem.uml#_T_5GEA5DEeWfxoP9jGN4_w */
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    time_t currentTime;
    struct tm *localTime;
    time( &currentTime );
    localTime = localtime( &currentTime );
    std::cout << std::setfill('0') << "[" << std::setw(2) << localTime->tm_hour << ":" << std::setw(2) << localTime->tm_min << ":" << std::setw(2) << localTime->tm_sec << "] ";
    /**
    * Telling the world that the ResourceManager is taking requests!
    */
    std::cout << "[" << this->getName() << "] ";
    if ( resMgr.resMgrRunning().send() ) {
    std::cout << "told ";

    } else {
    std::cout << "FAILED to tell ";
    }
    std::cout << "its clients that it is taking requests." << std::endl;
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

bool Capsule_ResourceManager::guard_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK__FailedInitialization( const UMLRTMessage * msg )
{
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    return ( ! status );
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

bool Capsule_ResourceManager::guard_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK__SuccesfulInitialization( const UMLRTMessage * msg )
{
    #define rtdata ( (void *)msg->getParam( 0 ) )
    // generated code ends
    return( status );
    // the following code has been generated
    #undef rtdata
    // generated code ends
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK( const UMLRTMessage * msg )
{
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK__InitiFailed( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__InitFail__initFailState( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK( const UMLRTMessage * msg )
{
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK__InstantiateSuccess( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitInitTimeout__waitOnTimeout( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__initialize( const UMLRTMessage * msg )
{
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__initialize__Initialize( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPortStorageRequest( const UMLRTMessage * msg )
{
    exitaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__requestReceived( msg );
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPortStorageRequest__sendAppPortStorageResource( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPrinterRequest( const UMLRTMessage * msg )
{
    exitaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__requestReceived( msg );
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPrinterRequest__sendAppPortPrinterResource( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrPrinterRequest( const UMLRTMessage * msg )
{
    exitaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__requestReceived( msg );
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrPrinterRequest__sendResMgrPrinterResource( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrStorageRequest( const UMLRTMessage * msg )
{
    exitaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__requestReceived( msg );
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrStorageRequest__sendResMgrStorageResource( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( msg );
}

void Capsule_ResourceManager::actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onTimeout( const UMLRTMessage * msg )
{
    transitionaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onTimeout__broadcastReady( msg );
    entryaction_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__WaitingForRequest__waitingForRequest( msg );
}

Capsule_ResourceManager::State Capsule_ResourceManager::choice_____top__instantiateOK( const UMLRTMessage * msg )
{
    if( guard_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK__SuccesfulInitialization( msg ) )
    {
        actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__OK( msg );
        return top__WaitInitTimeout;
    }
    else if( guard_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK__FailedInitialization( msg ) )
    {
        actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__NOK( msg );
        return top__InitFail;
    }
    return currentState;
}

Capsule_ResourceManager::State Capsule_ResourceManager::state_____top__InitFail( const UMLRTMessage * msg )
{
    switch( msg->destPort->role()->id )
    {
    default:
        this->unexpectedMessage();
        break;
    }
    return currentState;
}

Capsule_ResourceManager::State Capsule_ResourceManager::state_____top__WaitInitTimeout( const UMLRTMessage * msg )
{
    switch( msg->destPort->role()->id )
    {
    case port_timer:
        switch( msg->getSignalId() )
        {
        case UMLRTTimerProtocol::signal_timeout:
            actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onTimeout( msg );
            return top__WaitingForRequest;
        default:
            this->unexpectedMessage();
            break;
        }
        return currentState;
    default:
        this->unexpectedMessage();
        break;
    }
    return currentState;
}

Capsule_ResourceManager::State Capsule_ResourceManager::state_____top__WaitingForRequest( const UMLRTMessage * msg )
{
    switch( msg->destPort->role()->id )
    {
    case port_resMgr:
        switch( msg->getSignalId() )
        {
        case Resource::signal_requestPrinterDriver:
            actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrPrinterRequest( msg );
            return top__WaitingForRequest;
        case Resource::signal_requestStorageDriver:
            actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onResMgrStorageRequest( msg );
            return top__WaitingForRequest;
        default:
            this->unexpectedMessage();
            break;
        }
        return currentState;
    case port_appPort:
        switch( msg->getSignalId() )
        {
        case Resource::signal_requestPrinterDriver:
            actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPrinterRequest( msg );
            return top__WaitingForRequest;
        case Resource::signal_requestStorageDriver:
            actionchain_____action_____ComputerSystem__Computer__ResourceManager__ResourceManager_SM__Region1__onAppPortStorageRequest( msg );
            return top__WaitingForRequest;
        default:
            this->unexpectedMessage();
            break;
        }
        return currentState;
    default:
        this->unexpectedMessage();
        break;
    }
    return currentState;
}


static const UMLRTCapsuleRole roles[] = 
{
    {
        "usbPrinterDriver",
        &USBDeviceDriver,
        0,
        1,
        true,
        false
    },
    {
        "usbStorageDriver",
        &USBDeviceDriver,
        0,
        1,
        true,
        false
    }
};

static const UMLRTCommsPortRole portroles_border[] = 
{
    {
        Capsule_ResourceManager::port_resMgr,
        "Resource",
        "resMgr",
        "",
        1,
        true,
        false,
        false,
        false,
        false,
        false,
        true
    },
    {
        Capsule_ResourceManager::port_appPort,
        "Resource",
        "appPort",
        "",
        1,
        true,
        false,
        false,
        false,
        false,
        false,
        true
    },
    {
        Capsule_ResourceManager::port_frame,
        "Frame",
        "frame",
        "",
        1,
        true,
        false,
        false,
        false,
        false,
        false,
        false
    },
    {
        Capsule_ResourceManager::port_timer,
        "Timing",
        "timer",
        "",
        1,
        true,
        false,
        false,
        false,
        false,
        false,
        false
    }
};

static void instantiate_ResourceManager( const UMLRTRtsInterface * rts, UMLRTSlot * slot, const UMLRTCommsPort * * borderPorts )
{
    slot->capsule = new Capsule_ResourceManager( &ResourceManager, slot, borderPorts, NULL, false );
}

const UMLRTCapsuleClass ResourceManager = 
{
    "ResourceManager",
    NULL,
    instantiate_ResourceManager,
    2,
    roles,
    4,
    portroles_border,
    0,
    NULL
};