//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Component: PPRTowerCorrColl.cc
// Purpose: This class contains PPR offline LERs for every tower applied to CalData energies
//
// Created: 06/16/03  Beate Heinemann
//
/////////////////////////////////////////////////////////////////////////////////////////////////////

//-----------------------
// This Class's Header --
//-----------------------
#include "CalorObjects/PPRTowerCorrColl.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Experiment/Experiment.hh"
#include "AbsEnv/AbsEnv.hh"
#include "ErrorLogger_i/gERRLOG.hh"

// ROOT Headers :
#include "TBuffer.h"
#include "EdmUtilities/CdfClassImp.hh"

//-----------------------------------------------------------------------------
// Creation
//-----------------------------------------------------------------------------

PPRTowerCorrColl::PPRTowerCorrColl() : StorableObject() {}

PPRTowerCorrColl::PPRTowerCorrColl(const PPRTowerCorrColl& rhs) :
  StorableObject(rhs),
  _container(rhs._container) {}

//-----------------------------------------------------------------------------
// Destruction
//-----------------------------------------------------------------------------

void PPRTowerCorrColl::destroy()
{ PPRTowerCorrColl::deallocate();
  delete this;
}

void PPRTowerCorrColl::deallocate()
{ StorableObject::deallocate();
}

//-----------------------------------------------------------------------------
// EDM:  functions required by StorableObject
//-----------------------------------------------------------------------------
  
std::string PPRTowerCorrColl::class_name() const
{
  return "PPRTowerCorrColl";
}

Version_t PPRTowerCorrColl::class_version() const
{
  return PPRTowerCorrColl::Class_Version();
}

void PPRTowerCorrColl::print(std::ostream& os) const
{
  StorableObject::print(os);
  _container.print(os);
}

bool PPRTowerCorrColl::postread(EventRecord* record)
{ 
  bool status = StorableObject::postread(record);
  return status;
}

bool PPRTowerCorrColl::prewrite(EventRecord* record)
{
  bool status = StorableObject::prewrite(record);
  return status;
}

bool PPRTowerCorrColl::activate(EventRecord* record)
{
  bool status = StorableObject::activate(record);
  return status;
}

bool PPRTowerCorrColl::deactivate(EventRecord* record)
{
  bool status = StorableObject::deactivate(record);
  return status;
}

void PPRTowerCorrColl::Streamer(TBuffer& iobuffer)
{
  unsigned int start = 0 ;
  unsigned int byte_count = 0 ;

  
  //-----------------------------------------------------------------------------
  // Read object from buffer
  //-----------------------------------------------------------------------------
  
  if (iobuffer.IsReading()){
      Version_t original_version = iobuffer.ReadVersion(&start, &byte_count) ;
      if (original_version == 1)
	{ 
	  StorableObject::Streamer(iobuffer) ;
	  iobuffer >> original_version;
	  _container.Streamer(iobuffer);
	}
      else
	{ 
	  ERRLOG(ELerror,"PPRTowerCorrColl: ")  << "Unsupported  PPRTowerCorrColl class version cannot be treated" << endmsg;
	}
      iobuffer.CheckByteCount(start, byte_count, PPRTowerCorrColl::IsA()) ;
    }
  //-----------------------------------------------------------------------------
  // Write object to buffer
  //-----------------------------------------------------------------------------
  else if (iobuffer.IsWriting()){ 
      byte_count = iobuffer.WriteVersion(PPRTowerCorrColl::IsA(), kTRUE) ;
      Version_t current_version = PPRTowerCorrColl::class_version() ;
      
      if (current_version == 1)
	{ 
	  StorableObject::Streamer(iobuffer) ;
	  iobuffer << current_version;
	  _container.Streamer(iobuffer);
	}
      else
	{ 
	  ERRLOG(ELerror,"PPRTowerCorrColl: ")  << "Unsupported  PPRTowerCorrColl class version cannot be treated" << endmsg;
	}
      iobuffer.SetByteCount(byte_count, kTRUE) ;
    }
  //-----------------------------------------------------------------------------
  // Unanticipated action
  //-----------------------------------------------------------------------------
  else
    { 
      ERRLOG(ELerror,"PPRTowerCorrColl: ") << " (<unknown action>):  NOTHING DONE"  << endmsg;    
    }
}

//-----------------------------------------------------------------------------
// Functions to retrieve the collection from the event
//-----------------------------------------------------------------------------

PPRTowerCorrColl::Error PPRTowerCorrColl::find(PPRTowerCorrColl_ch& cHandle)
{
  EventRecord::ConstIterator theEvent(AbsEnv::theEvent(),"PPRTowerCorrColl");
  
  if (theEvent.is_valid())
    {
      cHandle = theEvent;
      return OK;
    }
  else
    {
      cHandle.set_null();
      return ERROR;
    } 

}

PPRTowerCorrColl::Error PPRTowerCorrColl::find(PPRTowerCorrColl_ch& cHandle,
					   const StorableObject::Selector & selector)
{
  EventRecord::ConstIterator theEvent(AbsEnv::theEvent(),"PPRTowerCorrColl");
  while (theEvent.is_valid() && !selector(*theEvent))
    {
      ++theEvent;
    }
  if (theEvent.is_valid()) 
    {
      cHandle = theEvent;
      return OK;      
    } 
  else 
    {
      cHandle.set_null();
      return ERROR;
    }
}

CdfClassImp(PPRTowerCorrColl)