ItemRegistryRef.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/common/WeakPtr.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/game_refs/WeakRef.h"
#include "mc/deps/puv/puv_load_data/LoadResultWithTiming.h"
 
// auto generated forward declare list
// clang-format off
class BaseGameVersion;
class BlockDefinitionGroup;
class BlockPalette;
class CreativeContentPacket;
class CreativeItemRegistry;
class Experiments;
class HashedString;
class IContainerRegistryAccess;
class IContainerRegistryTracker;
class IDynamicContainerSerialization;
class IEducationOptions;
class IMinecraftEventing;
class Item;
class ItemInstance;
class ItemRegistry;
class LinkedAssetValidator;
class ResourcePackManager;
class TagUpdateToken;
struct ItemRegistryComplexAlias;
struct ItemTag;
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class ItemRegistryRef {
public:
    // ItemRegistryRef inner types declare
    // clang-format off
    struct LoadedItem;
    class LockGuard;
    // clang-format on
 
    // ItemRegistryRef inner types define
    struct LoadedItem {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::WeakPtr<::Item>>                    mItem;
        ::ll::TypedStorage<8, 32, ::PuvLoadData::LoadResultWithTiming> mTiming;
        // NOLINTEND
    };
 
    class LockGuard {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 16, ::std::shared_ptr<::std::mutex>> mMutex;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        LockGuard();
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI explicit LockGuard(::std::shared_ptr<::std::mutex> mutex);
 
        MCNAPI ~LockGuard();
        // NOLINTEND
 
    public:
        // constructor thunks
        // NOLINTBEGIN
        MCNAPI void* $ctor(::std::shared_ptr<::std::mutex> mutex);
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCNAPI void $dtor();
        // NOLINTEND
    };
 
    using CreativeItemsServerInitCallbackSignature = void(
        ::ItemRegistryRef,
        ::BlockDefinitionGroup const&,
        ::CreativeItemRegistry*,
        ::BaseGameVersion const&,
        ::Experiments const&,
        ::ResourcePackManager const&,
        ::cereal::ReflectionCtx const&,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> const,
        ::IMinecraftEventing&,
        ::IEducationOptions const&
    );
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 16, ::std::weak_ptr<::ItemRegistry>> mWeakRegistry;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI void addItemToTagMap(::Item const& item) const;
 
    MCAPI ::TagUpdateToken allowTagUpdate() const;
 
    MCNAPI void buildServerRegistry(
        ::Experiments const&                               experiments,
        ::BaseGameVersion const&                           baseGameVersion,
        ::IEducationOptions const&                         educationOptions,
        ::ResourcePackManager*                             rpm,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> validator,
        ::IMinecraftEventing&                              eventing
    ) const;
 
    MCNAPI ::Bedrock::NonOwnerPointer<::cereal::ReflectionCtx const> cerealContext() const;
 
    MCNAPI void clearDeadItemRegistry() const;
 
    MCNAPI ::std::vector<::std::reference_wrapper<::HashedString const>> const&
    getComplexAliasSplitNames(::HashedString const& oldName) const;
 
    MCAPI ::Bedrock::NonOwnerPointer<::CreativeItemRegistry> getCreativeItemRegistry();
 
    MCFOLD ::WeakPtr<::Item> getItem(::HashedString const& id) const;
 
    MCAPI ::WeakPtr<::Item> getItem(short itemId) const;
 
    MCAPI ::HashedString getNameFromLegacyID(short id) const;
 
    MCAPI ::std::unordered_map<::HashedString, ::WeakPtr<::Item>> const& getNameToItemMap() const;
 
    MCNAPI ::BaseGameVersion getWorldBaseGameVersion() const;
 
#ifdef LL_PLAT_C
    MCNAPI void initCreativeItemsClient(
        ::CreativeContentPacket const& creativeContentPacket,
        ::BlockPalette const&          blockPalette
    ) const;
#endif
 
    MCNAPI void initCreativeItemsServer(
        ::BlockDefinitionGroup const&                      blockDefinitionGroup,
        ::Experiments const&                               experiment,
        ::ResourcePackManager const&                       resourcePackManager,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> validator,
        ::IMinecraftEventing&                              eventing,
        ::IEducationOptions const&                         educationOptions,
        ::std::function<void(
            ::ItemRegistryRef,
            ::BlockDefinitionGroup const&,
            ::CreativeItemRegistry*,
            ::BaseGameVersion const&,
            ::Experiments const&,
            ::ResourcePackManager const&,
            ::cereal::ReflectionCtx const&,
            ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>,
            ::IMinecraftEventing&,
            ::IEducationOptions const&
        )>                                                 registerCallback
    ) const;
 
    MCNAPI bool isComplexAlias(::HashedString const& oldName) const;
 
    MCNAPI bool isCreativeItem(::ItemInstance const& itemInstance) const;
 
    MCNAPI ::ItemRegistryRef::LockGuard lockItemWorldCompatibilityMutex() const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(::HashedString const& inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(int& outItemAux, ::std::string_view inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(int& outItemId, int& outItemAux, ::std::string_view inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByNameNoAlias(::HashedString const& inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByNameNoAlias(::std::string_view inString) const;
 
    MCNAPI ::WeakPtr<::Item> lookupByNameNoParsing(int& inOutItemAux, ::HashedString const& fullName) const;
 
    MCAPI ::std::unordered_set<::Item const*> lookupByTag(::ItemTag const& tag) const;
 
    MCFOLD ::WeakPtr<::Item> lookupByVanillaName(::HashedString const& inString) const;
 
    MCNAPI void onLevelInit(
        ::WeakRef<::IDynamicContainerSerialization> containerSerialization,
        ::WeakRef<::IContainerRegistryAccess>       containerAccess,
        ::WeakRef<::IContainerRegistryTracker>      containerTracker
    ) const;
 
    MCAPI void
    registerAlias(::HashedString const& alias, ::HashedString const& name, ::BaseGameVersion const& fromVersion) const;
 
    MCNAPI ::WeakPtr<::Item>
    registerComplexAlias(::HashedString const& alias, ::ItemRegistryComplexAlias const& complexAlias) const;
 
    MCNAPI void registerExtraItemInitCallback(::std::function<void(::ItemRegistryRef)> callback) const;
 
    MCNAPI void registerLegacyID(::HashedString const& name, short id) const;
 
    MCNAPI void registerLegacyMapping(
        ::HashedString const&    alias,
        ::HashedString const&    name,
        ::BaseGameVersion const& fromVersion
    ) const;
 
    MCNAPI uint64 remapToLegacyNameByHash(uint64 newHash) const;
 
    MCNAPI void setCheckForItemWorldCompatibility(bool value) const;
 
    MCAPI void unregisterItem(::HashedString const& itemName) const;
    // NOLINTEND
};