RefToBaseProd.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefToBaseProd_h
#define DataFormats_Common_RefToBaseProd_h

/* \class edm::RefToBaseProd<T>
 *
 * \author Luca Lista, INFN
 *
 */
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"

#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/FillView.h"
#include "DataFormats/Common/interface/FillViewHelperVector.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Common/interface/RefCore.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/View.h"
#include "DataFormats/Common/interface/WrapperBase.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "FWCore/Utilities/interface/EDMException.h"

#include <utility>
#include <vector>

namespace edm {

  template<typename T>
  class RefToBaseProd {
  public:
    typedef View<T> product_type;

    RefToBaseProd() : product_(){}

    template<typename C>
    explicit RefToBaseProd(Handle<C> const& handle);
    explicit RefToBaseProd(Handle<View<T> > const& handle);
    template<typename C>
    explicit RefToBaseProd(OrphanHandle<C> const& handle);
    RefToBaseProd(const RefToBaseProd<T>&);
    template<typename C>
    explicit RefToBaseProd(const RefProd<C>&);
    RefToBaseProd(ProductID const&, EDProductGetter const*);

    ~RefToBaseProd() { delete viewPtr();}

    product_type const&  operator*() const;

    product_type const* operator->() const;

    product_type const* get() const {
      return isNull() ? 0 : this->operator->();
    }

    product_type const* product() const {
      return isNull() ? 0 : this->operator->();
    }

    bool isNull() const {return !isNonnull(); }

    bool isNonnull() const { return product_.isNonnull(); }

    bool operator!() const {return isNull(); }

    ProductID id() const {return product_.id();}

    EDProductGetter const* productGetter() const {return product_.productGetter();}

    bool hasCache() const {return product_.productPtr() != 0;}

    RefToBaseProd<T>& operator=(const RefToBaseProd<T>& other);

    void swap(RefToBaseProd<T>&);

    //Needed for ROOT storage
    CMS_CLASS_VERSION(10)
  private:
    //NOTE: Access to RefCore should be private since we modify the use of productPtr
    RefCore const& refCore() const {
      return product_;
    }
    
    View<T> const* viewPtr() const {
      return reinterpret_cast<const View<T>*>(product_.productPtr());
    }

    RefCore product_;
  };

  template<typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd(Handle<View<T> > const& handle) :
    product_(handle.id(), 0, 0, false){
    product_.setProductPtr(new View<T>(* handle));
  }

  template<typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd(const RefToBaseProd<T>& ref) :
    product_(ref.product_) {
      if(product_.productPtr()) {
        product_.setProductPtr(ref.viewPtr() ? (new View<T>(* ref)) : 0);
      }
  }

  template<typename T>
  inline
  RefToBaseProd<T>& RefToBaseProd<T>::operator=(const RefToBaseProd<T>& other) {
    RefToBaseProd<T> temp(other);
    this->swap(temp);
    return *this;
  }

  template<typename T>
  inline
  View<T> const& RefToBaseProd<T>::operator*() const {
    return * operator->();
  }

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
  template<typename T>
  inline
  View<T> const* RefToBaseProd<T>::operator->() const {
    //Another thread might change the value returned so just get it once
    auto getter = product_.productGetter();
    if(getter != nullptr) {
      if(product_.isNull()) {
        Exception::throwThis(errors::InvalidReference,
          "attempting get view from a null RefToBaseProd.\n");
      }
      ProductID tId = product_.id();
      std::vector<void const*> pointers;
      FillViewHelperVector helpers;
      WrapperBase const* prod = getter->getIt(tId);
      if(prod == nullptr) {
        Exception::throwThis(errors::InvalidReference,
                             "attempting to get view from an unavailable RefToBaseProd.");
      }
      prod->fillView(tId, pointers, helpers);
      std::unique_ptr<View<T>> tmp{ new View<T>(pointers, helpers, getter) };
      if( product_.tryToSetProductPtrForFirstTime(tmp.get())) {
        tmp.release();
      }
    }
    return viewPtr();
  }
#endif

  template<typename T>
  inline
  void RefToBaseProd<T>::swap(RefToBaseProd<T>& other) {
    edm::swap(product_, other.product_);
  }

  template<typename T>
  inline
  bool
  operator== (RefToBaseProd<T> const& lhs, RefToBaseProd<T> const& rhs) {
    return lhs.refCore() == rhs.refCore();
  }

  template<typename T>
  inline
  bool
  operator!= (RefToBaseProd<T> const& lhs, RefToBaseProd<T> const& rhs) {
    return !(lhs == rhs);
  }

  template<typename T>
  inline
  bool
  operator< (RefToBaseProd<T> const& lhs, RefToBaseProd<T> const& rhs) {
    return (lhs.refCore() < rhs.refCore());
  }

  template<typename T>
  inline void swap(edm::RefToBaseProd<T> const& lhs, edm::RefToBaseProd<T> const& rhs) {
    lhs.swap(rhs);
  }
}

#include "DataFormats/Common/interface/FillView.h"

namespace edm {
#ifndef __GCCXML__
  template<typename T>
  template<typename C>
  inline
  RefToBaseProd<T>::RefToBaseProd(const RefProd<C>& ref) :
    product_(ref.refCore()) {
    std::vector<void const*> pointers;
    FillViewHelperVector helpers;
    fillView(* ref.product(), ref.id(), pointers, helpers);
    product_.setProductPtr(new View<T>(pointers, helpers, ref.refCore().productGetter()));
  }
#endif

  template<typename T>
  template<typename C>
  inline
  RefToBaseProd<T>::RefToBaseProd(Handle<C> const& handle) :
    product_(handle.id(), handle.product(), 0, false) {
    std::vector<void const*> pointers;
    FillViewHelperVector helpers;
    fillView(* handle, handle.id(), pointers, helpers);
    product_.setProductPtr(new View<T>(pointers, helpers,0));
  }

  template<typename T>
  template<typename C>
  inline
  RefToBaseProd<T>::RefToBaseProd(OrphanHandle<C> const& handle) :
    product_(handle.id(), handle.product(), 0, false) {
    std::vector<void const*> pointers;
    FillViewHelperVector helpers;
    fillView(* handle, handle.id(), pointers, helpers);
    product_.setProductPtr(new View<T>(pointers, helpers,0));
  }

  template<typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd(ProductID const& id, EDProductGetter const* getter) :
    product_(id, nullptr, getter, false) { }
}

#endif