Tag.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/platform/Result.h"
 
// auto generated forward declare list
// clang-format off
class IDataInput;
class IDataOutput;
class PrintStream;
// clang-format on
 
enum class SnbtFormat : uint {
    Minimize           = 0,
    CompoundLineFeed   = 1 << 0,
    ArrayLineFeed      = 1 << 1,
    Colored            = 1 << 2,
    Console            = 1 << 3,
    ForceAscii         = 1 << 4,
    ForceQuote         = 1 << 5,
    CommentMarks       = 1 << 6,
    Jsonify            = ForceQuote | CommentMarks,
    PartialLineFeed    = CompoundLineFeed,
    AlwaysLineFeed     = CompoundLineFeed | ArrayLineFeed,
    PrettyFilePrint    = PartialLineFeed,
    PrettyChatPrint    = PrettyFilePrint | Colored,
    PrettyConsolePrint = PrettyFilePrint | Colored | Console,
};
[[nodiscard]] constexpr SnbtFormat operator|(SnbtFormat const l, SnbtFormat const r) noexcept {
    return static_cast<SnbtFormat>(
        static_cast<std::underlying_type_t<SnbtFormat>>(l) | static_cast<std::underlying_type_t<SnbtFormat>>(r)
    );
}
[[nodiscard]] constexpr SnbtFormat operator&(SnbtFormat const l, SnbtFormat const r) noexcept {
    return static_cast<SnbtFormat>(
        static_cast<std::underlying_type_t<SnbtFormat>>(l) & static_cast<std::underlying_type_t<SnbtFormat>>(r)
    );
}
 
class Tag {
protected:
    constexpr Tag() = default;
 
public:
    // Tag inner types define
    enum class Type : uchar {
        End         = 0x0,
        Byte        = 0x1,
        Short       = 0x2,
        Int         = 0x3,
        Int64       = 0x4,
        Float       = 0x5,
        Double      = 0x6,
        ByteArray   = 0x7,
        String      = 0x8,
        List        = 0x9,
        Compound    = 0xA,
        IntArray    = 0xB,
        NumTagTypes = 0xC,
    };
    using enum Type;
 
    template <std::derived_from<Tag> T>
    T const* as_ptr() const {
        return static_cast<T const*>(this);
    }
    template <std::derived_from<Tag> T>
    T* as_ptr() {
        return static_cast<T*>(this);
    }
    template <std::derived_from<Tag> T>
    T const& as() const {
        return *static_cast<T const*>(this);
    }
    template <std::derived_from<Tag> T>
    T& as() {
        return *static_cast<T*>(this);
    }
 
    [[nodiscard]] bool operator==(Tag const& other) const { return equals(other); }
 
    LLNDAPI std::string toSnbt(SnbtFormat snbtFormat = SnbtFormat::PrettyFilePrint, uchar indent = 4) const noexcept;
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~Tag() = default;
 
    virtual void deleteChildren();
 
    virtual void write(::IDataOutput& dos) const = 0;
 
    virtual ::Bedrock::Result<void> load(::IDataInput& dis) = 0;
 
    virtual ::std::string toString() const = 0;
 
    virtual ::Tag::Type getId() const = 0;
 
    virtual bool equals(::Tag const& rhs) const = 0;
 
    virtual void print(::PrintStream& out) const;
 
    virtual void print(::std::string const& prefix, ::PrintStream& out) const;
 
    virtual ::std::unique_ptr<::Tag> copy() const = 0;
 
    virtual uint64 hash() const = 0;
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCAPI static ::Bedrock::Result<::std::unique_ptr<::Tag>> newTag(::Tag::Type type);
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCFOLD void $deleteChildren();
 
    MCAPI void $print(::PrintStream& out) const;
 
    MCAPI void $print(::std::string const& prefix, ::PrintStream& out) const;
 
 
    // NOLINTEND
};