CSV.h

Go to the documentation of this file.

/*
 *  This is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *  The software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  You should have received a copy of the GNU General Public License
 *  along with the software. If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2017, 2018, Kuylen E, Willem L, Broeckhove J
 */

#pragma once

#include "CSVRow.h"

#include "util/StringUtils.h"
#include "util/is_iterator.h"

#include <iosfwd>
#include <type_traits>
#include <vector>

#ifdef BOOST_FOUND
#include <boost/filesystem.hpp>
#include <boost/filesystem/path.hpp>
namespace filesys = boost::filesystem;
#else
#include <filesystem>
namespace filesys = std::filesystem;
#endif
namespace stride {
namespace util {

class CSV : protected std::vector<CSVRow>
{
public:
        explicit CSV(const filesys::path& path, std::initializer_list<std::string> optLabels = {});

        explicit CSV(std::istream& inputStream);

        explicit CSV(size_t columnCount);

        explicit CSV(const std::vector<std::string>& labels);

        template <typename It>
        explicit CSV(It labelsBegin, It labelsEnd)
            : m_labels(ToString(labelsBegin, labelsEnd)), m_column_count(m_labels.size())
        {
        }

        CSV() = default;

        using std::vector<CSVRow>::begin;
        using std::vector<CSVRow>::end;
        using std::vector<CSVRow>::size;

        bool operator==(const CSV& other) const;

        template <typename... T>
        void AddRow(const T&... values);

        void AddRows(const std::vector<std::vector<std::string>>& rows);

        void AddRow(const std::vector<std::string>& row);

        template <typename It>
        void AddRow(typename std::enable_if<is_iterator<It>::value, It>::type first, It last)
        {
                CSVRow csvRow(this, ToString(first, last));
                this->push_back(csvRow);
        }

        size_t GetColumnCount() const { return m_column_count; }

        size_t GetIndexForLabel(const std::string& label) const;

        void Write(const filesys::path& path) const;

        const std::vector<std::string>& GetLabels() const;

private:
        friend std::ofstream& operator<<(std::ofstream& ofs, const CSV& csv);

        void ReadFromStream(std::istream& inputStream);

        void WriteLabels(std::ofstream& file) const;

        void WriteRows(std::ofstream& file) const;

        std::vector<std::string> m_labels;
        size_t                   m_column_count = 0;
};

template <typename... T>
inline void CSV::AddRow(const T&... values)
{
        AddRow({ToString(values)...});
}

inline std::ofstream& operator<<(std::ofstream& ofs, const CSV& csv)
{
        csv.WriteLabels(ofs);
        csv.WriteRows(ofs);
        return ofs;
}

} // namespace util
} // namespace stride