csv_output.h

Go to the documentation of this file.

#ifndef FPMAS_CSV_OUTPUT_H
#define FPMAS_CSV_OUTPUT_H
 
#include <fstream>
#include <functional>
#include <vector>
#include <sstream>
#include "output.h"
#include "fpmas/communication/communication.h"
 
namespace fpmas { namespace io {
    using api::io::Watcher;
 
 
    template<typename T>
        struct CsvSerial {
            static std::string to_csv(const T& data) {
                std::ostringstream stream;
                stream << data;
                return stream.str();
            }
        };
    
    template<typename... DataField>
    class CsvOutputBase : public OutputBase {
        private:
            std::vector<std::string> _headers;
            std::tuple<std::function<DataField()>...> watchers;
    
            /*
             * Tuple unrolling helper structs.
             */
            template<int ...> struct seq {};
            template<int N, int ...S> struct gens {
                public:
                    typedef typename gens<N-1, N-1, S...>::type type;
            }; template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
 
            /*
             * Unrolls the input tuple to feed internal _headers, that are then
             * accessible with headers().
             */
            template<int ...S>
                void build_headers(
                        std::tuple<std::pair<std::string, std::function<DataField()>>...> csv_fields,
                        const seq<S...>) {
                    _headers = {std::get<S>(csv_fields).first...};
                }
 
            /*
             * Unrolls the input tuple and calls each watcher. 
             * Data is serialized and returned in a vector.
             */
            template<int ...S>
                std::vector<std::string> _dump_fields(const seq<S...>) {
                    std::tuple<DataField...> data {std::get<S>(watchers)() ...};
                    std::ostringstream output_str;
                    return {CsvSerial<typename std::tuple_element<S, decltype(data)>::type>::to_csv(std::get<S>(data))...};
                }
 
        protected:
            void dump_csv(const std::vector<std::string>& data) {
                std::ostream& output = output_stream.get();
                for(std::size_t i = 0; i < data.size()-1; i++)
                    output << data[i] << ",";
                output << data.back() << std::endl;
            }
 
            std::vector<std::string> headers() {
                return _headers;
            }
            std::vector<std::string> dump_fields() {
                return _dump_fields(typename gens<sizeof...(DataField)>::type());
            }
 
 
            CsvOutputBase(
                    api::io::OutputStream& output_stream,
                    std::pair<std::string, std::function<DataField()>>... csv_fields)
                : OutputBase(output_stream), watchers(csv_fields.second...) {
                    build_headers({csv_fields...}, typename gens<sizeof...(DataField)>::type());
                }
    };
 
    template<typename... DataField>
        class CsvOutput : public CsvOutputBase<DataField...> {
            public:
                CsvOutput(
                    api::io::OutputStream& output_stream,
                    std::pair<std::string, std::function<DataField()>>... csv_fields)
                    : CsvOutputBase<DataField...>(output_stream, csv_fields...) {
                        this->dump_csv(this->headers());
                    }
 
                void dump() override {
                    this->dump_csv(this->dump_fields());
                };
        };
 
    template<typename Operation>
        struct DistributedCsvField : public std::tuple<
                                    std::string,
                                    Watcher<typename Operation::Type>,
                                    typename Operation::Params>
    {
        using std::tuple<
            std::string,
        std::function<typename Operation::Type()>,
        typename Operation::Params>::tuple;
 
        DistributedCsvField(
                const std::string& name,
                std::function<typename Operation::Type()> watcher)
            : DistributedCsvField(name, watcher, {}) {}
    };
 
    template<typename... DataFieldOperation>
        class DistributedCsvOutput : public CsvOutputBase<typename DataFieldOperation::Type...> {
            private:
                api::communication::MpiCommunicator& comm;
                int root;
                bool all_out;
 
            public:
                DistributedCsvOutput(
                        api::communication::MpiCommunicator& comm, int root,
                        api::io::OutputStream& output_stream,
                        DistributedCsvField<DataFieldOperation>... csv_fields)
                    : CsvOutputBase<typename DataFieldOperation::Type...>(
                            output_stream,
                            {
                            // Field name
                            std::get<0>(csv_fields),
                            // DistributedOperation
                            typename DataFieldOperation::Single(
                                    comm, root,
                                    // Watcher
                                    std::get<1>(csv_fields),
                                    // Extra Params
                                    std::get<2>(csv_fields))
                            }...),
                    comm(comm), root(root), all_out(false)
                    {
                        if(comm.getRank() == root)
                            this->dump_csv(this->headers());
                    }
 
 
                DistributedCsvOutput(
                        api::communication::MpiCommunicator& comm,
                        api::io::OutputStream& output_stream,
                        DistributedCsvField<DataFieldOperation>... csv_fields)
                    : CsvOutputBase<typename DataFieldOperation::Type...>(
                            output_stream,
                            {
                            // Field name
                            std::get<0>(csv_fields),
                            // DistributedOperation
                            typename DataFieldOperation::All(
                                    comm,
                                    // Watcher
                                    std::get<1>(csv_fields),
                                    // Extra Params
                                    std::get<2>(csv_fields))
                            }...),
                    comm(comm), all_out(true)
                    {
                        this->dump_csv(this->headers());
                    }
 
                void dump() override {
                    std::vector<std::string> data_fields = this->dump_fields();
                    if(all_out || comm.getRank() == root)
                        this->dump_csv(data_fields);
                }
        };
 
}}
#endif