CSV.h

Go to the documentation of this file.

// Copyright 2015 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_CSV_h_GUID_30FA2504_8CCF_4B87_71C7_5974F968BC19
#define INCLUDED_CSV_h_GUID_30FA2504_8CCF_4B87_71C7_5974F968BC19

// Internal Includes
// - none

// Library/third-party includes
// - none

// Standard includes
#include <cassert>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>

namespace osvr {
namespace util {
    template <typename Derived> class CSVBase;
    namespace detail {
        template <typename T> class CellBase {
          protected:
            explicit CellBase(T const &data) : data_(data) {}

          public:
            T const &getData() const { return data_; }

          private:
            T const &data_;
        };
        template <typename T, typename HeaderType = std::string> class Cell;
        template <typename T> class Cell<T, std::string> : public CellBase<T> {
          public:
            using Base = CellBase<T>;
            Cell(std::string const &header, T const &data)
                : Base(data), header_(header) {}

            Cell(const char *header, T const &data)
                : Base(data), header_(header) {}
            Cell(std::string &&header, T const &data)
                : Base(data), header_(std::move(header)) {}

            std::string const &getHeader() const { return header_; }

          private:
            std::string header_;
        };

        template <typename T, typename Dummy = void> struct CellStreamPrep {
            static void prepareStream(std::ostream &) {
            }
        };

        template <typename T>
        struct CellStreamPrep<T, typename std::enable_if<
                                     std::is_floating_point<T>::value>::type> {
            static void prepareStream(std::ostream &os) {
                // Floating point values: please set precision to maximum.
                os << std::setprecision(std::numeric_limits<T>::digits10 + 1);
            }
        };

        template <typename T>
        inline void prepareStream(std::ostream &os, T const &cell) {
            using DataValueConstType =
                typename std::remove_reference<decltype(cell.getData())>::type;
            using DataValueType =
                typename std::remove_const<DataValueConstType>::type;
            using PrepType = CellStreamPrep<DataValueType>;
            PrepType::prepareStream(os);
        }

        template <typename Derived> class CSVRowProxy {
          public:
            using BaseCSVType = CSVBase<Derived>;
            friend class CSVBase<Derived>;
            using CSV = Derived;
            using type = CSVRowProxy<Derived>;

          private:
            explicit CSVRowProxy(BaseCSVType &csv) : csv_(csv) {}

          public:
            CSVRowProxy(CSVRowProxy const &) = delete;
            CSVRowProxy &operator=(CSVRowProxy const &) = delete;
            CSVRowProxy(CSVRowProxy &&other)
                : csv_(other.csv_), preparedRow_(other.preparedRow_),
                  active_(other.active_) {
                other.active_ = false;
            }

            ~CSVRowProxy() {
                if (active_ && preparedRow_) {
                    csv_.finalizeLatestRow();
                }
            }

            template <typename... CellArgs>
            void add(Cell<CellArgs...> const &c) {
                commonPreAdd();
                std::ostringstream os;
                prepareStream(os, c);
                os << c.getData();
                commonPostAdd(c.getHeader(), os.str());
            }

          private:
            void commonPreAdd() {
                if (!preparedRow_) {
                    csv_.prepareForRow();
                    preparedRow_ = true;
                }
            }
            void commonPostAdd(std::string const &header,
                               std::string const &value) {
                csv_.dataForLatestRow(header, value);
            }

            BaseCSVType &csv_;
            bool preparedRow_ = false;
            bool active_ = true;
        };

        namespace csv {
            static const char COMMA[] = ",";
            static const char DOUBLEQUOTE[] = "\"";
            static const char DOUBLEQUOTE_COMMA[] = "\",";
            static const char NEWLINE[] = "\n";
        } // namespace csv

        class CSVCommonBase {
          public:
            using DataRow = std::vector<std::string>;
            using column_id = std::size_t;
            column_id getColumn(std::string const &heading) {
                auto it = columnsMap_.find(heading);
                // If we don't find it, this is where it will be.
                column_id ret = columns_.size();
                if (end(columnsMap_) != it) {
                    // OK, found it somewhere already.
                    ret = it->second;
                    return ret;
                }
                // didn't find it, add it.
                columns_.push_back(heading);
                columnsMap_.insert(std::make_pair(heading, ret));
                return ret;
            }
            column_id numColumns() const { return columns_.size(); }

          protected:
            void outputHeaders(std::ostream &os) const {
                for (auto &colName : columns_) {
                    os << csv::DOUBLEQUOTE << colName << csv::DOUBLEQUOTE_COMMA;
                }
                os << csv::NEWLINE;
            }

          private:
            std::vector<std::string> columns_;
            std::unordered_map<std::string, column_id> columnsMap_;
        };

        template <typename Derived, typename... CellArgs>
        inline CSVRowProxy<Derived> &&
        operator<<(CSVRowProxy<Derived> &&row, Cell<CellArgs...> const &cell) {
            row.add(cell);
            return std::move(row);
        }

        template <typename Derived, typename... CellArgs>
        inline CSVRowProxy<Derived> &operator<<(CSVRowProxy<Derived> &row,
                                                Cell<CellArgs...> const &cell) {
            row.add(cell);
            return row;
        }
    } // namespace detail

    template <typename Derived> class CSVBase : public detail::CSVCommonBase {
      public:
        friend class detail::CSVRowProxy<Derived>;
        using RowProxy = detail::CSVRowProxy<Derived>;

        RowProxy row() { return RowProxy(*this); }

        std::size_t numDataRows() const { return data_.size(); }

        std::size_t numRows() const { return rows_; }

      protected:
        void prepareForRow() { latestRow().clear(); }
        void dataForLatestRow(std::string const &heading,
                              std::string const &data) {
            auto col = getColumn(heading);
            ensureLatestRowCanHoldColId(col);
            latestRow()[col] = data;
        }
        void finalizeLatestRow() {
            rows_++;
            derived().finalizeLatestRow();
        }

        DataRow &latestRow() { return latestRow_; }

        void outputRow(std::ostream &os, DataRow const &row) const {
            for (auto &cell : row) {
                os << cell << detail::csv::COMMA;
            }
            os << detail::csv::NEWLINE;
        }

        void outputData(std::ostream &os) const {
            for (auto &row : data_) {
                outputRow(os, row);
            }
        }

        void moveLatestRowToData() {
            data_.emplace_back(std::move(latestRow()));
        }

      private:
        void ensureLatestRowCanHoldColId(column_id id) {
            if (id >= latestRow().size()) {
                latestRow().resize(id + 1);
            }
        }

        Derived const &derived() const {
            return *static_cast<Derived const *>(this);
        }
        Derived &derived() { return *static_cast<Derived *>(this); }
        std::size_t rows_ = 0;
        std::vector<DataRow> data_;
        DataRow latestRow_;
    };

    class CSV : public CSVBase<CSV> {
        using Base = CSVBase<CSV>;
        friend class CSVBase<CSV>;

      public:
        void output(std::ostream &os) const {
            Base::outputHeaders(os);
            Base::outputData(os);
        }

      private:
        void finalizeLatestRow() { Base::moveLatestRowToData(); }
    };

    class StreamCSV : public CSVBase<StreamCSV> {
        using Base = CSVBase<StreamCSV>;
        friend class CSVBase<StreamCSV>;

      public:
        explicit StreamCSV(std::ostream &os) : m_stream(os) {}

        void startOutput() {
            Base::outputHeaders(m_stream);
            outputData(m_stream);
            m_streaming = true;
        }

      private:
        std::ostream &m_stream;

        bool m_streaming = false;

        void finalizeLatestRow() {
            if (m_streaming) {
                Base::outputRow(m_stream, Base::latestRow());
            } else {
                Base::moveLatestRowToData();
            }
        }
    };

    template <typename T>
    inline detail::Cell<T> cell(const char *header, T const &data) {
        return detail::Cell<T>{header, data};
    }

    template <typename T>
    inline detail::Cell<T> cell(std::string const &header, T const &data) {
        return detail::Cell<T>{header, data};
    }

} // namespace util
} // namespace osvr

#endif // INCLUDED_CSV_h_GUID_30FA2504_8CCF_4B87_71C7_5974F968BC19