RefVector.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefVector_h
#define DataFormats_Common_RefVector_h

/*----------------------------------------------------------------------

RefVector: A template for a vector of interproduct references.
        Each vector element is a reference to a member of the same product.

----------------------------------------------------------------------*/

#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/FillView.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefHolderBase.h"
#include "DataFormats/Common/interface/RefTraits.h"
#include "DataFormats/Common/interface/RefVectorBase.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "DataFormats/Common/interface/RefVectorTraits.h"
#include "DataFormats/Common/interface/traits.h"
#include "DataFormats/Provenance/interface/ProductID.h"

#include <algorithm>
#include <stdexcept>
#include <vector>

namespace edm {

  template<typename C,
            typename T = typename refhelper::ValueTrait<C>::value,
            typename F = typename refhelper::FindTrait<C, T>::value>
  class RefVector {
  public:
    typedef C                               collection_type;
    typedef T                               member_type;
    typedef F                               finder_type;
    typedef typename refhelper::RefVectorTrait<C, T, F>::iterator_type iterator;
    typedef iterator                        const_iterator;
    typedef typename refhelper::RefVectorTrait<C, T, F>::ref_type value_type;
    typedef value_type const                const_reference; // better this than the default 'const value_type &'
    typedef const_reference                 reference;       // as operator[] returns 'const R' and not 'R &'

    // key_type is the type of the key into the collection
    typedef typename value_type::key_type   key_type;
    typedef std::vector<key_type>           KeyVec;

    // size_type is the type of the index into the RefVector
    typedef typename KeyVec::size_type      size_type;
    typedef RefVectorBase<key_type>         contents_type;

    RefVector() : refVector_() {}
    ~RefVector() = default;

    RefVector(RefVector const& rh) : refVector_(rh.refVector_){}
    RefVector(RefVector && rh)  noexcept : refVector_(std::move(rh.refVector_)){}

    RefVector& operator=(RefVector const& rhs);
    RefVector& operator=(RefVector  && rhs)  noexcept {
      refVector_ = std::move(rhs.refVector_);
      return *this;
    }



    RefVector(ProductID const& iId) : refVector_(iId) {}
    void push_back(value_type const& ref) {
      refVector_.pushBack(ref.refCore(), ref.key());
    }
    

    value_type const operator[](size_type idx) const {
      RefCore const& core = refVector_.refCore();
      key_type const& key = refVector_.keys()[idx];
      void const* memberPointer = refVector_.cachedMemberPointer(idx);
      if(memberPointer) {
        RefCore newCore(core);
        newCore.setProductPtr(memberPointer);
        return value_type(newCore, key);
      }
      return value_type(core, key);
    }

    value_type const at(size_type idx) const {
      RefCore const& core = refVector_.refCore();
      key_type const& key = refVector_.keys().at(idx);
      void const* memberPointer = refVector_.cachedMemberPointer(idx);
      if(memberPointer) {
        RefCore newCore(core);
        newCore.setProductPtr(memberPointer);
        return value_type(newCore, key);
      }
      return value_type(core, key);
    }

    contents_type const& refVector() const {return refVector_;}

    bool empty() const {return refVector_.empty();}

    size_type size() const {return refVector_.size();}

    size_type capacity() const {return refVector_.capacity();}

    void reserve(size_type n) {refVector_.reserve(n);}

    const_iterator begin() const;

    const_iterator end() const;

    ProductID id() const {return refVector_.refCore().id();}

    EDProductGetter const* productGetter() const {return refVector_.refCore().productGetter();}

    bool isNull() const {return !id().isValid();}

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

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

    bool isAvailable() const;

    bool isTransient() const {return refVector_.refCore().isTransient();}

    iterator erase(iterator const& pos);

    void clear() {refVector_.clear();}

    void swap(RefVector<C, T, F> & other)  noexcept;

    bool hasProductCache() const {return refVector_.refCore().productPtr() != 0;}

    void fillView(ProductID const& id,
                  std::vector<void const*>& pointers,
                  FillViewHelperVector& helpers) const;

    //Needed for ROOT storage
    CMS_CLASS_VERSION(13)

  private:

    contents_type refVector_;
  };

  template<typename C, typename T, typename F>
  inline
  void
  RefVector<C, T, F>::swap(RefVector<C, T, F> & other) noexcept {
    refVector_.swap(other.refVector_);
  }

  template<typename C, typename T, typename F>
  inline
  RefVector<C, T, F>&
  RefVector<C, T, F>::operator=(RefVector<C, T, F> const& rhs) {
    RefVector<C, T, F> temp(rhs);
    this->swap(temp);
    return *this;
  }

  template<typename C, typename T, typename F>
  inline
  void
  swap(RefVector<C, T, F> & a, RefVector<C, T, F> & b)  noexcept {
    a.swap(b);
  }

  template<typename C, typename T, typename F>
  void
  RefVector<C,T,F>::fillView(ProductID const&,
                             std::vector<void const*>& pointers,
                             FillViewHelperVector& helpers) const {

    pointers.reserve(this->size());
    helpers.reserve(this->size());

    size_type key = 0;
    for(const_iterator i=begin(), e=end(); i!=e; ++i, ++key) {
      member_type const* address = i->isNull() ? 0 : &**i;
      pointers.push_back(address);
      helpers.emplace_back(i->id(),i->key());
    }
  }

  template<typename C, typename T, typename F>
  inline
  void
  fillView(RefVector<C,T,F> const& obj,
           ProductID const& id,
           std::vector<void const*>& pointers,
           FillViewHelperVector& helpers) {
    obj.fillView(id, pointers, helpers);
  }

  template<typename C, typename T, typename F>
  struct has_fillView<RefVector<C,T,F> > {
    static bool const value = true;
  };

  template<typename C, typename T, typename F>
  inline
  bool
  operator==(RefVector<C, T, F> const& lhs, RefVector<C, T, F> const& rhs) {
    return lhs.refVector() == rhs.refVector();
  }

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

  template<typename C, typename T, typename F>
  inline
  typename RefVector<C, T, F>::iterator
  RefVector<C, T, F>::erase(iterator const& pos) {
    typename contents_type::keys_type::size_type index = pos - begin();
    typename contents_type::keys_type::iterator newPos =
      refVector_.eraseAtIndex(index);
    typename contents_type::keys_type::size_type newIndex = newPos - refVector_.keys().begin();
    return iterator(this, newIndex);
  }

  template<typename C, typename T, typename F>
  typename RefVector<C, T, F>::const_iterator RefVector<C, T, F>::begin() const {
    return iterator(this, 0);
  }

  template<typename C, typename T, typename F>
  typename RefVector<C, T, F>::const_iterator RefVector<C, T, F>::end() const {
    return iterator(this, size());
  }

  template<typename C, typename T, typename F>
  bool
  RefVector<C, T, F>::isAvailable() const {
    if(refVector_.refCore().isAvailable()) {
      return true;
    } else if(empty()) {
      return false;
    }

    // The following is the simplest implementation, but
    // this is woefully inefficient and could be optimized
    // to run much faster with some nontrivial effort. There
    // is only 1 place in the code base where this function
    // is used at all and I'm not sure whether it will ever
    // be used with thinned collections, so for the moment I
    // am not spending the time to optimize this.
    for(size_type i = 0; i < size(); ++i) {
      if(!(*this)[i].isAvailable()) {
        return false;
      }
    }
    return true;
  }

  template<typename C, typename T, typename F>
  std::ostream&
  operator<<(std::ostream& os, RefVector<C,T,F> const& r) {
    for(typename RefVector<C,T,F>::const_iterator
           i = r.begin(),
           e = r.end();
           i != e;
           ++i) {
        os << *i << '\n';
      }
    return os;
  }
}

#include "DataFormats/Common/interface/GetProduct.h"
namespace edm {
  namespace detail {

    template<typename C, typename T, typename F>
    struct GetProduct<RefVector<C, T, F> > {
      typedef T element_type;
      typedef typename RefVector<C, T, F>::const_iterator iter;
      static element_type const* address(iter const& i) {
        return &**i;
      }
    };
  }
}
#endif