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;
}  // namespace pat

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