IIndex.h

#pragma once
 
#include "IAsyncContext.h"
#include "IDescriptor.h"
 
namespace fsdk {
    
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
        DECLARE_SMARTPTR(IStaticDescriptorStorage);
        DECLARE_SMARTPTR(IDynamicDescriptorStorage);
        DECLARE_SMARTPTR(IIndex);
        DECLARE_SMARTPTR(IDenseIndex);
        DECLARE_SMARTPTR(IDynamicIndex);
        DECLARE_SMARTPTR(IIndexBuilder);
    #endif
    
    using DescriptorId = size_t;
    
    struct SearchResult : MatchingResult {
        DescriptorId index;
 
        SearchResult() noexcept
            : MatchingResult()
            , index(std::numeric_limits<DescriptorId>::max())
        {}
 
        SearchResult(
            float distance,
            float similarity,
            DescriptorId index) noexcept
            : MatchingResult(distance, similarity)
            , index(index)
        {}
    };
 
    struct IStaticDescriptorStorage {
        virtual Result<FSDKError> descriptorByIndex(
            const DescriptorId index,
            IDescriptor* descriptor) const noexcept = 0;
        
        virtual uint64_t size() const noexcept = 0;
    };
    
    struct IDynamicDescriptorStorage
    : IStaticDescriptorStorage {
        virtual ResultValue<FSDKError, DescriptorId> appendDescriptor(
            const IDescriptor* desciptor) noexcept = 0;
        
        virtual ResultValue<FSDKError, DescriptorId> appendBatch(
            const IDescriptorBatch* batch) noexcept = 0;
        
        virtual Result<FSDKError> removeDescriptor(const DescriptorId index) noexcept = 0;
    };
    
    struct IIndex
    : IRefCounted {
        virtual ResultValue<FSDKError, int> search(
            const IDescriptor* reference,
            int maxResultsCount,
            SearchResult* results) const noexcept = 0;
    };
    
    struct IDenseIndex
    : IStaticDescriptorStorage
    , IIndex {
        
    };
    
    struct IDynamicIndex
    : IDynamicDescriptorStorage
    , IIndex {
        virtual Result<FSDKError> saveToDenseIndex(const char* path) const noexcept = 0;
        
        virtual Result<FSDKError> saveToDynamicIndex(const char* path) const noexcept = 0;
        
        virtual uint64_t countOfIndexedDescriptors() const noexcept = 0;
    };
 
    struct IProgressTracker {
        virtual void progress(const float completion) const noexcept = 0;
    };
    
    struct IIndexBuilder
    : IDynamicDescriptorStorage
    , IRefCounted {
        virtual ResultValue<FSDKError, IDynamicIndex*> buildIndex(
            const IProgressTracker* const progressTracker = nullptr) noexcept = 0;
        
        virtual ResultValue<FSDKError, Future<ResultValue<FSDKError, IDynamicIndex*>>>
        buildIndexAsync(
            IAsyncContext* const asyncContext,
            const IProgressTracker* const progressTracker = nullptr) noexcept = 0;
    };
 
 
}