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