src/FileReader.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_VECTOR
#include <vector>
#endif

#ifndef _GLIBCXX_STRING
#include <string>
#endif

#ifndef _GLIBCXX_QUEUE
#include <queue>
#endif

#ifndef _GLIBCXX_SSTREAM
#include <sstream>
#endif

#ifndef _GLIBCXX_FSTREAM
#include <fstream>
#endif

#ifndef _GLIBCXX_IOSTREAM
#include <iostream>
#endif

#ifndef FILEREADER_H
#include "FileReader.h"
#endif

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

void Tokenize(const string& str,
                      shared_ptr< vector< shared_ptr<string> > > tokens,
                      const string& delimiters = " ")
{
    // Skip delimiters at beginning.
    string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        shared_ptr<string> temp( new string( str.substr(lastPos, pos - lastPos) ) );
        tokens->push_back(temp);
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

//      TODO Because the C mode of Flex is used instead of the C++ mode a global declaration of the filereader instance is needed to allow the send method to send messages to the messagecontroller. It is not nice to circumvent the OO construction but it works for the moment.
FileReader *myr;

bool send(char* line)
{
        stringstream s;
        s << line;

        shared_ptr< vector <shared_ptr<string> > > message( new vector<shared_ptr<string> >() );

        Tokenize(s.str(), message, " ");

        myr->msgcontroller->processMessageFromComm(message);

        return true;
}

#include "lex.yy.c"

void *flexRead( void *ptr )
{
        FileReader *myreader = (FileReader*) ptr;
        yyin = fopen((myreader->filename).c_str() , "r");

        yylex();

        int status = 0;
        pthread_exit(&status);
}

void *readFile( void *ptr )
{
        FileReader *myreader = (FileReader*) ptr;

        cout << "Attempting to read from file: " << myreader->filename << endl;
        string line;
        bool validline = true;

        ifstream myfile ((myreader->filename).c_str());

        if (myfile.is_open())
        {
                while (!myfile.eof() && myreader->filereadthread_run )
                {
                        /*      Get new line from file, tokenize it using " " as a delimiter and put it in the vector messages.*/
                        validline = true;
                        getline (myfile, line);
                        //      Ignore comments
                        if ( !line.empty() ) {
                                if ( line.at(0) == '#' ) {
                                        validline = false;
                                }
                        } else validline = false;

                        if( validline ) {
                                shared_ptr< vector <shared_ptr<string> > > message( new vector<shared_ptr<string> >() );
                                Tokenize(line, message, " ");

                                /* Messagebody is properly constructed. Now do something useful with it.*/
                                myreader->msgcontroller->processMessageFromComm(message);
                        }
                }
                myfile.close();
        }
        else cout << "Unable to open file" << endl;

        int status = 0;
        pthread_exit(&status);
}

//      ---------------------------------------------------------------------------------------------
//      FileReader code.

FileReader::FileReader(string nfilename, MessageController* ptr) {
        msgcontroller = ptr;
        myr = this;
        filename = nfilename;
        filereadthread_run = true;

        /*
         *      We have 2 ways to read the inputfile. The 1st one is a dumb
         *      filereader which doesn't look at what it reads, It only ignores
         *      commentlines and empty line. The 2nd one uses flex to recognise
         *      messages and invoke the messagecontroller. The flex method is far
         *      superior and should be used at all times.
         */
        //pthread_create( &filereadthread, NULL, readFile, (void*)this);
        pthread_create( &filereadthread, NULL, flexRead, (void*)this);
}

FileReader::~FileReader() {
        cout << "FileReader destructor." << endl;

        filereadthread_run = false;

        pthread_join( filereadthread, NULL);
}

bool FileReader::sendMessage( shared_ptr< vector< shared_ptr< string > > > ) {
        cout << "FileReader cannot send messages since it has nowhere to send them." << endl;
        return false;
}

---