decl_composite.hpp

#pragma once
 
#include <vector>
#include <memory>
#include <mutex>
#include <unordered_map>
 
#include "../_cexports/c_core.h"
#include "../_cexports/c_img.h"
 
#include "../_decl/decl_plane_enumerator.hpp"
 
#include "../exception.hpp"
#include "../global.hpp"
#include "../image.hpp"
#include "../buffer.hpp"
#include "../pfnc_buffer.hpp"
#include "../compressed_pfnc_buffer.hpp"
#include "../handle_only.hpp"
#include "../shims/stdvariant.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
    class MultiPartImage;
  }
 
  template <>
  inline HandleGuard<Composite>::HandleGuard(void *handle) noexcept
      : HandleGuard<Composite>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }

  using CompositeVariant = Cvb::variant<ImagePtr, PlanePtr, PlaneEnumeratorPtr, BufferPtr, PFNCBufferPtr,
                                        CompressedPFNCBufferPtr, HandleOnlyPtr>;


  class Composite final
  {
    friend class Driver::MultiPartImage;
 
  public:
    using GuardType = HandleGuard<Composite>;


    static std::unique_ptr<Composite> Create(CompositePurpose purpose = CompositePurpose::Custom)
    {
      return Internal::DoHandleCallObjectOut<class Composite>(
          CVB_CALL_CAPI(CVCCreateComposite(static_cast<CExports::CVCCompositePurpose>(purpose))));
    }
 
  private:
    template <class OTHER>
    explicit Composite(const OTHER &object)
        : Composite(MakeShared(object.Handle()))
    {
    }
 
    explicit Composite(HandleGuard<Composite> &&guard)
        : handle_(std::move(guard))
    {
      if (!CVB_CALL_CAPI(CVCIsComposite(Handle())))
        throw std::runtime_error("composite handle must be an IComposite object");
    }
 
    static HandleGuard<Composite> MakeShared(void *handle) noexcept
    {
      CVB_CALL_CAPI(ShareObject(handle));
      return HandleGuard<Composite>{handle};
    }
 
  public:

    void *Handle() const noexcept
    {
      return handle_.Handle();
    }


    static std::unique_ptr<Composite> FromHandle(HandleGuard<Composite> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::unique_ptr<Composite>(new Composite(std::move(guard)));
    }
 
    template <class T>
    static std::unique_ptr<T> FromHandle(HandleGuard<Composite> &&guard)
    {
      static_assert(std::is_base_of<Composite, T>::value, "CVB: Type must be derived from Composite");
      return FromHandle(std::move(guard));
    }


    template <class T>
    static CompositePtr FromObject(std::shared_ptr<T> object);


    CompositePurpose Purpose() const noexcept
    {
      CExports::CVCCompositePurpose purpose = CExports::CVCCompositePurpose::CVCCP_Custom;
      CVB_CALL_CAPI(CVCCompositeGetPurpose(Handle(), purpose));
      return static_cast<CompositePurpose>(purpose);
    }


    std::unique_ptr<Driver::GenDcDescriptor> GenDCFinalDescriptor() const; // Implementation at detail_gendc_descriptor.hpp to avoid CVCDriver link.


    bool ContainsItem(const CompositeVariant &item) const
    {
      const auto itemHandle = HandleOf(item);
 
      for (auto i = ItemCount() - 1; i >= 0; --i)
      {
        if (itemHandle == HandleOf(ItemAt(i)))
          return true;
      }
      return false;
    }


    int ItemCount() const noexcept
    {
      CExports::cvbdim_t numElements = 0;
      CVB_CALL_CAPI(CVCCompositeGetCount(Handle(), numElements));
      return static_cast<int>(numElements);
    }


    void InsertItemAt(int index, const CompositeVariant &item)
    {
      const auto handle = HandleOf(item);
      Internal::DoResCall(
          [this, index, handle]() { return CVB_CALL_CAPI(CVCCompositeInsertAt(Handle(), index, handle)); });
 
      std::lock_guard<std::mutex> guard{cacheMtx_};
      const auto pos = itemCache_.find(handle);
      if (pos == itemCache_.end())
        itemCache_.emplace_hint(pos, handle, item);
    }


    void PushBackItem(const CompositeVariant &item)
    {
      InsertItemAt(ItemCount(), item);
    }


    CompositeVariant ItemAt(int index) const
    {
      auto item         = MakeWrapperFrom(index);
      const auto handle = HandleOf(item);
 
      std::lock_guard<std::mutex> guard{cacheMtx_};
      const auto pos = itemCache_.find(handle);
      if (pos != itemCache_.end())
        return pos->second;
 
      itemCache_.emplace_hint(pos, handle, item);
      return item;
    }


    void RemoveItemAt(int index)
    {
      const auto item = MakeWrapperFrom(index);
 
      Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVCCompositeRemoveAt(Handle(), index)); });
 
      if (!ContainsItem(item))
      {
        std::lock_guard<std::mutex> guard{cacheMtx_};
        itemCache_.erase(HandleOf(item));
      }
    }
 
  private:
    static void *HandleOf(const CompositeVariant &item)
    {
      return Cvb::visit([](const auto &obj) { return obj->Handle(); }, item);
    }
 
    CompositeVariant MakeWrapperFrom(int index) const;
 
  private:
    HandleGuard<Composite> handle_;
    mutable std::mutex cacheMtx_;
    mutable std::unordered_map<void *, CompositeVariant> itemCache_;
  };
 
  CVB_END_INLINE_NS
}  // namespace Cvb