strong_types.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#pragma once
 
#include <array>
#include <openpfc/core/types.hpp>
#include <type_traits>
 
namespace pfc {
 
// ============================================================================
// Strong Types for Discrete (Index) Space
// ============================================================================
 
struct GridSize {
  Int3 value; 
 
  GridSize(const Int3 &v) : value(v) {}
 
  const Int3 &get() const noexcept { return value; }
 
  operator const Int3 &() const noexcept { return value; }
 
  bool operator==(const GridSize &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const GridSize &other) const noexcept {
    return value != other.value;
  }
};
 
struct LocalOffset {
  Int3 value; 
 
  LocalOffset(const Int3 &v) : value(v) {}
 
  const Int3 &get() const noexcept { return value; }
 
  operator const Int3 &() const noexcept { return value; }
 
  bool operator==(const LocalOffset &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const LocalOffset &other) const noexcept {
    return value != other.value;
  }
};
 
struct GlobalOffset {
  Int3 value; 
 
  GlobalOffset(const Int3 &v) : value(v) {}
 
  const Int3 &get() const noexcept { return value; }
 
  operator const Int3 &() const noexcept { return value; }
 
  bool operator==(const GlobalOffset &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const GlobalOffset &other) const noexcept {
    return value != other.value;
  }
};
 
struct IndexBounds {
  Int3 lower; 
  Int3 upper; 
 
  IndexBounds(const Int3 &lo, const Int3 &hi) : lower(lo), upper(hi) {}
};
 
// ============================================================================
// Strong Types for Physical (Coordinate) Space
// ============================================================================
 
struct GridSpacing {
  Real3 value; 
 
  GridSpacing(const Real3 &v) : value(v) {}
 
  const Real3 &get() const noexcept { return value; }
 
  operator const Real3 &() const noexcept { return value; }
 
  bool operator==(const GridSpacing &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const GridSpacing &other) const noexcept {
    return value != other.value;
  }
};
 
struct PhysicalOrigin {
  Real3 value; 
 
  PhysicalOrigin(const Real3 &v) : value(v) {}
 
  const Real3 &get() const noexcept { return value; }
 
  operator const Real3 &() const noexcept { return value; }
 
  bool operator==(const PhysicalOrigin &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const PhysicalOrigin &other) const noexcept {
    return value != other.value;
  }
};
 
struct PhysicalCoords {
  Real3 value; 
 
  PhysicalCoords(const Real3 &v) : value(v) {}
 
  const Real3 &get() const noexcept { return value; }
 
  operator const Real3 &() const noexcept { return value; }
 
  bool operator==(const PhysicalCoords &other) const noexcept {
    return value == other.value;
  }
 
  bool operator!=(const PhysicalCoords &other) const noexcept {
    return value != other.value;
  }
};
 
struct PhysicalBounds {
  Real3 lower; 
  Real3 upper; 
 
  PhysicalBounds(const Real3 &lo, const Real3 &hi) : lower(lo), upper(hi) {}
};
 
// ============================================================================
// Compile-Time Assertions (Zero-Cost Verification)
// ============================================================================
 
// Verify zero-cost: same size as underlying types
static_assert(sizeof(GridSize) == sizeof(Int3),
              "GridSize must be same size as Int3 (zero-cost)");
static_assert(sizeof(LocalOffset) == sizeof(Int3),
              "LocalOffset must be same size as Int3 (zero-cost)");
static_assert(sizeof(GlobalOffset) == sizeof(Int3),
              "GlobalOffset must be same size as Int3 (zero-cost)");
static_assert(sizeof(GridSpacing) == sizeof(Real3),
              "GridSpacing must be same size as Real3 (zero-cost)");
static_assert(sizeof(PhysicalOrigin) == sizeof(Real3),
              "PhysicalOrigin must be same size as Real3 (zero-cost)");
static_assert(sizeof(PhysicalCoords) == sizeof(Real3),
              "PhysicalCoords must be same size as Real3 (zero-cost)");
 
// Verify trivial copyability (required for performance)
static_assert(std::is_trivially_copyable_v<GridSize>,
              "GridSize must be trivially copyable");
static_assert(std::is_trivially_copyable_v<LocalOffset>,
              "LocalOffset must be trivially copyable");
static_assert(std::is_trivially_copyable_v<GlobalOffset>,
              "GlobalOffset must be trivially copyable");
static_assert(std::is_trivially_copyable_v<IndexBounds>,
              "IndexBounds must be trivially copyable");
static_assert(std::is_trivially_copyable_v<GridSpacing>,
              "GridSpacing must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PhysicalOrigin>,
              "PhysicalOrigin must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PhysicalCoords>,
              "PhysicalCoords must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PhysicalBounds>,
              "PhysicalBounds must be trivially copyable");
 
// Verify standard layout (required for interop)
static_assert(std::is_standard_layout_v<GridSize>,
              "GridSize must have standard layout");
static_assert(std::is_standard_layout_v<LocalOffset>,
              "LocalOffset must have standard layout");
static_assert(std::is_standard_layout_v<GlobalOffset>,
              "GlobalOffset must have standard layout");
static_assert(std::is_standard_layout_v<IndexBounds>,
              "IndexBounds must have standard layout");
static_assert(std::is_standard_layout_v<GridSpacing>,
              "GridSpacing must have standard layout");
static_assert(std::is_standard_layout_v<PhysicalOrigin>,
              "PhysicalOrigin must have standard layout");
static_assert(std::is_standard_layout_v<PhysicalCoords>,
              "PhysicalCoords must have standard layout");
static_assert(std::is_standard_layout_v<PhysicalBounds>,
              "PhysicalBounds must have standard layout");
 
} // namespace pfc