CSVWriter.hpp

/*
 * CSVWriter.hpp
 *
 *  Created on: Dec 15, 2014
 *      Author: Pietro Incardona
 */

#ifndef CSVWRITER_HPP_
#define CSVWRITER_HPP_

#include <iostream>
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <fstream>
#include "util/common.hpp"
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
#include "csv_multiarray.hpp"
#include "util/util.hpp"
#include "is_csv_writable.hpp"

#define CSV_WRITER 0x30000

template<typename Tobj>
struct csv_prp
{
    std::stringstream & str;

    Tobj & obj;

    csv_prp(std::stringstream & str, Tobj & obj)
    :str(str),obj(obj)
    {
    };

    template<typename T>
    void operator()(T& t)
    {
        // This is the type of the csv column
        typedef decltype(obj.template get<T::value>()) col_type;

        // Remove the reference from the column type
        typedef typename boost::remove_reference<col_type>::type col_rtype;
        typedef typename std::remove_all_extents<col_rtype>::type base_col_rtype;

        csv_value_str<col_rtype, is_csv_writable<base_col_rtype>::value >(obj.template get<T::value>(),str);
    }
};

template<typename Tobj, bool attr>
struct csv_col
{
    std::stringstream & str;

    csv_col(std::stringstream & str)
    :str(str)
    {
    };

    template<typename T>
    inline void operator()(T& t)
    {
        // This is the type of the csv column
        typedef typename boost::mpl::at<typename Tobj::type,boost::mpl::int_<T::value>>::type col_type;

        csv_col_str<col_type>(std::string(Tobj::attributes::name[T::value]),str);
    }
};

template<typename Tobj>
struct csv_col<Tobj,false>
{
    std::stringstream & str;

    csv_col(std::stringstream & str)
    :str(str)
    {
    };

    template<typename T>
    void operator()(T& t)
    {
        // This is the type of the csv column
        typedef typename boost::fusion::result_of::at_c<typename Tobj::type,T::value>::type col_type;

        // Remove the reference from the column type
        typedef typename boost::remove_reference<col_type>::type col_rtype;

        std::stringstream str2;
        str2 << "column_" << T::value;

        csv_col_str<col_rtype>(str2.str(),str);
    }
};

#define VECTOR 1

template <typename v_pos, typename v_prp, unsigned int impl = VECTOR>
class CSVWriter
{
    std::string get_csv_colums()
    {
        std::stringstream str;

        // write positional columns
        for (size_t i = 0 ; i < v_pos::value_type::dims ; i++)
        {
            if (i == 0)
                str << "x[" << i << "]";
            else
                str << "," << "x[" << i << "]";
        }

        // write positional information

        csv_col<typename v_prp::value_type,has_attributes<typename v_prp::value_type>::value> col(str);

        // Iterate through all the vertex and create the vertex list
        boost::mpl::for_each< boost::mpl::range_c<int,0,v_prp::value_type::max_prop> >(col);

        str << "\n";

        return str.str();
    }

    std::string get_csv_data(v_pos & vp, v_prp & vpr, size_t offset)
    {
        std::stringstream str;

        // The position and property vector size must match
        if (vp.size() != vpr.size())
        {
            std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " position vector and property vector must have the same size \n";
            return std::string("");
        }

        // Write the data
        for (size_t i = offset ; i < vp.size() ; i++)
        {
            for (size_t j = 0 ; j < v_pos::value_type::dims ; j++)
            {
                if (j == 0)
                    str << vp.template get<0>(i)[j];
                else
                    str << "," << vp.template get<0>(i)[j];
            }

            // Object to write
            auto obj = vpr.get(i);

            csv_prp<decltype(obj)> c_prp(str,obj);

            // write the properties to the stream string
            boost::mpl::for_each< boost::mpl::range_c<int,0,v_prp::value_type::max_prop> >(c_prp);

            str << "\n";
        }

        return str.str();
    }

public:

    bool write(std::string file, v_pos & v , v_prp & prp, size_t offset=0)
    {
        // Header for csv (colums name)
        std::string csv_header;
        // Data point
        std::string point_data;

        // Get csv columns
        csv_header = get_csv_colums();

        // For each property in the vertex type produce a point data
        point_data = get_csv_data(v,prp,offset);

        // write the file
        std::ofstream ofs(file);

        // Check if the file is open
        if (ofs.is_open() == false)
        {std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " cannot create the CSV file: " << file << std::endl;}

        ofs << csv_header << point_data;

        // Close the file

        ofs.close();

        // Completed succefully
        return true;
    }
};


#endif /* CSVWRITER_HPP_ */