/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/RawFile/RawFile-00-00-10/src/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

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

Definition at line 146 of file RawFileUtil.cxx.

References file_end_record::end_marker, file_end_record::events_in_file, DataSeparatorRecord::getRecord(), is, FileEndRecord::m_record, file_end_record::marker, and file_end_record::record_size.

                                                                                               {
  // 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;
}

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

Definition at line 222 of file RawFileUtil.cxx.

References FileEndRecord::m_record.

                                                                  {
  // 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;
}

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

Definition at line 212 of file RawFileUtil.cxx.

References DataSeparatorRecord::m_record.

                                                                        {
  // 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;
}

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

Definition at line 202 of file RawFileUtil.cxx.

References RunParametersRecord::m_record.

                                                                        {
  // 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;
}

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

Definition at line 185 of file RawFileUtil.cxx.

References file_name_strings::length1, file_name_strings::length2, FileNameStrings::m_appName, FileNameStrings::m_record, and FileNameStrings::m_usrTag.

                                                                    {
  // 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;
}

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

Definition at line 175 of file RawFileUtil.cxx.

References FileStartRecord::m_record.

                                                                    {
  // 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;
}

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

Definition at line 121 of file RawFileUtil.cxx.

References file_end_record::end_marker, is, FileEndRecord::m_record, file_end_record::marker, and file_end_record::record_size.

                                                                  {
  // 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;
}

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

Definition at line 96 of file RawFileUtil.cxx.

References is, DataSeparatorRecord::m_record, data_separator_record::marker, and data_separator_record::record_size.

                                                                        {
  // 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;
}

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

Definition at line 75 of file RawFileUtil.cxx.

References is, RunParametersRecord::m_record, run_parameters_record::marker, and run_parameters_record::record_size.

                                                                       {
  // 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;
}

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

Definition at line 28 of file RawFileUtil.cxx.

References is, file_name_strings::length1, file_name_strings::length2, FileNameStrings::m_appName, FileNameStrings::m_record, FileNameStrings::m_usrTag, and file_name_strings::marker.

                                                                    {
  // 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;
}

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

Definition at line 7 of file RawFileUtil.cxx.

References is, FileStartRecord::m_record, file_start_record::marker, and file_start_record::record_size.

                                                                    {
  // 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;
}

---