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:


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



      template<class T>
      void WriteField(FieldID fieldId, const T& value)
      {
        WriteFieldTyped(fieldId, 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());
      }


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


      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);
      }


      void ClearField(FieldID fieldId)
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CVSMetaDataClearField(handle_.Handle(),
            static_cast<CExports::CVSField>(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;
      }


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


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


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


      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 Cvb::CvbException::FromCvbResult(CExports::CVC_E_NOTSUPPORTED, "Unknown interleaved type");
      }


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



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


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


      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)));
      }


    private:
      MetaData(HandleGuard<MetaData>&& guard) noexcept
        : handle_(std::move(guard))
      {
      }

      MetaData(MetaData && other) noexcept
        : handle_(std::move(other.handle_))
      {
      }

      MetaData & operator=(MetaData && other) = default;


      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_;


    };
  }

using Spectral::MetaData;

CVB_END_INLINE_NS

}