GenRunInfo.h

// -*- C++ -*-
//
// This file is part of HepMC
// Copyright (C) 2014-2023 The HepMC collaboration (see AUTHORS for details)
//
#ifndef HEPMC3_GENRUNINFO_H
#define HEPMC3_GENRUNINFO_H
 
#if !defined(__CINT__)
#include "HepMC3/Units.h"
#include "HepMC3/Attribute.h"
#include <mutex>
#endif // __CINT__
 
#ifdef HEPMC3_ROOTIO
class TBuffer;
#endif
 
namespace HepMC3 {
using namespace std;
 
struct GenRunInfoData;

class GenRunInfo {
 
public:

    struct ToolInfo {

        std::string name;

        std::string version;

        std::string description;
    };
 
public:

    GenRunInfo() {}
    GenRunInfo(const GenRunInfo& r);
    GenRunInfo& operator=(const GenRunInfo& r);
 
#if !defined(__CINT__)

    const std::vector<ToolInfo> & tools() const {
        return m_tools;
    }

    std::vector<ToolInfo> & tools() {
        return m_tools;
    }

    bool has_weight(const std::string& name) const {
        return m_weight_indices.find(name) !=  m_weight_indices.end();
    }

    std::map<std::string, int> weight_indices() const {
        return m_weight_indices;
    }

    int weight_index(const std::string& name) const {
        std::map<std::string, int>::const_iterator it = m_weight_indices.find(name);
        return it == m_weight_indices.end()? -1: it->second;
    }

    const std::vector<std::string> & weight_names() const {
        return m_weight_names;
    }

    void set_weight_names(const std::vector<std::string> & names);

    void add_attribute(const std::string &name,
                       const std::shared_ptr<Attribute> &att) {
        std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
        if ( att ) m_attributes[name] = att;
    }

    void remove_attribute(const std::string &name) {
        std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
        m_attributes.erase(name);
    }

    template<class T>
    std::shared_ptr<T> attribute(const std::string &name) const;

    std::string attribute_as_string(const std::string &name) const;

    std::vector<std::string> attribute_names() const;

    std::map< std::string, std::shared_ptr<Attribute> > attributes() const {
        return m_attributes;
    }
 
 
#endif // __CINT__


    void write_data(GenRunInfoData &data) const;

    void read_data(const GenRunInfoData &data);
 
#ifdef HEPMC3_ROOTIO
    void Streamer(TBuffer &b);
#endif
 
private:

 
#if !defined(__CINT__)

    std::vector<ToolInfo> m_tools;

    std::map<std::string, int> m_weight_indices;

    std::vector<std::string> m_weight_names;

    mutable std::map< std::string, std::shared_ptr<Attribute> > m_attributes;

    mutable std::recursive_mutex m_lock_attributes;
 
#endif // __CINT__
};
 
#if !defined(__CINT__)
 
//
// Template methods
//
 
template<class T>
std::shared_ptr<T> GenRunInfo::attribute(const std::string &name) const {
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    std::map< std::string, std::shared_ptr<Attribute> >::iterator i =
        m_attributes.find(name);
    if ( i == m_attributes.end() ) return std::shared_ptr<T>();
 
    if ( !i->second->is_parsed() ) {
 
        std::shared_ptr<T> att = std::make_shared<T>();
        if ( att->from_string(i->second->unparsed_string()) &&
                att->init(*this) ) {
            // update map with new pointer
            i->second = att;
 
            return att;
        }
        else
            return std::shared_ptr<T>();
    }
    else return std::dynamic_pointer_cast<T>(i->second);
}
 
/*
template<typename T> std::map<std::string, T> weight_indices() const {
        std::map<std::string, T> ret;
        ret.insert(m_weight_indices.begin(),m_weight_indices.end());
        return ret;
}
*/
 
#endif // __CINT__
 
} // namespace HepMC3
 
#endif