type.hxx

#pragma once
 
#include <StormByte/config/exception.hxx>
#include <StormByte/config/visibility.h>
 
#include <cstddef>
#include <concepts>
#include <string>
#include <type_traits>
 
namespace StormByte::Config::Item {
    enum class Type: char {
        Bool,       
        Comment,    
        Container,  
        Double,     
        Integer,    
        String      
    };
 
    static constexpr std::string TypeToString(const Type& t) noexcept {
        switch(t) {
            case Type::String:      return "String";
            case Type::Integer:     return "Integer";
            case Type::Double:      return "Double";
            case Type::Comment:     return "Comment";
            case Type::Bool:        return "Bool";
            case Type::Container:   return "Container";
            default:                return "Unknown";
        }
    }
 
    enum class STORMBYTE_CONFIG_PUBLIC CommentType: char {
        SingleLineBash = 2,     
        SingleLineC=5,      
        MultiLineC=8            
    };
 
    constexpr STORMBYTE_CONFIG_PUBLIC std::string TypeToString(const CommentType& t) noexcept {
        switch(t) {
            case CommentType::SingleLineBash:   return "Bash like single line comment";
            case CommentType::SingleLineC:      return "C++ like single line comment";
            case CommentType::MultiLineC:       return "C/C++ like multi line comment";
            default:                            return "Unknown";
        }
    }
 
    enum class STORMBYTE_CONFIG_PUBLIC ContainerType: char {
        Group,  
        List    
    };
 
    constexpr STORMBYTE_CONFIG_PUBLIC std::string TypeToString(const ContainerType& t) noexcept {
        switch(t) {
            case ContainerType::Group:  return "Group";
            case ContainerType::List:   return "List";
            default:                    return "Unknown";
        }
    }
 
    constexpr STORMBYTE_CONFIG_PUBLIC ContainerType TypeFromStartCharacter(const char& start) noexcept {
        switch(start) {
            case '{':           return ContainerType::Group;
            case '[':           return ContainerType::List;
            default:            throw Exception("Unknown start character " + std::string(1, start) + " for container");
        }
    }
 
    template<typename T>
    concept AllowedValueType = std::is_same_v<T, int> || 
                          std::is_same_v<T, double> || 
                          std::is_same_v<T, bool> || 
                          std::is_same_v<T, std::string>;
}