RawFileUtil.cxx File Reference

#include "RawFile/RawFileUtil.h"
#include "IRawFile/RawFileExceptions.h"
#include "RawFile/raw_ifstream.h"
#include "RawFile/raw_ofstream.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)
std::ofstream &	operator<< (std::ofstream &os, FileStartRecord &record)
std::ofstream &	operator<< (std::ofstream &os, FileNameStrings &record)
std::ofstream &	operator<< (std::ofstream &os, RunParametersRecord &record)
std::ofstream &	operator<< (std::ofstream &os, DataSeparatorRecord &record)
std::ofstream &	operator<< (std::ofstream &os, FileEndRecord &record)

Function Documentation

makeEndRecord()

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

Definition at line 164 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]

std::ofstream & operator<<	(	std::ofstream &	os,
		DataSeparatorRecord &	record )

Definition at line 239 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]

std::ofstream & operator<<	(	std::ofstream &	os,
		FileEndRecord &	record )

Definition at line 250 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]

std::ofstream & operator<<	(	std::ofstream &	os,
		FileNameStrings &	record )

Definition at line 210 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]

std::ofstream & operator<<	(	std::ofstream &	os,
		FileStartRecord &	record )

Definition at line 199 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]

std::ofstream & operator<<	(	std::ofstream &	os,
		RunParametersRecord &	record )

Definition at line 228 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 108 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 135 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 31 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[length1_word * 4] = '\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[length2_word * 4] = '\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 84 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;
}