RefToBase.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefToBase_h
#define DataFormats_Common_RefToBase_h
// -*- C++ -*-
//
// Package:     Common
// Class  :     RefToBase
//
//
// Original Author:  Chris Jones
//         Created:  Mon Apr  3 16:37:59 EDT 2006
//

// system include files

// user include files

#include "boost/shared_ptr.hpp"
#include "boost/static_assert.hpp"
#include "boost/type_traits/is_base_of.hpp"

#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/EDProductfwd.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "DataFormats/Common/interface/BaseHolder.h"

#include "DataFormats/Common/interface/Holder.h"
#include "DataFormats/Common/interface/IndirectHolder.h"
#include "DataFormats/Common/interface/RefHolder.h"

namespace edm {
  //--------------------------------------------------------------------
  // Class template RefToBase<T>
  //--------------------------------------------------------------------


  template<typename T> class RefToBaseVector;
  template<typename C, typename T, typename F> class Ref;
  template<typename C> class RefProd;
  template<typename T> class RefToBaseProd;
  template<typename T> class View;

  template <class T>
  class RefToBase
  {
  public:
    typedef T   value_type;

    RefToBase();
    RefToBase(RefToBase const& other);
    template <typename C1, typename T1, typename F1>
    explicit RefToBase(Ref<C1, T1, F1> const& r);
    template <typename C>
    explicit RefToBase(RefProd<C> const& r);
    RefToBase(RefToBaseProd<T> const& r, size_t i);
    RefToBase(Handle<View<T> > const& handle, size_t i);
    template <typename T1>
    explicit RefToBase(RefToBase<T1> const & r );
    RefToBase(boost::shared_ptr<reftobase::RefHolderBase> p);
    ~RefToBase();

    RefToBase& operator= (RefToBase const& rhs);

    value_type const& operator*() const;
    value_type const* operator->() const;
    value_type const* get() const;

    ProductID id() const;
    size_t key() const;

    template <class REF> REF castTo() const;

    bool isNull() const;
    bool isNonnull() const;
    bool operator!() const;

    bool operator==(RefToBase const& rhs) const;
    bool operator!=(RefToBase const& rhs) const;

    void swap(RefToBase& other);

    std::auto_ptr<reftobase::RefHolderBase> holder() const;

    EDProductGetter const* productGetter() const;
    bool hasProductCache() const;
    void const * product() const;

    bool isAvailable() const { return holder_->isAvailable(); }
    
    //Needed for ROOT storage
    CMS_CLASS_VERSION(10)
  private:
    value_type const* getPtrImpl() const;
    reftobase::BaseHolder<value_type>* holder_;
    friend class RefToBaseVector<T>;
    friend class RefToBaseProd<T>;
    template<typename B> friend class RefToBase;
  };

  //--------------------------------------------------------------------
  // Implementation of RefToBase<T>
  //--------------------------------------------------------------------

  template <class T>
  inline
  RefToBase<T>::RefToBase() :
    holder_(0)
  { }

  template <class T>
  inline
  RefToBase<T>::RefToBase(RefToBase const& other) :
    holder_(other.holder_  ? other.holder_->clone() : 0)
  { }

  template <class T>
  template <typename C1, typename T1, typename F1>
  inline
  RefToBase<T>::RefToBase(Ref<C1, T1, F1> const& iRef) :
    holder_(new reftobase::Holder<T,Ref<C1, T1, F1> >(iRef))
  { }

  template <class T>
  template <typename C>
  inline
  RefToBase<T>::RefToBase(RefProd<C> const& iRef) :
    holder_(new reftobase::Holder<T,RefProd<C> >(iRef))
  { }

  template <class T>
  template <typename T1>
  inline
  RefToBase<T>::RefToBase(RefToBase<T1> const& iRef) :
        holder_(new reftobase::IndirectHolder<T> (
             boost::shared_ptr< edm::reftobase::RefHolderBase>(iRef.holder().release())
        ) )
  {
    // OUT: holder_( new reftobase::Holder<T,RefToBase<T1> >(iRef ) )  {
    // Forcing the conversion through IndirectHolder,
    //   as Holder<T,RefToBase<T1>> would need dictionaries we will never have.
    // In this way we only need the IndirectHolder<T> and the RefHolder of the real type of the item
    // This might cause a small performance penalty.
    BOOST_STATIC_ASSERT( ( boost::is_base_of<T, T1>::value ) );
  }

  template <class T>
  inline
  RefToBase<T>::RefToBase(boost::shared_ptr<reftobase::RefHolderBase> p) :
    holder_(new reftobase::IndirectHolder<T>(p))
  { }

  template <class T>
  inline
  RefToBase<T>::~RefToBase()
  {
    delete holder_;
  }

  template <class T>
  inline
  RefToBase<T>&
  RefToBase<T>:: operator= (RefToBase<T> const& iRHS)
  {
    RefToBase<T> temp( iRHS);
    temp.swap(*this);
    return *this;
  }

  template <class T>
  inline
  T const&
  RefToBase<T>::operator*() const
  {
    return *getPtrImpl();
  }

  template <class T>
  inline
  T const*
  RefToBase<T>::operator->() const
  {
    return getPtrImpl();
  }

  template <class T>
  inline
  T const*
  RefToBase<T>::get() const
  {
    return getPtrImpl();
  }

  template <class T>
  inline
  ProductID
  RefToBase<T>::id() const
  {
    return  holder_ ? holder_->id() : ProductID();
  }

  template <class T>
  inline
  size_t
  RefToBase<T>::key() const
  {
    if ( holder_ == 0 )
    Exception::throwThis(errors::InvalidReference,
      "attempting get key from  null RefToBase;\n"
      "You should check for nullity before calling key().");
    return  holder_->key();
  }

  template <class T>
  template <class REF>
  REF
  RefToBase<T>::castTo() const
  {
    if (!holder_)
      {
    Exception::throwThis(errors::InvalidReference,
      "attempting to cast a null RefToBase;\n"
      "You should check for nullity before casting.");
      }

    reftobase::RefHolder<REF> concrete_holder;
    std::string hidden_ref_type;
    if (!holder_->fillRefIfMyTypeMatches(concrete_holder,
                     hidden_ref_type))
      {
    Exception::throwThis(errors::InvalidReference,
      "cast to type: ",
      typeid(REF).name(),
      "\nfrom type: ",
      hidden_ref_type.c_str(),
      " failed. Catch this exception in case you need to check"
      " the concrete reference type.");
      }
    return concrete_holder.getRef();
  }

  template <class T>
  inline
  bool
  RefToBase<T>::isNull() const
  {
    return !id().isValid();
  }

  template <class T>
  inline
  bool
  RefToBase<T>::isNonnull() const
  {
    return !isNull();
  }

  template <class T>
  inline
  bool
  RefToBase<T>::operator!() const
  {
    return isNull();
  }

  template <class T>
  inline
  bool
  RefToBase<T>::operator==(RefToBase<T> const& rhs) const
  {
    return holder_
      ? holder_->isEqualTo(*rhs.holder_)
      : holder_ == rhs.holder_;
  }

  template <class T>
  inline
  bool
  RefToBase<T>::operator!=(RefToBase<T> const& rhs) const
  {
    return !(*this == rhs);
  }

  template <class T>
  inline
  void
  RefToBase<T>::swap(RefToBase<T> & other)
  {
    std::swap(holder_, other.holder_);
  }

  template <class T>
  inline
  EDProductGetter const* RefToBase<T>::productGetter() const {
    return holder_->productGetter();
  }

  template <class T>
  inline
  bool RefToBase<T>::hasProductCache() const {
    return holder_->hasProductCache();
  }

  template <class T>
  inline
  void const * RefToBase<T>::product() const {
    return holder_->product();
  }

  template <class T>
  inline
  T const*
  RefToBase<T>::getPtrImpl() const
  {
    return holder_ ? holder_->getPtr() : 0;
  }

  template <class T>
  std::auto_ptr<reftobase::RefHolderBase> RefToBase<T>::holder() const {
    return holder_->holder();
  }

  // Free swap function
  template <class T>
  inline
  void
  swap(RefToBase<T>& a, RefToBase<T>& b)
  {
    a.swap(b);
  }
}

#include "DataFormats/Common/interface/RefToBaseProd.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/View.h"

namespace edm {
  template <class T>
  inline
  RefToBase<T>::RefToBase(RefToBaseProd<T> const& r, size_t i) :
    holder_( r.operator->()->refAt( i ).holder_->clone() ) {
  }

  template<typename T>
  inline
  RefToBase<T>::RefToBase(Handle<View<T> > const& handle, size_t i) :
    holder_( handle.operator->()->refAt( i ).holder_->clone() ) {
  }

}

#endif