---

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.

$Id: RefVector.h,v 1.39 2009/02/12 19:46:18 wmtan Exp $

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

#include <vector>
#include <stdexcept>
#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/FillView.h"
#include "DataFormats/Common/interface/RefVectorBase.h"
#include "DataFormats/Common/interface/RefHolderBase.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "DataFormats/Common/interface/RefItem.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/traits.h"
#include "DataFormats/Common/interface/RefTraits.h"
#include "DataFormats/Common/interface/RefVectorTraits.h"

namespace edm {

  template <typename T>
  T const* getProduct(RefCore const& ref);

  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 RefItem<key_type>               RefItemType;
    typedef std::vector<RefItemType>        RefItemVec;

    // size_type is the type of the index into the RefVector
    typedef typename RefItemVec::size_type  size_type;
    typedef RefVectorBase<key_type>         contents_type;
    
    RefVector() : refVector_() {}

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

    value_type const operator[](size_type idx) const {
      RefItemType const& item = refVector_.items()[idx];
      RefCore const& prod = refVector_.refCore();
      return value_type(prod, item);
    }

    value_type const at(size_type idx) const {
      RefItemType const& item = refVector_.items().at(idx);
      RefCore const& prod = refVector_.refCore();
      return value_type(prod, item);
    }

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

    // Accessor must get the product if necessary
    C const* product() const;

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

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

    iterator erase(iterator const& pos);

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

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

    RefVector& operator=(RefVector const& rhs);

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

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

  private:
    contents_type refVector_;
  };

  template <typename C, typename T, typename F>
  inline
  void
  RefVector<C, T, F>::swap(RefVector<C, T, F> & other) {
    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) {
    a.swap(b);
  }

  template <typename C, typename T, typename F>
  void
  RefVector<C,T,F>::fillView(ProductID const& id,
                             std::vector<void const*>& pointers,
                             helper_vector& helpers) const
  {
    typedef Ref<C,T,F>                     ref_type;
    typedef reftobase::RefHolder<ref_type> holder_type;

    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);
      holder_type h(ref_type(i->id(), address, i->key(), product() ));
      helpers.push_back( & h ); 
    }
  }


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

  template <typename C, typename T, typename F>
  struct has_fillView<edm::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::RefItems::size_type index = pos - begin();
    typename contents_type::RefItems::iterator newPos = 
      refVector_.eraseAtIndex(index);
    RefCore const& prod = refVector_.refCore();
    //return typename RefVector<C, T, F>::iterator(prod, newPos);
    return iterator(prod, newPos);
  }

  template <typename C, typename T, typename F>
  typename RefVector<C, T, F>::const_iterator RefVector<C, T, F>::begin() const {
    return iterator(refVector_.refCore(), refVector_.items().begin());
  }
  
  template <typename C, typename T, typename F>
  typename RefVector<C, T, F>::const_iterator RefVector<C, T, F>::end() const {
    return iterator(refVector_.refCore(), refVector_.items().end());
  }

  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/RefCoreGet.h"

namespace edm {

  template <typename C, typename T, typename F>
  C const* RefVector<C,T,F>::product() const {
    return isNull() ? 0 : edm::template getProduct<C>(refVector_.refCore());
  }

}

#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 const element_type * address( const iter & i ) {
        return &**i;
      }
      static const C * product( const RefVector<C, T, F> & coll ) {
        return coll.product();
      }
    };
  }
}
#endif

---