CsvGridMain.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef CSVGRIDMAIN
#define CSVGRIDMAIN

#include <fstream>
#include <limits>
#include <cmath>
#include "CsvGridRow.h"

namespace core_lib
{
namespace csv_grid
{

enum class eSaveToFileOptions
{
    truncate,
    append
};

template <template <class, class> class C, class T = Cell> class TCsvGrid final
{
public:
    using row_type = TRow<C, T>;
    using container_type = C<row_type, std::allocator<row_type>>;
    TCsvGrid() = default;
    TCsvGrid(const TCsvGrid&) = default;
#ifdef USE_EXPLICIT_MOVE_

    TCsvGrid(TCsvGrid&& csvGrid)
    {
        *this = std::move(csvGrid);
    }
#else

    TCsvGrid(TCsvGrid&&) = default;
#endif

    TCsvGrid(size_t rows, size_t cols)
    {
        if ((rows == 0) || (cols == 0))
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("rows or cols is 0"));
        }

        m_grid.resize(rows, row_type(cols));
    }
    TCsvGrid(const std::string& filename, eCellFormatOptions options)
    {
        LoadFromCSVFile(filename, options);
    }
    // cppcheck-suppress noExplicitConstructor
    TCsvGrid(std::initializer_list<row_type> rows)
        : m_grid(rows)
    {
    }
    ~TCsvGrid() = default;
    TCsvGrid& operator=(const TCsvGrid&) = default;
#ifdef USE_EXPLICIT_MOVE_

    TCsvGrid& operator=(TCsvGrid&& csvGrid)
    {
        std::swap(m_grid, csvGrid.m_grid);
        return *this;
    }
#else

    TCsvGrid& operator=(TCsvGrid&&) = default;
#endif

    row_type& operator[](size_t row)
    {
        if (row >= GetRowCount())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("row out of range"));
        }

        return *std::next(m_grid.begin(), row);
    }
    const row_type& operator[](size_t row) const
    {
        if (row >= GetRowCount())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("row out of range"));
        }

        return *std::next(m_grid.begin(), row);
    }
    bool Empty() const
    {
        return m_grid.empty();
    }
    size_t GetRowCount() const
    {
        return std::distance(m_grid.begin(), m_grid.end());
    }
    size_t GetColCount(size_t row) const
    {
        if (row >= GetRowCount())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("row out of range"));
        }

        auto n = std::next(m_grid.begin(), row);
        return n->GetSize();
    }
    void SetRowCount(size_t rows, size_t defaultCols = 0)
    {
        m_grid.resize(rows, row_type(defaultCols));
    }
    void AddRow(size_t cols = 0)
    {
        m_grid.emplace_back(cols);
    }
    // cppcheck-suppress functionConst
    void AddColumnToAllRows()
    {
        for (auto& row : m_grid)
        {
            row.AddColumn();
        }
    }
    void InsertRow(size_t row, size_t defaultCols = 0)
    {
        if (row >= GetRowCount())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("row out of range"));
        }

        m_grid.emplace(std::next(m_grid.begin(), row), defaultCols);
    }
    // cppcheck-suppress functionConst
    void InsertColumnInAllRows(size_t col)
    {
        for (auto& row : m_grid)
        {
            if (col < row.GetSize())
            {
                row.InsertColumn(col);
            }
        }
    }
    // cppcheck-suppress functionConst
    void ClearCells()
    {
        for (auto& row : m_grid)
        {
            row.ClearCells();
        }
    }
    void ResetGrid()
    {
        m_grid.clear();
    }
    void LoadFromCSVFile(const std::string& filename, eCellFormatOptions options,
                         size_t firstRowToLoad   = 0,
                         size_t maxNumRowsToLoad = std::numeric_limits<size_t>::max())
    {
        std::ifstream csvfile{filename.c_str()};

        if (!csvfile.is_open())
        {
            std::string err("failed to create file stream for loading: ");
            err.append(filename);

            BOOST_THROW_EXCEPTION(std::runtime_error(err));
        }

        m_grid.clear();
        size_t      rowCount = 0;
        std::string row;
        bool        rowComplete = false;

        while (csvfile.good() && (m_grid.size() < maxNumRowsToLoad))
        {
            std::string line;
            std::getline(csvfile, line);
            string_utils::PackStdString(line);

            if ((csvfile.tellg() == csvfile.gcount()) || csvfile.eof())
            {
                if (line.compare("") == 0)
                {
                    break;
                }
            }

            // Because a cell may have line breaks within it we have to
            // accumulate lines from the file until we have a complete row.
            // But as we join the lines back to gether to form a complete
            // row we must add back in the new-line char for each line end.
            if (!row.empty())
            {
                row.append("\n");
            }

            row.append(line);

            if (ContainsEndOfRow(row))
            {
                rowComplete = true;
            }

            if ((rowCount >= firstRowToLoad) && rowComplete)
            {
                m_grid.emplace_back(row, options);
            }

            if (rowComplete)
            {
                ++rowCount;
                rowComplete = false;
                row.clear();
            }
        }

        csvfile.close();
    }
    void SaveToCsvFile(const std::string& filename,
                       eSaveToFileOptions option = eSaveToFileOptions::truncate) const
    {
        std::ofstream csvfile;

        if (option == eSaveToFileOptions::append)
        {
            csvfile.open(filename.c_str(), std::ofstream::app);
        }
        else
        {
            csvfile.open(filename.c_str(), std::ofstream::trunc);
        }

        if (!csvfile.is_open())
        {
            std::string err("failed to create file stream for saving: ");
            err.append(filename);

            BOOST_THROW_EXCEPTION(std::runtime_error(err));
        }

        OutputCsvGridToStream(csvfile);
        csvfile.close();
    }

private:
    void OutputCsvGridToStream(std::ostream& os) const
    {
        size_t row = 0;

        for (const auto& rowItem : m_grid)
        {
            rowItem.OutputRowToStream(os);

            if (row++ < GetRowCount() - 1)
            {
                os << std::endl;
            }
        }
    }
    static bool ContainsEndOfRow(const std::string& row)
    {
        std::string::difference_type numQuotes = std::count(row.begin(), row.end(), '"');
        return (numQuotes % 2) == 0;
    }

private:
    container_type m_grid{};
};

} // namespace csv_grid
} // namespace core_lib

#endif // CSVGRIDMAIN