fdl_collection_helpers.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024-present American Society Of Cinematographers
// SPDX-License-Identifier: Apache-2.0
#ifndef FDL_COLLECTION_HELPERS_H
#define FDL_COLLECTION_HELPERS_H
 
#include "fdl_doc.h"
 
#include <cstdint>
#include <memory>
#include <string_view>
 
namespace fdl::detail {
 
inline uint32_t root_collection_count(fdl_doc_t* doc, const char* key) {
    auto& data = doc->doc.data();
    if (!data.contains(key) || !data[key].is_array()) {
        return 0;
    }
    return static_cast<uint32_t>(data[key].size());
}
 
template<typename HandleT, typename MakeHandleFn, typename GetCacheFn>
HandleT* root_collection_at(
    fdl_doc_t* doc, const char* key, uint32_t index, MakeHandleFn make_handle, GetCacheFn get_cache) {
    auto& data = doc->doc.data();
    if (!data.contains(key) || !data[key].is_array()) {
        return nullptr;
    }
    if (index >= data[key].size()) {
        return nullptr;
    }
 
    auto [vec, map] = get_cache(doc);
    auto it = map.find(index);
    if (it != map.end()) {
        return it->second;
    }
 
    auto handle = make_handle(doc, index);
    auto* ptr = handle.get();
    vec.push_back(std::move(handle));
    map[index] = ptr;
    return ptr;
}
 
template<typename HandleT, typename MakeHandleFn, typename GetCacheFn>
HandleT* root_collection_find(
    fdl_doc_t* doc,
    const char* array_key,
    const char* field_key,
    const char* target,
    MakeHandleFn make_handle,
    GetCacheFn get_cache) {
    auto& data = doc->doc.data();
    if (!data.contains(array_key) || !data[array_key].is_array()) {
        return nullptr;
    }
 
    const std::string_view sv(target);
    auto& arr = data[array_key];
    for (size_t i = 0; i < arr.size(); ++i) {
        auto& elem = arr[i];
        if (elem.contains(field_key) && elem[field_key].is_string() && elem[field_key].as<std::string_view>() == sv) {
            auto index = static_cast<uint32_t>(i);
            auto [vec, map] = get_cache(doc);
            auto it = map.find(index);
            if (it != map.end()) {
                return it->second;
            }
            auto handle = make_handle(doc, index);
            auto* ptr = handle.get();
            vec.push_back(std::move(handle));
            map[index] = ptr;
            return ptr;
        }
    }
    return nullptr;
}
 
inline uint32_t child_collection_count(const jsoncons::ojson* parent_node, const char* key) {
    if (parent_node == nullptr || !parent_node->contains(key) || !(*parent_node)[key].is_array()) {
        return 0;
    }
    return static_cast<uint32_t>((*parent_node)[key].size());
}
 
template<typename HandleT, typename KeyT, typename MakeHandleFn, typename GetCacheFn>
HandleT* child_collection_at(
    const jsoncons::ojson* parent_node,
    const char* key,
    uint32_t index,
    KeyT dedup_key,
    MakeHandleFn make_handle,
    GetCacheFn get_cache) {
    if (parent_node == nullptr || !parent_node->contains(key) || !(*parent_node)[key].is_array()) {
        return nullptr;
    }
    if (index >= (*parent_node)[key].size()) {
        return nullptr;
    }
 
    auto [vec, map] = get_cache();
    auto it = map.find(dedup_key);
    if (it != map.end()) {
        return it->second;
    }
 
    auto handle = make_handle(index);
    auto* ptr = handle.get();
    vec.push_back(std::move(handle));
    map[dedup_key] = ptr;
    return ptr;
}
 
template<typename HandleT, typename MakeKeyFn, typename MakeHandleFn, typename GetCacheFn>
HandleT* child_collection_find(
    const jsoncons::ojson* parent_node,
    const char* array_key,
    const char* field_key,
    const char* target,
    MakeKeyFn make_key,
    MakeHandleFn make_handle,
    GetCacheFn get_cache) {
    if (parent_node == nullptr || !parent_node->contains(array_key) || !(*parent_node)[array_key].is_array()) {
        return nullptr;
    }
 
    const std::string_view sv(target);
    const auto& arr = (*parent_node)[array_key];
    for (size_t i = 0; i < arr.size(); ++i) {
        const auto& elem = arr[i];
        if (elem.contains(field_key) && elem[field_key].is_string() && elem[field_key].as<std::string_view>() == sv) {
            auto index = static_cast<uint32_t>(i);
            auto dedup_key = make_key(index);
            auto [vec, map] = get_cache();
            auto it = map.find(dedup_key);
            if (it != map.end()) {
                return it->second;
            }
            auto handle = make_handle(index);
            auto* ptr = handle.get();
            vec.push_back(std::move(handle));
            map[dedup_key] = ptr;
            return ptr;
        }
    }
    return nullptr;
}
 
} // namespace fdl::detail
 
#endif // FDL_COLLECTION_HELPERS_H