Info.h

// -*- C++ -*-
//
// This file is part of LHAPDF
// Copyright (C) 2012-2022 The LHAPDF collaboration (see AUTHORS for details)
//
#pragma once
#ifndef LHAPDF_Info_H
#define LHAPDF_Info_H

#include "LHAPDF/Utils.h"
#include "LHAPDF/Paths.h"
#include "LHAPDF/Exceptions.h"

namespace LHAPDF {


  // class Info;
  // Info& config();



  class Info {
  public:

    Info() { }

    Info(const std::string& path) {
      load(path);
    }

    virtual ~Info() { }



    void load(const std::string& filepath);




    // /// Get all metadata as a map
    // const std::map<std::string, std::string>& metadata() const {
    //   return _metadict;
    // }

    // /// Get all metadata as a map (non-const)
    // std::map<std::string, std::string>& metadata() {
    //   return _metadict;
    // }


    bool has_key_local(const std::string& key) const {
      return _metadict.find(key) != _metadict.end();
    }

    virtual bool has_key(const std::string& key) const {
      return has_key_local(key);
    }


    const std::string& get_entry_local(const std::string& key) const {
      if (has_key_local(key)) return _metadict.find(key)->second;
      throw MetadataError("Metadata for key: " + key + " not found.");
    }

    virtual const std::string& get_entry(const std::string& key) const {
      return get_entry_local(key);
    }


    virtual const std::string& get_entry(const std::string& key, const std::string& fallback) const {
      try {
        return get_entry(key);
      } catch (...) {
        return fallback;
      }
    }


    template <typename T>
    T get_entry_as(const std::string& key) const {
      const string& s = get_entry(key);
      return lexical_cast<T>(s);
    }


    template <typename T>
    T get_entry_as(const std::string& key, const T& fallback) const {
      try {
        return get_entry_as<T>(key);
      } catch (...) {
        return fallback;
      }
    }


    template <typename T>
    void set_entry(const std::string& key, const T& val) {
      _metadict[key] = to_str(val);
    }



  protected:

    std::map<std::string, std::string> _metadict;

  };




  template <>
  inline bool Info::get_entry_as(const std::string& key) const {
    const string& s = get_entry(key);
    try {
      bool rtn = lexical_cast<bool>(s);
      return rtn;
    } catch (...) {
      if (s == "true" || s == "on" || s == "yes") return true;
      if (s == "false" || s == "off" || s == "no") return false;
    }
    throw MetadataError("'" + s + "' is not a valid string for conversion to bool type");
  }

  template <>
  inline std::vector<std::string> Info::get_entry_as(const std::string& key) const {
    static const string delim = ",";
    string strval = trim(get_entry(key));
    // cout << "@@ " << strval << endl;
    if (startswith(strval, "[")) strval = strval.substr(1, strval.size()-1);
    if (endswith(strval, "]")) strval = strval.substr(0, strval.size()-1);
    // cout << "## " << strval << endl;
    return split(strval, delim);
  }

  template <>
  inline std::vector<int> Info::get_entry_as(const std::string& key) const {
    const vector<string> strs = get_entry_as< vector<string> >(key);
    vector<int> rtn;
    rtn.reserve(strs.size());
    for (const string& s : strs) rtn.push_back( lexical_cast<int>(s) );
    assert(rtn.size() == strs.size());
    return rtn;
  }

  template <>
  inline std::vector<double> Info::get_entry_as(const std::string& key) const {
    const vector<string> strs = get_entry_as< vector<string> >(key);
    vector<double> rtn;
    rtn.reserve(strs.size());
    for (const string& s : strs) rtn.push_back( lexical_cast<double>(s) );
    assert(rtn.size() == strs.size());
    return rtn;
  }



}
#endif