// PlacementCategory.cxx

#include "PlacementCategory.h"

using hes::Name;
using hes::EventId;
using hes::EdoType;
using hes::EdoKey;
using hes::EdoTypeKey;
using hes::EdoId;
using hes::PlacementCategoryType;
using hes::PlacementCategory;

//**********************************************************************
// Local definitions.
//**********************************************************************

typedef PlacementCategory::EdoIdList EdoIdList;

//**********************************************************************

namespace {

PlacementCategoryType BADPCT;

}  // end unnamed namespace

//**********************************************************************
// Member functions.
//**********************************************************************

// Default constructor.
// Creates an invalid object.

PlacementCategory::PlacementCategory()
: m_ptype(0), m_closed(false) { }

//**********************************************************************

// Constructor from a placement category type and an event ID..

PlacementCategory::
PlacementCategory(const PlacementCategoryType& pct, EventId evid)
: m_ptype(0), m_closed(false) {
  if ( pct.is_valid() && pct.is_closed() && evid.is_valid() ) {
    m_ptype = &pct;
    m_evid = evid;
  }
}

//**********************************************************************

// Add an EDO ID.

int PlacementCategory::insert(EdoId edo_id) {
  if ( is_valid() &&
       ! is_closed() &&
       edo_id.is_valid() &&
       type().allows(edo_id.type_key()) &&
       edo_id.event_id() == event_id() &&
       ! has(edo_id.type_key()) ) {
    m_ids.push_back(edo_id);
    return 0;
  }
  return 1;
}

//**********************************************************************

// Close.

void PlacementCategory::close() {
  m_closed = true;
}

//**********************************************************************

// Is this object valid?

bool PlacementCategory::is_valid() const {
  return m_ptype!=0 && m_ptype->is_valid();
}

//**********************************************************************

// Is this object closed?

bool PlacementCategory::is_closed() const {
  return m_closed;
}

//**********************************************************************

// Return the name of the placement category type.
// Returns blank if this object is not valid.

Name PlacementCategory::name() const {
  if ( ! is_valid() ) {
    return Name();
  } else {
    return m_ptype->name();
  }
}

//**********************************************************************

// Return the placement category type.
// Something bad will happen if this object is not valid.

const PlacementCategoryType& PlacementCategory::type() const {
  if ( ! is_valid() ) {
    return BADPCT;
  } else {
    return *m_ptype;
  }
}

//**********************************************************************

// Return the event ID.

EventId PlacementCategory::event_id() const {
  return m_evid;
}

//**********************************************************************

// Return the number of EDO ID's.

PlacementCategory::size_type PlacementCategory::size() const {
  return m_ids.size();
}

//**********************************************************************

// Return the list of EDO ID's.

const EdoIdList& PlacementCategory::edo_ids() const {
  return m_ids;
}

//**********************************************************************

// Return whether a type-key is included.

bool PlacementCategory::has(EdoType type, EdoKey key) const {
  return has(EdoTypeKey(type,key));
}

//**********************************************************************

// Return if the specified type-key is included.

bool PlacementCategory::has(EdoTypeKey tk) const {
  return edo_id(tk).is_valid();
}

//**********************************************************************

// Find the EDO ID with the specified type-key.

EdoId PlacementCategory::edo_id(EdoTypeKey tk) const {
  for ( EdoIdList::const_iterator iid=m_ids.begin();
        iid!=m_ids.end(); ++iid ) {
    if ( iid->type_key() == tk ) {
      return *iid;
    }
  }
  return EdoId();
}

//**********************************************************************

// Find the EDO ID with the specified type-key.

EdoId PlacementCategory::edo_id(EdoType type, EdoKey key) const {
  return edo_id(EdoTypeKey(type,key));
}

//**********************************************************************
// Free functions.
//**********************************************************************

// Output stream.

ostream& operator<<(ostream& lhs, const PlacementCategory& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "invalid placement category";
    return lhs;
  }
  lhs << "Placement category of type " << rhs.name().name();
  lhs << " for event " << rhs.event_id();
  if ( rhs.edo_ids().size() == 0 ) {
    lhs << " is empty.";
    return lhs;
  }
  lhs << ":";
  const PlacementCategory::EdoIdList& ids = rhs.edo_ids();
  for ( PlacementCategory::EdoIdList::const_iterator iid=ids.begin();
        iid!=ids.end(); ++iid ) {
    lhs << "\n  " << *iid;
  }
  return lhs;
}

//**********************************************************************