Atmosphere/libraries/libstratosphere/include/stratosphere/ncm/ncm_content_meta_database.hpp

/*
 * Copyright (c) Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
#include <stratosphere/ncm/ncm_i_content_meta_database.hpp>

namespace ams::ncm {

    class ContentMetaDatabase {
        NON_COPYABLE(ContentMetaDatabase);
        public:
            struct ListCount {
                s32 written;
                s32 total;
            };
        private:
            sf::SharedPointer<IContentMetaDatabase> m_interface;
        public:
            ContentMetaDatabase() : m_interface(nullptr) { /* ... */ }
            explicit ContentMetaDatabase(sf::SharedPointer<IContentMetaDatabase> intf) : m_interface(intf) { /* ... */ }

            ContentMetaDatabase(ContentMetaDatabase &&rhs) {
                m_interface = std::move(rhs.m_interface);
            }

            ContentMetaDatabase &operator=(ContentMetaDatabase &&rhs) {
                ContentMetaDatabase(std::move(rhs)).swap(*this);
                return *this;
            }

            void swap(ContentMetaDatabase &rhs) {
                std::swap(m_interface, rhs.m_interface);
            }
        public:
            Result Set(const ContentMetaKey &key, const void *buf, size_t size) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->Set(key, sf::InBuffer(buf, size));
            }

            Result Get(size_t *out_size, void *dst, size_t dst_size, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                u64 size;
                R_TRY(m_interface->Get(std::addressof(size), key, sf::OutBuffer(dst, dst_size)));

                *out_size = size;
                return ResultSuccess();
            }

            #define AMS_NCM_DEFINE_GETTERS(Kind, IdType)                                                                                \
            Result Get##Kind(ContentId *out, IdType##Id id, u32 version) {                                                              \
                return m_interface->GetContentIdByType(out, ContentMetaKey::MakeUnknownType(id.value, version), ContentType::Kind); \
            }                                                                                                                           \
                                                                                                                                        \
            Result GetLatest##Kind(ContentId *out, IdType##Id id) {                                                                     \
                ContentMetaKey latest_key;                                                                                              \
                R_TRY(m_interface->GetLatestContentMetaKey(std::addressof(latest_key), id.value));                                  \
                return m_interface->GetContentIdByType(out, latest_key, ContentType::Kind);                                         \
            }

            AMS_NCM_DEFINE_GETTERS(Program,          Program)
            AMS_NCM_DEFINE_GETTERS(Data,             Data)
            AMS_NCM_DEFINE_GETTERS(Control,          Application)
            AMS_NCM_DEFINE_GETTERS(HtmlDocument,     Application)
            AMS_NCM_DEFINE_GETTERS(LegalInformation, Application)

            #undef AMS_NCM_DEFINE_GETTERS

            Result Remove(const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->Remove(key);
            }

            Result Remove(SystemProgramId id, u32 version) {
                return this->Remove(ContentMetaKey::Make(id, version));
            }

            Result Remove(SystemDataId id, u32 version) {
                return this->Remove(ContentMetaKey::Make(id, version));
            }

            Result Remove(ApplicationId id, u32 version) {
                return this->Remove(ContentMetaKey::Make(id, version));
            }

            Result GetContentIdByType(ContentId *out_content_id, const ContentMetaKey &key, ContentType type) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetContentIdByType(out_content_id, key, type);
            }

            Result GetContentIdByTypeAndIdOffset(ContentId *out_content_id, const ContentMetaKey &key, ContentType type, u8 id_offset) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetContentIdByTypeAndIdOffset(out_content_id, key, type, id_offset);
            }

            ListCount ListApplication(ApplicationContentMetaKey *dst, size_t dst_size) {
                ListCount lc = {};
                R_ABORT_UNLESS(m_interface->ListApplication(std::addressof(lc.total), std::addressof(lc.written), sf::OutArray<ApplicationContentMetaKey>(dst, dst_size), ContentMetaType::Unknown));
                return lc;
            }

            ListCount ListContentMeta(ContentMetaKey *dst, size_t dst_size, ContentMetaType type = ContentMetaType::Unknown, ApplicationId app_id = InvalidApplicationId, u64 min = std::numeric_limits<u64>::min(), u64 max = std::numeric_limits<u64>::max(), ContentInstallType install_type = ContentInstallType::Full) {
                ListCount lc = {};
                R_ABORT_UNLESS(m_interface->List(std::addressof(lc.total), std::addressof(lc.written), sf::OutArray<ContentMetaKey>(dst, dst_size), type, app_id, min, max, install_type));
                return lc;
            }

            Result GetLatest(ContentMetaKey *out_key, u64 id) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetLatestContentMetaKey(out_key, id);
            }

            Result ListContentInfo(s32 *out_count, ContentInfo *dst, size_t dst_size, const ContentMetaKey &key, s32 offset) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->ListContentInfo(out_count, sf::OutArray<ContentInfo>(dst, dst_size), key, offset);
            }

            Result ListContentMetaInfo(s32 *out_count, ContentMetaInfo *dst, size_t dst_size, const ContentMetaKey &key, s32 offset) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->ListContentMetaInfo(out_count, sf::OutArray<ContentMetaInfo>(dst, dst_size), key, offset);
            }

            Result Has(bool *out, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->Has(out, key);
            }

            Result HasAll(bool *out, const ContentMetaKey *keys, size_t num_keys) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->HasAll(out, sf::InArray<ContentMetaKey>(keys, num_keys));
            }

            Result HasContent(bool *out, const ContentMetaKey &key, const ContentId &content_id) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->HasContent(out, key, content_id);
            }

            Result GetSize(size_t *out_size, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                u64 size;
                R_TRY(m_interface->GetSize(std::addressof(size), key));

                *out_size = size;
                return ResultSuccess();
            }

            Result GetRequiredSystemVersion(u32 *out_version, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetRequiredSystemVersion(out_version, key);
            }

            Result GetPatchId(PatchId *out_patch_id, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetPatchId(out_patch_id, key);
            }

            Result DisableForcibly() {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->DisableForcibly();
            }

            Result LookupOrphanContent(bool *out_orphaned, ContentId *content_list, size_t count) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->LookupOrphanContent(sf::OutArray<bool>(out_orphaned, count), sf::InArray<ContentId>(content_list, count));
            }

            Result Commit() {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->Commit();
            }

            Result GetAttributes(u8 *out_attributes, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetAttributes(out_attributes, key);
            }

            Result GetRequiredApplicationVersion(u32 *out_version, const ContentMetaKey &key) {
                AMS_ASSERT(m_interface != nullptr);
                return m_interface->GetRequiredApplicationVersion(out_version, key);
            }
    };

}