src/Dispatcher.cpp

Go to the documentation of this file.

/*

Traplas visualisation.

Copyright (C) 2006 Herbert de Vos & Willem Drost

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

(For full Licence see ../GPL-Licence.txt)

*/

#ifndef _GLIBCXX_IOSTREAM
#include <iostream>
#endif

#ifndef _GLIBCXX_SSTREAM
#include <sstream>
#endif

#ifndef MESSAGECONTROLLER_H
#include "MessageController.h"
#endif

#ifndef DISPATCHER_H
#include "../include/Dispatcher.h"
#endif

#ifndef STATECONTROL_H
#include "../include/StateControl.h"
#endif

#ifndef _PTHREAD_H
#include <pthread.h>
#endif

#ifndef GLOBALS_H
#include "Globals.h"
#endif

#ifndef _GLIBCXX_STDEXCEPT
#include <stdexcept>
#endif

Dispatcher::Dispatcher(){
        world = new StateControl(this);
        mc = new MessageController(this);
        parseQ = shared_ptr< queue< shared_ptr< vector< shared_ptr<string> > > > >( new queue< shared_ptr< vector< shared_ptr<string> > > >() );

        mutex_ptr = new pthread_mutex_t();
        cond_ptr = new pthread_cond_t();
        pthread_mutex_init(mutex_ptr, NULL);
        pthread_cond_init(cond_ptr, NULL);
}

Dispatcher::~Dispatcher(){
        delete world;
        delete mc;
}

/*Public functions:*/

bool Dispatcher::proccessMessageFromMC(shared_ptr< vector< shared_ptr< string > > > msg){
        //place received message in queue. This thing is called from the outside.

        if ( pthread_mutex_trylock(mutex_ptr) != 0 )
            pthread_cond_wait(cond_ptr, mutex_ptr);

        parseQ->push(msg);
        pthread_mutex_unlock(mutex_ptr);
        pthread_cond_signal(cond_ptr);
        return true;
}

bool Dispatcher::dispatchMessage(){
        //      Parse anything in the queue. Call the correct methods in StateControl.

        //      Only try to lock the mutex, if not succesfull, better luck next time! This to prevent the OSG-mainloop from blocking.
        if ( pthread_mutex_trylock(mutex_ptr) != 0 ) {
                while(!(parseQ->empty())) {
                        shared_ptr< vector< shared_ptr< string > > > msg;
                        msg = (parseQ->front());
                        parseQ->pop();

                        shared_ptr< string > msgIdent = msg->at(0);

                        if(*msgIdent == "DRV")
                                drvparse(msg);
                        else if(*msgIdent == "LOAD")
                                loadparse(msg);
                        else if(*msgIdent == "UNLOAD")
                                unloadparse(msg);
                        else if(*msgIdent == "LOCATION")
                                locationparse(msg);
                        else if(*msgIdent == "SETSPDINVIZ")
                                setspdparse(msg);
                        else if(*msgIdent == "TRNEW")
                                trnewparse(msg);
                        else if(*msgIdent == "TRDEL")
                                trdelparse(msg);
                        else if(*msgIdent == "NEWCARG")
                                newcargparse(msg);
                        else if(*msgIdent == "RMCARG")
                                rmcargparse(msg);
                        else if(*msgIdent == "ARC")
                                arcparse(msg);
                        else {
                                cout << "In dispatchMessage(): Message ( " << *msgIdent << " ) not recognised." << endl;
                        }
                }
                pthread_mutex_unlock(mutex_ptr);
                pthread_cond_signal(cond_ptr);
        }

        return true;
}


bool Dispatcher::setSpdInSim(int R, double fraction, double ts, double te){
        //compose a message, send it to mc
        shared_ptr< vector< shared_ptr< string > > > spd_msg;
        ostringstream s;

        //      Create the message contents.
        shared_ptr< string > temp0( new string("SETSPDINSIM") );
        spd_msg->push_back( temp0 );

        shared_ptr< string > temp1( new string() );
        spd_msg->push_back( temp1 );

        s << R;
        shared_ptr< string > temp2( new string( s.str() ) );
        spd_msg->push_back( temp2 );
        s.str("");

        s << fraction;
        shared_ptr< string > temp3( new string( s.str() ) );
        spd_msg->push_back( temp3 );
        s.str("");

        s << ts;
        shared_ptr< string > temp4( new string( s.str() ) );
        spd_msg->push_back( temp4 );
        s.str("");

        s << te;
        shared_ptr< string > temp5( new string( s.str() ) );
        spd_msg->push_back( temp5 );
        s.str("");

        //      Send the message.
        mc->sendMessageToComm(spd_msg);
        return true;
}

bool Dispatcher::order(int Ris, int Rid, double ts, double tf){
        //compose a message, send it to mc
        shared_ptr< vector< shared_ptr< string > > > ord_msg;
        ostringstream s;

        //      Create the message contents
        shared_ptr< string > temp0( new string("ORDER") );
        ord_msg->push_back( temp0 );

        shared_ptr< string > temp1( new string() );
        ord_msg->push_back( temp1 );

        s << Ris;
        shared_ptr< string > temp2( new string( s.str() ) );
        ord_msg->push_back( temp2 );
        s.str("");

        s << Rid;
        shared_ptr< string > temp3( new string( s.str() ) );
        ord_msg->push_back( temp3 );
        s.str("");

        s << ts;
        shared_ptr< string > temp4( new string( s.str() ) );
        ord_msg->push_back( temp4 );
        s.str("");

        s << tf;
        shared_ptr< string > temp5( new string( s.str() ) );
        ord_msg->push_back( temp5 );
        s.str("");

        //      Send the message.
        mc->sendMessageToComm(ord_msg);
        return true;
}

bool Dispatcher::communicationMode(int cMode, string fileName){
        //set communication mode of MessageController.
        return(mc->communicationMode(cMode, fileName));
}

bool Dispatcher::communicationMode(int cMode, string thisName, string thatName){
        //set communication mode of MessageController.
        return(mc->communicationMode(cMode, thisName, thatName));
}

bool Dispatcher::setTimeFlow(double flowFactor){
        return(mc->setTimeFlow(flowFactor));
}

double Dispatcher::getTimeFlow(){
        return(mc->getTimeFlow());
}

double Dispatcher::getTime(){
        return(mc->getVisualisationTime());
}


/*Private functions: parsing*/
bool Dispatcher::drvparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try {
                int Rt = atoi(msg->at(2)->c_str());
                int RiFrom = atoi(msg->at(3)->c_str());
                int RiTo = atoi(msg->at(4)->c_str());
                int RiD = atoi(msg->at(5)->c_str());
                double ts = atof(msg->at(6)->c_str());
                double te = atof(msg->at(7)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (Rt == 0 && msg->at(2)->at(0) != '0') ||
                                (RiFrom == 0 && msg->at(3)->at(0) != '0') ||
                                (RiTo == 0 && msg->at(4)->at(0) != '0') ||
                                (RiD == 0 && msg->at(5)->at(0) != '0') ||
                                (ts == 0 && msg->at(6)->at(0) != '0') ||
                                (te == 0 && msg->at(7)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::drvparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
                
                return world->drv(Rt, RiFrom, RiTo, RiD, ts, te);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::drvparse) message malformed: Message too short." << endl;                
                assert( false );        
        }  
}

bool Dispatcher::loadparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{
                int Rt = atoi(msg->at(2)->c_str());
                int Ri = atoi(msg->at(3)->c_str());
                int C = atoi(msg->at(4)->c_str());
                double ts = atof(msg->at(5)->c_str());
                double tf = atof(msg->at(6)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (Rt == 0 && msg->at(2)->at(0) != '0') ||
                                (Ri == 0 && msg->at(3)->at(0) != '0') ||
                                (C == 0 && msg->at(4)->at(0) != '0') ||
                                (ts == 0 && msg->at(5)->at(0) != '0') ||
                                (tf == 0 && msg->at(6)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::loadparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->load(Rt, Ri, C, ts, tf);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::loadparse) message malformed: Message too short." << endl;               
                assert( false );                
        }  
}

bool Dispatcher::unloadparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int Rt = atoi(msg->at(2)->c_str());
                int Ri = atoi(msg->at(3)->c_str());
                int C = atoi(msg->at(4)->c_str());
                double ts = atof(msg->at(5)->c_str());
                double tf = atof(msg->at(6)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (Rt == 0 && msg->at(2)->at(0) != '0') ||
                                (Ri == 0 && msg->at(3)->at(0) != '0') ||
                                (C == 0 && msg->at(4)->at(0) != '0') ||
                                (ts == 0 && msg->at(5)->at(0) != '0') ||
                                (tf == 0 && msg->at(6)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::unloadparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->unload(Rt,Ri,C, ts, tf);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::unloadparse) message malformed: Message too short." << endl;             
                assert( false );                
        }  
}

bool Dispatcher::setspdparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int R  = atoi(msg->at(2)->c_str());
                double f = atof(msg->at(3)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (R == 0 && msg->at(2)->at(0) != '0') ||
                                (f == 0 && msg->at(3)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::setspdparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->setspdinviz(R, f);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::setspdparse) message malformed: Message too short." << endl;             
                assert( false );                
        }  
}

bool Dispatcher::locationparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int id = atoi(msg->at(2)->c_str());
                shared_ptr<string> desc = msg->at(3);
                unsigned int cap = atoi(msg->at(4)->c_str());
                double dist = atof(msg->at(5)->c_str());
                double spd = atof(msg->at(6)->c_str());
                int tile = atoi(msg->at(7)->c_str());
                double w = atof(msg->at(8)->c_str());
                double h = atof(msg->at(9)->c_str());
                double x = atof(msg->at(10)->c_str());
                double y = atof(msg->at(11)->c_str());
                double rot = atof(msg->at(12)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (id == 0 && msg->at(2)->at(0) != '0') ||
                                (cap == 0 && msg->at(4)->at(0) != '0') ||
                                (dist == 0 && msg->at(5)->at(0) != '0') ||
                                (spd == 0 && msg->at(6)->at(0) != '0') ||
                                (tile == 0 && msg->at(7)->at(0) != '0') ||
                                (w == 0 && msg->at(8)->at(0) != '0') ||
                                (h == 0 && msg->at(9)->at(0) != '0') ||
                                (x == 0 && msg->at(10)->at(0) != '0') ||
                                (y == 0 && msg->at(11)->at(0) != '0') ||
                                (rot == 0 && msg->at(12)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::locationparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->location(id, desc, cap, dist, spd, tile, w, h, x, y, rot);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::locationparse) message malformed: Message too short." << endl;           
                assert( false );                
        }
}

bool Dispatcher::trnewparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{
                int Rt = atoi(msg->at(2)->c_str());
                shared_ptr<string> desc = msg->at(3);
                int Ri = atoi(msg->at(4)->c_str());
                double s = atof(msg->at(5)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (Rt == 0 && msg->at(2)->at(0) != '0') ||
                                (Ri == 0 && msg->at(4)->at(0) != '0') ||
                                (s == 0 && msg->at(5)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::trnewparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->trnew(Rt, desc, Ri, s);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::trnewparse) message malformed: Message too short." << endl;              
                assert( false );                
        }
}

bool Dispatcher::trdelparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int Rt = atoi(msg->at(2)->c_str());
        
                //      Check if all conversions were succesfull.
                if ( (Rt == 0 && msg->at(2)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::trdelparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->trdel(Rt);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::trdelparse) message malformed: Message too short." << endl;              
                assert( false );                
        }
}

bool Dispatcher::newcargparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int C = atoi(msg->at(2)->c_str());
                shared_ptr<string> desc = msg->at(3);
                int Ri = atoi(msg->at(4)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (C == 0 && msg->at(2)->at(0) != '0') ||
                                (Ri == 0 && msg->at(4)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::newcargparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->newcarg(C, desc, Ri);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::newcargparse) message malformed: Message too short." << endl;            
                assert( false );                
        }
}

bool Dispatcher::rmcargparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{    
                int C = atoi(msg->at(2)->c_str());
        
                //      Check if all conversions were succesfull.
                if ( (C == 0 && msg->at(2)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::rmcargparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->rmcarg(C);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::rmcargparse) message malformed: Message too short." << endl;             
                assert( false );                
        }
}

bool Dispatcher::arcparse(shared_ptr< vector< shared_ptr< string > > > msg){
        try{
                int arcFrom = atoi(msg->at(2)->c_str());
                int arcTo = atoi(msg->at(3)->c_str());
        
                //      Check if all conversions were succesfull.
                if (    (arcFrom == 0 && msg->at(2)->at(0) != '0') ||
                                (arcTo == 0 && msg->at(3)->at(0) != '0') ){
        
                        cout << "Warning: (Dispatcher::arcparse) message malformed: Conversion error." << endl;
                        #if STRICT
                                assert( false );
                        #endif
                }
        
                return world->arc(arcFrom, arcTo);
        } catch ( out_of_range ) {
                cout << "Warning: (Dispatcher::arcparse) message malformed: Message too short." << endl;                
                assert( false );                
        }
}

---