types.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
 
#ifndef LIBZARR_TYPES_HPP
#define LIBZARR_TYPES_HPP
 
#include <cassert>
#include <cstdint>
#include <stdexcept>
#include <vector>
 
 
// Macros, not constants: consumers need these preprocessor-testable.
// NOLINTBEGIN(modernize-macro-to-enum,cppcoreguidelines-macro-to-enum)
#define LIBZARR_VERSION_MAJOR 1
#define LIBZARR_VERSION_MINOR 0
#define LIBZARR_VERSION_PATCH 0
// NOLINTEND(modernize-macro-to-enum,cppcoreguidelines-macro-to-enum)
 
#define LIBZARR_DEPRECATED(msg) [[deprecated(msg)]]
 
namespace zarr {
 
class error : public std::runtime_error {
 public:
  using std::runtime_error::runtime_error;
};
 
using Bytes = std::vector<std::uint8_t>;
 
enum class ZarrFormat : std::uint8_t {
  v2 = 2,
  v3 = 3,
};
 
enum class DType : std::uint8_t {
  boolean,
  int8,
  int16,
  int32,
  int64,
  uint8,
  uint16,
  uint32,
  uint64,
  float16,
  float32,
  float64,
  complex64,
  complex128,
  raw,
};
 
[[nodiscard]] constexpr bool is_float(DType kind) {
  return kind == DType::float16 || kind == DType::float32 || kind == DType::float64;
}
 
[[nodiscard]] constexpr bool is_signed_int(DType kind) {
  return kind == DType::int8 || kind == DType::int16 || kind == DType::int32 ||
         kind == DType::int64;
}
 
[[nodiscard]] constexpr bool is_unsigned_int(DType kind) {
  return kind == DType::uint8 || kind == DType::uint16 || kind == DType::uint32 ||
         kind == DType::uint64;
}
 
[[nodiscard]] constexpr bool is_complex(DType kind) {
  return kind == DType::complex64 || kind == DType::complex128;
}
 
[[nodiscard]] constexpr std::uint32_t fixed_itemsize(DType kind) {
  switch (kind) {
    case DType::boolean:
    case DType::int8:
    case DType::uint8:
      return 1;
    case DType::int16:
    case DType::uint16:
    case DType::float16:
      return 2;
    case DType::int32:
    case DType::uint32:
    case DType::float32:
      return 4;
    case DType::int64:
    case DType::uint64:
    case DType::float64:
    case DType::complex64:
      return 8;
    case DType::complex128:
      return 16;
    case DType::raw:
      return 0;
  }
  return 0;  // unreachable; keeps compilers satisfied
}
 
struct DataType {
  DType kind = DType::uint8;
  std::uint32_t itemsize = 1;
 
  [[nodiscard]] static constexpr DataType of(DType kind) {
    if (kind == DType::raw) {
      throw error("DataType::of(DType::raw): raw has no fixed size, use DataType::raw_bytes()");
    }
    return DataType{kind, fixed_itemsize(kind)};
  }
 
  [[nodiscard]] static constexpr DataType raw_bytes(std::uint32_t size) {
    return DataType{DType::raw, size};
  }
 
  [[nodiscard]] friend constexpr bool operator==(DataType a, DataType b) {
    return a.kind == b.kind && a.itemsize == b.itemsize;
  }
  [[nodiscard]] friend constexpr bool operator!=(DataType a, DataType b) { return !(a == b); }
};
 
}  // namespace zarr
 
#endif  // LIBZARR_TYPES_HPP