csv_cell.h

Go to the documentation of this file.

/**************************************************************************
Copyright: (C) 2021 - 2025 Alexander Shaduri
License: Zlib
***************************************************************************/
 
#ifndef CSV_CELL_H
#define CSV_CELL_H
 
#include "csv_util.h"
#include "csv_cell_string_buffer.h"
 
#include <string_view>
#include <string>
#include <optional>
#include <algorithm>
#include <variant>
#include <limits>
#include <stdexcept>
#include <array>
 
namespace Csv {
 
 
enum class CellTypeHint {
    Empty,  
    StringWithEscapedQuotes,  
    StringWithoutEscapedQuotes,  
    UnquotedData,  
};
 
 
enum class CellType {
    Empty,  
    Double,  
    String,  
};
 
 
 
class CellReference {
    public:
 
        constexpr CellReference() = default;
 
        template<typename BehaviorPolicy>
        constexpr CellReference(std::string_view cell, CellTypeHint hint, BehaviorPolicy policy) noexcept;
 
        [[nodiscard]] inline constexpr CellType getType() const;
 
        [[nodiscard]] inline constexpr bool isEmpty() const;
 
        [[nodiscard]] inline constexpr std::optional<double> getDouble() const;
 
        [[nodiscard]] inline constexpr std::optional<std::string_view> getOriginalStringView(
                bool* has_escaped_quotes = nullptr) const;
 
        [[nodiscard]] inline std::optional<std::string> getCleanString() const;
 
        template<std::size_t BufferSize>
        [[nodiscard]] constexpr CellStringBuffer<BufferSize> getCleanStringBuffer() const;
 
        [[nodiscard]] constexpr std::size_t getRequiredBufferSize() const;
 
 
    private:
 
        struct Empty { };
 
        struct String {
            std::string_view view;
            bool has_escaped_quotes = false;
        };
 
        std::variant<
            Empty,
            double,
            String
        > value_ = Empty();
};
 
 
 
class CellValue {
    public:
 
        CellValue() = default;
 
        template<typename BehaviorPolicy>
        CellValue(std::string_view cell, CellTypeHint hint, BehaviorPolicy policy);
 
        [[nodiscard]] inline CellType getType() const;
 
        [[nodiscard]] inline bool isEmpty() const;
 
        [[nodiscard]] inline std::optional<double> getDouble() const;
 
        [[nodiscard]] inline std::optional<std::string> getString() const;
 
    private:
 
        struct Empty { };
 
        std::variant<
            Empty,
            double,
            std::string
        > value_ = Empty();
};
 
 
 
class CellDoubleValue {
    public:
 
        constexpr CellDoubleValue() = default;
 
        template<typename BehaviorPolicy>
        constexpr explicit CellDoubleValue(std::string_view cell,
                CellTypeHint hint_ignored, BehaviorPolicy policy) noexcept;
 
        [[nodiscard]] inline constexpr double getValue() const;
 
    private:
        double value_ = std::numeric_limits<double>::quiet_NaN();
};
 
 
 
 
class CellStringReference {
    public:
 
        constexpr CellStringReference() = default;
 
        template<typename BehaviorPolicy>
        constexpr CellStringReference(std::string_view cell, CellTypeHint hint, BehaviorPolicy policy) noexcept;
 
        [[nodiscard]] inline constexpr std::string_view getOriginalStringView(
                bool* has_escaped_quotes = nullptr) const noexcept;
 
        [[nodiscard]] inline std::string getCleanString();
 
        template<std::size_t BufferSize>
        [[nodiscard]] constexpr CellStringBuffer<BufferSize> getCleanStringBuffer() const;
 
        [[nodiscard]] constexpr std::size_t getRequiredBufferSize() const;
 
 
    private:
 
        std::string_view value_;
 
        bool has_escaped_quotes_ = false;
 
};
 
 
 
class CellStringValue {
    public:
 
        CellStringValue() = default;
 
        template<typename BehaviorPolicy>
        CellStringValue(std::string_view cell, CellTypeHint hint, BehaviorPolicy policy);
 
        [[nodiscard]] inline const std::string& getString() const;
 
    private:
        std::string value_;
};
 
 
 
 
// ----- Implementation
 
 
 
template<typename BehaviorPolicy>
constexpr CellReference::CellReference(std::string_view cell, CellTypeHint hint,
        [[maybe_unused]] BehaviorPolicy policy) noexcept
{
    switch (hint) {
        case CellTypeHint::Empty:
            // Nothing, value is empty
            break;
 
        case CellTypeHint::StringWithEscapedQuotes:
            value_ = String{cell, true};
            break;
 
        case CellTypeHint::StringWithoutEscapedQuotes:
            value_ = String{cell, false};
            break;
 
        case CellTypeHint::UnquotedData:
            if (auto double_value = BehaviorPolicy::template readNumber<double>(cell); double_value.has_value()) {
                value_ = double_value.value();
            } else {
                value_ = String{cell, false};
            }
            break;
    }
}
 
 
 
constexpr CellType CellReference::getType() const
{
    if (std::holds_alternative<Empty>(value_)) {
        return CellType::Empty;
    }
    if (std::holds_alternative<double>(value_)) {
        return CellType::Double;
    }
    if (std::holds_alternative<String>(value_)) {
        return CellType::String;
    }
    throw std::bad_variant_access();
}
 
 
 
constexpr bool CellReference::isEmpty() const
{
    return std::holds_alternative<Empty>(value_);
}
 
 
 
constexpr std::optional<double> CellReference::getDouble() const
{
    if (std::holds_alternative<double>(value_)) {
        return std::get<double>(value_);
    }
    return {};
}
 
 
 
constexpr std::optional<std::string_view> CellReference::getOriginalStringView(bool* has_escaped_quotes) const
{
    if (std::holds_alternative<String>(value_)) {
        const auto& s = std::get<String>(value_);
        if (has_escaped_quotes) {
            *has_escaped_quotes = s.has_escaped_quotes;
        }
        return s.view;
    }
    return {};
}
 
 
 
std::optional<std::string> CellReference::getCleanString() const
{
    if (std::holds_alternative<String>(value_)) {
        const auto& s = std::get<String>(value_);
        return s.has_escaped_quotes ? cleanString(s.view) : std::string(s.view);
    }
    return {};
}
 
 
 
template<std::size_t BufferSize>
constexpr CellStringBuffer<BufferSize> CellReference::getCleanStringBuffer() const
{
    // This throws bad variant access
    const auto& s = std::get<String>(value_);
    return CellStringBuffer<BufferSize>(s.view, s.has_escaped_quotes);
}
 
 
 
constexpr std::size_t CellReference::getRequiredBufferSize() const
{
    // This throws bad variant access
    const auto& s = std::get<String>(value_);
    return s.has_escaped_quotes ? getCleanStringSize(s.view) : s.view.size();
}
 
 
 
 
 
template<typename BehaviorPolicy>
CellValue::CellValue(std::string_view cell, CellTypeHint hint, [[maybe_unused]] BehaviorPolicy policy)
{
    switch (hint) {
        case CellTypeHint::Empty:
            // Nothing, value is empty
            break;
 
        case CellTypeHint::StringWithEscapedQuotes:
            value_ = cleanString(cell);
            break;
 
        case CellTypeHint::StringWithoutEscapedQuotes:
            value_ = std::string(cell);
            break;
 
        case CellTypeHint::UnquotedData:
            if (auto double_value = BehaviorPolicy::template readNumber<double>(cell); double_value.has_value()) {
                value_ = double_value.value();
            } else {
                value_ = std::string(cell);
            }
            break;
    }
}
 
 
 
CellType CellValue::getType() const
{
    if (std::holds_alternative<Empty>(value_)) {
        return CellType::Empty;
    }
    if (std::holds_alternative<double>(value_)) {
        return CellType::Double;
    }
    if (std::holds_alternative<std::string>(value_)) {
        return CellType::String;
    }
    throw std::bad_variant_access();
}
 
 
 
bool CellValue::isEmpty() const
{
    return std::holds_alternative<Empty>(value_);
}
 
 
 
std::optional<double> CellValue::getDouble() const
{
    if (std::holds_alternative<double>(value_)) {
        return std::get<double>(value_);
    }
    return {};
}
 
 
 
std::optional<std::string> CellValue::getString() const
{
    if (std::holds_alternative<std::string>(value_)) {
        return std::get<std::string>(value_);
    }
    return {};
}
 
 
 
 
 
template<typename BehaviorPolicy>
constexpr CellDoubleValue::CellDoubleValue(std::string_view cell,
        [[maybe_unused]] CellTypeHint hint_ignored, [[maybe_unused]] BehaviorPolicy policy) noexcept
{
    if (auto double_value = BehaviorPolicy::template readNumber<double>(cell); double_value.has_value()) {
        value_ = double_value.value();
    }
}
 
 
 
constexpr double CellDoubleValue::getValue() const
{
    return value_;
}
 
 
 
 
 
template<typename BehaviorPolicy>
constexpr CellStringReference::CellStringReference(std::string_view cell, CellTypeHint hint,
        [[maybe_unused]] BehaviorPolicy policy) noexcept
        : value_(cell),
        has_escaped_quotes_(hint == CellTypeHint::StringWithEscapedQuotes)
{ }
 
 
 
constexpr std::string_view CellStringReference::getOriginalStringView(bool* has_escaped_quotes) const noexcept
{
    if (has_escaped_quotes) {
        *has_escaped_quotes = has_escaped_quotes_;
    }
    return value_;
}
 
 
 
std::string CellStringReference::getCleanString()
{
    return has_escaped_quotes_ ? cleanString(value_) : std::string(value_);
}
 
 
 
template<std::size_t BufferSize>
constexpr CellStringBuffer<BufferSize> CellStringReference::getCleanStringBuffer() const
{
    return CellStringBuffer<BufferSize>(value_, has_escaped_quotes_);
}
 
 
 
constexpr std::size_t CellStringReference::getRequiredBufferSize() const
{
    return getCleanStringSize(value_);
}
 
 
 
 
 
template<typename BehaviorPolicy>
CellStringValue::CellStringValue(std::string_view cell, CellTypeHint hint,
        [[maybe_unused]] BehaviorPolicy policy)
        : value_(hint == CellTypeHint::StringWithEscapedQuotes ? cleanString(cell) : std::string(cell))
{ }
 
 
 
const std::string& CellStringValue::getString() const
{
    return value_;
}
 
 
 
 
}  // end ns
 
 
 
#endif