LASCIIGlobalReader.cc

Go to the documentation of this file.

#include "LASCIIGlobalReader.hh"
#include "QObject.hh"
#include "QMatrix.hh"
#include "QString.hh"
#include "QBool.hh"
#include "QBaseType.hh"
#include <sstream>
 
// MV FIXME: invalidity if QInt, QString are not found
REGISTER_GLOBAL_READER(LASCIIGlobalReader,".txt")
 
using namespace Diana;
using std::istringstream;
using std::string;
using std::stringstream;
 
LASCIIGlobalReader::LASCIIGlobalReader() : QGlobalReader("ASCIIGlobalReader")
{
    fQObjectCache = new std::map<std::string, QObject*>;
}
 
LASCIIGlobalReader::~LASCIIGlobalReader()
{
    Close();
    delete fQObjectCache;
}
 
QError LASCIIGlobalReader::Open(const std::string& filename, const std::string& opt)
{
        QError err = QERR_SUCCESS;
        fFile = new QASCII(filename); 
        if(!fFile->Exists()) 
        {
                err = QERR_CANNOT_OPEN_FILE;
                err.SetDescription(GetName(),__LINE__,std::string("Cannot open file: ") + filename);
                delete fFile;
                fFile = NULL;
        }
        return err;
}
 
 
QError LASCIIGlobalReader::Close()
{
    QError err = QERR_SUCCESS;
         delete fFile;
         fFile = NULL;
    return err;
}
 
const QObject* LASCIIGlobalReader::GetQObject(const std::string& name,const std::string& className, QError& err) const
{
    if(className == "Diana::QBaseType<int>") {
        return new QInt(GetInt(name,err));
    } else if(className == "Diana::QBaseType<float>") {
        return new QFloat(GetFloat(name,err));
    } else if(className == "Diana::QBaseType<double>") {
        return new QDouble(GetDouble(name,err));
    } else if(className == "Diana::QBool") {
        return new QBool(GetBool(name,err));
    } else if(className == "Diana::QString") {
        return new QString(GetString(name,err));
    } else {
        return GetQObject(name, err);
    }
    return 0;
}
 
const QObject* LASCIIGlobalReader::GetQObject(const std::string& name, QError& err) const 
{
    err = QERR_SUCCESS;
    // check for already existing object
    std::map<std::string, QObject*>::const_iterator object = fQObjectCache->find(name);
    if(object != fQObjectCache->end()) return object->second;
 
         // If not in cache, look in file
         QObject* obj;
         int startline, endline;
         string startstring, endstring;
        
         string readstring;
         
         // does file exist?
 
         if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return NULL;
        }
        
         startstring = "# begin " + name;
         startline = 1 + fFile->FindLine(startstring);
        
         if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return NULL;
     }
        
         endstring = "# end " + name;
         endline = -1 + fFile->FindLine(endstring, startline); 
         
         readstring = fFile->ReadString(startline, startline);
         
         if(readstring == "# QVector")
         {
                 obj = fFile->ReadQVector(0, startline, endline);
         }
         else if(readstring == "# QVectorC")
         {
                 QVector* real = fFile->ReadQVector(0, startline, endline);
                 QVector* imag = fFile->ReadQVector(1, startline, endline);
                 
                 obj = new QVectorC(*real, *imag);
         }
         else if(readstring == "# QTime")
         {
                 obj = fFile->ReadQTime(startline);
         }
         else if(readstring == "# QMatrix")
         {
                 readstring = fFile->ReadString(startline+1, startline+1); 
                 istringstream iss(readstring);
                 int nrow, ncol;
                 char c;
                 if(!(iss >> c >> nrow >> ncol)) {
                          err = QERR_UNKNOWN_ERR;
              err.SetDescription(GetName(),__LINE__,std::string("Cannot read row and column numbers of object ") + name);
              return 0;
         }
 
                 QMatrix* qmat = new QMatrix(nrow, ncol);
                 QVector* dummy;
                 for(int i=0; i<ncol; i++)
                 {
                         dummy = fFile->ReadQVector(i, startline, endline);
                         qmat->SetCol(i, *dummy);
                 }
                 obj = qmat;
         }
         else
         {
 
          istringstream iss(readstring); 
          char c; string objtype;
          if(!(iss>>c>>objtype)) {
                          err = QERR_UNKNOWN_ERR;
              err.SetDescription(GetName(),__LINE__,std::string("Cannot read type of object ") + name);
              return 0;
          }
          obj = QObject::New(objtype.c_str());
          if(!obj) {
            stringstream msg;
            msg<<"Object \""<<name<<"\" has invalid type \""<<objtype<<"\"";
            err = QERR_UNKNOWN_ERR;
            err.SetDescription(GetName(),__LINE__,msg.str());
          } else {
              stringstream data;
              int line = startline+1;
              while(line <= endline) {
                readstring = fFile->ReadString(line,line);
                if(!readstring.empty() && readstring.at(0) != '#') data<<readstring<<std::endl;;
                line++;
              }
              err = obj->ReadFromStream(data);
              if(err != QERR_SUCCESS) {
                  delete obj;
                  obj = 0;
                  stringstream msg;
                  err = QERR_UNKNOWN_ERR;
                  msg<<"Error while reading object \""<< name <<"\": "<<err.GetDescription();
                  err.SetDescription(GetName(),__LINE__,msg.str());
 
              }
          }
     }
 
     if(obj) {
         // MV: We do not store the validity flag in ascii files so we assume that it is valid...
         obj->Validate();
         (*fQObjectCache)[name] = obj;
     }
     return obj;
}
 
std::string LASCIIGlobalReader::GetString(const std::string& name, QError& err) const  
{
 
    err = QERR_SUCCESS;
    string readstring = Q_STRING_DEFAULT;
        int startline, endline;
        string startstring, endstring;
        
        // does file exist?
        if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return readstring;
    }
 
        
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
        if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return readstring;
    }
        
        endstring = "# end " + name;
        endline = -1 + fFile->FindLine(endstring, startline); 
        
        readstring = fFile->ReadString(startline, endline);
        
        return readstring; 
}
 
int LASCIIGlobalReader::GetInt(const std::string& name,QError& err) const  
{
 
    err = QERR_SUCCESS;
    int obj = Q_INT_DEFAULT;
        int startline;
        string startstring;
        
        string readstring;
        
        // does file exist?
    if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return obj;
    }
        
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
    if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return obj;
    }
        
        readstring = fFile->ReadString(startline, startline);
        obj = atoi(readstring.c_str());
        
        return obj; 
}
 
double LASCIIGlobalReader::GetDouble(const std::string& name, QError& err) const  
{
    err = QERR_SUCCESS;
    double obj = Q_DOUBLE_DEFAULT;
        int startline;
        string startstring;
        
        string readstring;
        
        // does file exist?
    if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return obj;
    }
 
    startstring = "# begin " + name;
    startline = 1 + fFile->FindLine(startstring);
 
    if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return obj;
    }
        
        readstring = fFile->ReadString(startline, startline);
        obj = atof(readstring.c_str());
        
        return obj; 
}
 
float LASCIIGlobalReader::GetFloat(const std::string& name, QError& err) const  
{
 
    err = QERR_SUCCESS;
    float obj = Q_FLOAT_DEFAULT;
        int startline;
        string startstring;
        
        string readstring;
        
        // does file exist?
    if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return obj;
    }
        
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
    if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return obj;
    }
 
        readstring = fFile->ReadString(startline, startline);
        istringstream ss(readstring);
        ss >> obj;
        
        return obj; 
}
 
bool LASCIIGlobalReader::GetBool(const std::string& name, QError& err) const  
{
 
    err = QERR_SUCCESS;
    bool obj = Q_BOOL_DEFAULT;
        int startline;
        string startstring;
        
        string readstring;
        
        // does file exist?
    if(!fFile) {
        err = QERR_FILE_NOT_FOUND;
        err.SetDescription(GetName(),__LINE__,"no file is open");
        return obj;
    }
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
        
    if(startline < 0) {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Failed to find line: \"") + startstring + "\"");
        return obj;
    }
 
        readstring = fFile->ReadString(startline, startline);
        istringstream ss(readstring);
        ss >> obj;
        
        return obj; 
}
 
/*
QVector* LASCIIGlobalReader::GetQVector(const std::string& name) const  
{
        QVector* obj;
        
        int startline, endline;
        string startstring, endstring;
        
        string readstring;
        
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
        if(startline < 0) return NULL;
        
        endstring = "# end " + name;
        endline = -1 + fFile->FindLine(endstring, startline); 
        
        obj = fFile->ReadQVector(0, startline, endline);
        
        return obj; 
}
 
QVectorC* LASCIIGlobalReader::GetQVectorC(const std::string& name) const  
{
        QVectorC* obj;
        
        QVector* real;
        QVector* imag;
        
        int startline, endline;
        string startstring, endstring;
        
        string readstring;
        
        startstring = "# begin " + name;
        startline = 1 + fFile->FindLine(startstring);
        
        if(startline < 0) return NULL;
        
        endstring = "# end " + name;
        endline = -1 + fFile->FindLine(endstring, startline); 
        
        real = fFile->ReadQVector(0, startline, endline);
        imag = fFile->ReadQVector(1, startline, endline);
        
        obj = new QVectorC(*real, *imag);
        
        return obj; 
}
 
*/