filval/container.hpp

/**
 * @file
 * @author  Caleb Fangmeier <caleb@fangmeier.tech>
 * @version 0.1
 *
 * @section LICENSE
 *
 *
 * MIT License
 *
 * Copyright (c) 2017 Caleb Fangmeier
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef container_hpp
#define container_hpp
#include <typeindex>
#include <vector>
#include <map>

#include "value.hpp"
#include "filter.hpp"

template class std::vector<std::vector<float> >;
template class std::vector<std::vector<int> >;


namespace fv::util{
std::string get_type_name(const std::type_index& index){
    std::map<std::type_index, std::string> _map;
    // Add to this list as needed :)
    _map[typeid(int)]="int";
    _map[typeid(unsigned int)]="unsigned int";
    _map[typeid(float)]="float";
    _map[typeid(double)]="double";
    _map[typeid(std::vector<int>)]="std::vector<int>";
    _map[typeid(std::vector<float>)]="std::vector<float>";
    _map[typeid(std::pair<std::vector<float>,std::vector<float>>)]="std::pair<std::vector<float>,std::vector<float>>";
    _map[typeid(std::vector<std::pair<float,int>>)]="std::vector<std::pair<float,int>>";
    _map[typeid(std::map<std::string,std::string>)] = "std::map<std::string,std::string>";

    if (_map[index] == ""){
        CRITICAL("Cannot lookup type name of \"" << index.name() << "\"",-1);
    }
    return _map[index];
}
}

namespace fv{

/**
 * Enumeration of different options that can be used to save Containers. Not
 * all options are allowed for all Containers.
 */
enum SaveOption{
    PNG = 0,
    PDF = 1,
    ROOT = 2
};

/**
 * Generic, untyped parent class of Container. Used to allow for placing
 * Containers of disparate types in common data structures.
 */
class GenContainer{
    private:
        std::string name;
        std::string desc;
        std::vector<ObsFilter*> filters;
    protected:
        virtual void _fill() = 0;
    public:
        GenContainer(const std::string name, const std::string& desc)
          :name(name),desc(desc) { }

        GenContainer(const std::string name)
          :GenContainer(name,"N/A"){ }

        GenContainer* add_filter(GenValue* filter){
            filters.push_back(static_cast<ObsFilter*>(filter));
            return this;
        }

        void fill(){
            for (auto filter : filters){
                if (!filter->get_value()) return;
            }
            _fill();
        }

        void set_description(const std::string& description){
            desc = description;
        }

        const std::string& get_name(){
            return name;
        }

        virtual const std::string get_value_name(){
            return "N/A";
        }

        virtual GenContainer* clone_as(const std::string& new_name) = 0;

        virtual void save_as(const std::string& fname, const SaveOption& option) = 0;

        virtual void save(const SaveOption& option=SaveOption::PNG) {
            save_as(get_name(), option);
        }
};

/**
 * A class that is used to "hold" values. When an event is loaded, the
 * associated filters on this container are checked. If they all pass, the
 * \c _fill() method is called and the Container can access the stored Value
 * object to process it. For example, if the Container is a ROOT Histogram
 * object, it may call <tt>container->Fill(value->get_value())</tt>.
 */
template <typename H, typename V>
class Container : public GenContainer{
    protected:
        H* container;
        Value<V> *value;
    public:
        Container(const std::string& name, Value<V>* value)
          :GenContainer(name),
           container(nullptr),
           value(value){ }

        virtual ~Container(){
            if (container != nullptr) delete container;
        }

        virtual H* get_container(){
            return container;
        }

        virtual const std::string get_value_name(){
            return value->get_name();
        }
};

/**
 * Calculate the Mean of a Value over a series of observations. This class is
 * given a value of some type that supports addition and division(eg. a \c
 * float) and yields the mean value. Note that this implementation does \i not
 * support serialization so it is not incredibly useful. See the ROOT
 * Containers for Containers that support serialization using ROOT's
 * facilities.
 */
template <typename T>
class ContainerMean : public Container<T,T>{
    private:
        int count;
        T sum;

        void _fill(){
            count++;
            sum += this->value->get_value();
        }
    public:
        ContainerMean(const std::string& name, Value<T>* value)
          :Container<std::vector<T>,T>(name, value){
            this->container = new T();
        }

        T* get_container(){
            *(this->container) = sum/count;
            return (this->container);
        }

        GenContainer* clone_as(const std::string& new_name){
            return new ContainerMean(new_name, this->value);
        }

        void save_as(const std::string&) {
            WARNING("Saving of ContainerMean objects not supported");
        }
};

template<typename T>
std::ostream& operator<< (std::ostream & out, const std::vector<T>& data) {
    size_t len = data.size();
    if (len == 0) out << "[]";
    else {
        out << "[" << data[0];
        for (size_t i=1; i<len; i++) out << ", " << data[i];
        out << "]";
    }
    return out ;
}

/**
 * Prints out the value registered to it
 */
template <typename T>
class Logger : public Container<std::ostream, T>{
    private:
    using to_str_t = std::function<void(T, std::ostream&)>;
    to_str_t value_to_string;

        static void default_to_string(T& t, std::ostream& os) {
            os << t;
        }

        void _fill(){
            auto& os = (*this->container);
            std::stringstream vs;
            os << this->get_name() << std::endl;
            if (value_to_string != nullptr) value_to_string(this->value->get_value(), vs);
            else                            default_to_string(this->value->get_value(), vs);
            for (const char& c : vs.str()) {
                if (c == '\n') os << std::endl << "  ";
                else           os << c;
            }
            os << std::endl;
        }

    public:
        Logger(Value<T>* value, std::ostream* out, to_str_t value_to_string = nullptr)
          :Container<std::ostream,T>("Logger:" + value->get_name(), value),
           value_to_string(value_to_string) {
            this->container = out;
        }

        std::ostream* get_container(){
            return this->container;
        }

        GenContainer* clone_as(const std::string& new_name){
            return new Logger(this->value, this->container, value_to_string);
        }

        void save_as(const std::string&, const SaveOption&) { }
};

/**
 * Prints out the value registered to it
 */
class FuncLogger : public GenContainer {
    private:
    std::ostream* os;
    using to_str_t = std::function<void(std::ostream&)>;
    to_str_t value_to_string;

        void _fill(){
            auto& os_ref = (*this->os);
            std::stringstream vs;
            os_ref << this->get_name() << std::endl << "  ";
            value_to_string(vs);
            for (const char& c : vs.str()) {
                if (c == '\n') os_ref << std::endl << "  ";
                else           os_ref << c;
            }
            os_ref << std::endl;
        }

    public:
        FuncLogger(const std::string& name, std::ostream* os, to_str_t value_to_string)
          :GenContainer("Logger:" + name),
           value_to_string(value_to_string),
           os(os) { }

        std::ostream* get_container(){
            return os;
        }

        GenContainer* clone_as(const std::string& new_name){
            return new FuncLogger(new_name, this->os, value_to_string);
        }

        void save_as(const std::string&, const SaveOption&) { }
};

}
#endif // container_hpp