UserData.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_UserData_h
#define DataFormats_PatCandidates_UserData_h

#include <string>
#include <vector>
#include <typeinfo>
#include "DataFormats/Common/interface/OwnVector.h"


namespace pat {

  class UserData {
  public:
    UserData() {}
    virtual ~UserData() {}

    virtual UserData * clone() const = 0;

    virtual const std::type_info & typeId() const = 0;
    virtual const std::string    & typeName() const = 0;

    /*  I don't think there is an easy way to get it working with generic type T,
        barrying the use of ROOT::Reflex and all the edm::Ptr technicalities.
        I'd say we can live without polymorphic storage of polymorphic data */
    template<typename T> const T * get() const {
        if (typeid(T) != typeId()) return nullptr;
        return static_cast<const T *>(data_());
    }

    //  Really needed for CINT? I would really like to avoid this
    const void * bareData() const { return data_(); }

    template<typename T>
    static std::unique_ptr<UserData> make(const T &value, bool transientOnly=false) ;

  protected:
    virtual const void * data_  () const = 0;
    static std::string typeNameFor(std::type_info const& iInfo);

  private:
    static void checkDictionaries(const std::type_info &type) ;
    
  };

  template<typename T>
  class UserHolder : public UserData {
    public:
        UserHolder() : obj_() {}
        UserHolder(const T &data) : obj_(data) {}
        UserHolder<T> * clone() const override { return new UserHolder<T>(*this); }
        const std::type_info & typeId()   const override { return typeid(T); }
        const std::string    & typeName() const override { return typeName_(); }
    protected:
        const void *           data_()  const override { return &obj_; }
    private: 
        T obj_;
        static const std::string & typeName_() ;
  };

  typedef edm::OwnVector<pat::UserData>   UserDataCollection;
}


template<typename T>
std::unique_ptr<pat::UserData> pat::UserData::make(const T &value, bool transientOnly) {
    if (!transientOnly) {
        checkDictionaries(typeid(T));
        checkDictionaries(typeid(pat::UserHolder<T>));
    }
    return std::unique_ptr<UserData>(new pat::UserHolder<T>(value));  
}

template<typename T> 
const std::string & pat::UserHolder<T>::typeName_() {
    static const std::string name(typeNameFor(typeid(T)));
    return name;
}

#endif