DataPieceTypes.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
 
#include <type_traits>
 
namespace vrs {
 
using std::enable_if;
using std::size_t;
 
#pragma pack(push, 1)
 
class Bool {
 public:
  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  Bool(bool value = false) : value_(value) {}
  Bool& operator=(bool value) {
    value_ = value;
    return *this;
  }
  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  operator bool() const {
    return value_;
  }
  const bool* operator&() const {
    return &value_;
  }
  bool* operator&() {
    return &value_;
  }
  bool operator==(const Bool& rhs) const {
    return value_ == rhs.value_;
  }
  bool operator==(bool rhs) const {
    return value_ == rhs;
  }
  bool operator!=(const Bool& rhs) const {
    return value_ != rhs.value_;
  }
  bool operator!=(bool rhs) const {
    return value_ != rhs;
  }
 
 private:
  bool value_;
};
 
template <typename T, size_t N>
struct PointND {
  using type = T;
  static constexpr size_t kSize = N;
 
  PointND() : dim{} {}
  /* implicit */ PointND(const T arr[N]) {
    operator=(arr);
  }
 
  template <typename Z = enable_if<(N == 2), T>>
  PointND(T x, T y) : dim{x, y} {}
 
  template <typename Z = enable_if<(N == 3), T>>
  PointND(T x, T y, T z) : dim{x, y, z} {}
 
  template <typename W = enable_if<(N == 4), T>>
  PointND(T x, T y, T z, T w) : dim{x, y, z, w} {}
 
  bool operator==(const PointND<T, N>& rhs) const {
    for (size_t s = 0; s < N; s++) {
      if (dim[s] != rhs.dim[s]) {
        return false;
      }
    }
    return true;
  }
  bool operator!=(const PointND<T, N>& rhs) const {
    return !operator==(rhs);
  }
  PointND& operator=(const T rhs[N]) {
    for (size_t s = 0; s < N; s++) {
      dim[s] = rhs[s];
    }
    return *this;
  }
 
  // Convenience aliases for the dimensions that actually exist
  T& x() {
    return dim[0];
  }
  const T& x() const {
    return dim[0];
  }
  T& y() {
    return dim[1];
  }
  const T& y() const {
    return dim[1];
  }
  template <typename Z = enable_if<(N > 2), T>>
  T& z() {
    return dim[2];
  }
  template <typename Z = enable_if<(N > 2), T>>
  const T& z() const {
    return dim[2];
  }
  template <typename W = enable_if<(N > 3), T>>
  T& w() {
    return dim[3];
  }
  template <typename W = enable_if<(N > 3), T>>
  const T& w() const {
    return dim[3];
  }
 
  T& operator[](size_t n) {
    return dim[n];
  }
  const T& operator[](size_t n) const {
    return dim[n];
  }
 
  T dim[N];
};
 
using Point2Dd = PointND<double, 2>;
using Point2Df = PointND<float, 2>;
using Point2Di = PointND<int32_t, 2>;
 
using Point3Dd = PointND<double, 3>;
using Point3Df = PointND<float, 3>;
using Point3Di = PointND<int32_t, 3>;
 
using Point4Dd = PointND<double, 4>;
using Point4Df = PointND<float, 4>;
using Point4Di = PointND<int32_t, 4>;
 
template <typename T, size_t N>
struct MatrixND {
  using type = T;
  static constexpr size_t kMatrixSize = N;
 
  MatrixND() = default;
  /* implicit */ MatrixND(const T arr[N][N]) {
    operator=(arr);
  }
 
  PointND<T, N>& operator[](size_t n) {
    return points[n];
  }
  const PointND<T, N>& operator[](size_t n) const {
    return points[n];
  }
 
  bool operator==(const MatrixND<T, N>& rhs) const {
    for (size_t s = 0; s < N; s++) {
      if (points[s] != rhs[s]) {
        return false;
      }
    }
    return true;
  }
  bool operator!=(const MatrixND<T, N>& rhs) const {
    return !operator==(rhs);
  }
  MatrixND& operator=(const T rhs[N][N]) {
    for (size_t s = 0; s < N; s++) {
      points[s] = rhs[s];
    }
    return *this;
  }
 
  PointND<T, N> points[N];
};
 
using Matrix2Dd = MatrixND<double, 2>;
using Matrix2Df = MatrixND<float, 2>;
using Matrix2Di = MatrixND<int32_t, 2>;
 
using Matrix3Dd = MatrixND<double, 3>;
using Matrix3Df = MatrixND<float, 3>;
using Matrix3Di = MatrixND<int32_t, 3>;
 
using Matrix4Dd = MatrixND<double, 4>;
using Matrix4Df = MatrixND<float, 4>;
using Matrix4Di = MatrixND<int32_t, 4>;
 
#pragma pack(pop)
 
} // namespace vrs