/data/refman/pasoursint/CMSSW_4_1_8_patch9/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/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_(), viewCache_(0) {}

    // 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->();
    }

    RefCore const& refCore() const {
      return product_;
    }

    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> &);

  private:
    View<T> const* viewPtr() const {
      return reinterpret_cast<const View<T>*>(viewCache_.ptr_);
    }
    RefCore product_;
    mutable ConstPtrCache viewCache_;
  };
}

#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 ),
    viewCache_( 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 ),
    viewCache_( new View<T>( view ) ) {
  }

  template <typename T>
  inline
  RefToBaseProd<T>::RefToBaseProd( const RefToBaseProd<T> & ref ) :
    product_( ref.product_ ),
    viewCache_( 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 ( viewCache_.ptr_ == 0 ) {
      if ( product_.isNull() ) {
        Exception::throwThis(errors::InvalidReference,
          "attempting get view from a null RefToBaseProd.\n");
      }
      ProductID id = product_.id();
      std::vector<void const*> pointers;
      helper_vector_ptr helpers;
      product_.productGetter()->getIt(id)->fillView(id, pointers, helpers);
      viewCache_.ptr_ =( new View<T>( pointers, helpers ) );
    }
    return viewPtr();
  }

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

  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 );
    viewCache_.ptr_=( 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 );
    viewCache_.ptr_=( 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 );
    viewCache_.ptr_=( 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 );
    viewCache_.ptr_=( new View<T>( pointers, helpers ) );
  }

}

#endif