IDocumentMetadata.h

// SPDX-FileCopyrightText: 2023 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <cstdint>
#include <string>
#include <variant>
#include <functional>
#include <limits>
#include <optional>
#include <type_traits>
#include "types.h"
 
namespace imgdoc2
{
    enum class DocumentMetadataType : std::uint8_t
    {
        kInvalid = 0,
 
        kDefault,
 
        kNull,
 
        kText,
 
        kInt32,
 
        kJson,
 
        kDouble
    };
 
    class IDocumentMetadata
    {
    public:
        typedef std::variant<std::string, std::int32_t, double, std::monostate> metadata_item_variant;
 
        virtual ~IDocumentMetadata() = default;
 
        // no copy and no move (-> https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c21-if-you-define-or-delete-any-copy-move-or-destructor-function-define-or-delete-them-all )
        IDocumentMetadata() = default;
        IDocumentMetadata(const IDocumentMetadata&) = delete;             // copy constructor
        IDocumentMetadata& operator=(const IDocumentMetadata&) = delete;  // copy assignment
        IDocumentMetadata(IDocumentMetadata&&) = delete;                  // move constructor
        IDocumentMetadata& operator=(IDocumentMetadata&&) = delete;       // move assignment
    };
 
    enum class DocumentMetadataItemFlags : std::uint8_t
    {
        None = 0,               
        kPrimaryKeyValid = 1,   
        kNameValid = 2,         
        kDocumentMetadataTypeAndValueValid = 4,  
        kCompletePath = 8,      
 
        kAll = kPrimaryKeyValid | kNameValid | kDocumentMetadataTypeAndValueValid,
        kAllWithCompletePath = kAll | kCompletePath
    };
 
    inline constexpr DocumentMetadataItemFlags operator|(DocumentMetadataItemFlags x, DocumentMetadataItemFlags y)
    {
        return static_cast<DocumentMetadataItemFlags>(static_cast<std::underlying_type_t<DocumentMetadataItemFlags>>(x) | static_cast<std::underlying_type_t<DocumentMetadataItemFlags>>(y));
    }
 
    inline constexpr DocumentMetadataItemFlags operator&(DocumentMetadataItemFlags x, DocumentMetadataItemFlags y)
    {
        return static_cast<DocumentMetadataItemFlags>(static_cast<std::underlying_type_t<DocumentMetadataItemFlags>>(x) & static_cast<std::underlying_type_t<DocumentMetadataItemFlags>>(y));
    }
 
    inline constexpr DocumentMetadataItemFlags operator~(DocumentMetadataItemFlags x)
    {
        return static_cast<DocumentMetadataItemFlags>(~static_cast<std::underlying_type_t<DocumentMetadataItemFlags>>(x));
    }
 
    struct DocumentMetadataItem
    {
        DocumentMetadataItemFlags flags{ DocumentMetadataItemFlags::None };             
        imgdoc2::dbIndex primary_key{ std::numeric_limits<imgdoc2::dbIndex>::max() };   
        std::string name;                                                               
        std::string complete_path;                                                      
        DocumentMetadataType type{ DocumentMetadataType::kInvalid };                    
        IDocumentMetadata::metadata_item_variant value;                                 
    };
 
    class IDocumentMetadataRead : public IDocumentMetadata
    {
    public:
        ~IDocumentMetadataRead() override = default;
 
        virtual imgdoc2::DocumentMetadataItem GetItem(imgdoc2::dbIndex primary_key, DocumentMetadataItemFlags flags) = 0;
 
        virtual imgdoc2::DocumentMetadataItem GetItemForPath(const std::string& path, imgdoc2::DocumentMetadataItemFlags flags) = 0;
 
        virtual void EnumerateItems(
            std::optional<imgdoc2::dbIndex> parent,
            bool recursive,
            DocumentMetadataItemFlags flags,
            const std::function<bool(imgdoc2::dbIndex, const DocumentMetadataItem& item)>& func) = 0;
 
        virtual void EnumerateItemsForPath(
            const std::string& path,
            bool recursive,
            DocumentMetadataItemFlags flags,
            const std::function<bool(imgdoc2::dbIndex, const DocumentMetadataItem& item)>& func) = 0;
 
        // no copy and no move (-> https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c21-if-you-define-or-delete-any-copy-move-or-destructor-function-define-or-delete-them-all )
        IDocumentMetadataRead() = default;
        IDocumentMetadataRead(const IDocumentMetadataRead&) = delete;             // copy constructor
        IDocumentMetadataRead& operator=(const IDocumentMetadataRead&) = delete;  // copy assignment
        IDocumentMetadataRead(IDocumentMetadataRead&&) = delete;                  // move constructor
        IDocumentMetadataRead& operator=(IDocumentMetadataRead&&) = delete;       // move assignment
    };
 
    class IDocumentMetadataWrite : public IDocumentMetadata
    {
    public:
        ~IDocumentMetadataWrite() override = default;
 
        virtual imgdoc2::dbIndex UpdateOrCreateItem(
                    std::optional<imgdoc2::dbIndex> parent,
                    bool create_node_if_not_exists,
                    const std::string& name,
                    DocumentMetadataType type,
                    const IDocumentMetadata::metadata_item_variant& value) = 0;
 
        virtual imgdoc2::dbIndex UpdateOrCreateItemForPath(
            bool create_path_if_not_exists,
            bool create_node_if_not_exists,
            const std::string& path,
            DocumentMetadataType type,
            const IDocumentMetadata::metadata_item_variant& value) = 0;
 
        virtual std::uint64_t DeleteItem(
                    std::optional<imgdoc2::dbIndex> primary_key,
                    bool recursively) = 0;
 
        virtual std::uint64_t DeleteItemForPath(
                   const std::string& path,
                   bool recursively) = 0;
 
        // no copy and no move (-> https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c21-if-you-define-or-delete-any-copy-move-or-destructor-function-define-or-delete-them-all )
        IDocumentMetadataWrite() = default;
        IDocumentMetadataWrite(const IDocumentMetadataWrite&) = delete;             // copy constructor
        IDocumentMetadataWrite& operator=(const IDocumentMetadataWrite&) = delete;  // copy assignment
        IDocumentMetadataWrite(IDocumentMetadataWrite&&) = delete;                  // move constructor
        IDocumentMetadataWrite& operator=(IDocumentMetadataWrite&&) = delete;       // move assignment
    };
}