FEvent/Eye.cc

Go to the documentation of this file.

#include <sstream>
#include <utl/ErrorLogger.h>

#include <fevt/EyeRecData.h>
#include <fevt/EyeTriggerData.h>
#include <fevt/Telescope.h>
#include <fevt/EyeHeader.h>
#include <fevt/Eye.h>

#include <utl/AugerException.h>
#include <utl/IteratorDeprecator.h>

using namespace std;
using namespace utl;
using namespace fevt;


Eye::Eye(const unsigned int eyeId, const ComponentSelector::Status status) :
  fId(eyeId),
  fStatus(status)
{ }


Eye::Eye(const Eye& eyeData)
{
  *this = eyeData;
}


Eye::~Eye()
{
  for (const auto p : fTelescopes)
    delete p;
}


Eye&
Eye::operator=(const Eye& eyeData)
{
  if (this != &eyeData) {
    fId = eyeData.fId;
    fRecData = eyeData.fRecData;
    fTriggerData = eyeData.fTriggerData;
    fHeader = eyeData.fHeader;
    for (const auto p : fTelescopes)
      delete p;
    fTelescopes.clear();
    for (const auto p : eyeData.fTelescopes)
      fTelescopes.push_back(new Telescope(*p));
    fStatus = eyeData.fStatus;
  }
  return *this;
}


Telescope&
Eye::GetTelescope(const unsigned int telescopeId, const ComponentSelector::Status status)
{
  for (TelescopeIterator tIt = TelescopesBegin(status);
       tIt != TelescopesEnd(status); ++tIt)
    if (tIt->GetId() == telescopeId)
      return *tIt;

  ostringstream err;
  err << "Non existent telescope requested, Eye=" << fId
      << " Tel=" << telescopeId << " at status=" << status << ".";

  if (HasTelescope(telescopeId, ComponentSelector::eUnknown))
    err << " Telescope has status: " << GetTelescope(telescopeId, ComponentSelector::eUnknown).GetStatus() << "! ";
  else
    err << " Telescope not defined! ";

  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


const Telescope&
Eye::GetTelescope(const unsigned int telescopeId, const ComponentSelector::Status status)
  const
{
  for (ConstTelescopeIterator tIt = TelescopesBegin(status);
       tIt != TelescopesEnd(status); ++tIt)
    if (tIt->GetId() == telescopeId)
      return *tIt;

  ostringstream err;
  err << "Non existent telescope requested, Eye=" << fId
      << " Tel=" << telescopeId << " at status=" << status << ".";

  if (HasTelescope(telescopeId, ComponentSelector::eUnknown))
    err << " Telescope has status: " << GetTelescope(telescopeId, ComponentSelector::eUnknown).GetStatus() << "! ";
  else
    err << " Telescope not defined! ";

  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


void
Eye::MakeTelescope(const unsigned int telescopeId, const ComponentSelector::Status status)
{
  if (HasTelescope(telescopeId, ComponentSelector::eExists)) {
    ostringstream err;
    err << "Telescope already exists, Eye: " << fId
        << " Telescope: " << telescopeId;
    WARNING(err);
    return;
  }

  fTelescopes.push_back(new Telescope(fId, telescopeId, status));
}


bool
Eye::HasTelescope(const unsigned int telescopeId, const ComponentSelector::Status status)
  const
{
  for (ConstTelescopeIterator tIt = TelescopesBegin(status);
       tIt != TelescopesEnd(status); ++tIt)
    if (tIt->GetId() == telescopeId)
      return true;

  return false;
}


fevt::EyeRecData&
Eye::GetRecData()
{
  return *fRecData;
}


const fevt::EyeRecData&
Eye::GetRecData()
  const
{
  return *fRecData;
}


void
Eye::MakeRecData()
{
  if (fRecData)
    ERROR("EyeRecData already exists - Not Replacing");
  else
    fRecData = new EyeRecData(GetId());
}


fevt::EyeTriggerData&
Eye::GetTriggerData()
{
  return *fTriggerData;
}


const fevt::EyeTriggerData&
Eye::GetTriggerData()
  const
{
  return *fTriggerData;
}


void
Eye::MakeTriggerData()
{
  if (fTriggerData)
    ERROR("EyeTriggerData already exists - Not Replacing");
  else
    fTriggerData = new EyeTriggerData;
}


fevt::EyeHeader&
Eye::GetHeader()
{
  return *fHeader;
}


const fevt::EyeHeader&
Eye::GetHeader()
  const
{
  return *fHeader;
}


void
Eye::MakeHeader()
{
  if (fHeader) {
    ERROR("Eye::Header already exists - Not Replacing");
  }
  else
    fHeader = new EyeHeader;
}


// This is deprecated!
Eye::TelescopeIterator
Eye::TelescopesBegin()
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Eye::TelescopesBegin");

  return TelescopeIterator(ComponentSelector(ComponentSelector::eHasData),
                           AllTelescopesBegin(), AllTelescopesEnd());
}


// This is deprecated!
Eye::ConstTelescopeIterator
Eye::TelescopesBegin()
  const
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Eye::TelescopesBegin");

  return ConstTelescopeIterator(ComponentSelector(ComponentSelector::eHasData),
                                AllTelescopesBegin(), AllTelescopesEnd());
}


// This is deprecated!
Eye::TelescopeIterator
Eye::TelescopesEnd()
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Eye::TelescopesEnd");

  return TelescopeIterator(ComponentSelector(ComponentSelector::eHasData),
                           AllTelescopesEnd(), AllTelescopesEnd());
}


// This is deprecated!
Eye::ConstTelescopeIterator
Eye::TelescopesEnd()
  const
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Eye::TelescopesEnd");

  return ConstTelescopeIterator(ComponentSelector(ComponentSelector::eHasData),
                                AllTelescopesEnd(), AllTelescopesEnd());
}