/data/refman/pasoursint/CMSSW_5_3_1/src/DataFormats/Common/interface/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/WrapperHolder.h"
#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/RefCore.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/ConstPtrCache.h"

namespace edm {
  template<typename T> class View;
  template<typename C> class Handle;

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

    RefToBaseProd() : product_(){}

    // The templating is artificial.
    // HandleC must have the following methods:
    //   id(),      returning a ProductID,
   //   product(), returning a C*.
    template<class HandleC>
    explicit RefToBaseProd(HandleC const& handle);
    explicit RefToBaseProd(Handle<View<T> > const& handle);
    template<typename C, typename F>
    explicit RefToBaseProd(Ref<C, T, F> const& ref);
    explicit RefToBaseProd(RefToBase<T> const& ref);
    explicit RefToBaseProd(const View<T>&);
    RefToBaseProd(const RefToBaseProd<T>&);
    template<typename C>
    RefToBaseProd(const RefProd<C>&);

    ~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 id().isValid(); }

    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());
    }
    //needs to be mutable so we can modify the 'productPtr' it holds
    // so that 'productPtr' can hold our View
    mutable RefCore product_;
  };
}

#include "DataFormats/Common/interface/View.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefCoreGet.h"
#include "DataFormats/Common/interface/RefVectorHolder.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefTraits.h"

namespace edm {

  namespace refhelper {
    template<typename C,
             typename T = typename refhelper::ValueTrait<C>::value,
             typename F = typename refhelper::FindTrait<C, T>::value>
    struct RefToBaseProdTrait {
      typedef RefVector<C, T, F> ref_vector_type;
    };

    template<typename C, typename T, typename F, typename T1, typename F1>
    struct RefToBaseProdTrait<RefVector<C, T, F>, T1, F1> {
      typedef RefVector<C, T, F> ref_vector_type;
    };
  }

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

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

  template<typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd(const RefToBaseProd<T>& ref) :
    product_(ref.product_) {
      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->();
  }

  template<typename T>
  inline
  View<T> const* RefToBaseProd<T>::operator->() const {
    if(product_.productPtr() == 0) {
      if(product_.isNull()) {
        Exception::throwThis(errors::InvalidReference,
          "attempting get view from a null RefToBaseProd.\n");
      }
      ProductID tId = product_.id();
      std::vector<void const*> pointers;
      helper_vector_ptr helpers;
      WrapperHolder it = product_.productGetter()->getIt(tId);
      it.fillView(tId, pointers, helpers);
      product_.setProductPtr((new View<T>(pointers, helpers)));
    }
    return viewPtr();
  }

  template<typename T>
  inline
  void RefToBaseProd<T>::swap(RefToBaseProd<T>& other) {
    std::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 {
  template<typename T>
  template<typename C>
  inline
  RefToBaseProd<T>::RefToBaseProd(const RefProd<C>& ref) :
    product_(ref.refCore()) {
    std::vector<void const*> pointers;
    typedef typename refhelper::RefToBaseProdTrait<C>::ref_vector_type ref_vector;
    typedef reftobase::RefVectorHolder<ref_vector> holder_type;
    helper_vector_ptr helpers(new holder_type);
    detail::reallyFillView(* ref.product(), ref.id(), pointers, * helpers);
    product_.setProductPtr(new View<T>(pointers, helpers));
  }

  template<typename T>
  template<class HandleC>
  inline
  RefToBaseProd<T>::RefToBaseProd(HandleC const& handle) :
    product_(handle.id(), handle.product(), 0, false) {
    std::vector<void const*> pointers;
    typedef typename refhelper::RefToBaseProdTrait<typename HandleC::element_type>::ref_vector_type ref_vector;
    typedef reftobase::RefVectorHolder<ref_vector> holder_type;
    helper_vector_ptr helpers(new holder_type);
    detail::reallyFillView(* handle, handle.id(), pointers, * helpers);
    product_.setProductPtr(new View<T>(pointers, helpers));
  }

  template<typename T>
  template<typename C, typename F>
  inline
  RefToBaseProd<T>::RefToBaseProd(Ref<C, T, F> const& ref) :
      product_(ref.id(),
               ref.hasProductCache() ? ref.product() : 0,
               ref.productGetter(),
               false) {
    std::vector<void const*> pointers;
    typedef typename refhelper::RefToBaseProdTrait<C>::ref_vector_type ref_vector;
    typedef reftobase::RefVectorHolder<ref_vector> holder_type;
    helper_vector_ptr helpers(new holder_type);
    detail::reallyFillView(* ref.product(), ref.id(), pointers, * helpers);
    product_.setProductPtr(new View<T>(pointers, helpers));
  }

  template<typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd(RefToBase<T> const& ref) :
    product_(ref.id(),
             ref.hasProductCache() ? ref.product() : 0,
             ref.productGetter(),
             false) {
    std::vector<void const*> pointers;
    helper_vector_ptr helpers(ref.holder_->makeVectorBaseHolder().release());
    helpers->reallyFillView(ref.product(), ref.id(), pointers);
    product_.setProductPtr(new View<T>(pointers, helpers));
  }

}

#endif