type.hxx

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Config.
 *
 * StormByte-Config is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * or later, as published by the Free Software Foundation.
 *
 * StormByte-Config is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with StormByte-Config. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 */
 
#pragma once
 
#include <StormByte/config/exception.hxx>
#include <StormByte/config/visibility.h>
 
#include <concepts>
#include <cstddef>
#include <string>
#include <type_traits>
#include <vector>
 
namespace StormByte::Config::Item {
    enum class Type: char {
        Bool,       
        Comment,    
        Container,  
        Double,     
        Integer,    
        String,     
        Binary      
    };
 
    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";
            case Type::Binary:      return "Binary";
            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) {
        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> ||
        std::is_same_v<T, std::vector<std::byte>>;
}