Self-contained '.inl' headers + minor refactoring

include/SFML/Audio/Sound.hpp

@@ -31,8 +31,6 @@
 
 #include <SFML/Audio/SoundSource.hpp>
 
-#include <cstdlib>
-
 
 namespace sf
 {

include/SFML/Audio/SoundBuffer.hpp

@@ -34,10 +34,11 @@
 #include <SFML/System/Time.hpp>
 
 #include <filesystem>
-#include <string>
 #include <unordered_set>
 #include <vector>
 
+#include <cstdint>
+
 
 namespace sf
 {

include/SFML/Audio/SoundFileFactory.hpp

@@ -29,11 +29,12 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Export.hpp>
 
-#include <algorithm>
 #include <filesystem>
 #include <memory>
 #include <vector>
 
+#include <cstddef>
+
 
 namespace sf
 {

include/SFML/Audio/SoundFileFactory.inl

@@ -25,6 +25,9 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include <SFML/Audio/SoundFileFactory.hpp> // NOLINT(misc-header-include-cycle)
+
+#include <algorithm>
 
 
 namespace sf

include/SFML/Graphics/Color.hpp

@@ -226,10 +226,10 @@ constexpr Color& operator-=(Color& left, const Color& right);
 ////////////////////////////////////////////////////////////
 constexpr Color& operator*=(Color& left, const Color& right);
 
-#include <SFML/Graphics/Color.inl>
-
 } // namespace sf
 
+#include <SFML/Graphics/Color.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Color

include/SFML/Graphics/Color.inl

@@ -22,7 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Color.hpp> // NOLINT(misc-header-include-cycle)
 
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 constexpr Color::Color() = default;
 
@@ -149,3 +156,5 @@ inline constexpr Color Color::Yellow(255, 255, 0);
 inline constexpr Color Color::Magenta(255, 0, 255);
 inline constexpr Color Color::Cyan(0, 255, 255);
 inline constexpr Color Color::Transparent(0, 0, 0, 0);
+
+} // namespace sf

include/SFML/Graphics/Glsl.hpp

@@ -47,8 +47,6 @@ struct Matrix;
 template <typename T>
 struct Vector4;
 
-#include <SFML/Graphics/Glsl.inl>
-
 } // namespace priv
 
 
@@ -195,6 +193,8 @@ using Mat4  = priv::Matrix<4, 4>;
 } // namespace Glsl
 } // namespace sf
 
+#include <SFML/Graphics/Glsl.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \namespace sf::Glsl

include/SFML/Graphics/Glsl.inl

@@ -22,7 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Glsl.hpp> // NOLINT(misc-header-include-cycle)
 
+
+namespace sf::priv
+{
 ////////////////////////////////////////////////////////////
 /// \brief Helper functions to copy sf::Transform to sf::Glsl::Mat3/4
 ///
@@ -149,3 +156,5 @@ struct Vector4
     T z{}; //!< 3rd component (Z) of the 4D vector
     T w{}; //!< 4th component (W) of the 4D vector
 };
+
+} // namespace sf::priv

include/SFML/Graphics/Rect.hpp

@@ -173,14 +173,14 @@ template <typename T>
 template <typename T>
 [[nodiscard]] constexpr bool operator!=(const Rect<T>& left, const Rect<T>& right);
 
-#include <SFML/Graphics/Rect.inl>
-
 // Create type aliases for the most common types
 using IntRect   = Rect<int>;
 using FloatRect = Rect<float>;
 
 } // namespace sf
 
+#include <SFML/Graphics/Rect.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Rect

include/SFML/Graphics/Rect.inl

@@ -22,7 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Rect.hpp> // NOLINT(misc-header-include-cycle)
 
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 template <typename T>
 constexpr Rect<T>::Rect() = default;
@@ -150,3 +157,5 @@ constexpr bool operator!=(const Rect<T>& left, const Rect<T>& right)
 {
     return !(left == right);
 }
+
+} // namespace sf

include/SFML/Graphics/Text.hpp

@@ -35,8 +35,7 @@
 #include <SFML/Graphics/VertexArray.hpp>
 
 #include <SFML/System/String.hpp>
-
-#include <vector>
+#include <SFML/System/Vector2.hpp>
 
 
 namespace sf

include/SFML/Graphics/Transform.hpp

@@ -33,8 +33,6 @@
 
 #include <SFML/System/Vector2.hpp>
 
-#include <array>
-
 
 namespace sf
 {
@@ -347,10 +345,10 @@ constexpr Vector2f operator*(const Transform& left, const Vector2f& right);
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr bool operator!=(const Transform& left, const Transform& right);
 
-#include <SFML/Graphics/Transform.inl>
-
 } // namespace sf
 
+#include <SFML/Graphics/Transform.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Transform

include/SFML/Graphics/Transform.inl

@@ -22,7 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Transform.hpp> // NOLINT(misc-header-include-cycle)
 
+#include <array>
+
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 constexpr Transform::Transform() = default;
 
@@ -229,3 +238,5 @@ constexpr bool operator!=(const Transform& left, const Transform& right)
 // Note: the 'inline' keyword here is technically not required, but VS2019 fails
 // to compile with a bogus "multiple definition" error if not explicitly used.
 inline constexpr Transform Transform::Identity;
+
+} // namespace sf

include/SFML/Graphics/Vertex.hpp

@@ -97,10 +97,10 @@ public:
     Vector2f texCoords;           //!< Coordinates of the texture's pixel to map to the vertex
 };
 
-#include <SFML/Graphics/Vertex.inl>
-
 } // namespace sf
 
+#include <SFML/Graphics/Vertex.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Vertex

include/SFML/Graphics/Vertex.inl

@@ -22,7 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Vertex.hpp> // NOLINT(misc-header-include-cycle)
 
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 constexpr Vertex::Vertex() = default;
 
@@ -54,3 +61,5 @@ color(theColor),
 texCoords(theTexCoords)
 {
 }
+
+} // namespace sf

include/SFML/Network/Socket.hpp

@@ -31,8 +31,6 @@
 
 #include <SFML/Network/SocketHandle.hpp>
 
-#include <vector>
-
 
 namespace sf
 {

include/SFML/Network/TcpSocket.hpp

@@ -34,6 +34,7 @@
 #include <SFML/System/Time.hpp>
 
 #include <optional>
+#include <vector>
 
 #include <cstddef>
 

include/SFML/System/Angle.hpp

@@ -29,8 +29,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/System/Export.hpp>
 
-#include <cassert>
-
 
 namespace sf
 {
@@ -471,11 +469,10 @@ namespace Literals
 [[nodiscard]] constexpr Angle operator""_rad(unsigned long long int angle);
 
 } // namespace Literals
+} // namespace sf
 
 #include <SFML/System/Angle.inl>
 
-} // namespace sf
-
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Angle

include/SFML/System/Angle.inl

@@ -22,6 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Angle.hpp> // NOLINT(misc-header-include-cycle)
+
+#include <cassert>
+
+
+namespace sf
+{
 namespace priv
 {
 constexpr float pi = 3.141592654f;
@@ -267,3 +277,5 @@ constexpr Angle operator""_rad(unsigned long long angle)
 // Note: the 'inline' keyword here is technically not required, but VS2019 fails
 // to compile with a bogus "multiple definition" error if not explicitly used.
 inline constexpr Angle Angle::Zero;
+
+} // namespace sf

include/SFML/System/String.hpp

@@ -636,10 +636,10 @@ SFML_SYSTEM_API bool operator>=(const String& left, const String& right);
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API String operator+(const String& left, const String& right);
 
-#include <SFML/System/String.inl>
-
 } // namespace sf
 
+#include <SFML/System/String.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::String

include/SFML/System/String.inl

@@ -22,7 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/String.hpp> // NOLINT(misc-header-include-cycle)
 
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 template <typename T>
 String String::fromUtf8(T begin, T end)
@@ -51,3 +58,5 @@ String String::fromUtf32(T begin, T end)
     string.m_string.assign(begin, end);
     return string;
 }
+
+} // namespace sf

include/SFML/System/Time.hpp

@@ -30,9 +30,7 @@
 #include <SFML/System/Export.hpp>
 
 #include <chrono>
-#include <ratio>
 
-#include <cassert>
 #include <cstdint>
 
 
@@ -450,10 +448,10 @@ constexpr Time& operator/=(Time& left, std::int64_t right);
 ////////////////////////////////////////////////////////////
 constexpr Time& operator%=(Time& left, Time right);
 
-#include <SFML/System/Time.inl>
-
 } // namespace sf
 
+#include <SFML/System/Time.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Time

include/SFML/System/Time.inl

@@ -22,7 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Time.hpp> // NOLINT(misc-header-include-cycle)
 
+#include <ratio>
+
+#include <cassert>
+
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 constexpr Time::Time() = default;
 
@@ -273,3 +284,5 @@ constexpr Time& operator%=(Time& left, Time right)
 // Note: the 'inline' keyword here is technically not required, but VS2019 fails
 // to compile with a bogus "multiple definition" error if not explicitly used.
 inline constexpr Time Time::Zero;
+
+} // namespace sf

include/SFML/System/Utf.hpp

@@ -731,8 +731,6 @@ public:
     static Out encodeWide(std::uint32_t codepoint, Out output, wchar_t replacement = 0);
 };
 
-#include <SFML/System/Utf.inl>
-
 // Make type aliases to get rid of the template syntax
 using Utf8  = Utf<8>;
 using Utf16 = Utf<16>;
@@ -740,6 +738,8 @@ using Utf32 = Utf<32>;
 
 } // namespace sf
 
+#include <SFML/System/Utf.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Utf

include/SFML/System/Utf.inl

@@ -22,6 +22,11 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Utf.hpp> // NOLINT(misc-header-include-cycle)
+
 
 ////////////////////////////////////////////////////////////
 // References:
@@ -34,6 +39,8 @@
 ////////////////////////////////////////////////////////////
 
 
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 template <typename InputIt, typename OutputIt>
 OutputIt priv::copy(InputIt first, InputIt last, OutputIt dFirst)
@@ -727,3 +734,5 @@ Out Utf<32>::encodeWide(std::uint32_t codepoint, Out output, wchar_t replacement
 
     return output;
 }
+
+} // namespace sf

include/SFML/System/Vector2.hpp

@@ -28,8 +28,6 @@
 
 #include <SFML/System/Angle.hpp>
 
-#include <cassert>
-
 
 namespace sf
 {
@@ -398,10 +396,10 @@ template <typename T>
 template <typename T>
 [[nodiscard]] constexpr bool operator!=(const Vector2<T>& left, const Vector2<T>& right);
 
-#include <SFML/System/Vector2.inl>
-
 } // namespace sf
 
+#include <SFML/System/Vector2.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Vector2

include/SFML/System/Vector2.inl

@@ -22,7 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Vector2.hpp> // NOLINT(misc-header-include-cycle)
 
+#include <cassert>
+
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 template <typename T>
 constexpr Vector2<T>::Vector2() = default;
@@ -219,3 +228,5 @@ const Vector2<T> Vector2<T>::UnitX(static_cast<T>(1), static_cast<T>(0));
 
 template <typename T>
 const Vector2<T> Vector2<T>::UnitY(static_cast<T>(0), static_cast<T>(1));
+
+} // namespace sf

include/SFML/System/Vector3.hpp

@@ -26,7 +26,6 @@
 
 #include <SFML/System/Export.hpp>
 
-#include <cassert>
 
 namespace sf
 {
@@ -309,14 +308,14 @@ template <typename T>
 template <typename T>
 [[nodiscard]] constexpr bool operator!=(const Vector3<T>& left, const Vector3<T>& right);
 
-#include <SFML/System/Vector3.inl>
-
 // Define the most common types
 using Vector3i = Vector3<int>;
 using Vector3f = Vector3<float>;
 
 } // namespace sf
 
+#include <SFML/System/Vector3.inl>
+
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Vector3

include/SFML/System/Vector3.inl

@@ -22,7 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Vector3.hpp> // NOLINT(misc-header-include-cycle)
 
+#include <cassert>
+
+
+namespace sf
+{
 ////////////////////////////////////////////////////////////
 template <typename T>
 constexpr Vector3<T>::Vector3() = default;
@@ -208,3 +217,5 @@ constexpr bool operator!=(const Vector3<T>& left, const Vector3<T>& right)
 {
     return (left.x != right.x) || (left.y != right.y) || (left.z != right.z);
 }
+
+} // namespace sf

src/SFML/Network/SocketImpl.hpp

@@ -46,6 +46,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <cstddef>
+
 #endif
 
 #include <cstdint>

test/Graphics/Font.test.cpp

@@ -73,8 +73,8 @@ TEST_CASE("[Graphics] sf::Font", runDisplayTests())
         SECTION("Invalid data and size")
         {
             CHECK(!font.loadFromMemory(nullptr, 1));
-            const std::byte byte{0xCD};
-            CHECK(!font.loadFromMemory(&byte, 0));
+            const std::byte testByte{0xCD};
+            CHECK(!font.loadFromMemory(&testByte, 0));
         }
 
         SECTION("Successful load")

test/Graphics/Image.test.cpp

@@ -155,8 +155,8 @@ TEST_CASE("[Graphics] sf::Image")
 
         SECTION("Invalid size")
         {
-            const std::byte byte{0xAB};
-            CHECK(!image.loadFromMemory(&byte, 0));
+            const std::byte testByte{0xAB};
+            CHECK(!image.loadFromMemory(&testByte, 0));
         }
 
         SECTION("Failed load")