wrapped_cube.hpp

#pragma once
 
#include <memory>
 
#include "../global.hpp"
#include "../_cexports/c_img.h"
#include "cube.hpp"
 
 
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
    template <>
  inline HandleGuard<Spectral::WrappedCube>::HandleGuard(void * handle) noexcept
    : HandleGuard<Spectral::WrappedCube>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Spectral
  {
    class WrappedCube
      : public Cube
    {
    public:
 
 
      static std::unique_ptr<WrappedCube> Create(void* pBase,
        int numSamples, int numLines, int numBands, Cvb::DataType datatype, 
        intptr_t sampleInc, intptr_t lineInc, intptr_t bandInc)
      {
        std::vector<CExports::cvbdim_t> dimensions = { numSamples, numLines, numBands };
        std::vector<intptr_t> increments = { sampleInc, lineInc, bandInc };
        return Internal::DoResCallObjectOut<WrappedCube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSCreateCubeFromPointer(pBase,
            dimensions.data(), datatype.NativeDescriptor(),
            increments.data(),
            [](void *, void *) {}, nullptr,
            cubeOut));
        });
      }
 
 
 
      void* Handle() const noexcept
      {
        return this->Handle();
      }
 
 
 
      static std::unique_ptr<WrappedCube> FromHandle(HandleGuard<WrappedCube>&& guard)
      {
        return std::unique_ptr<WrappedCube>(new WrappedCube(std::move(HandleGuard<Cube>(guard.Release()))));
      }
 
 
    protected:
      WrappedCube(HandleGuard<Cube>&& guard) noexcept
        : Cube(std::move(guard))
      {
      }
 
      WrappedCube(WrappedCube && other) noexcept
        : Cube(HandleGuard<Cube>(std::move(other.Handle())))
      {
      }
 
      WrappedCube & operator=(WrappedCube && other) = default;
    };
 
 
 
  }
 
  using Spectral::WrappedCube;
 
  CVB_END_INLINE_NS
}