value_view.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "core/value_types.h"
 
#include <string>
#include <string_view>
#include <cstdlib>
#include <optional>
#include <type_traits>
 
namespace kcenon::container
{
 
class value_view
{
public:
    value_view(const char* name_data, size_t name_length,
               const char* value_data, size_t value_length,
               value_types type) noexcept
        : name_data_(name_data)
        , name_length_(name_length)
        , value_data_(value_data)
        , value_length_(value_length)
        , type_(type)
    {}
 
    [[nodiscard]] std::string_view name() const noexcept
    {
        return {name_data_, name_length_};
    }
 
    [[nodiscard]] value_types type() const noexcept
    {
        return type_;
    }
 
    [[nodiscard]] std::string_view as_string_view() const noexcept
    {
        return {value_data_, value_length_};
    }
 
    [[nodiscard]] std::string as_string() const
    {
        return {value_data_, value_length_};
    }
 
    template<typename T>
    [[nodiscard]] std::optional<T> as() const noexcept
    {
        if constexpr (std::is_same_v<T, std::string_view>) {
            if (type_ == value_types::string_value ||
                type_ == value_types::bytes_value) {
                return as_string_view();
            }
            return std::nullopt;
        }
        else if constexpr (std::is_same_v<T, std::string>) {
            if (type_ == value_types::string_value ||
                type_ == value_types::bytes_value) {
                return as_string();
            }
            return std::nullopt;
        }
        else if constexpr (std::is_same_v<T, bool>) {
            if (type_ == value_types::bool_value && value_length_ > 0) {
                return (value_data_[0] == 't' || value_data_[0] == 'T' ||
                        value_data_[0] == '1');
            }
            return std::nullopt;
        }
        else if constexpr (std::is_integral_v<T>) {
            return parse_integral<T>();
        }
        else if constexpr (std::is_floating_point_v<T>) {
            return parse_floating<T>();
        }
        else {
            return std::nullopt;
        }
    }
 
    [[nodiscard]] bool is_null() const noexcept
    {
        return type_ == value_types::null_value;
    }
 
    [[nodiscard]] const char* data() const noexcept
    {
        return value_data_;
    }
 
    [[nodiscard]] size_t size() const noexcept
    {
        return value_length_;
    }
 
private:
    template<typename T>
    [[nodiscard]] std::optional<T> parse_integral() const noexcept
    {
        if (!is_integral_type(type_)) {
            return std::nullopt;
        }
 
        if (value_length_ == 0) {
            return std::nullopt;
        }
 
        // Use strtoll/strtoull for parsing
        char* end = nullptr;
        std::string temp(value_data_, value_length_);
 
        if constexpr (std::is_signed_v<T>) {
            long long val = std::strtoll(temp.c_str(), &end, 10);
            if (end != temp.c_str() + temp.size()) {
                return std::nullopt;
            }
            return static_cast<T>(val);
        } else {
            unsigned long long val = std::strtoull(temp.c_str(), &end, 10);
            if (end != temp.c_str() + temp.size()) {
                return std::nullopt;
            }
            return static_cast<T>(val);
        }
    }
 
    template<typename T>
    [[nodiscard]] std::optional<T> parse_floating() const noexcept
    {
        if (type_ != value_types::float_value &&
            type_ != value_types::double_value) {
            return std::nullopt;
        }
 
        if (value_length_ == 0) {
            return std::nullopt;
        }
 
        char* end = nullptr;
        std::string temp(value_data_, value_length_);
 
        if constexpr (std::is_same_v<T, float>) {
            float val = std::strtof(temp.c_str(), &end);
            if (end != temp.c_str() + temp.size()) {
                return std::nullopt;
            }
            return val;
        } else {
            double val = std::strtod(temp.c_str(), &end);
            if (end != temp.c_str() + temp.size()) {
                return std::nullopt;
            }
            return static_cast<T>(val);
        }
    }
 
    [[nodiscard]] static bool is_integral_type(value_types t) noexcept
    {
        switch (t) {
            case value_types::short_value:
            case value_types::ushort_value:
            case value_types::int_value:
            case value_types::uint_value:
            case value_types::long_value:
            case value_types::ulong_value:
            case value_types::llong_value:
            case value_types::ullong_value:
                return true;
            default:
                return false;
        }
    }
 
    const char* name_data_;
    size_t name_length_;
    const char* value_data_;
    size_t value_length_;
    value_types type_;
};
 
struct value_index_entry
{
    std::string_view name;      
    size_t value_offset;        
    size_t value_length;        
    value_types type;           
 
    value_index_entry() noexcept
        : value_offset(0)
        , value_length(0)
        , type(value_types::null_value)
    {}
 
    value_index_entry(std::string_view n, size_t offset, size_t length, value_types t) noexcept
        : name(n)
        , value_offset(offset)
        , value_length(length)
        , type(t)
    {}
};
 
} // namespace kcenon::container