QCsv.hpp

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <sstream>

class QCsv
{
    public:
        std::map<std::string, std::vector<std::string>> df;
        std::vector<std::string> headers;
        
        void ReadCsvFile(const std::string &csvfn)
        {
            csvfile.open(csvfn, std::ios::in);

            if(!csvfile.is_open())
            {
                std::cerr << "QCsv: Error while opening a file" << std::endl;
                return;
            }
            
            ReadCsv();
        }

        void PrintDf()
        {
            if(headers.empty())
            {
                std::cerr << "QCsv: Please define QCsv::headers string vector" << std::endl;
                return;
                
            }

            for(const std::string &h : headers)
                std::cout << h << '\t';
            std::cout << std::endl;

            for(size_t i = 0 ; i < df[headers[0]].size() ; i++)
            {
                for(const std::string &h : headers)
                    std::cout << df[h][i] << '\t';

                std::cout << std::endl;
            }
        }

        void WriteCsv(const std::string &csvfn)
        {
            if(headers.empty())
            {
                std::cerr << "QCsv: Please define QCsv::headers string vector" << std::endl;
                return;
                
            }

            std::ofstream writecsvfile;
            writecsvfile.open(csvfn);

            for(size_t i = 0 ; i < headers.size() ; i++)
            {
                if(i == headers.size()-1)
                    writecsvfile << headers[i];
                else    
                    writecsvfile << headers[i] << ",";
            }
            writecsvfile << '\n';

            for(size_t i = 0 ; i < df[headers[0]].size() ; i++)
            {
                for(size_t j = 0 ; j < headers.size() ; j++)
                {
                    if(j == headers.size()-1)
                        writecsvfile << df[headers[j]][i];
                    else
                        writecsvfile << df[headers[j]][i] << ",";
                }
                
                writecsvfile << '\n';
            }
        }

        template<typename T>
        std::vector<std::string> convertAVectorToStringVector(const std::vector<T> &vec)
        {
            std::vector<std::string> res;
            
            for(size_t i = 0 ; i < vec.size() ; i++)
                res.push_back(std::to_string(vec[i]));

            return res;
        }

        std::vector<std::string>& operator[](const std::string &h)
        {
            return df[h];
        }

        ~QCsv()
        {
            csvfile.close();
        }


    private:
        std::fstream csvfile;

        void ReadCsv()
        {
            if(csvfile.is_open())
            {
                std::string sa;
                std::vector<std::string> row;
                bool firstline = true;

                while(std::getline(csvfile, sa))
                {
                    if(firstline)
                    {
                        headers = Split(sa);
                        firstline = false;
                    }
                    else
                    {
                        row = Split(sa);

                        for(size_t i = 0 ; i < headers.size() ; i++)
                            df[headers[i]].push_back(row[i]);
                    }
                }
            }
            else
            {
                std::cerr << "QCsv: Error while reading the file" << std::endl; 
                return;
            }
        }

        std::vector<std::string> 
            Split(const std::string &s)
        {
            std::string t;
            std::stringstream ss(s);
            std::vector<std::string> res;

            while(std::getline(ss, t, ','))
                res.push_back(t);

            return res;
        }
};