Attribute.h

// -*- C++ -*-
//
// This file is part of HepMC
// Copyright (C) 2014-2023 The HepMC collaboration (see AUTHORS for details)
//
#ifndef HEPMC3_ATTRIBUTE_H
#define HEPMC3_ATTRIBUTE_H
#include <cstdio> // sprintf
#include <string>
#include <limits>
#include <sstream>
#include <iomanip>
#include <map>
 
#include "HepMC3/GenParticle_fwd.h"
#include "HepMC3/GenVertex_fwd.h"

using std::string;
 
namespace HepMC3 {

class GenEvent;

class GenRunInfo;

class Attribute {
//
// Constructors
//
public:
    //Note: m_event should be set to nullptr in case event is deleted!
    Attribute():m_is_parsed(true) {    m_event=nullptr; }

    virtual ~Attribute() {}
 
protected:
    //Note: m_event should be set to nullptr n case event is deleted!
    explicit Attribute(const std::string &st):m_is_parsed(false),m_string(st) { m_event=nullptr; }

    friend class GenEvent;
 
//
// Virtual Functions
//
public:
    virtual bool from_string(const std::string & att) = 0;

    virtual bool init() {
        return true;
    }

    virtual bool init(const GenRunInfo & ) {
        return true;
    }

    virtual bool to_string(std::string &att) const = 0;
 
//
// Accessors
//
public:
    bool is_parsed() const { return m_is_parsed; }

    const std::string& unparsed_string() const { return m_string; }

    const GenEvent * event() const {
        return m_event;
    }

    GenParticlePtr particle() {
        return m_particle;
    }

    ConstGenParticlePtr particle() const {
        return std::const_pointer_cast<GenParticle>(m_particle);
    }

    GenVertexPtr vertex() {
        return m_vertex;
    }

    ConstGenVertexPtr vertex() const {
        return std::const_pointer_cast<GenVertex>(m_vertex);
    }
 
protected:
    void set_is_parsed(bool flag) { m_is_parsed = flag; }

    void set_unparsed_string(const std::string &st) { m_string = st; }
 
//
// Fields
//
private:
    bool   m_is_parsed;             
    std::string m_string;                
    const GenEvent * m_event;       
    GenParticlePtr m_particle; 
    GenVertexPtr m_vertex;      
};

class IntAttribute : public Attribute {
public:

    IntAttribute():Attribute(),m_val(0) {}

    IntAttribute(int val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        m_val = atoi( att.c_str() );
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    int value() const {
        return m_val;
    }

    void set_value(const int& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    int m_val; 
};

class LongAttribute : public Attribute {
public:

    LongAttribute(): Attribute(), m_val(0) {}

    LongAttribute(long val): Attribute(), m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = atol( att.c_str() );
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    long value() const {
        return m_val;
    }

    void set_value(const long& l) {
        m_val = l;
        set_is_parsed(true);
    }
 
private:
 
    long m_val; 
 
};

class DoubleAttribute : public Attribute {
public:

    DoubleAttribute(): Attribute(), m_val(0.0) {}

    DoubleAttribute(double val): Attribute(), m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = atof( att.c_str() );
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        std::ostringstream oss;
        oss << std::setprecision(std::numeric_limits<double>::digits10)
            << m_val;
        att = oss.str();
        return true;
    }

    double value() const {
        return m_val;
    }

    void set_value(const double& d) {
        m_val = d;
        set_is_parsed(true);
    }
 
private:
 
    double m_val; 
};

class FloatAttribute : public Attribute {
public:

    FloatAttribute(): Attribute(), m_val(0.0) {}

    FloatAttribute(float val): Attribute(), m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = float(atof( att.c_str() ));
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        std::ostringstream oss;
        oss << std::setprecision(std::numeric_limits<float>::digits10)
            << m_val;
        att = oss.str();
        return true;
    }

    float value() const {
        return m_val;
    }

    void set_value(const float& f) {
        m_val = f;
        set_is_parsed(true);
    }
 
private:
 
    float m_val; 
};

class StringAttribute : public Attribute {
public:

    StringAttribute():Attribute() {}

    StringAttribute(const std::string &st):Attribute(st) {}

    bool from_string(const std::string &att)  override {
        set_unparsed_string(att);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = unparsed_string();
        return true;
    }

    std::string value() const {
        return unparsed_string();
    }

    void set_value(const std::string& s) {
        set_unparsed_string(s);
    }
 
};

class CharAttribute : public Attribute {
public:

    CharAttribute():Attribute(),m_val(0) {}

    CharAttribute(char val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        set_is_parsed(true);
        if (att.size())
        {
            m_val = att.at(0);
            return true;
        }
        return false;
    }

    bool to_string(std::string &att) const override {
        att = std::to_string(m_val);
        return true;
    }

    char value() const {
        return m_val;
    }

    void set_value(const char& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    char m_val; 
};

class LongLongAttribute : public Attribute {
public:

    LongLongAttribute(): Attribute(), m_val(0) {}

    LongLongAttribute(long long val): Attribute(), m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = atoll( att.c_str() );
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    long long value() const {
        return m_val;
    }

    void set_value(const long long& l) {
        m_val = l;
        set_is_parsed(true);
    }
 
private:
 
    long long m_val; 
 
};

class LongDoubleAttribute : public Attribute {
public:

    LongDoubleAttribute(): Attribute(), m_val(0.0) {}

    LongDoubleAttribute(long double val): Attribute(), m_val(val) {}

    bool from_string(const std::string &att) override {
        m_val = strtold( att.c_str(),NULL);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        std::ostringstream oss;
        oss << std::setprecision(std::numeric_limits<long double>::digits10)
            << m_val;
        att = oss.str();
        return true;
    }

    long double value() const {
        return m_val;
    }

    void set_value(const long double& d) {
        m_val = d;
        set_is_parsed(true);
    }
 
private:
 
    long double m_val; 
};
 
 

class UIntAttribute : public Attribute {
public:

    UIntAttribute():Attribute(),m_val(0) {}

    UIntAttribute(unsigned int val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = strtoul(att.c_str(), NULL, 0);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    unsigned int value() const {
        return m_val;
    }

    void set_value(const unsigned int& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    unsigned int m_val; 
};
 
 

class ULongAttribute : public Attribute {
public:

    ULongAttribute():Attribute(),m_val(0) {}

    ULongAttribute(unsigned long val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = strtoul(att.c_str(), NULL, 0);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    unsigned long value() const {
        return m_val;
    }

    void set_value(const unsigned long& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    unsigned long m_val; 
};
 

class ULongLongAttribute : public Attribute {
public:

    ULongLongAttribute():Attribute(),m_val(0) {}

    ULongLongAttribute(unsigned long long val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att)  override {
        m_val = strtoull(att.c_str(), NULL, 0);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att = std::to_string(m_val);
        return true;
    }

    unsigned long long value() const {
        return m_val;
    }

    void set_value(const unsigned long long& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    unsigned long long m_val; 
};

class BoolAttribute : public Attribute {
public:

    BoolAttribute():Attribute(),m_val(false) {}

    BoolAttribute(bool val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att)  override {
        if (att.size()!=1) return false;
        if (att==std::string("1")) {m_val = true;  return true;}
        if (att==std::string("0")) {m_val = false; return true;}
        set_is_parsed(true);
        return false;
    }

    bool to_string(std::string &att) const override {
        att = std::to_string(m_val);
        return true;
    }

    bool value() const {
        return m_val;
    }

    void set_value(const bool& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    bool m_val; 
};

class VectorCharAttribute : public Attribute {
public:

    VectorCharAttribute():Attribute(),m_val() {}

    VectorCharAttribute(std::vector<char> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        char  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<char> value() const {
        return m_val;
 
    }

    void set_value(const std::vector<char>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<char> m_val; 
};

class VectorFloatAttribute : public Attribute {
public:

    VectorFloatAttribute():Attribute(),m_val() {}

    VectorFloatAttribute(std::vector<float> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        float  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<float> value() const {
        return m_val;
    }

    void set_value(const std::vector<float>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<float> m_val; 
};
 

class VectorLongDoubleAttribute : public Attribute {
public:

    VectorLongDoubleAttribute():Attribute(),m_val() {}

    VectorLongDoubleAttribute(std::vector<long double> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        long double  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<long double> value() const {
        return m_val;
    }

    void set_value(const std::vector<long double>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<long double> m_val; 
};
 
 

class VectorLongLongAttribute : public Attribute {
public:

    VectorLongLongAttribute():Attribute(),m_val() {}

    VectorLongLongAttribute(std::vector<long long> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        long long  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<long long> value() const {
        return m_val;
    }

    void set_value(const std::vector<long long>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<long long> m_val; 
};

class VectorUIntAttribute : public Attribute {
public:

    VectorUIntAttribute():Attribute(),m_val() {}

    VectorUIntAttribute(std::vector<unsigned int> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        unsigned int  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<unsigned int> value() const {
        return m_val;
    }

    void set_value(const std::vector<unsigned int>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<unsigned int> m_val; 
};

class VectorULongAttribute : public Attribute {
public:

    VectorULongAttribute():Attribute(),m_val() {}

    VectorULongAttribute(std::vector<unsigned long> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        unsigned long  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<unsigned long> value() const {
        return m_val;
    }

    void set_value(const std::vector<unsigned long>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<unsigned long> m_val; 
};
 

class VectorULongLongAttribute : public Attribute {
public:

    VectorULongLongAttribute():Attribute(),m_val() {}

    VectorULongLongAttribute(std::vector<unsigned long long> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        unsigned long long  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<unsigned long long> value() const {
        return m_val;
    }

    void set_value(const std::vector<unsigned long long>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<unsigned long long> m_val; 
};

class VectorIntAttribute : public Attribute {
public:

    VectorIntAttribute():Attribute(),m_val() {}

    VectorIntAttribute(std::vector<int> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        int  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<int> value() const {
        return m_val;
 
    }

    void set_value(const std::vector<int>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<int> m_val; 
};

class VectorLongIntAttribute : public Attribute {
public:

    VectorLongIntAttribute():Attribute(),m_val() {}

    VectorLongIntAttribute(std::vector<long int> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        long int  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<long int> value() const {
        return m_val;
    }

    void set_value(const std::vector<long int>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<long int> m_val; 
};

class VectorDoubleAttribute : public Attribute {
public:

    VectorDoubleAttribute():Attribute(),m_val() {}

    VectorDoubleAttribute(std::vector<double> val):Attribute(),m_val(val) {}

    bool from_string(const std::string &att) override {
        double  datafoo;
        m_val.clear();
        std::stringstream datastream(att);
        while (datastream >> datafoo) m_val.emplace_back(datafoo);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=std::to_string(a);}
        return true;
    }

    std::vector<double> value() const {
        return m_val;
    }

    void set_value(const std::vector<double>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<double> m_val; 
};
 

class VectorStringAttribute : public Attribute {
public:

    VectorStringAttribute():Attribute(),m_val() {}

    VectorStringAttribute(std::vector<std::string> val):Attribute(),m_val(val) {}

    bool from_string(const string &att) override {
        size_t posb = att.find_first_not_of(' ');
        do {
            size_t pose = att.find_first_of(' ', posb);
            m_val.push_back(att.substr(posb, pose - posb));
            posb = att.find_first_not_of(' ', pose);
        } while (posb != std::string::npos);
        set_is_parsed(true);
        return true;
    }

    bool to_string(std::string &att) const  override {
        att.clear();
        for (const auto& a:  m_val) {if (att.length()) att+=" ";  att+=a;}
        return true;
    }

    std::vector<std::string> value() const {
        return m_val;
    }

    void set_value(const std::vector<std::string>& i) {
        m_val = i;
        set_is_parsed(true);
    }
 
private:
    std::vector<std::string> m_val; 
};
 
 
} // namespace HepMC3
 
#endif