---

PtrVectorBase.h

Go to the documentation of this file.

#ifndef DataFormats_Common_PtrVectorBase_h
#define DataFormats_Common_PtrVectorBase_h
// -*- C++ -*-
//
// Package:     Common
// Class  :     PtrVectorBase
// 
//
// Original Author:  Chris Jones
//         Created:  Wed Oct 24 15:26:45 EDT 2007
// $Id: PtrVectorBase.h,v 1.8 2008/05/16 15:49:13 chrjones Exp $
//

// system include files
#include <vector>
#include <typeinfo>

// user include files
#include "DataFormats/Common/interface/RefCore.h"

// forward declarations

namespace edm {
  class PtrVectorBase {
    
  public:
    typedef unsigned long key_type;
    typedef key_type size_type;
    
    virtual ~PtrVectorBase();
    
    // ---------- const member functions ---------------------
    bool isNull() const {return !isNonnull(); }
    
    //bool isNonnull() const {return id().isValid(); }
    bool isNonnull() const { return core_.isNonnull(); }
    
    bool operator!() const {return isNull();}
    
    ProductID id() const {return core_.id();}
    
    EDProductGetter const* productGetter() const {return core_.productGetter();}
    
    bool hasCache() const { return !cachedItems_.empty(); }
    
    bool isAvailable() const{ return core_.isAvailable(); }

    bool empty() const {return indicies_.empty();}
    
    size_type size() const {return indicies_.size();}
    
    size_type capacity() const {return indicies_.capacity();}

    void clear() { core_ = RefCore(); indicies_.clear(); cachedItems_.clear(); }
    
    bool operator==(PtrVectorBase const& iRHS) const;
    // ---------- static member functions --------------------
    
    // ---------- member functions ---------------------------
    void reserve(size_type n) {indicies_.reserve(n); cachedItems_.reserve(n);}
    
    void setProductGetter(EDProductGetter* iGetter) const { core_.setProductGetter(iGetter); }

    bool isTransient() const {return core_.isTransient();}

  protected:
    PtrVectorBase();

    void swap(PtrVectorBase& other);

    void push_back_base(RefCore const& core, key_type iKey, void const* iData);
    
    std::vector<void const*>::const_iterator void_begin() const {
      getProduct_();
      return cachedItems_.begin();
    }
    std::vector<void const*>::const_iterator void_end() const {
      getProduct_();
      return cachedItems_.end();
    }
    
    template<typename TPtr>
    TPtr makePtr(unsigned long iIndex) const {
      if (isTransient()) {
        return TPtr(reinterpret_cast<typename TPtr::value_type const*>(cachedItems_[iIndex]),
                  indicies_[iIndex]);
      }
      if (hasCache()) {
        return TPtr(this->id(),
                  reinterpret_cast<typename TPtr::value_type const*>(cachedItems_[iIndex]),
                  indicies_[iIndex]);
      }
      return TPtr(this->id(), indicies_[iIndex], productGetter());
    }
    
    template<typename TPtr>
    TPtr makePtr(std::vector<void const*>::const_iterator const iIt) const {
      if (isTransient()) {
        return TPtr(reinterpret_cast<typename TPtr::value_type const*>(*iIt),
                  indicies_[iIt - cachedItems_.begin()]);
      }
      if (hasCache()) {
        return TPtr(this->id(),
                  reinterpret_cast<typename TPtr::value_type const*>(*iIt),
                  indicies_[iIt - cachedItems_.begin()]);
      }
      return TPtr(this->id(), indicies_[iIt - cachedItems_.begin()], productGetter());
    }
    
  private:
    void getProduct_() const;
    virtual std::type_info const& typeInfo() const=0;
    // ---------- member data --------------------------------
    RefCore core_;
    std::vector<key_type> indicies_;
    mutable std::vector<void const*> cachedItems_; 
  };
}

#endif

---