Tweak internal namespaces

source/base/test/src/numeric/saturate_cast_test.cpp

@@ -7,8 +7,8 @@
 
 #include <gtest/gtest.h>
 
-namespace tactile {
-inline namespace saturate_cast_test {
+namespace tactile::test {
+namespace {
 
 template <typename T = std::int8_t>
 inline constexpr T kMinI8 = T {std::numeric_limits<std::int8_t>::min()};
@@ -25,9 +25,9 @@ inline constexpr T kMinI16 = T {std::numeric_limits<std::int16_t>::min()};
 template <typename T = std::int16_t>
 inline constexpr T kMaxI16 = T {std::numeric_limits<std::int16_t>::max()};
 
-}  // namespace saturate_cast_test
+}  // namespace
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, SignedToSignedNarrowing)
 {
   EXPECT_EQ(saturate_cast<std::int8_t>(std::int16_t {0x00}), std::int8_t {0x00});
@@ -41,7 +41,7 @@ TEST(SaturateCast, SignedToSignedNarrowing)
   EXPECT_EQ(saturate_cast<std::int8_t>(kMaxI8<std::int16_t> + std::int16_t {1}), kMaxI8<>);
 }
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, SignedToSignedPromoting)
 {
   EXPECT_EQ(saturate_cast<std::int32_t>(std::int16_t {0}), std::int32_t {0});
@@ -51,7 +51,7 @@ TEST(SaturateCast, SignedToSignedPromoting)
   EXPECT_EQ(saturate_cast<std::int32_t>(kMaxI16<>), kMaxI16<std::int32_t>);
 }
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, UnsignedToSignedNarrowing)
 {
   EXPECT_EQ(saturate_cast<std::int8_t>(std::uint8_t {0}), std::int8_t {0});
@@ -61,7 +61,7 @@ TEST(SaturateCast, UnsignedToSignedNarrowing)
   EXPECT_EQ(saturate_cast<std::int8_t>(kMaxI8<std::uint8_t> + std::uint8_t {1}), kMaxI8<>);
 }
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, UnsignedToSignedPromoting)
 {
   EXPECT_EQ(saturate_cast<std::int16_t>(std::uint8_t {0}), std::int16_t {0});
@@ -70,7 +70,7 @@ TEST(SaturateCast, UnsignedToSignedPromoting)
   EXPECT_EQ(saturate_cast<std::int16_t>(kMaxU8<>), kMaxU8<std::int16_t>);
 }
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, SignedToUnsignedNarrowing)
 {
   EXPECT_EQ(saturate_cast<std::uint8_t>(std::int16_t {0}), std::uint8_t {0});
@@ -84,7 +84,7 @@ TEST(SaturateCast, SignedToUnsignedNarrowing)
   EXPECT_EQ(saturate_cast<std::uint8_t>(kMaxU8<std::int16_t> + std::int16_t {1}), kMaxU8<>);
 }
 
-/// \trace tactile::saturate_cast
+// tactile::saturate_cast
 TEST(SaturateCast, SignedToUnsignedPromoting)
 {
   EXPECT_EQ(saturate_cast<std::uint8_t>(std::int8_t {0}), std::uint8_t {0});

source/core/src/tactile/core/io/compress/compression_error.cpp

@@ -3,7 +3,7 @@
 #include "tactile/core/io/compress/compression_error.hpp"
 
 namespace tactile {
-inline namespace compression_error {
+namespace {
 
 class CompressionErrorCategory final : public std::error_category
 {
@@ -29,7 +29,7 @@ class CompressionErrorCategory final : public std::error_category
   }
 };
 
-}  // namespace compression_error
+}  // namespace
 
 auto get_compression_error_category() noexcept -> const std::error_category&
 {

source/core/src/tactile/core/io/save/vec_serialization.cpp

@@ -10,7 +10,7 @@
 #include "tactile/core/util/string_ops.hpp"
 
 namespace tactile {
-inline namespace vec_serialization {
+namespace {
 
 template <typename VecType>
 [[nodiscard]] auto _deserialize_vec(const std::string_view str)
@@ -42,7 +42,7 @@ template <typename VecType>
   return vec;
 }
 
-}  // namespace vec_serialization
+}  // namespace
 
 auto serialize(const Int2& vec) -> std::string
 {

source/core/src/tactile/core/layer/group_layer.cpp

@@ -16,7 +16,7 @@
 #include "tactile/core/meta/meta.hpp"
 
 namespace tactile {
-namespace group_layer_impl {
+namespace {
 
 struct FindLayerResult final
 {
@@ -31,9 +31,9 @@ struct FindLayerConstResult final
 };
 
 [[nodiscard]]
-auto find_layer(Registry& registry,
-                const EntityID root_layer_id,
-                const EntityID target_layer_id) -> std::optional<FindLayerResult>
+auto _find_layer(Registry& registry,
+                 const EntityID root_layer_id,
+                 const EntityID target_layer_id) -> std::optional<FindLayerResult>
 {
   const auto parent_id = find_parent_layer(registry, root_layer_id, target_layer_id);
 
@@ -56,9 +56,9 @@ auto find_layer(Registry& registry,
 }
 
 [[nodiscard]]
-auto find_layer(const Registry& registry,
-                const EntityID root_layer_id,
-                const EntityID target_layer_id) -> std::optional<FindLayerConstResult>
+auto _find_layer(const Registry& registry,
+                 const EntityID root_layer_id,
+                 const EntityID target_layer_id) -> std::optional<FindLayerConstResult>
 {
   const auto parent_id = find_parent_layer(registry, root_layer_id, target_layer_id);
 
@@ -81,12 +81,12 @@ auto find_layer(const Registry& registry,
 }
 
 [[nodiscard]]
-auto can_move_layer(const Registry& registry,
-                    const EntityID root_layer_id,
-                    const EntityID target_layer_id,
-                    const std::ptrdiff_t offset) -> bool
+auto _can_move_layer(const Registry& registry,
+                     const EntityID root_layer_id,
+                     const EntityID target_layer_id,
+                     const std::ptrdiff_t offset) -> bool
 {
-  const auto find_result = find_layer(registry, root_layer_id, target_layer_id);
+  const auto find_result = _find_layer(registry, root_layer_id, target_layer_id);
 
   if (!find_result.has_value()) {
     return false;
@@ -99,10 +99,10 @@ auto can_move_layer(const Registry& registry,
 }
 
 [[nodiscard]]
-auto get_global_layer_index(const Registry& registry,
-                            const EntityID root_layer_id,
-                            const EntityID target_layer_id,
-                            std::size_t& index) -> bool
+auto _get_global_layer_index(const Registry& registry,
+                             const EntityID root_layer_id,
+                             const EntityID target_layer_id,
+                             std::size_t& index) -> bool
 {
   const auto& root_layer = registry.get<CGroupLayer>(root_layer_id);
 
@@ -114,7 +114,7 @@ auto get_global_layer_index(const Registry& registry,
     ++index;
 
     if (is_group_layer(registry, layer_id)) {
-      if (get_global_layer_index(registry, layer_id, target_layer_id, index)) {
+      if (_get_global_layer_index(registry, layer_id, target_layer_id, index)) {
         return true;
       }
     }
@@ -123,7 +123,7 @@ auto get_global_layer_index(const Registry& registry,
   return false;
 }
 
-}  // namespace group_layer_impl
+}  // namespace
 
 auto is_group_layer(const Registry& registry, const EntityID entity) -> bool
 {
@@ -216,8 +216,8 @@ auto get_local_layer_index(const Registry& registry,
   TACTILE_ASSERT(is_group_layer(registry, root_layer_id));
   TACTILE_ASSERT(is_layer(registry, target_layer_id));
 
-  return group_layer_impl::find_layer(registry, root_layer_id, target_layer_id)
-      .transform([](const group_layer_impl::FindLayerConstResult& result) {
+  return _find_layer(registry, root_layer_id, target_layer_id)
+      .transform([](const FindLayerConstResult& result) {
         return saturate_cast<std::size_t>(result.layer_index);
       });
 }
@@ -231,10 +231,7 @@ auto get_global_layer_index(const Registry& registry,
 
   std::size_t index = 0;
 
-  if (group_layer_impl::get_global_layer_index(registry,
-                                               root_layer_id,
-                                               target_layer_id,
-                                               index)) {
+  if (_get_global_layer_index(registry, root_layer_id, target_layer_id, index)) {
     return index;
   }
 
@@ -249,8 +246,8 @@ void move_layer_down(Registry& registry,
   TACTILE_ASSERT(is_layer(registry, target_layer_id));
   TACTILE_ASSERT(can_move_layer_down(registry, root_layer_id, target_layer_id));
 
-  std::ignore = group_layer_impl::find_layer(registry, root_layer_id, target_layer_id)
-                    .transform([](const group_layer_impl::FindLayerResult& result) {
+  std::ignore = _find_layer(registry, root_layer_id, target_layer_id)
+                    .transform([](const FindLayerResult& result) {
                       const auto layers_begin = result.parent_layer->layers.begin();
 
                       const auto curr_pos = layers_begin + result.layer_index;
@@ -269,8 +266,8 @@ void move_layer_up(Registry& registry,
   TACTILE_ASSERT(is_layer(registry, target_layer_id));
   TACTILE_ASSERT(can_move_layer_up(registry, root_layer_id, target_layer_id));
 
-  std::ignore = group_layer_impl::find_layer(registry, root_layer_id, target_layer_id)
-                    .transform([](const group_layer_impl::FindLayerResult& result) {
+  std::ignore = _find_layer(registry, root_layer_id, target_layer_id)
+                    .transform([](const FindLayerResult& result) {
                       const auto layers_begin = result.parent_layer->layers.begin();
 
                       const auto curr_pos = layers_begin + result.layer_index;
@@ -288,7 +285,7 @@ auto can_move_layer_up(const Registry& registry,
   TACTILE_ASSERT(is_group_layer(registry, root_layer_id));
   TACTILE_ASSERT(is_layer(registry, target_layer_id));
 
-  return group_layer_impl::can_move_layer(registry, root_layer_id, target_layer_id, -1);
+  return _can_move_layer(registry, root_layer_id, target_layer_id, -1);
 }
 
 auto can_move_layer_down(const Registry& registry,
@@ -298,7 +295,7 @@ auto can_move_layer_down(const Registry& registry,
   TACTILE_ASSERT(is_group_layer(registry, root_layer_id));
   TACTILE_ASSERT(is_layer(registry, target_layer_id));
 
-  return group_layer_impl::can_move_layer(registry, root_layer_id, target_layer_id, 1);
+  return _can_move_layer(registry, root_layer_id, target_layer_id, 1);
 }
 
 }  // namespace tactile

source/core/src/tactile/core/tile/tileset.cpp

@@ -22,13 +22,13 @@
 #include "tactile/core/util/lookup.hpp"
 
 namespace tactile {
-namespace tileset {
+namespace {
 
 [[nodiscard]]
-auto add_tileset_component(Registry& registry,
-                           const EntityID tileset_id,
-                           const Int2& texture_size,
-                           const Int2& tile_size) -> std::expected<void, std::error_code>
+auto _add_tileset_component(Registry& registry,
+                            const EntityID tileset_id,
+                            const Int2& texture_size,
+                            const Int2& tile_size) -> std::expected<void, std::error_code>
 {
   if (tile_size.x() <= 0 || tile_size.y() <= 0) {
     TACTILE_LOG_ERROR("Invalid tileset tile size: {}", tile_size);
@@ -53,17 +53,17 @@ auto add_tileset_component(Registry& registry,
   return {};
 }
 
-void add_viewport_component(Registry& registry,
-                            const EntityID tileset_id,
-                            const Int2& texture_size)
+void _add_viewport_component(Registry& registry,
+                             const EntityID tileset_id,
+                             const Int2& texture_size)
 {
   auto& viewport = registry.add<CViewport>(tileset_id);
   viewport.pos = Float2 {0.0f, 0.0f};
   viewport.size = vec_cast<Float2>(texture_size) * 0.5f;
   viewport.scale = 1.0f;
 }
 
-void create_tiles(Registry& registry, CTileset& tileset)
+void _create_tiles(Registry& registry, CTileset& tileset)
 {
   const auto tile_count = tileset.extent.rows * tileset.extent.cols;
   tileset.tiles.reserve(tile_count);
@@ -77,9 +77,9 @@ void create_tiles(Registry& registry, CTileset& tileset)
 }
 
 [[nodiscard]]
-auto create_tiles(Registry& registry,
-                  CTileset& tileset,
-                  const ir::Tileset& ir_tileset) -> std::expected<void, std::error_code>
+auto _create_tiles(Registry& registry,
+                   CTileset& tileset,
+                   const ir::Tileset& ir_tileset) -> std::expected<void, std::error_code>
 {
   const auto tile_count = saturate_cast<std::size_t>(ir_tileset.tile_count);
   tileset.tiles.resize(tile_count, kInvalidEntity);
@@ -108,7 +108,7 @@ auto create_tiles(Registry& registry,
   return {};
 }
 
-}  // namespace tileset
+}  // namespace
 
 auto is_tileset(const Registry& registry, const EntityID entity) -> bool
 {
@@ -128,18 +128,18 @@ auto make_tileset(Registry& registry, const TilesetSpec& spec) -> EntityID
   const auto tileset_id = registry.make_entity();
 
   const auto add_tileset_result =
-      tileset::add_tileset_component(registry, tileset_id, spec.texture.size, spec.tile_size);
+      _add_tileset_component(registry, tileset_id, spec.texture.size, spec.tile_size);
   if (!add_tileset_result.has_value()) {
     return kInvalidEntity;
   }
 
-  tileset::add_viewport_component(registry, tileset_id, spec.texture.size);
+  _add_viewport_component(registry, tileset_id, spec.texture.size);
 
   registry.add<CMeta>(tileset_id);
   registry.add<CTexture>(tileset_id, spec.texture);
 
   auto& tileset = registry.get<CTileset>(tileset_id);
-  tileset::create_tiles(registry, tileset);
+  _create_tiles(registry, tileset);
 
   TACTILE_ASSERT(is_tileset(registry, tileset_id));
   TACTILE_ASSERT(tileset.extent.rows > 0);
@@ -162,21 +162,19 @@ auto make_tileset(Registry& registry,
 
   auto& texture = registry.add<CTexture>(tileset_id, std::move(*texture_result));
 
-  tileset::add_viewport_component(registry, tileset_id, texture.size);
+  _add_viewport_component(registry, tileset_id, texture.size);
 
-  const auto add_tileset_result =
-      tileset::add_tileset_component(registry,
-                                     tileset_id,
-                                     texture.size,
-                                     ir_tileset_ref.tileset.tile_size);
+  const auto add_tileset_result = _add_tileset_component(registry,
+                                                         tileset_id,
+                                                         texture.size,
+                                                         ir_tileset_ref.tileset.tile_size);
   if (!add_tileset_result.has_value()) {
     return kInvalidEntity;
   }
 
   auto& tileset = registry.get<CTileset>(tileset_id);
 
-  const auto create_tiles_result =
-      tileset::create_tiles(registry, tileset, ir_tileset_ref.tileset);
+  const auto create_tiles_result = _create_tiles(registry, tileset, ir_tileset_ref.tileset);
   if (!create_tiles_result.has_value()) {
     return std::unexpected {create_tiles_result.error()};
   }

source/core/src/tactile/core/ui/fonts.cpp

@@ -12,11 +12,11 @@
 #include "tactile/core/model/settings.hpp"
 
 namespace tactile::ui {
-inline namespace fonts {
+namespace {
 
 inline constexpr std::array<ImWchar, 3> kFontIconRange {ICON_MIN_FA, ICON_MAX_FA, 0};
 
-}  // namespace fonts
+}  // namespace
 
 void reload_fonts(IRenderer& renderer, const Settings& settings, const float framebuffer_scale)
 {

source/core/src/tactile/core/ui/viewport.cpp

@@ -7,7 +7,7 @@
 #include "tactile/core/entity/registry.hpp"
 
 namespace tactile {
-inline namespace viewport {
+namespace {
 
 inline constexpr float kZoomPercentage = 0.05f;
 
@@ -33,7 +33,7 @@ void _scale_viewport_zoom(CViewport& viewport,
   }
 }
 
-}  // namespace viewport
+}  // namespace
 
 auto is_viewport(const Registry& registry, const EntityID entity) -> bool
 {