/*!
  \file
  \version $Id: TAGmbsEvent.cxx,v 1.6 2003/06/19 17:53:28 mueller Exp $
  \brief   Implementation of TATOFmbsEvent.
*/

#include <string.h>

#include "TString.h"

#include "TATOFmbsEvent.h"

/*!
  \class TATOFmbsEvent TATOFmbsEvent.h "TATOFmbsEvent.h"
  \brief Representation of MBS raw data event. **
*/

ClassImp(TATOFmbsEvent);

//------------------------------------------+-----------------------------------
//! Default constructor.

TATOFmbsEvent::TATOFmbsEvent()
{}

//------------------------------------------+-----------------------------------
//! Destructor.

TATOFmbsEvent::~TATOFmbsEvent()
{}

//------------------------------------------+-----------------------------------
//! Set EventInfo.

void TATOFmbsEvent::SetEventInfo(const TATOFmbsEventInfo& info)
{
  fInfo = info;
  return;
}

//------------------------------------------+-----------------------------------
//! Add a sub event.

void TATOFmbsEvent::AddSubEvent(Int_t i_typ, Int_t i_styp, Int_t i_pid,
			      Int_t i_ptyp, Int_t i_crate, Int_t i_size,
			      const UInt_t data[])
{
  Int_t i_base = (Int_t)fData.size();
  fData.resize(i_base + 3 + i_size);
  fData[i_base]   = i_size;
  fData[i_base+1] = ((i_typ&0xffff)<<16) | (i_styp&0xffff);
  fData[i_base+2] = ((i_pid&0xffff)<<16) | ((i_ptyp&0xff)<<8) | (i_crate&0xff);
  memcpy(&fData[i_base+3], data, i_size * sizeof(UInt_t));
  fOffset.push_back(i_base);
  return;
}

//------------------------------------------+-----------------------------------
//! Reserve space for \a i_nsub sub events and \a i_nword words data.

void TATOFmbsEvent::Reserve(Int_t i_nsub, Int_t i_nword)
{
  fData.reserve(3*i_nsub + i_nword);
  return;
}

//------------------------------------------+-----------------------------------
//! Returns \c true if object needs automatic delete when read from tree.

Bool_t TATOFmbsEvent::NeedAutoDelete() const
{
  return kFALSE;
}

///------------------------------------------+-----------------------------------
//! Clear event.

void TATOFmbsEvent::Clear(Option_t*)
{
  TATOFdata::Clear();
  fInfo.Clear();
  fData.clear();
  fOffset.clear();
  return;
}

/*------------------------------------------+---------------------------------*/
//! ostream insertion.

void TATOFmbsEvent::ToStream(ostream& os, Option_t* option) const
{
  os << "TATOFmbsEvent  " << Form("trig %2d", EventTrigger()) 
     << Form(" id %9d", EventRawId()) << endl;
  for (Int_t i = 0; i < NSubEvent(); i++) {
    os << Form("  Sub typ %4d", SubEventType(i)) 
       << Form(" / %4d", SubEventSubType(i)) 
       << Form(" size %5d", SubEventSize(i)) 
       << Form(" proc %3d", SubEventProcId(i)) 
       << Form(" / %3d", SubEventProcType(i)) 
       << Form(" / %3d", SubEventCrate(i)) << endl;
    if (option != 0 && option[0] != 0) {    // !!! check for -d properly....
      const UInt_t* p_data = SubEventData(i);
      Int_t i_nshow = SubEventSize(i);
      Int_t i_ind   = 0;
      if (i_nshow > 32) i_nshow = 32;
      while (i_ind < i_nshow) {
	os << Form("  %4d: ", i_ind);
	for (Int_t j = 0; j < 8; j++) {
	  os << Form("%08x ", p_data[i_ind]);
	  i_ind += 1;
	  if (i_ind >= i_nshow) break;
	}
	os << endl;
      }
    }
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! Custom streamer.

void TATOFmbsEvent::Streamer(TBuffer &R__b)
{
  UInt_t R__s, R__c;
  if (R__b.IsReading()) {
    Int_t i_size;
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c); 
    if (R__v) { }
    TATOFdata::Streamer(R__b);
    fInfo.Streamer(R__b);
    if (R__v == 1) {			    // discard version of embedded
      Version_t i_dummy;		    // object in V1
      R__b >> i_dummy;
    }
    R__b >> i_size;
    fData.resize(i_size);
    R__b.ReadFastArray(&fData[0], i_size);
    SetupOffset();
    R__b.CheckByteCount(R__s, R__c, TATOFmbsEvent::IsA());

  } else {
    R__c = R__b.WriteVersion(TATOFmbsEvent::IsA(), kTRUE);
    TATOFdata::Streamer(R__b);
    fInfo.Streamer(R__b);
    R__b << (Int_t) fData.size();
    R__b.WriteFastArray(&fData[0], (Int_t) fData.size());
    R__b.SetByteCount(R__c, kTRUE);
  }

  return;
}
/*------------------------------------------+---------------------------------*/
//! Setup sub event offset vector

void TATOFmbsEvent::SetupOffset()
{
  fOffset.clear();
  Int_t i_offset = 0;
  while (i_offset < (Int_t)fData.size()) {
    fOffset.push_back(i_offset);
    i_offset += fData[i_offset] + 3;
  }
  return;
}