CsvGridRow.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 CSVGRIDROW
#define CSVGRIDROW

#include <initializer_list>
#include <ostream>
#include <algorithm>
#include <iterator>
#include <stdexcept>
#ifdef USE_EXPLICIT_MOVE_
#include <utility>
#endif
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/throw_exception.hpp>
#include "CoreLibraryDllGlobal.h"
#include "Platform/PlatformDefines.h"
#include "StringUtils/StringUtils.h"
#include "CsvGridCell.h"
#include "CsvGridCellDouble.h"

namespace core_lib
{
namespace csv_grid
{

enum class eCellFormatOptions
{
    simpleCells,
    doubleQuotedCells
};

namespace reserver
{

template <template <class, class> class C, class T> class ContainerReserver
{
public:
    using container_type = C<T, std::allocator<T>>;
    void operator()(container_type& container, size_t size) const
    {
        (void)container;
        (void)size;

        // Do nothing.
    }
};

template <class T> class ContainerReserver<std::vector, T>
{
public:
    using container_type = std::vector<T>;
    void operator()(container_type& container, size_t size) const
    {
        container.reserve(size);
    }
};

} // namespace reserver

// forward declaration for using in Row class.
template <template <class, class> class C, class T> class TCsvGrid;

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

    TRow(TRow&& row)
    {
        *this = std::move(row);
    }
#else

    TRow(TRow&&) = default;
#endif

    explicit TRow(size_t numCols)
        : m_cells(numCols)
    {
    }
    TRow(const std::string& line, eCellFormatOptions options)
    {
        LoadRowFromCsvFileLine(line, options);
    }
    // cppcheck-suppress noExplicitConstructor
    TRow(std::initializer_list<T> cells)
        : m_cells(cells)
    {
    }
    ~TRow() = default;
    TRow& operator=(const TRow&) = default;
#ifdef USE_EXPLICIT_MOVE_

    TRow& operator=(TRow&& row)
    {
        std::swap(m_cells, row.m_cells);
        return *this;
    }
#else

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

    cell_type& operator[](size_t col)
    {
        if (col >= GetSize())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("col out of range"));
        }

        return *std::next(m_cells.begin(), col);
    }
    const cell_type& operator[](size_t col) const
    {
        if (col >= GetSize())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("col out of range"));
        }

        return *std::next(m_cells.begin(), col);
    }
    bool Empty() const
    {
        return m_cells.empty();
    }
    size_t GetSize() const
    {
        return std::distance(m_cells.begin(), m_cells.end());
    }
    void SetSize(size_t cols)
    {
        m_cells.resize(cols);
    }
    template <typename V> void AddColumn(V value)
    {
        m_cells.emplace_back(value);
    }
    void AddColumn()
    {
        m_cells.emplace_back();
    }
    template <typename V> void InsertColumn(size_t col, V value)
    {
        if (col >= GetSize())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("col out of range"));
        }

        m_cells.emplace(std::next(m_cells.begin(), col), value);
    }
    void InsertColumn(size_t col)
    {
        if (col >= GetSize())
        {
            BOOST_THROW_EXCEPTION(std::out_of_range("col out of range"));
        }

        m_cells.emplace(std::next(m_cells.begin(), col));
    }
    void ClearCells()
    {
        std::fill(m_cells.begin(), m_cells.end(), Cell());
    }
    void ResetRow()
    {
        m_cells.clear();
    }

private:
    void LoadRowFromCsvFileLine(const std::string& line, eCellFormatOptions options)
    {
        if (options == eCellFormatOptions::doubleQuotedCells)
        {
            TokenizeLineQuoted(line);
        }
        else
        {
            TokenizeLine(line);
        }
    }
    void OutputRowToStream(std::ostream& os) const
    {
        // for each row loop over its columns...
        size_t col = 0;

        for (const auto& cellItem : m_cells)
        {
            // let's get our cell value...
            std::string cell{static_cast<std::string>(cellItem)};

            // if string contains quotes, insert an
            // extra quote...
            size_t pos{cell.find('"')};

            while (pos < cell.length())
            {
                cell.insert(pos, "\"");
                pos = cell.find('"', pos + 2);
            }

            // if cell contains ',', '\n' or '\r' wrap it in quotes...
            if (cell.find_first_of(",\r\n") != std::string::npos)
            {
                std::string temp = "\"";
                temp.append(cell);
                temp.append("\"");
                cell.swap(temp);
            }

            // output corrected cell...
            os << cell;

            // add ',' if not last cell on current row...
            if (col++ < GetSize() - 1)
            {
                os << ",";
            }
        }
    }
    void TokenizeLineQuoted(const std::string& line)
    {
        using Tokenizer = boost::tokenizer<boost::escaped_list_separator<char>>;
        Tokenizer                 tokzr{line};
        Tokenizer::const_iterator tokIter{tokzr.begin()};

        while (tokIter != tokzr.end())
        {
            // cppcheck-suppress eraseDereference
            std::string tok{*tokIter++};
            boost::trim(tok);
            m_cells.emplace_back(tok);
        }
    }
    void TokenizeLine(const std::string& line)
    {
        std::stringstream line_ss{line};
        std::string       tok;

        while (std::getline(line_ss, tok, ','))
        {
            string_utils::PackStdString(tok);
            boost::trim(tok);
            m_cells.emplace_back(tok);
        }
    }

private:
    reserver::ContainerReserver<C, T> m_reserve{};
    container_type m_cells{};
};

} // namespace csv_grid
} // namespace core_lib

#endif // CSVGRIDROW