meta_data.hpp

#pragma once
 
#include <memory>
 
#include "../global.hpp"
#include "../_cexports/c_img.h"
#include "../string.hpp"
#include "../_cexports/c_spectral.h"
#include "spectral.hpp"
#include "../exception.hpp"
#include <cctype>
#include <algorithm>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<Spectral::MetaData>::HandleGuard(void *handle) noexcept
      : HandleGuard<Spectral::MetaData>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Spectral
  {


    class MetaData final
    {
    public:
      MetaData(const MetaData &other) noexcept   = delete;
      MetaData &operator=(const MetaData &other) = delete;
      MetaData(MetaData &&other) noexcept        = default;
      MetaData &operator=(MetaData &&other)      = default;
      ~MetaData()                                = default;


      template <class T>
      T ReadField(const FieldID &fieldId) const
      {
        T val;
        GetField(fieldId, val);
        return val;
      }
      T ReadField(const FieldID &fieldId) const {…}


      template <class T>
      void WriteField(FieldID fieldId, const T &value)
      {
        WriteFieldTyped(fieldId, value);
      }
      void WriteField(FieldID fieldId, const T &value) {…}


      String FieldNameAsString(FieldID fieldId) const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetFieldnameAsStringTyped(
            handle_.Handle(), static_cast<CExports::CVSField>(fieldId), reinterpret_cast<Char *>(NULL), sz));
        std::vector<Char> cvbVal(sz);
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetFieldnameAsStringTyped(
            handle_.Handle(), static_cast<CExports::CVSField>(fieldId), cvbVal.data(), sz));
        return String(cvbVal.data());
      }
      String FieldNameAsString(FieldID fieldId) const {…}


      Spectral::FieldType FieldType(FieldID fieldId) const
      {
        auto fieldType = CFieldType(fieldId);
        return static_cast<Spectral::FieldType>(fieldType);
      }
      Spectral::FieldType FieldType(FieldID fieldId) const {…}


      int NumberOfFields() const
      {
        auto valOut = Internal::DoResCallValueOut<size_t>(
            [&](size_t &val) { return CVB_CALL_CAPI(CVSMetaDataGetNumberOfFields(handle_.Handle(), val)); });
        return static_cast<int>(valOut);
      }
      int NumberOfFields() const {…}


      void ClearField(FieldID fieldId)
      {
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVSMetaDataClearField(handle_.Handle(), static_cast<CExports::CVSField>(fieldId)));
        });
      }
      void ClearField(FieldID fieldId) {…}


      bool IsFieldDefined(FieldID fieldId)
      {
        auto valOut = Internal::DoResCallValueOut<CExports::cvbbool_t>([&](CExports::cvbbool_t &isDefined) {
          return CVB_CALL_CAPI(
              CVSMetaDataIsFieldDefined(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), isDefined));
        });
        return valOut ? true : false;
      }
      bool IsFieldDefined(FieldID fieldId) {…}


      int Samples() const
      {
        return ReadField<int>(FieldID::Samples);
      }
      int Samples() const {…}


      int Lines() const
      {
        return ReadField<int>(FieldID::Lines);
      }
      int Lines() const {…}


      int Bands() const
      {
        return ReadField<int>(FieldID::Bands);
      }
      int Bands() const {…}


      CubeEncoding InterleavedType() const
      {
        auto interleaveStr = ReadField<String>(FieldID::Interleave);
        std::transform(interleaveStr.begin(), interleaveStr.end(), interleaveStr.begin(),
                       [](String::value_type ch) { return static_cast<String::value_type>(std::toupper(ch)); });
        if (interleaveStr == CVB_LIT("BIL"))
          return CubeEncoding::BandInterleavedByLine;
        if (interleaveStr == CVB_LIT("BSQ"))
          return CubeEncoding::BandSequential;
        if (interleaveStr == CVB_LIT("BIP"))
          return CubeEncoding::BandInterleavedByPixel;
 
        throw std::runtime_error("Unknown interleaved type");
      }
      CubeEncoding InterleavedType() const {…}


      std::vector<double> Wavelengths() const
      {
        return ReadField<std::vector<double>>(FieldID::Wavelength);
      }
      std::vector<double> Wavelengths() const {…}


      static std::unique_ptr<MetaData> Create()
      {
        return Internal::DoResCallObjectOut<MetaData>(
            [&](void *&metaDataOut) { return CVB_CALL_CAPI(CVSCreateMetaData(metaDataOut)); });
      }
      static std::unique_ptr<MetaData> Create() {…}


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


      static std::unique_ptr<MetaData> FromHandle(HandleGuard<MetaData> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
        return std::unique_ptr<MetaData>(new MetaData(std::move(guard)));
      }
      static std::unique_ptr<MetaData> FromHandle(HandleGuard<MetaData> &&guard) {…}
 
    private:
      explicit MetaData(HandleGuard<MetaData> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      void GetField(FieldID fieldId, int &valueOut) const
      {
        CExports::cvbint64_t cvbVal = 0;
        CVB_CALL_CAPI_CHECKED(
            CVSMetaDataGetAsInteger(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), cvbVal));
        valueOut = static_cast<int>(cvbVal);
      }
 
      void GetField(FieldID fieldId, double &valueOut) const
      {
        double cvbVal = 0;
        CVB_CALL_CAPI_CHECKED(
            CVSMetaDataGetAsFloat(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), cvbVal));
        valueOut = std::move(cvbVal);
      }
 
      void GetField(FieldID fieldId, String &valueOut) const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetAsStringTyped(handle_.Handle(), static_cast<CExports::CVSField>(fieldId),
                                                          reinterpret_cast<char *>(NULL), sz));
        std::vector<char> cvbVal(sz);
        CVB_CALL_CAPI_CHECKED(
            CVSMetaDataGetAsStringTyped(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), cvbVal.data(), sz));
        std::string str(cvbVal.data());
        valueOut = String(str.begin(), str.end());
      }
 
      void GetField(FieldID fieldId, std::vector<int> &valueOut) const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetArraySize(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), sz));
        std::vector<int> cvbVal(sz);
        for (CExports::cvbval_t i = 0; i < static_cast<CExports::cvbval_t>(sz); ++i)
        {
          CExports::cvbint64_t cvbElement = 0;
          CVB_CALL_CAPI_CHECKED(
              CVSMetaDataGetAsIntegerArray(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), i, cvbElement));
          cvbVal.at(i) = static_cast<int>(cvbElement);
        }
        valueOut = std::move(cvbVal);
      }
 
      void GetField(FieldID fieldId, std::vector<double> &valueOut) const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetArraySize(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), sz));
        std::vector<double> cvbVal(sz);
        for (CExports::cvbval_t i = 0; i < static_cast<CExports::cvbval_t>(sz); ++i)
        {
          double cvbElement = 0;
          CVB_CALL_CAPI_CHECKED(
              CVSMetaDataGetAsFloatArray(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), i, cvbElement));
          cvbVal.at(i) = static_cast<double>(cvbElement);
        }
        valueOut = std::move(cvbVal);
      }
 
      void GetField(FieldID fieldId, std::vector<String> &valueOut) const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSMetaDataGetArraySize(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), sz));
        std::vector<String> cvbVal(sz);
 
        for (CExports::cvbval_t i = 0; i < static_cast<CExports::cvbval_t>(sz); ++i)
        {
          size_t szString = 0;
          CVB_CALL_CAPI_CHECKED(CVSMetaDataGetAsStringArrayTyped(
              handle_.Handle(), static_cast<CExports::CVSField>(fieldId), i, reinterpret_cast<char *>(NULL), szString));
          std::vector<char> cvbElement(szString);
          CVB_CALL_CAPI_CHECKED(CVSMetaDataGetAsStringArrayTyped(
              handle_.Handle(), static_cast<CExports::CVSField>(fieldId), i, cvbElement.data(), szString));
          std::string tmpStr(cvbElement.data());
          cvbVal.at(i) = String(tmpStr.begin(), tmpStr.end());
        }
 
        valueOut = std::move(cvbVal);
      }
 
      void WriteFieldTyped(FieldID fieldId, const int &value)
      {
        CVB_CALL_CAPI_CHECKED(CVSMetaDataSetAsInteger(handle_.Handle(), static_cast<CExports::CVSField>(fieldId),
                                                      static_cast<CExports::cvbint64_t>(value)));
      }
 
      void WriteFieldTyped(FieldID fieldId, const double &value)
      {
        CVB_CALL_CAPI_CHECKED(CVSMetaDataSetAsFloat(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), value));
      }
 
      void WriteFieldTyped(FieldID fieldId, const String &value)
      {
        CVB_CALL_CAPI_CHECKED(
            CVSMetaDataSetAsStringTyped(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), value.c_str()));
      }
 
      void WriteFieldTyped(FieldID fieldId, const std::vector<int> &value)
      {
        CVB_CALL_CAPI_CHECKED(CVSMetaDataClearField(handle_.Handle(), static_cast<CExports::CVSField>(fieldId)));
        for (auto e : value)
          CVB_CALL_CAPI_CHECKED(CVSMetaDataAddToIntegerArray(handle_.Handle(), static_cast<CExports::CVSField>(fieldId),
                                                             static_cast<CExports::cvbint64_t>(e)));
      }
 
      void WriteFieldTyped(FieldID fieldId, const std::vector<double> &value)
      {
        CVB_CALL_CAPI_CHECKED(CVSMetaDataClearField(handle_.Handle(), static_cast<CExports::CVSField>(fieldId)));
        for (auto e : value)
          CVB_CALL_CAPI_CHECKED(CVSMetaDataAddToFloatArray(handle_.Handle(), static_cast<CExports::CVSField>(fieldId),
                                                           static_cast<double>(e)));
      }
 
      void WriteFieldTyped(FieldID fieldId, const std::vector<String> &value)
      {
        CVB_CALL_CAPI_CHECKED(CVSMetaDataClearField(handle_.Handle(), static_cast<CExports::CVSField>(fieldId)));
        for (auto e : value)
          CVB_CALL_CAPI_CHECKED(
              CVSMetaDataAddToStringArrayTyped(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), e.c_str()));
      }


      CExports::CVSFieldType CFieldType(FieldID fieldId) const
      {
        return Internal::DoResCallValueOut<CExports::CVSFieldType>([&](CExports::CVSFieldType &val) {
          return CVB_CALL_CAPI(
              CVSMetaDataGetFieldType(handle_.Handle(), static_cast<CExports::CVSField>(fieldId), val));
        });
      }
 
    private:
      HandleGuard<MetaData> handle_;
    };
    class MetaData final {…};
  }  // namespace Spectral
 
  using Spectral::MetaData;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb