stats_base.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_STATS_BASE_H
#define DISMEC_STATS_BASE_H
 
#include "matrix_types.h"
#include <memory>
#include <string>
#include <nlohmann/json_fwd.hpp>
 
namespace dismec::stats {
    class StatisticsCollection;
 
    class TagContainer {
    public:
        [[nodiscard]] const std::string& get_name() const { return m_Name; }
 
        [[nodiscard]] int get_value() const {
            assert(!is_empty());
            return *m_Value;
        }
 
        // Returns whether the container is currently empty.
        [[nodiscard]] bool is_empty() const { return m_Value == nullptr; }
 
        void set_value(int value) {
            assert(!is_empty());
            *m_Value = value;
        }
 
        static TagContainer create_empty_container(std::string name) {
            return TagContainer(std::move(name), nullptr);
        }
        static TagContainer create_full_container(std::string name) {
            return TagContainer(std::move(name), std::make_shared<int>());
        }
 
    private:
        explicit TagContainer(std::string name, std::shared_ptr<int> val) : m_Name(std::move(name)), m_Value( std::move(val) ) {}
 
        std::string m_Name;
        std::shared_ptr<int> m_Value;
    };
 
    class Statistics {
    public:
        virtual ~Statistics() = default;
 
        // this overload is provided to prevent the int -> long / float ambiguity
        void record(int integer) { record(long(integer)); }
 
        void record(long integer) { record_int(integer); }
        void record(real_t real) { record_real(real); }
        void record(const DenseRealVector& vector) { record_vec(vector); }
 
        [[nodiscard]] virtual std::unique_ptr<Statistics> clone() const = 0;
 
        virtual void setup(const StatisticsCollection& source) {  };
 
        virtual void merge(const Statistics& other) = 0;
 
        [[nodiscard]] virtual nlohmann::json to_json() const = 0;
 
    private:
        // Virtual functions to actually implement.
        virtual void record_int(long integer) { throw std::logic_error("Not implemented"); }
        virtual void record_real(real_t real) { throw std::logic_error("Not implemented"); }
        virtual void record_vec(const DenseRealVector& vector) { throw std::logic_error("Not implemented"); }
    };
 
    std::unique_ptr<stats::Statistics> make_stat_from_json(const nlohmann::json& source);
 
    template<class Derived>
    class StatImplBase : public Statistics {
    public:
        void merge(const Statistics& other) override {
            static_assert(std::is_final_v<Derived>, "Derived needs to be declared final, because further derived classes would break the merge code.");
            static_cast<Derived*>(this)->merge_imp(dynamic_cast<const Derived&>(other));
        }
 
        void record_vec(const DenseRealVector& vector) override {
            for(int i = 0; i < vector.size(); ++i) {
                static_cast<Derived*>(this)->record(vector.coeff(i));
            }
        }
    };
 
}
 
#endif //DISMEC_STATS_BASE_H