xmodel.h

Go to the documentation of this file.

#pragma once

#include "xdata.h"
#include "xdefs.h"
#include "xtools.h"
#include "xunits.h"
#include <cctype>
#include <cmath>
#include <gsl/gsl_const_mksa.h>
#include <optional>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>

namespace nmx {

class XModel
{
private:
    //speichere ID für alle Instanzen dieser Klasse
    static inline std::string _name;

public:
    XModel() = delete;

    XModel(const char *name) {
        if (_name.empty()) {
            _name = name;
            std::transform(ALL(_name), _name.begin(), tolower);
        }
    }
    inline static std::ofstream get_output_stream(Format fmt) {
        return Output::get_stream(class_name(), fmt);
    }

    template<class T>
    inline static std::ofstream get_output_stream(Format fmt, const T &id) {
        return Output::get_stream(class_name(), fmt, id);
    }

    template<class T>
    inline static void save(const T &data, Format fmt) {
        std::ofstream output = get_output_stream(fmt);
        data.save(output, fmt);
    }

    template<class T, class ID>
    inline static void save(const T &data, Format fmt, const ID &id) {
        std::ofstream output = get_output_stream(fmt, id);
        data.save(output, fmt);
    }

    inline static std::string class_name() { //
        if (_name.empty()) {
            throw std::invalid_argument(nmx_msg);
        }
        return _name;
    }
}; //XModel

template<size_t N, class IDX, class VTYPE = double>
class CResult
{
private:
    //speichere Elemente vom Typ VTYPE
    std::array<VTYPE, N> _result;

protected:
    inline void set_result(IDX idx, VTYPE val) { //
        _result[static_cast<size_t>(idx)] = val;
    }

    template<class T>
    inline void set_result(const T &v) {
        //der Container muss die gleiche Länge wie das intern
        //gespeicherte Feld haben
        Check::error_if<std::out_of_range>(nmx_msg, v.size() != N);
        std::copy(v.begin(), v.end(), std::begin(_result));
    }

    inline void set_result(std::initializer_list<VTYPE> lst) { //
        Check::error_if<std::out_of_range>(nmx_msg, lst.size() != N);
        std::copy(lst.begin(), lst.end(), std::begin(_result));
    }

    inline void set_result(std::unordered_map<IDX, VTYPE> args) {
        Check::error_if<std::out_of_range>(nmx_msg, args.size() < N);
        for (const auto &val : args) {
            set_result(val.first, val.second);
        }
    }

public:
    inline auto operator()(IDX idx) const { //
        return _result[static_cast<size_t>(idx)];
    }

    inline auto get(IDX idx) const { //
        return _result[static_cast<size_t>(idx)];
    }

    inline const auto &result() const { return _result; }
};

} // namespace nmx