datread.cpp

   1 #include "datread.h"
   2
   3 #define HEADER_READOK   0
   4 #define HEADER_READERR  1
   5 #define HEADER_READLAST 2
   6
   7 datread::datread (const unsigned int& _blocksize, ostream *_log) : blocksize(_blocksize), log(_log)
   8 {
   9   inbuffer = NULL;
  10 }
  11
  12 int datread::openFile (const string& filename)
  13 {
  14   infile.open(filename.c_str(), std::ios::binary);
  15
  16   if ( ! infile.is_open() ) return -1;
  17
  18   if( filename.substr(filename.size()-4) == ".dat" ) {
  19     format = DAT;
  20   }
  21   else if( filename.substr(filename.size()-4) == "edat" ) {
  22     format = EDAT;
  23   }
  24   else if( filename.substr(filename.size()-4) == "sdat" ) {
  25     format = SDAT;
  26     getline(infile, parastring);
  27   }
  28
  29   if ( inbuffer != NULL )
  30     delete inbuffer;
  31
  32   inbuffer = new boost::iostreams::filtering_istreambuf;
  33   inbuffer->push( boost::iostreams::bzip2_decompressor() );
  34   inbuffer->push(infile);
  35
  36   return 0;
  37 }
  38
  39 int datread::readDataToMem (char *tmpData, long unsigned int dataSize)
  40 {
  41   int readturn = -1;
  42
  43   if ( dataSize == 0 ) return 0;
  44
  45   try { readturn = boost::iostreams::read(*inbuffer, tmpData, dataSize); }
  46   catch(boost::iostreams::bzip2_error& error) {
  47     if(log) *log << "DATREAD: Caught bzip2 exception with error code: " << error.error() << endl << flush;
  48     infile.close();
  49   }
  50   catch (std::exception const& ex) {
  51     if(log) *log << "DATREAD: Caught exception: " << ex.what() << endl << flush;
  52     infile.close();
  53   }
  54   catch( ... ) {
  55     if(log) *log << "DATREAD: Caught unknown exception while reading." << endl << flush;
  56     infile.close();
  57   }
  58
  59   return readturn;
  60 }
  61
  62 int datread::readHeader ()
  63 {
  64   long unsigned int headersize;
  65
  66   if( readDataToMem((char *)&headersize, sizeof(long unsigned int)) == sizeof(long unsigned int) && infile.is_open() ) {
  67     if ( headersize == 0 )
  68       return HEADER_READLAST;
  69
  70     pair<unsigned long, void *> newHeader;
  71
  72     if( readDataToMem((char *)&newHeader.first, sizeof(unsigned long)) == sizeof(unsigned long) && infile.is_open() ) {
  73       newHeader.second = malloc(headersize);
  74
  75       if( readDataToMem((char *)newHeader.second, headersize) == headersize && infile.is_open() ) {
  76         headerStore.push_back(newHeader);
  77         return HEADER_READOK;
  78       }
  79       else {
  80         if(log) *log << "DATREAD: Could not read heade-data! Closing dat-file." << endl << flush;
  81         infile.close();
  82         return HEADER_READERR;
  83       }
  84     }
  85     else {
  86       if(log) *log << "DATREAD: Could not read headerid-hash! Closing dat-file." << endl << flush;
  87       infile.close();
  88       return HEADER_READERR;
  89     }
  90   }
  91   else {
  92     if(log) *log << "DATREAD: Could not read header size. Closing dat-file." << endl << flush;
  93     infile.close();
  94     return HEADER_READERR;
  95   }
  96 }
  97
  98 void datread::deleteHeaderStore ()
  99 {
 100   while ( headerStore.size() > 0 ) {
 101     free(headerStore.back().second);
 102     headerStore.pop_back();
 103   }
 104 }
 105
 106 bool datread::readAllHeaders ()
 107 {
 108   int readHeaderStatus;
 109
 110   deleteHeaderStore();
 111
 112   do {
 113     readHeaderStatus = readHeader();
 114   }
 115   while ( readHeaderStatus == HEADER_READOK );
 116
 117   if ( readHeaderStatus == HEADER_READLAST ) return true;
 118   else if ( readHeaderStatus == HEADER_READERR ) return false;
 119 }
 120
 121 int datread::readFullBlock (char *tmpData)
 122 {
 123   if ( ! infile.is_open() )
 124     return -4;
 125
 126   /* try to read header */
 127   if ( format == EDAT || format == SDAT )
 128     if ( ! readAllHeaders() ) {
 129       infile.close();
 130       return -1;
 131     }
 132
 133   /* read data */
 134   if ( readDataToMem(tmpData, blocksize) != blocksize ) {
 135     if(log) *log << "DATREAD: Could not read full datablock. Closing dat-file." << endl << flush;
 136     infile.close();
 137     return -2;
 138   }
 139
 140   if ( ! infile.is_open() )
 141     return -3;
 142
 143   return 0;
 144 }
 145
 146 void * datread::getHeader (const string& headerid) {
 147   for (vector< pair<unsigned long, void *> >::iterator headerStoreIt = headerStore.begin(); headerStoreIt != headerStore.end(); ++headerStoreIt)
 148     if ( headerStoreIt->first == hash(headerid) )
 149       return headerStoreIt->second;
 150
 151   return NULL;
 152 }
 153
 154 bool datread::fisopen ()
 155 {
 156   return infile.is_open();
 157 }
 158
 159 unsigned long datread::hash(const string& str)
 160 {
 161   unsigned long hash = 5381;
 162
 163   for(string::const_iterator it=str.begin();it!=str.end();it++)
 164     hash = ((hash << 5) + hash) + *it; /* hash * 33 + character */
 165
 166   return hash;
 167 }
 168
 169 string datread::getParaString ()
 170 {
 171   return parastring;
 172 }
 173
 174 void datread::closeFile ()
 175 {
 176   if ( infile.is_open() )
 177     infile.close();
 178 }
 179
 180 datread::~datread ()
 181 {
 182   if ( inbuffer != NULL )
 183     delete inbuffer;
 184 }