ContentManagerFactoryImpl.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/client/gui/screens/models/ContentFlags.h"
#include "mc/client/gui/screens/models/ContentManagerFactoryArgs.h"
#include "mc/client/gui/screens/models/ContentType.h"
#include "mc/client/gui/screens/models/IContentManagerFactory.h"
#include "mc/client/gui/screens/models/IPackManagerContentQueries.h"
#include "mc/client/resources/ContentCatalogPackSource.h"
#include "mc/deps/core/file/PathBuffer.h"
#include "mc/deps/core/resource/PackOrigin.h"
#include "mc/deps/core/resource/PackType.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
 
// auto generated forward declare list
// clang-format off
class AppPlatform;
class CachedHostPackIdProvider;
class CompositePackSource;
class ContentTierInfo;
class IContentTierManager;
class Pack;
class PackSource;
class StoreCatalogRepository;
struct ContentSource;
struct InvalidPacksFilterGroup;
struct InvalidResourceSource;
struct PackManagerContentSourceArgs;
struct PackManagerContentSourceData;
struct RealmsUnknownPackSources;
struct WorldContentSource;
struct WorldTemplateSource;
namespace ContentManagerUtils { class ISourcesAsyncReloader; }
namespace Core { class Path; }
namespace Realms { class RealmsServicePackSource; }
namespace Realms { struct Content; }
namespace Realms { struct RealmId; }
namespace mce { class UUID; }
// clang-format on
 
class ContentManagerFactoryImpl : public ::IContentManagerFactory {
public:
    // ContentManagerFactoryImpl inner types declare
    // clang-format off
    class PackManagerContentQueriesImpl;
    // clang-format on
 
    // ContentManagerFactoryImpl inner types define
    class PackManagerContentQueriesImpl : public ::IPackManagerContentQueries {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::StoreCatalogRepository>>       mStoreCatalog;
        ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const>> mContentTierManager;
        // NOLINTEND
 
    public:
        // virtual functions
        // NOLINTBEGIN
        virtual ::ContentTierInfo getContentTierInfo() const /*override*/;
 
        virtual ::std::string const*
        getStoreCatalogItemAvailableDateByPackIdentityAndType(::mce::UUID const& uuid) const /*override*/;
        // NOLINTEND
 
    public:
        // virtual function thunks
        // NOLINTBEGIN
        MCNAPI ::ContentTierInfo $getContentTierInfo() const;
 
        MCNAPI ::std::string const*
        $getStoreCatalogItemAvailableDateByPackIdentityAndType(::mce::UUID const& uuid) const;
        // NOLINTEND
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 184, ::ContentManagerFactoryArgs> mArgs;
    // NOLINTEND
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ::std::unique_ptr<::WorldContentSource> createWorldContentSource() const /*override*/;
 
    virtual ::std::unique_ptr<::WorldTemplateSource> createWorldTemplateSource() const /*override*/;
 
    virtual ::std::unique_ptr<::InvalidResourceSource>
    createInvalidResourceSource(::InvalidPacksFilterGroup const& filter) const /*override*/;
 
    virtual ::std::unique_ptr<::ContentSource> createWorldPackManagerContentSource(
        ::std::string const&                            worldID,
        ::Core::PathBuffer<::std::string>               worldPath,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data,
        ::std::weak_ptr<::CachedHostPackIdProvider>     provider
    ) const /*override*/;
 
    virtual ::std::unique_ptr<::ContentSource> createRealmPackManagerContentSource(
        int64                                           realmID,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const /*override*/;
 
    virtual ::std::unique_ptr<::ContentSource> createRealmsWorldPackManagerContentSource(
        ::Realms::RealmId                               realmId,
        ::std::vector<::Realms::Content>&&              serviceAppliedContent,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const /*override*/;
 
    virtual ::std::unique_ptr<::ContentSource> createPackManagerContentSource(
        ::ContentType                                   type,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const /*override*/;
 
    virtual ::std::unique_ptr<::CompositePackSource>
    createCompositePackSource(::std::vector<::PackSource*> sources) const /*override*/;
 
    virtual ::PackSource* getInPackagePackSource(::PackType type) const /*override*/;
 
    virtual ::PackSource* getDirectoryPackSource(::Core::Path const& path, ::PackType type) const /*override*/;
 
    virtual ::PackSource&
    createDirectoryPackSource(::Core::Path const& path, ::PackType type, ::PackOrigin origin) const /*override*/;
 
    virtual ::PackSource&
    createWorldTemplatePackSource(::mce::UUID const& id, ::PackType type, ::PackOrigin origin) const /*override*/;
 
    virtual ::ContentCatalogPackSource& createContentCatalogPackSource(
        ::std::weak_ptr<::ContentManagerUtils::ISourcesAsyncReloader>&& weakSourcesAsyncReloader,
        bool                                                            enabled
    ) const /*override*/;
 
    virtual ::PackSource& createWorldHistoryPackSource(::Core::Path const& path, ::PackType type) const /*override*/;
 
    virtual ::RealmsUnknownPackSources& getRealmsUnknownPackSources() const /*override*/;
 
    virtual ::std::unique_ptr<::Realms::RealmsServicePackSource> createRealmsServicePackSource(
        int64                                                       realmId,
        ::PackType                                                  packType,
        ::std::vector<::gsl::not_null<::std::shared_ptr<::Pack>>>&& servicePackData
    ) const /*override*/;
 
    virtual ::Bedrock::Threading::Async<void> refreshPacksAsync() const /*override*/;
 
    virtual bool allowsResourcePackDevelopment() const /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::AppPlatform> getPlatform() const /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI ::PackManagerContentSourceArgs createPackManagerArgs(
        ::ContentType                                   type,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const;
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI ::std::unique_ptr<::WorldContentSource> $createWorldContentSource() const;
 
    MCNAPI ::std::unique_ptr<::WorldTemplateSource> $createWorldTemplateSource() const;
 
    MCNAPI ::std::unique_ptr<::InvalidResourceSource>
    $createInvalidResourceSource(::InvalidPacksFilterGroup const& filter) const;
 
    MCNAPI ::std::unique_ptr<::ContentSource> $createWorldPackManagerContentSource(
        ::std::string const&                            worldID,
        ::Core::PathBuffer<::std::string>               worldPath,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data,
        ::std::weak_ptr<::CachedHostPackIdProvider>     provider
    ) const;
 
    MCNAPI ::std::unique_ptr<::ContentSource> $createRealmPackManagerContentSource(
        int64                                           realmID,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const;
 
    MCNAPI ::std::unique_ptr<::ContentSource> $createRealmsWorldPackManagerContentSource(
        ::Realms::RealmId                               realmId,
        ::std::vector<::Realms::Content>&&              serviceAppliedContent,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const;
 
    MCNAPI ::std::unique_ptr<::ContentSource> $createPackManagerContentSource(
        ::ContentType                                   type,
        ::ContentFlags                                  flags,
        ::std::vector<::PackManagerContentSourceData>&& data
    ) const;
 
    MCNAPI ::std::unique_ptr<::CompositePackSource>
    $createCompositePackSource(::std::vector<::PackSource*> sources) const;
 
    MCNAPI ::PackSource* $getInPackagePackSource(::PackType type) const;
 
    MCNAPI ::PackSource* $getDirectoryPackSource(::Core::Path const& path, ::PackType type) const;
 
    MCNAPI ::PackSource&
    $createDirectoryPackSource(::Core::Path const& path, ::PackType type, ::PackOrigin origin) const;
 
    MCNAPI ::PackSource&
    $createWorldTemplatePackSource(::mce::UUID const& id, ::PackType type, ::PackOrigin origin) const;
 
    MCNAPI ::ContentCatalogPackSource& $createContentCatalogPackSource(
        ::std::weak_ptr<::ContentManagerUtils::ISourcesAsyncReloader>&& weakSourcesAsyncReloader,
        bool                                                            enabled
    ) const;
 
    MCNAPI ::PackSource& $createWorldHistoryPackSource(::Core::Path const& path, ::PackType type) const;
 
    MCNAPI ::RealmsUnknownPackSources& $getRealmsUnknownPackSources() const;
 
    MCNAPI ::std::unique_ptr<::Realms::RealmsServicePackSource> $createRealmsServicePackSource(
        int64                                                       realmId,
        ::PackType                                                  packType,
        ::std::vector<::gsl::not_null<::std::shared_ptr<::Pack>>>&& servicePackData
    ) const;
 
    MCNAPI ::Bedrock::Threading::Async<void> $refreshPacksAsync() const;
 
    MCNAPI bool $allowsResourcePackDevelopment() const;
 
    MCNAPI ::Bedrock::NonOwnerPointer<::AppPlatform> $getPlatform() const;
    // NOLINTEND
};