RawFileUtil.cxx File Reference

#include "RawFile/RawFileUtil.h"
#include "RawFile/raw_ifstream.h"
#include "RawFile/raw_ofstream.h"
#include "IRawFile/RawFileExceptions.h"
#include <cstring>

Go to the source code of this file.

Functions
raw_ifstream &	operator>> (raw_ifstream &is, FileStartRecord &record)
raw_ifstream &	operator>> (raw_ifstream &is, FileNameStrings &record)
raw_ifstream &	operator>> (raw_ifstream &is, RunParametersRecord &record)
raw_ifstream &	operator>> (raw_ifstream &is, DataSeparatorRecord &record)
raw_ifstream &	operator>> (raw_ifstream &is, FileEndRecord &record)
raw_ifstream &	makeEndRecord (DataSeparatorRecord &sep, raw_ifstream &is, FileEndRecord &record)
raw_ofstream &	operator<< (raw_ofstream &os, FileStartRecord &record)
raw_ofstream &	operator<< (raw_ofstream &os, FileNameStrings &record)
raw_ofstream &	operator<< (raw_ofstream &os, RunParametersRecord &record)
raw_ofstream &	operator<< (raw_ofstream &os, DataSeparatorRecord &record)
raw_ofstream &	operator<< (raw_ofstream &os, FileEndRecord &record)

Function Documentation

makeEndRecord()

raw_ifstream & makeEndRecord	(	DataSeparatorRecord &	sep,
		raw_ifstream &	is,
		FileEndRecord &	record
	)

Definition at line 146 of file RawFileUtil.cxx.

                                                                                               {
  // copy file_end_record data that already read by data_separator_record
  memcpy((void*)&record.m_record, (const void*)&(sep.getRecord()), sizeof(data_separator_record));
  // read data block
  if (is.read((char*)(&record.m_record.events_in_file), (
      sizeof(file_end_record) - sizeof(data_separator_record)
      )).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileEndRecord");
  }
 
  // data validation checks
  if (record.m_record.marker != 0x1234dddd) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234dddd, record.m_record.marker);
  }
  if (record.m_record.end_marker != 0x1234eeee) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234eeee, record.m_record.end_marker);
  }
 
  if (record.m_record.record_size != 10) {
    //std::cerr << "[RawFile] Get an unexpected record size" << std::endl;
    throw UnexpectedRecordSize("FileEndRecord", 10, record.m_record.record_size);
  }
 
  return is;
}

operator<<() [1/5]

raw_ofstream & operator<<	(	raw_ofstream &	os,
		DataSeparatorRecord &	record
	)

Definition at line 212 of file RawFileUtil.cxx.

                                                                        {
  // write data block
  if (os.write((char*)(&record.m_record), sizeof(data_separator_record)).fail()) {
    std::cerr << "[RawFile] Error occurred while writing file" << std::endl;
    throw FailedToWrite("DataSeparatorRecord");
  }
 
  return os;
}

operator<<() [2/5]

raw_ofstream & operator<<	(	raw_ofstream &	os,
		FileEndRecord &	record
	)

Definition at line 222 of file RawFileUtil.cxx.

                                                                  {
  // write data block
  if (os.write((char*)(&record.m_record), sizeof(file_end_record)).fail()) {
    std::cerr << "[RawFile] Error occurred while writing file" << std::endl;
    throw FailedToWrite("FileEndRecord");
  }
 
  return os;
}

operator<<() [3/5]

raw_ofstream & operator<<	(	raw_ofstream &	os,
		FileNameStrings &	record
	)

Definition at line 185 of file RawFileUtil.cxx.

                                                                    {
  // write data block
  os.write((char*)(&record.m_record), sizeof(uint32_t)*2);
  uint32_t sizebyte = record.m_record.length1;
  uint32_t sizeword = (sizebyte+3)/4;
  os.write(record.m_appName.c_str(), sizeword*4);
  os.write((char*)(&record.m_record.length2), sizeof(uint32_t));
  sizebyte = record.m_record.length2;
  sizeword = (sizebyte+3)/4;
  os.write(record.m_usrTag.c_str(), sizeword*4);
  if ( os.fail() ) {
    std::cerr << "[RawFile] Error occurred while writing file" << std::endl;
    throw FailedToWrite("FileNameStrings");
  }
  return os;
}

operator<<() [4/5]

raw_ofstream & operator<<	(	raw_ofstream &	os,
		FileStartRecord &	record
	)

Definition at line 175 of file RawFileUtil.cxx.

                                                                    {
  // write data block
  if (os.write((char*)(&record.m_record), sizeof(file_start_record)).fail()) {
    std::cerr << "[RawFile] Error occurred while writing file" << std::endl;
    throw FailedToWrite("FileStartRecord");
  }
 
  return os;
}

operator<<() [5/5]

raw_ofstream & operator<<	(	raw_ofstream &	os,
		RunParametersRecord &	record
	)

Definition at line 202 of file RawFileUtil.cxx.

                                                                        {
  // write data block
  if (os.write((char*)(&record.m_record), sizeof(run_parameters_record)).fail()) {
    std::cerr << "[RawFile] Error occurred while writing file" << std::endl;
    throw FailedToWrite("RunParametersRecord");
  }
 
  return os;
}

operator>>() [1/5]

raw_ifstream & operator>>	(	raw_ifstream &	is,
		DataSeparatorRecord &	record
	)

Definition at line 96 of file RawFileUtil.cxx.

                                                                        {
  // read data block
  if (is.read((char*)(&record.m_record), sizeof(data_separator_record)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading file" << std::endl;
    throw BadInputStream("DataSeparatorRecord");
    //throw ReachEndOfFile();
  }
 
  // data validation checks
  if (record.m_record.marker != 0x1234cccc) {
    if (record.m_record.marker == 0x1234dddd) {
      throw ReachEndOfFile(is.currentFile().c_str());
    }
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234cccc, record.m_record.marker);
  }
 
  if (record.m_record.record_size != 4) {
    //std::cerr << "[RawFile] Get an unexpected record size" << std::endl;
    throw UnexpectedRecordSize("DataSeparatorRecord", 4, record.m_record.record_size);
  }
 
  return is;
}

operator>>() [2/5]

raw_ifstream & operator>>	(	raw_ifstream &	is,
		FileEndRecord &	record
	)

Definition at line 121 of file RawFileUtil.cxx.

                                                                  {
  // read data block
  if (is.read((char*)(&record.m_record), sizeof(file_end_record)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileEndRecord");
  }
 
  // data validation checks
  if (record.m_record.marker != 0x1234dddd) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234dddd, record.m_record.marker);
  }
  if (record.m_record.end_marker != 0x1234eeee) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234eeee, record.m_record.end_marker);
  }
 
  if (record.m_record.record_size != 10) {
    //std::cerr << "[RawFile] Get an unexpected record size" << std::endl;
    throw UnexpectedRecordSize("FileEndRecord", 10, record.m_record.record_size);
  }
 
  return is;
}

operator>>() [3/5]

raw_ifstream & operator>>	(	raw_ifstream &	is,
		FileNameStrings &	record
	)

Definition at line 28 of file RawFileUtil.cxx.

                                                                    {
  // read marker
  if (is.read((char*)(&record.m_record.marker), sizeof(uint32_t)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileNameStrings::marker");
  }
 
  // marker validation
  if (record.m_record.marker != 0x1234aabb) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234aabb, record.m_record.marker);
  }
 
  // read length and strings
  if (is.read((char*)(&record.m_record.length1), sizeof(uint32_t)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileNameStrings::length1");
  }
 
  uint32_t length1_word = (record.m_record.length1 + 3) / 4;
  char* appName = new char[length1_word * 4 + 1];
  if (is.read(appName, length1_word*4).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileNameStrings::appName");
  }
  appName[record.m_record.length1] = '\0';
  record.m_appName = appName;
  delete[] appName;
 
  if (is.read((char*)(&record.m_record.length2), sizeof(uint32_t)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileNameStrings::length2");
  }
 
  uint32_t length2_word = (record.m_record.length2 + 3) / 4;
  char* usrTag = new char[length2_word * 4 + 1];
  if (is.read(usrTag, length2_word*4).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileNameStrings::usrTag");
  }
  usrTag[record.m_record.length2] = '\0';
  record.m_usrTag = usrTag;
  delete[] usrTag;
 
  return is;
}

operator>>() [4/5]

raw_ifstream & operator>>	(	raw_ifstream &	is,
		FileStartRecord &	record
	)

Definition at line 7 of file RawFileUtil.cxx.

                                                                    {
  // read data block
  if (is.read((char*)(&record.m_record), sizeof(file_start_record)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("FileStartRecord");
  }
 
  // data validation checks
  if (record.m_record.marker != 0x1234aaaa) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234aaaa, record.m_record.marker);
  }
 
  if (record.m_record.record_size != 8) {
    //std::cerr << "[RawFile] Get an unexpected record size" << std::endl;
    throw UnexpectedRecordSize("FileStartRecord", 8, record.m_record.record_size);
  }
 
  return is;
}

operator>>() [5/5]

raw_ifstream & operator>>	(	raw_ifstream &	is,
		RunParametersRecord &	record
	)

Definition at line 75 of file RawFileUtil.cxx.

                                                                       {
  // read data block
  if (is.read((char*)(&record.m_record), sizeof(run_parameters_record)).fail()) {
    //std::cerr << "[RawFile] Error occurred while reading files" << std::endl;
    throw BadInputStream("RunParametersRecord");
  }
 
  // data validation checks
  if (record.m_record.marker != 0x1234bbbb) {
    //std::cerr << "[RawFile] Get an invalid record marker" << std::endl;
    throw WrongMarker(0x1234bbbb, record.m_record.marker);
  }
 
  if (record.m_record.record_size != 9) {
    //std::cerr << "[RawFile] Get an unexpected record size" << std::endl;
    throw UnexpectedRecordSize("RunParametersRecord", 9, record.m_record.record_size);
  }
 
  return is;
}