Addressing.h

#ifndef SCT_ADDRESSING_H
#define SCT_ADDRESSING_H

#include <iostream>
#include <string>
#include "Sct/Addressing.hh"

namespace Sct {
  
  typedef unsigned int       PartitionIdentifier;

  typedef unsigned int           CrateIdentifier;

  typedef unsigned int             RodIdentifier;

  // forward declarations
  class UniquePartitionIdentifier;
  class UniqueCrateIdentifier;
  class UniqueRodIdentifier;
  class UniqueTimIdentifier;

  // shorter forms:
  typedef UniquePartitionIdentifier UPID;
  typedef UniqueCrateIdentifier     UCID;
  typedef UniqueRodIdentifier       URID;
  typedef UniqueTimIdentifier       UTID;

  // defns:

  class UniquePartitionIdentifier {
    PartitionIdentifier m_partition;
  public:
    UniquePartitionIdentifier(const Sct::Corba::UPID & other) :
      m_partition(other.partition) {
    };
    UniquePartitionIdentifier(const UniquePartitionIdentifier & other) :
      m_partition(other.m_partition) {
    };
    explicit UniquePartitionIdentifier(const PartitionIdentifier p) :
      m_partition(p) {
    };
    explicit UniquePartitionIdentifier(const std::string & s);
    UniquePartitionIdentifier() {};
    UniquePartitionIdentifier & operator=(const UniquePartitionIdentifier & other) {
      m_partition = other.m_partition;
      return *this;
    };
    bool operator==(const UniquePartitionIdentifier & other) const {
      return m_partition == other.m_partition;
    };
    bool operator!=(const UniquePartitionIdentifier & other) const {
      return m_partition != other.m_partition;
    };
    PartitionIdentifier partition() const {
      return m_partition;
    };
    operator std::string () const;
    bool operator<(const UniquePartitionIdentifier & other) const {
      return this->m_partition < other.m_partition;
    };
  private:
    std::string tag() const { return "UPID"; };
  };
  
  class UniqueCrateLevelIdentifierBase {
    UniquePartitionIdentifier m_partition;
    CrateIdentifier           m_crate;
  public:
    UniqueCrateLevelIdentifierBase(const UniquePartitionIdentifier p,
                   const CrateIdentifier c) : 
      m_partition(p),
      m_crate(c) {
    };
    UniqueCrateLevelIdentifierBase(const PartitionIdentifier p,
                   const CrateIdentifier c) : 
      m_partition(p),
      m_crate(c) {
    };
    UniqueCrateLevelIdentifierBase() {};
    
  public:
    UniquePartitionIdentifier upid() const { return m_partition; };

  public:
    PartitionIdentifier partition() const { return m_partition.partition(); };

    CrateIdentifier crate() const { return m_crate; };

  protected: // Protected because we don't want people to be able to compare different specialisations with each other,or work with the bases themselves.
    UniqueCrateLevelIdentifierBase & operator=(const UniqueCrateLevelIdentifierBase & other) {
      m_partition = other.m_partition;
      m_crate = other.m_crate;
      return *this;
    };
    bool operator==(const UniqueCrateLevelIdentifierBase & other) const {
      return 
    m_crate     == other.m_crate &&
    m_partition == other.m_partition;
    };
    bool operator!=(const UniqueCrateLevelIdentifierBase & other) const {
      return 
    m_crate     != other.m_crate ||
    m_partition != other.m_partition;
    };
    bool operator<(const UniqueCrateLevelIdentifierBase & other) const {
      return 
    m_partition < other.m_partition ||
    m_partition == other.m_partition && m_crate < other.m_crate;
    };
    const UniqueCrateLevelIdentifierBase & base() const {
      return *this;
    };
    UniqueCrateLevelIdentifierBase & base() {
      return *this;
    };
  };

  class UniqueCrateIdentifier : 
    public UniqueCrateLevelIdentifierBase {
  public:
    UniqueCrateIdentifier(const Sct::Corba::UCID & other) :
      UniqueCrateLevelIdentifierBase(other.partition, other.crate) {
    };
    UniqueCrateIdentifier(const UniquePartitionIdentifier p,
              const CrateIdentifier c) : 
      UniqueCrateLevelIdentifierBase(p,c) {
    };
    UniqueCrateIdentifier(const PartitionIdentifier p,
              const CrateIdentifier c) : 
      UniqueCrateLevelIdentifierBase(p,c) {
    };
    explicit UniqueCrateIdentifier(const std::string & s);
    UniqueCrateIdentifier() {};
    // Not necessary: default will do!
    /*
      UniqueCrateIdentifier & operator=(const UniqueCrateIdentifier & other) {
      this->UniqueCrateLevelIdentifierBase::operator=(other);
      return *this;
      };
    */
    bool operator==(const UniqueCrateIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator==(other);
    };
    bool operator!=(const UniqueCrateIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator!=(other);
    };
    bool operator<(const UniqueCrateIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator<(other);
    };
    operator std::string () const;
  private:
    std::string tag() const { return "UCID"; };
  };
  
  class UniqueTimIdentifier :
    public UniqueCrateLevelIdentifierBase {
  public:
    UniqueTimIdentifier(const UniquePartitionIdentifier p,
            const CrateIdentifier c) : 
      UniqueCrateLevelIdentifierBase(p,c) {
    };
    UniqueTimIdentifier(const PartitionIdentifier p,
            const CrateIdentifier c) : 
      UniqueCrateLevelIdentifierBase(p,c) {
    };
    UniqueTimIdentifier(const std::string & s);
    UniqueTimIdentifier() {};
    // Not necessary: default will do!
    /*
      UniqueTimIdentifier & operator=(const UniqueTimIdentifier & other) {
      this->UniqueCrateLevelIdentifierBase::operator=(other);
      return *this;
      };
    */
    bool operator==(const UniqueTimIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator==(other);
    };
    bool operator!=(const UniqueTimIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator!=(other);
    };
    bool operator<(const UniqueTimIdentifier & other) const {
      return this->UniqueCrateLevelIdentifierBase::operator<(other);
    };
    operator std::string () const;
  private:
    std::string tag() const { return "UTID"; };
  };

  class UniqueRodIdentifier {
    UniqueCrateIdentifier m_ucid;
    RodIdentifier         m_rid;
  public:
    UniqueRodIdentifier(const Sct::Corba::URID & other) :
      m_ucid(UniqueCrateIdentifier(other.partition, other.crate)),
      m_rid(other.rod) {
    };
    UniqueRodIdentifier(const UniqueCrateIdentifier c,
            const RodIdentifier r) : 
      m_ucid(c),
      m_rid(r) {
    };
    UniqueRodIdentifier(const PartitionIdentifier p,
            const CrateIdentifier c,
            const RodIdentifier r) : 
      m_ucid(UniqueCrateIdentifier(p,c)),
      m_rid(r) {
    };
    explicit UniqueRodIdentifier(const std::string & s);
    UniqueRodIdentifier() {};
      
  public:
    UniquePartitionIdentifier upid() const { return m_ucid.upid(); };

    UniqueCrateIdentifier ucid() const { return m_ucid; };

  public:
    PartitionIdentifier partition() const { return m_ucid.partition(); };

    RodIdentifier crate() const { return m_ucid.crate(); };

    RodIdentifier rod() const { return m_rid; };


    bool operator==(const UniqueRodIdentifier & other) const {
      return
    m_rid  == other.m_rid &&
    m_ucid == other.m_ucid;
    };
    bool operator!=(const UniqueRodIdentifier & other) const {
      return
    m_rid  != other.m_rid ||
    m_ucid != other.m_ucid;
    };
    bool operator<(const UniqueRodIdentifier & other) const {
      return 
    m_ucid < other.m_ucid ||
    m_ucid == other.m_ucid && m_rid < other.m_rid;
    };
    operator std::string () const;
  private:
    std::string tag() const { return "URID"; };
  };

}
 
inline std::ostream & operator<<(std::ostream & os, const Sct::UniquePartitionIdentifier & upid) {
  return os << std::string(upid);
};

inline std::ostream & operator<<(std::ostream & os, const Sct::UniqueCrateIdentifier & ucid) {
  return os << std::string(ucid);
};

inline std::ostream & operator<<(std::ostream & os, const Sct::UniqueRodIdentifier & urid) {
  return os << std::string(urid);
};

inline std::ostream & operator<<(std::ostream & os, const Sct::UniqueTimIdentifier & utid) {
  return os << std::string(utid);
};

#endif

---