util24.cxx File Reference

#include "eformat/old/util.h"
#include "eformat/old/UnboundSourceIdentifierIssue.h"
#include "eformat/old/FullEventFragment.h"
#include "eformat/old/SubDetectorFragment.h"
#include "eformat/old/ROSFragment.h"
#include "eformat/old/ROBFragment.h"
#include "eformat/old/RODFragment.h"
#include "eformat/SourceIdentifier.h"
#include "eformat/HeaderMarker.h"
#include "eformat/WrongMarkerIssue.h"
#include "eformat/Version.h"
#include "eformat/BadVersionIssue.h"
#include "ers/StreamFactory.h"
#include "eformat/write/FullEventFragment.h"

Go to the source code of this file.

Functions
uint32_t	convert_ros (const uint32_t *src, uint32_t *dest, uint32_t max)

Function Documentation

convert_ros()

uint32_t convert_ros	(	const uint32_t *	src,
		uint32_t *	dest,
		uint32_t	max
	)

Converts a ROS fragment, from the old to new format, using the space of contiguous memory storage area given. If the event given is already on v3.0 format, no conversion takes place.

Parameters

src	A pointer to the first word of the fragment, lying in a contiguous area of memory.
dest	The destination area of memory, preallocated
max	The maximum number of words that fit in the preallocated memory area "dest".

Returns

A counter, for the number of words copied from the source to the destination. If that number is zero, something wrong happened.

Definition at line 176 of file util24.cxx.

{
  using namespace eformat;
 
  if (src[0] != ROS) {
    throw EFORMAT_WRONG_MARKER(src[0], ROS);
  }
 
  //check version
  helper::Version version(src[3]);
  if (version.major2() == MAJOR_DEFAULT_VERSION) {
    memcpy(dest, src, sizeof(uint32_t)*src[1]);
    return src[1];
  }
  if (version.major2() != MAJOR_OLD_VERSION)
    throw EFORMAT_BAD_VERSION(version.major2(), MAJOR_DEFAULT_VERSION);
  
  //this is from the old major version of eformat, proceed with conversion
  old::ROSFragment ros(src);
  ros.check_tree(); //this may throw
/**********renzy edit***/
//  write::ROSFragment nros(old::convert_source(ros.source_id()),
  eformat::write::ROSFragment nros(old::convert_source(ros.source_id()),
/**********renzy edit***/
              ros.run_no(), ros.lvl1_id(), ros.bc_id());
  nros.status(ros.nstatus(), ros.status());
  helper::Version ros_version(ros.version());
  nros.minor_version(ros_version.minor2());
 
/**********renzy edit***/
  //std::vector<write::ROBFragment*> acc_rob;
  std::vector<eformat::write::ROBFragment*> acc_rob;
/**********renzy edit***/
  for (size_t k=0; k<ros.noffset(); ++k) {
    old::ROBFragment rob(ros.child(k));
    uint32_t source_id = rob.source_id();
    
    for (size_t l=0; l<rob.noffset(); ++l) {
      old::RODFragment rod(rob.rod(l));
      if (rob.noffset() != 1) source_id = rod.source_id();
/**********renzy edit***/
      //write::ROBFragment* nrob = new write::ROBFragment
      eformat::write::ROBFragment* nrob = new eformat::write::ROBFragment
/**********renzy edit***/
    (old::convert_source(source_id), rod.run_no(), rod.lvl1_id(),
     rod.bc_id(), rod.lvl1_trigger_type(), rod.detev_type(), 
     rod.ndata(), rod.data(), rod.status_position());
      nrob->status(rob.nstatus(), rob.status());
      nrob->rod_status(rod.nstatus(), rod.status());
      helper::Version rob_version(rob.version());
      nrob->minor_version(rob_version.minor2());
      helper::Version rod_version(rod.version());
      nrob->rod_minor_version(rod_version.minor2());
      
      //make this new ROB part of the new ROS
      nros.append(nrob);
      //make sure we don't forget to delete this guy
      acc_rob.push_back(nrob);
    }
  }
 
  //now the ROS is in `nros', bind
  const eformat::write::node_t* top = nros.bind();
  //memcpy the list of pages into contiguous memory
  uint32_t retval = eformat::write::copy(*top, dest, max);
 
  //delete the dynamically allocated stuff
  for (size_t i=0; i<acc_rob.size(); ++i) delete acc_rob[i];
 
  return retval;
}

Referenced by eformat::old::convert().