/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/DataFormats/Common/interface/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
//

// 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;
    
    explicit PtrVectorBase(ProductID const& productID, void const* prodPtr = 0,
                           EDProductGetter const* prodGetter = 0) :
      core_(productID, prodPtr, prodGetter, false), indicies_() {}

    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 hasProductCache() const { return 0 == core_.productPtr(); }
    
    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();}

    void const* product() const {
       return 0;
    }

  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