RawDataBlock.cxx

Go to the documentation of this file.

// $Id: RawDataBlock.cxx,v 1.19 2005/04/29 22:32:06 minoscvs Exp $
// 
// RawDataBlock 
// 
// RawDataBlock is the base class for a block of raw MINOS data 
// The block is an unstructured collection of raw long (32-bit) words.
// The use of long words is important for letting the underlying ROOT I/O
// deal with the big vs. little endian-ism.  The consequence of this
// is to require the data suppliers to block their data (and pad if
// necessary) into 32-bit units.  This should not impose any serious
// costs as they are free to pack the block as they wish.
//
// Derived versions specialize how to unpack that data.
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawDataBlock.h"

#include <cassert>
#include <string.h>

#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"
//CVSID("$Id: RawDataBlock.cxx,v 1.19 2005/04/29 22:32:06 minoscvs Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDataBlock,0,0);

ClassImp(RawDataBlock)

//_____________________________________________________________________________

Bool_t RawDataBlock::fgForceHexDump = false;

//_____________________________________________________________________________

std::ostream& operator<<(std::ostream& os, const RawDataBlock& r) 
{ return r.FormatToOStream(os); }

//_____________________________________________________________________________
RawDataBlock::RawDataBlock()
   : fSize(0), fRawBlock(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawDataBlock::RawDataBlock(const Int_t *block)
   : fSize(0), fRawBlock(0)
{
   // Normal constructor
   //
   // build from flat buffer simply by duplicating data
   //
   if ( ! block ) return;

   fSize = (*block);

   if (fSize > 0) {
      fRawBlock = new Int_t [fSize];
      memcpy(fRawBlock,block,sizeof(Int_t)*fSize);
   } else {
      fSize = 0;
   }
}

//_____________________________________________________________________________
RawDataBlock::RawDataBlock(const RawDataBlock &rhs)
   : TObject(rhs), fSize(0), fRawBlock(0)
{
   // deep copy constructor
   //
   // build from rhs's buffer simply by duplicating data
   //
   fSize = rhs.GetSize();

   if (fSize > 0) {
      const Int_t* block = rhs.GetData();
      fRawBlock = new Int_t [fSize];
      memcpy(fRawBlock,block,sizeof(Int_t)*fSize);
   } else {
      fSize = 0;
   }
}

//_____________________________________________________________________________
RawDataBlock::~RawDataBlock()
{
   if (fSize > 0) delete [] fRawBlock;
}

//_____________________________________________________________________________
RawDataBlock& RawDataBlock::operator=(const RawDataBlock& rhs)
{
  // deep copy assignment
   //
   // build from rhs's buffer simply by duplicating data
   //

   // don't try assigning to self
   if (this == &rhs) return *this;

   // delete any existing info
   if (fSize > 0) { delete [] fRawBlock; fRawBlock = 0; }

   fSize = rhs.GetSize();

   if (fSize > 0) {
      const Int_t* block = rhs.GetData();
      fRawBlock = new Int_t [fSize];
      memcpy(fRawBlock,block,sizeof(Int_t)*fSize);
   } else {
      fSize = 0;
   }

   return *this;
}
//_____________________________________________________________________________
Int_t*  RawDataBlock::AppendToBuffer(Int_t *bstart) const
{
   // serialize this out to a buffer
   memcpy(bstart,fRawBlock,sizeof(Int_t)*fSize);
   Int_t *buff_end = bstart + fSize;
   return buff_end;
}

//_____________________________________________________________________________
void RawDataBlock::Print(Option_t *option) const
{
   FormatToOStream(cout,option); 
}

//_____________________________________________________________________________
std::ostream& RawDataBlock::FormatToOStream(std::ostream& os, 
                                            Option_t *option) const
{
   // print out the block 
   // if option == 'x' or 'X' dump it in hex

   RawBlockId rbid = GetBlockId();

   os << GetName()
      << " size=" << fSize
      << endl
      << " checksum=0x" 
      << hex << setw(8) << setfill('0') 
      << GetChecksum() << setfill(' ') << dec
      << ((TestChecksum()) ? " (error)" : " (okay)")
      << endl
      << " " << rbid.AsString() 
      << " 0x" << hex << setw(8) << setfill('0') 
      << rbid.GetEncoded() << setfill(' ') << dec
      << endl;

   Bool_t inhex = (strchr(option,'x')!=0 || strchr(option,'X')!=0);

   if ( fSize>0 && ( inhex || fgForceHexDump ) ) {

      os << hex << setfill('0');

      // format into columns, suppress duplicate lines unless 
      // it is the last line
      // -- this could probably be done in a cleaner fashion
      Int_t  ncol        = 4;
      Int_t  ncol_last   = (fSize+ncol-1)%ncol + 1;
      Bool_t lastmatch   = false;
      Bool_t lastline    = false;
      Int_t *next_word   = fRawBlock;
      Int_t  nfull_lines = fSize/ncol;
      if (ncol_last == ncol) nfull_lines--; // if exact, pretend last is partial
      Int_t *start_last  = fRawBlock + ncol*nfull_lines;
      Int_t  nbytes = 0;

      while (next_word < fRawBlock+fSize) {
         // adjust down the number of columns if this is the last line
         if (next_word == start_last) {
            lastline = true;
            ncol = ncol_last;
         }

         Int_t *prev = next_word - ncol;
         if (prev >= fRawBlock && !lastline ) { 
            // check for match of previous line
            Bool_t linematch = true;
            Int_t *chek = next_word;
            for (int i=0; i<ncol; i++)
               linematch = ( *prev++ == *chek++ ) ? linematch : false;
            if (linematch) {
               next_word += ncol;
               nbytes += sizeof(Int_t)*ncol;
               if (!lastmatch) {
                  // was a match, but previous line wasn't also "*"
                  // and it isn't the very last line
                  os << "  *\n";
               }
               lastmatch = true;
               continue;
            } 
            else lastmatch = false;

         }
         // print offset info
         os << "0x" << setw(6) << nbytes << ":";
         // print elements of line (advance pointer and count)
         for (int i=0; i<ncol; i++) {
            os << " " << setw(8) << *next_word;
            next_word++;
            nbytes += sizeof(Int_t);
         }
         // end the line
         os << "\n";
      }

   }

   // make sure everythings back to normal
   os << setfill(' ') << dec;
   return os;
}

//_____________________________________________________________________________

---