Ref.h

#ifndef PandaTree_Framework_Ref_h
#define PandaTree_Framework_Ref_h

#include "ContainerBase.h"

#include <stdexcept>

namespace panda {


  template<class E>
  class Ref {
  public:
    typedef Ref<E> self_type;
    typedef E value_type;
    typedef Short_t index_type;

    Ref() {}

    Ref(ContainerBase const*& c, index_type& idx) : container_(&c), idx_(&idx) {}
    Ref(self_type const& orig) : container_(orig.container_), idx_(orig.idx_) {}
    void setIndex(index_type& idx) { idx_ = &idx; }

    void setContainer(ContainerBase const*& c) { container_ = &c; }

    value_type const* operator->() const
    {
      if (!container_ || !(*container_) || !idx_ || (*idx_) < 0)
        return 0;
  
      return &static_cast<E const&>((*container_)->elemAt(*idx_));
    }

    value_type const& operator*() const
    {
      if (!container_ || !(*container_) || !idx_ || (*idx_) < 0)
        throw std::runtime_error("Dereferencing an invalid Ref");
  
      return static_cast<E const&>((*container_)->elemAt(*idx_));
    }

    self_type& operator=(self_type const& rhs)
    {
      container_ = rhs.container_;
      if (idx_) {
        if (rhs.idx_)
          (*idx_) = (*rhs.idx_);
        else
          (*idx_) = -1;
      }
      return *this;
    }

    Bool_t setRef(value_type const* rhs)
    {
      if (!rhs) {
        container_ = 0;
        idx_ = 0;
      }
  
      if (!container_ || !(*container_) || !idx_)
        return false;
  
      // loop through the container and return when a match is found
      for ((*idx_) = 0; (*idx_) != Short_t((*container_)->size()); ++(*idx_)) {
        if (&(*container_)->elemAt(*idx_) == rhs)
          return true;
      }
  
      // otherwise set to -1 and return false
  
      (*idx_) = -1;
      return true;
    }
    Bool_t isValid() const { return container_ && *container_ && idx_ && unsigned(*idx_) < (*container_)->size(); }

    void init() { if (idx_) (*idx_) = -1; }

    index_type& idx()
    {
      if (!idx_)
        throw std::runtime_error("Invalid index ref");
  
      return *idx_;
    }

    index_type idx() const
    {
      if (!idx_)
        throw std::runtime_error("Invalid index ref");
  
      return *idx_;
    }

    ContainerBase const* container() const
    {
      if (!container_)
        throw std::runtime_error("Invalid container ref");
  
      return *container_;
    }
    value_type const* get() const { return operator->(); }

  private:
    ContainerBase const** container_{0};
    index_type* idx_{0};
  };



  template<class E>
  class ConstRef {
  public:
    typedef ConstRef<E> self_type;
    typedef E value_type;
    typedef Short_t index_type;

    ConstRef() {}

    ConstRef(ContainerBase const*& c, index_type const& idx) : container_(&c), idx_(&idx) {}
    ConstRef(self_type const& orig) : container_(orig.container_), idx_(orig.idx_) {}

    self_type& operator=(self_type const&) = delete;

    void setIndex(index_type const& idx) { idx_ = &idx; }

    void setContainer(ContainerBase const*& c) { container_ = &c; }

    value_type const* operator->() const
    {
      if (!container_ || !(*container_) || !idx_ || (*idx_) < 0)
        return 0;
  
      return &static_cast<E const&>((*container_)->elemAt(*idx_));
    }

    value_type const& operator*() const
    {
      if (!container_ || !(*container_) || !idx_ || (*idx_) < 0)
        throw std::runtime_error("Dereferencing an invalid ConstRef");
  
      return static_cast<E const&>((*container_)->elemAt(*idx_));
    }
    Bool_t isValid() const { return container_ && *container_ && idx_ && unsigned(*idx_) < (*container_)->size(); }

    index_type const& idx() const
    {
      if (!idx_)
        throw std::runtime_error("Invalid index ref");
  
      return *idx_;
    }

    ContainerBase const* container() const
    {
      if (!container_)
        throw std::runtime_error("Invalid container ref");
  
      return *container_;
    }
    value_type const* get() const { return operator->(); }

  private:
    ContainerBase const** container_{0};
    index_type const* idx_{0};
  };

}

template<class E>
std::ostream& operator<<(std::ostream& _out, panda::Ref<E> const& _ref)
{
  _out << "Ref<" << E::typeName() << ">";
  if (_ref.isValid())
    _out << " " << _ref.container()->getName() << "(" << _ref.idx() << ")";
  else
    _out << " (null)";

  return _out;
}

template<class E>
std::ostream& operator<<(std::ostream& _out, panda::ConstRef<E> const& _ref)
{
  _out << "Ref<" << E::typeName() << ">";
  if (_ref.isValid())
    _out << " " << _ref.container()->getName() << "(" << _ref.idx() << ")";
  else
    _out << " (null)";

  return _out;
}

#endif