IndirectVectorHolder.h

Go to the documentation of this file.

#ifndef DataFormats_Common_IndirectVectorHolder_h
#define DataFormats_Common_IndirectVectorHolder_h
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/BaseVectorHolder.h"
#include "DataFormats/Common/interface/RefVectorHolderBase.h"
#include "DataFormats/Common/interface/IndirectHolder.h"
#include <memory>

namespace edm {
  namespace reftobase {

    template <typename T>
    class IndirectVectorHolder : public BaseVectorHolder<T> {
    public:
      typedef BaseVectorHolder<T>                base_type;
      typedef typename base_type::size_type      size_type;
      typedef typename base_type::element_type   element_type;
      typedef typename base_type::base_ref_type  base_ref_type;
      typedef typename base_type::const_iterator const_iterator;

      IndirectVectorHolder();
      IndirectVectorHolder( const IndirectVectorHolder & other);
      IndirectVectorHolder(std::shared_ptr<RefVectorHolderBase> p);
      IndirectVectorHolder(RefVectorHolderBase * p);
      ~IndirectVectorHolder() override;
      IndirectVectorHolder& operator= (IndirectVectorHolder const& rhs);
      void swap(IndirectVectorHolder& other);
      BaseVectorHolder<T>* clone() const override;
      BaseVectorHolder<T>* cloneEmpty() const override;
      ProductID id() const override;
      EDProductGetter const* productGetter() const override;
      bool empty() const override;
      size_type size() const override;
      void clear() override;
      base_ref_type const at(size_type idx) const override;
      std::unique_ptr<reftobase::RefVectorHolderBase> vectorHolder() const override {
    return std::unique_ptr<reftobase::RefVectorHolderBase>( helper_->clone() );
      }
      void push_back( const BaseHolder<T> * r ) override {
    typedef IndirectHolder<T> holder_type;
    const holder_type * h = dynamic_cast<const holder_type *>( r );
    if( h == nullptr )
      Exception::throwThis( errors::InvalidReference,
        "In IndirectHolder<T> trying to push_back wrong reference type");
    helper_->push_back( h->helper_ );
      }

      bool isAvailable() const override { return helper_->isAvailable(); }

      //Used by ROOT storage
      CMS_CLASS_VERSION(10)

    private:
      typedef typename base_type::const_iterator_imp const_iterator_imp;
      RefVectorHolderBase* helper_;

    public:
      struct const_iterator_imp_specific : public const_iterator_imp {
    typedef ptrdiff_t difference_type;
    const_iterator_imp_specific() { }
    explicit const_iterator_imp_specific( const typename RefVectorHolderBase::const_iterator & it ) : i ( it ) { }
    ~const_iterator_imp_specific() override { }
    const_iterator_imp_specific * clone() const override { return new const_iterator_imp_specific( i ); }
    void increase() override { ++i; }
    void decrease() override { --i; }
    void increase( difference_type d ) override { i += d; }
    void decrease( difference_type d ) override { i -= d; }
    bool equal_to( const const_iterator_imp * o ) const override { return i == dc( o ); }
    bool less_than( const const_iterator_imp * o ) const override { return i < dc( o ); }
    void assign( const const_iterator_imp * o ) override { i = dc( o ); }
    base_ref_type deref() const override {
      return base_ref_type( * i );
    }
    difference_type difference( const const_iterator_imp * o ) const override { return i - dc( o ); }
      private:
    const typename RefVectorHolderBase::const_iterator & dc( const const_iterator_imp * o ) const {
      if ( o == nullptr ) {
        Exception::throwThis( edm::errors::InvalidReference,
          "In IndirectVectorHolder trying to dereference a null pointer");
      }
      const const_iterator_imp_specific * oo = dynamic_cast<const const_iterator_imp_specific *>( o );
      if ( oo == nullptr ) {
        Exception::throwThis( errors::InvalidReference,
          "In IndirectVectorHolder trying to cast iterator to wrong type ");
      }
      return oo->i;
    }
    typename RefVectorHolderBase::const_iterator i;
      };

      const_iterator begin() const override {
    return const_iterator( new const_iterator_imp_specific( helper_->begin() ) );
      }
      const_iterator end() const override {
    return const_iterator( new const_iterator_imp_specific( helper_->end() ) );
      }
    };

    template <typename T>
    IndirectVectorHolder<T>::IndirectVectorHolder() : BaseVectorHolder<T>(), helper_( nullptr ) { }

    template <typename T>
    IndirectVectorHolder<T>::IndirectVectorHolder(std::shared_ptr<RefVectorHolderBase> p) :
      BaseVectorHolder<T>(), helper_(p->clone()) { }

    template <typename T>
    IndirectVectorHolder<T>::IndirectVectorHolder(RefVectorHolderBase * p) :
      BaseVectorHolder<T>(), helper_(p) { }

    template <typename T>
    IndirectVectorHolder<T>::IndirectVectorHolder( const IndirectVectorHolder & other ) :
      BaseVectorHolder<T>(), helper_( other.helper_->clone() ) { }

    template <typename T>
    IndirectVectorHolder<T>::~IndirectVectorHolder() {
      delete helper_;
    }

    template <typename T>
    inline void IndirectVectorHolder<T>::swap(IndirectVectorHolder& other) {
      this->BaseVectorHolder<T>::swap(other);
      std::swap(helper_, other.helper_);
    }

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

    template <typename T>
    BaseVectorHolder<T>*
    IndirectVectorHolder<T>::clone() const {
      return new IndirectVectorHolder<T>(*this);
    }

    template <typename T>
    BaseVectorHolder<T>*
    IndirectVectorHolder<T>::cloneEmpty() const {
      return new IndirectVectorHolder<T>( helper_->cloneEmpty() );
    }

    template <typename T>
    ProductID
    IndirectVectorHolder<T>::id() const {
      return helper_->id();
    }

    template <typename T>
    EDProductGetter const* IndirectVectorHolder<T>::productGetter() const {
      return helper_->productGetter();
    }

    template <typename T>
    bool IndirectVectorHolder<T>::empty() const {
      return helper_->empty();
    }

    template <typename T>
    typename IndirectVectorHolder<T>::size_type IndirectVectorHolder<T>::size() const {
      return helper_->size();
    }

    template <typename T>
    void IndirectVectorHolder<T>::clear() {
      return helper_->clear();
    }

    template <typename T>
    typename IndirectVectorHolder<T>::base_ref_type const IndirectVectorHolder<T>::at(size_type idx) const {
      return helper_ ? helper_->template getRef<T>( idx ) : typename IndirectVectorHolder<T>::base_ref_type();
    }

    // Free swap function
    template <typename T>
    inline
    void swap(IndirectVectorHolder<T>& lhs, IndirectVectorHolder<T>& rhs) {
      lhs.swap(rhs);
    }
  }
}

#endif