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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Experiment/Experiment.hh"
#include "AbsEnv/AbsEnv.hh"
#include "ErrorLogger_i/gERRLOG.hh"
//#include "Trybos/TRY_Bank_Name.hh"
//#include "Trybos/TRY_Bank_Number.hh"
//#include "Trybos/TRY_Bank_Type.hh"

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

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

CC2Q_Storable::CC2Q_Storable() : StorableObject() {}

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

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

CC2Q_Storable::~CC2Q_Storable() {}

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

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

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

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

void CC2Q_Storable::print(std::ostream& os) const
{
  os << "\n**********************************************************\n";
  os << "\n  CC2Q_Storable " << "\n";
  os << "\n**********************************************************\n\n";
  
_container.print(os);
}

bool CC2Q_Storable::postread(EventRecord* record)
{
  return true;
}

bool CC2Q_Storable::prewrite(EventRecord* record)
{
  // Note : ValueVector does not currently call prewrite on its elements,
  // so do so here :
  bool status = StorableObject::prewrite(record);
  status = _container.prewrite(record) && status;
  for (CC2Q_Storable::iterator i = _container.contents().begin();
       i != _container.contents().end(); ++i)
    {
      status = (*i).prewrite(record) && status;
    }
  return status;
}

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

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

void CC2Q_Storable::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 == 2)
	{ 
	  StorableObject::Streamer(iobuffer) ;
	  _container.Streamer(iobuffer); 
	}
      else
	{ 
	  ERRLOG( ELerror, "Unsupported CC2Q_Storable version" )
	    << "@SUB=CC2Q_Storable::Streamer(<isReading>)"
	    << "CC2Q_Storable cannot be read."
	    << endmsg;
	}
      iobuffer.CheckByteCount(start, byte_count, CC2Q_Storable::IsA()) ;
    }
  
  //-----------------------------------------------------------------------------
  // Write object to buffer
  //-----------------------------------------------------------------------------
  else if (iobuffer.IsWriting())
    { 
      byte_count = iobuffer.WriteVersion(CC2Q_Storable::IsA(), kTRUE) ;
      Version_t current_version = CC2Q_Storable::class_version() ;
      if (current_version == 2)
	{ 
	  StorableObject::Streamer(iobuffer) ;
	  _container.Streamer(iobuffer); 
	}
      else
	{ 
	  ERRLOG( ELerror, "Unsupported CC2Q_Storable version" )
	    << "@SUB=CC2Q_Storable::Streamer(<isWriting>)"
	    << "CC2Q_Storable cannot be written."
	    << endmsg;
	}
      iobuffer.SetByteCount(byte_count, kTRUE) ;
    }
  
  //-----------------------------------------------------------------------------
  // Unanticipated action
  //-----------------------------------------------------------------------------
  else
    { 
      ERRLOG( ELerror, "CC2Q_Storable::Streamer(<unknown action>)" )
	<< "@SUB=CC2Q_Storable::Streamer"
	<< "NOTHING DONE."
	<< endmsg;
    }
}

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

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

}

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




//=============================================================================
// ROOT I/O Hook
//=============================================================================
CdfClassImp(CC2Q_Storable)