// StreamType.cxx

#include "StreamType.h"
#include <iostream>

using std::ostream;
using hes::Name;
using hes::PlacementCategoryType;
using hes::StreamType;

typedef StreamType::PCList PCLIst;

//**********************************************************************
// Local definitions.
//**********************************************************************
namespace {

// Invalid PC type.
PlacementCategoryType INVALID_PCTYPE;

}  // end unnamed namespace

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

// Default constructor.

StreamType::StreamType() { }

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

// Constructor.

StreamType::StreamType(Name name, const PCList& pctypes)
: m_name(name), m_pctypes(pctypes) {
  bool ok = m_name.is_valid() && m_pctypes.size()>0;
  if ( ok ) {
    for ( PCList::const_iterator ipct=m_pctypes.begin();
          ipct!=m_pctypes.end(); ++ipct ) {
      if ( ! (ipct->is_valid() && ipct->is_closed()) ) {
        ok = false;
        break;
      }
    }
  }
  if ( ! ok ) {
    m_name = Name();
    m_pctypes.erase(m_pctypes.begin(), m_pctypes.end());
  }
}

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

// Is this a valid stream type?
// Must have valid name and one or more PC types.

bool StreamType::is_valid() const {
  return m_name.is_valid() && size()>0;
}

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

// Return the name.

Name StreamType::name() const {
  return m_name;
}

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

// Return the number of PC types.

int StreamType::size() const {
  return m_pctypes.size();
}

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

// Return the i'th (0 </= i < size()) PC type.

const PlacementCategoryType& StreamType::operator[](int i) const {
  if ( i>=0 && i<size() ) {
    return m_pctypes[i];
  }
  return INVALID_PCTYPE;
}

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

// Output stream.
ostream& operator<<(ostream& lhs, const StreamType& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "invalid stream type";
    return lhs;
  }
  lhs << "Stream type " << rhs.name() << " has " << rhs.size() << " ";
  if ( rhs.size() == 1 ) {
    lhs << "entry";
  } else {
    lhs << "entries";
  }
  lhs << ":";
  for ( int i=0; i<rhs.size(); ++i ) {
    lhs << "\n" << rhs[i];
  }
  return lhs;
}

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

// Equality.

bool operator==(const StreamType& lhs, const StreamType& rhs) {
  if ( lhs.name() != rhs.name() ) return false;
  if ( lhs.size() != rhs.size() ) return false;
  for ( int i=0; i<lhs.size(); ++i ) {
    if ( lhs[i] != rhs[i] ) return false;
  }
  return true;
}

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

// Inequality.

bool operator!=(const StreamType& lhs, const StreamType& rhs) {
  return ! (lhs == rhs);
}

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