type.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Config.
 *
 * StormByte-Config original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Config source in this
 * repository. They do not cover other StormByte modules or any third-party
 * material shipped with this repository. The bundled StormByte Base tree
 * under thirdparty/ remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * 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
 * version 3 along with StormByte-Config. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/config/exception.hxx>
#include <StormByte/config/visibility.h>
#include <StormByte/safe/string.hxx>
 
#include <string_view>
 
namespace StormByte::Config::Item {
    enum class Type: char {
        Bool,       
        Comment,    
        Container,  
        Double,     
        Integer,    
        String,     
        Binary,     
        Value       
    };
 
    static constexpr std::string_view 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";
            case Type::Value:       return "Value";
            default:                return "Unknown";
        }
    }
 
    enum class STORMBYTE_CONFIG_PUBLIC CommentType: char {
        SingleLineBash = 2,     
        SingleLineC = 5,        
        MultiLineC = 8          
    };
 
    constexpr STORMBYTE_CONFIG_PUBLIC std::string_view 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_view 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 {} for container", start);
        }
    }
 
    struct Integer {};  
    struct Double {};   
    struct Bool {};     
    struct Text {};     
    struct Binary {};   
}