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