value.hpp

Go to the documentation of this file.

#ifndef value_hpp
#define value_hpp
#include <iostream>
#include <utility>
#include <algorithm>
#include <map>
#include <vector>
#include <tuple>
#include <initializer_list>
#include <functional>

namespace filval{

class GenValue{
    private:
        std::string name;
    protected:
        virtual void _reset() = 0;
        inline static std::map<const std::string, GenValue*> values;
    public:
        GenValue(const std::string& name)
          :name(name) {
            values[name] = this;
        }
        const std::string& get_name(){
            return name;
        }
        static void reset(){
            for (auto val : values){
                val.second->_reset();
            }
        }
        static GenValue* get_value(const std::string& name){
            return values.at(name);
        }
        static void summary(){
            std::cout << "The following values have been created: " << std::endl;
            for (auto value : values){
                std::cout << "\t\"" << value.first << "\" at address " << value.second << std::endl;
            }
        }
};
typedef std::map<std::string, GenValue*> ValueSet;


template <typename T>
class Value : public GenValue{
    public:
        Value(const std::string& name)
          :GenValue(name){ }
        virtual T& get_value() = 0;
};


template <typename T>
class ObservedValue : public Value<T>{
    private:
        T *val_ref;
        void _reset(){ }
    public:
        ObservedValue(const std::string& name, T* val_ref)
          :Value<T>(name),
           val_ref(val_ref){ }
        T& get_value(){
            return *val_ref;
        }
};


template <typename T>
class DerivedValue : public Value<T>{
    private:
        void _reset(){
            value_valid = false;
        }
    protected:
        T value;
        bool value_valid;

        virtual void update_value() = 0;
    public:
        DerivedValue(const std::string& name)
          :Value<T>(name),
           value_valid(false) { }

        T& get_value(){
            if (!value_valid){
                update_value();
                value_valid = true;
            }
            return value;
        }
};


template <typename T>
class WrapperVector : public DerivedValue<std::vector<T> >{
    private:
        Value<int>* size;
        Value<T*>* data;

        void update_value(){
            int n = size->get_value();
            T* data_ref = data->get_value();
            this->value.resize(n);
            for (int i=0; i<n; i++){
                this->value[i] = *(data_ref+i);
            }
        }

    public:
        WrapperVector(const std::string& name, Value<int>* _size, Value<T*>* _data)
          :DerivedValue<std::vector<T> >(name),
           size(_size), data(_data){ }

        WrapperVector(const std::string& name, const std::string &label_size, const std::string &label_data)
          :WrapperVector(name,
                         dynamic_cast<Value<int>*>(GenValue::values.at(label_size)),
                         dynamic_cast<Value<T*>*>(GenValue::values.at(label_data))) { }
};

template <typename T1, typename T2>
class Pair : public DerivedValue<std::pair<T1, T2> >{
    protected:
        std::pair<Value<T1>*, Value<T2>* > value_pair;
        void update_value(){
            this->value.first = value_pair.first->get_value();
            this->value.second = value_pair.second->get_value();
        }
    public:
        Pair(const std::string name, Value<T1> *value1, Value<T2> *value2)
          :DerivedValue<std::pair<T1, T2> >(name),
           value_pair(value1, value2){ }
        Pair(const std::string& name, const std::string& label1, const std::string& label2)
          :Pair(name,
                dynamic_cast<Value<T1>*>(GenValue::values.at(label1)),
                dynamic_cast<Value<T1>*>(GenValue::values.at(label2))){ }
};

template <typename R, typename T>
class ZipMapFour : public DerivedValue<std::vector<R> >{
    private:
        std::function<R(T, T, T, T)> f;
        Value<std::vector<T> >* v1;
        Value<std::vector<T> >* v2;
        Value<std::vector<T> >* v3;
        Value<std::vector<T> >* v4;

        void update_value(){
            std::vector<T> v1_val = v1->get_value();
            std::vector<T> v2_val = v2->get_value();
            std::vector<T> v3_val = v3->get_value();
            std::vector<T> v4_val = v4->get_value();

            int n;
            std::tie(n, std::ignore) = std::minmax({v1_val.size(), v2_val.size(), v3_val.size(), v4_val.size()});
            this->value.resize(n);
            for (int i=0; i<n; i++){
                this->value[i] = f(v1_val[i], v2_val[i], v3_val[i], v4_val[i]);
            }
        }

    public:
        ZipMapFour(const std::string& name, std::function<R(T, T, T, T)> f,
                   Value<std::vector<T> >* v1, Value<std::vector<T> >* v2,
                   Value<std::vector<T> >* v3, Value<std::vector<T> >* v4)
          :DerivedValue<std::vector<R> >(name),
           f(f), v1(v1), v2(v2), v3(v3), v4(v4) { }

        ZipMapFour(const std::string& name,
                   std::function<R(T, T, T, T)> f,
                   const std::string &label1, const std::string &label2,
                   const std::string &label3, const std::string &label4)
          :ZipMapFour(name, f,
                      dynamic_cast<Value<std::vector<T> >*>(GenValue::values.at(label1)),
                      dynamic_cast<Value<std::vector<T> >*>(GenValue::values.at(label2)),
                      dynamic_cast<Value<std::vector<T> >*>(GenValue::values.at(label3)),
                      dynamic_cast<Value<std::vector<T> >*>(GenValue::values.at(label4))){ }
};

template <typename T>
class Reduce : public DerivedValue<T>{
    private:
        std::function<T(std::vector<T>)> reduce;
        Value<std::vector<T> >* v;
        void update_value(){
            this->value = reduce(v->get_value());
        }
    public:
        Reduce(const std::string& name, std::function<T(std::vector<T>)> reduce, Value<std::vector<T> >* v)
          :DerivedValue<T>(name),
           reduce(reduce), v(v) { }

        Reduce(const std::string& name, std::function<T(std::vector<T>)> reduce, const std::string& v_name)
          :Reduce(name, reduce, dynamic_cast<Value<std::vector<T> >*>(GenValue::get_value(v_name))) { }
};

template <typename T>
class Max : public Reduce<T>{
    public:
        Max(const std::string& name, const std::string& v_name)
          :Reduce<T>(name, [](std::vector<T> vec){ return std::max(vec.begin(), vec.end());}, v_name) { }
};

template <typename T>
class Min : public Reduce<T>{
    public:
        Min(const std::string& name, const std::string& v_name)
          :Reduce<T>(name, [](std::vector<T> vec){ return std::min(vec.begin(), vec.end());}, v_name) { }
};

template <typename T>
class Mean : public Reduce<T>{
    public:
        Mean(const std::string& name, const std::string& v_name)
          :Reduce<T>(name,
                     [](std::vector<T> vec){
                        int n = 0; T sum = 0;
                        for (T e : vec){ n++; sum += e; }
                        return n>0 ? sum / n : 0; },
                     v_name) { }
};

template <typename T>
class ElementOf : public Reduce<T>{
    public:
        ElementOf(const std::string& name, Value<int>* index, const std::string& v_name)
          :Reduce<T>(name, [index](std::vector<T> vec){return vec[index->get_value()];}, v_name) { }
        ElementOf(const std::string& name, int index, const std::string& v_name)
          :Reduce<T>(name, [index](std::vector<T> vec){return vec[index];}, v_name) { }
};

template <typename T>
class ReduceIndex : public DerivedValue<std::pair<T, int> >{
    private:
        std::function<std::pair<T,int>(std::vector<T>)> reduce;
        Value<std::vector<T> >* v;
        void update_value(){
            this->value = reduce(v->get_value());
        }
    public:
        ReduceIndex(const std::string& name, std::function<std::pair<T,int>(std::vector<T>)> reduce, Value<std::vector<T> >* v)
          :DerivedValue<T>(name),
           reduce(reduce), v(v) { }

        ReduceIndex(const std::string& name, std::function<std::pair<T,int>(std::vector<T>)> reduce, const std::string& v_name)
          :ReduceIndex(name, reduce, dynamic_cast<Value<std::vector<T> >*>(GenValue::get_value(v_name))) { }
};

template <typename T>
class MaxIndex : public ReduceIndex<T>{
    public:
        MaxIndex(const std::string& name, const std::string& v_name)
          :ReduceIndex<T>(name,
                          [](std::vector<T> vec){ 
                              auto elptr = std::max_element(vec.begin(), vec.end());
                              return std::pair<T,int>(*elptr, int(elptr-vec.begin()));},
                          v_name) { }
};

template <typename T>
class MinIndex : public ReduceIndex<T>{
    public:
        MinIndex(const std::string& name, const std::string& v_name)
          :ReduceIndex<T>(name,
                          [](std::vector<T> vec){ 
                              auto elptr = std::min_element(vec.begin(), vec.end());
                              return std::pair<T,int>(*elptr, int(elptr-vec.begin()));},
                          v_name) { }
};


template <typename R, typename... T>
class MultiFunc : public DerivedValue<R>{
    private:
        std::function<R(T...)> f;
        std::tuple<T...> value_tuple;

        void update_value(){
            this->value = f(value_tuple);
        }

    public:
        MultiFunc(const std::string& name, std::function<R(std::tuple<T...>)> f, T... varargs)
          :DerivedValue<R>(name),
           f(f),
           value_tuple(varargs...){ }
};

template <typename T>
class BoundValue : public DerivedValue<T>{
    protected:
        std::function<T()> f;
        void update_value(){
            this->value = f();
        }
    public:
        BoundValue(const std::string& name, std::function<T()> f)
          :DerivedValue<T>(name),
           f(f) { }
};

template <typename T>
class ConstantValue : public DerivedValue<T>{
    protected:
        T const_value;
        void update_value(){
            this->value = const_value;
        }
    public:
        ConstantValue(const std::string& name, T const_value)
            :DerivedValue<T>(name),
             const_value(const_value) { }
};
}
#endif // value_hpp