AnyReference.h

// -*- C++ -*-
//
// AnyReference.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
// Copyright (C) 2010-2019 Simon Platzer
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_AnyReference_H
#define ThePEG_AnyReference_H

#include "ThePEG/Config/ThePEG.h"
#include "Exception.h"

namespace ThePEG {

  class AnyReference {

    struct ReferenceHolderBase {

      virtual ~ReferenceHolderBase() {}

      virtual const std::type_info& type() const = 0;

      virtual ReferenceHolderBase* clone() const = 0;

    };

    template<class T>
    struct ReferenceHolder 
      : public ReferenceHolderBase {

      T& value;

      static T& init() {
        static T v; return v;
      }

      ReferenceHolder()
        : value(init()) {}

      explicit ReferenceHolder(T& v)
        : value(v) {}

      virtual const std::type_info& type() const {
        return typeid(T);
      }

      virtual ReferenceHolderBase* clone() const {
        return new ReferenceHolder(*this);
      }

    };

    ReferenceHolderBase* holder;

  public:

    AnyReference()
      : holder(0) {}

    template<class T>
    AnyReference(T& v)
      : holder(new ReferenceHolder<T>(v)) {}

    AnyReference(const AnyReference& other)
      : holder(other.holder ? other.holder->clone() : 0) {}

    ~AnyReference() {
        delete holder; holder = 0;
    }

  public:

    const std::type_info& type() const { return holder ? holder->type() : typeid(void); }

    bool empty() const { return !holder; }

  public:

    AnyReference& swap(AnyReference& other) { 
      std::swap(holder,other.holder); return *this;
    }

    template<class T>
    AnyReference& operator=(T& v) {
      AnyReference(v).swap(*this);
      return *this;
    }

    AnyReference& operator=(AnyReference other) {
      other.swap(*this);
      return *this;
    }

    void reset() {
      delete holder; holder = 0;
    }

  public:

    template<class T>
    T& cast() const {
      if ( !empty() && type() == typeid(T) ) {
        return static_cast<ReferenceHolder<T>*>(holder)->value;
      }
      throw Exception() << "Bad cast in AnyReference" << Exception::abortnow;
      return ReferenceHolder<T>::init();
    }

  };

}

#endif // ThePEG_AnyReference_H