csv_error.hpp

Go to the documentation of this file.

 
#pragma once
#include "common.hpp"
#include <cstring>
#include <memory>
#include <string>
#include <system_error>
#include <utility>
 
namespace csv {
    enum class CSVConversionError {
        None = 0,
 
        NotANumber,
 
        Overflow,
 
        FloatToInt,
 
        NegativeToUnsigned
    };
 
    namespace internals {
        typedef const char* csv_error_message;
 
        static CONSTEXPR_VALUE_14 csv_error_message CSV_CONVERSION_ERROR_MESSAGES[] = {
            "",
            "Not a number.",
            "Overflow error.",
            "Attempted to convert a floating point value to an integral type.",
            "Negative numbers cannot be converted to unsigned types."
        };
    }
 
    inline const char* csv_conversion_error_message(CSVConversionError error) noexcept {
        const size_t index = static_cast<size_t>(error);
        return index < (sizeof(internals::CSV_CONVERSION_ERROR_MESSAGES) / sizeof(internals::CSV_CONVERSION_ERROR_MESSAGES[0]))
            ? internals::CSV_CONVERSION_ERROR_MESSAGES[index]
            : internals::CSV_CONVERSION_ERROR_MESSAGES[static_cast<size_t>(CSVConversionError::NotANumber)];
    }
 
    enum class CSVErrorCode {
        None,                
        InvalidArgument,     
        InvalidFormat,       
        InvalidChunkSize,    
        OpenFailed,          
        MappingFailed,       
        ReadFailed,          
        WriteFailed,         
        UnsupportedEncoding, 
        RowTooLarge,         
        RowLengthMismatch,   
        ColumnNotFound,      
        IndexOutOfBounds,    
        ConversionFailed,   
        MissingKeyColumn,    
        KeyNotFound,         
        DuplicateKey,        
        UnkeyedFrame,        
        ReadOnlyProxy,       
        InvalidProxy,        
        KeyColumnProtected,  
        UnsupportedOperation, 
        SizeLimitExceeded    
    };
 
    struct CSVError {
        CSVErrorCode code = CSVErrorCode::None;
        std::error_code system;
        csv::string_view context;
 
        CSVError() = default;
        CSVError(CSVErrorCode value, csv::string_view message) : code(value) {
            this->set_context(message);
        }
        CSVError(const CSVError& other)
            : code(other.code), system(other.system), context(other.context) {
            if (other.owned_context_) this->set_context(other.context);
        }
        CSVError(CSVError&& other) noexcept
            : code(other.code), system(other.system), context(other.context),
              owned_context_(std::move(other.owned_context_)) {
            other.clear();
        }
        CSVError& operator=(const CSVError& other) {
            if (this != &other) {
                CSVError copy(other);
                *this = std::move(copy);
            }
            return *this;
        }
        CSVError& operator=(CSVError&& other) noexcept {
            if (this != &other) {
                code = other.code;
                system = other.system;
                context = other.context;
                owned_context_ = std::move(other.owned_context_);
                other.clear();
            }
            return *this;
        }
 
        static CSVError from_static(CSVErrorCode value, csv::string_view message) noexcept {
            CSVError error;
            error.code = value;
            error.context = message;
            return error;
        }
 
        void set_context(csv::string_view message) {
            std::unique_ptr<char[]> buffer;
            if (!message.empty()) {
                buffer.reset(new char[message.size()]);
                std::memcpy(buffer.get(), message.data(), message.size());
            }
            context = message.empty() ? csv::string_view()
                : csv::string_view(buffer.get(), message.size());
            owned_context_ = std::move(buffer);
        }
        explicit operator bool() const noexcept { return code != CSVErrorCode::None; }
        void clear() noexcept {
            code = CSVErrorCode::None;
            system.clear();
            context = csv::string_view();
            owned_context_.reset();
        }
        std::string message() const {
            const std::string text = context.empty() ? std::string() : std::string(context);
            return system ? text + ": " + system.message() : text;
        }
 
    private:
        // Keep success and borrowed static diagnostics allocation-free.
        std::unique_ptr<char[]> owned_context_;
    };
 
    namespace internals {
        inline bool fail(CSVError& error, CSVErrorCode code, csv::string_view message) {
            error = CSVError(code, message);
            return false;
        }
 
        // Use only for literals or other text with static lifetime. Runtime
        // pointers (notably exception::what()) must use the owning fail().
        inline bool fail_static(CSVError& error, CSVErrorCode code, csv::string_view message) noexcept {
            error = CSVError::from_static(code, message);
            return false;
        }
    }
}