Replace 'sf::NonCopyable' with '= delete'

include/SFML/Audio/InputSoundFile.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Time.hpp>
 #include <string>
 #include <cstddef>
@@ -44,7 +43,7 @@ class SoundFileReader;
 /// \brief Provide read access to sound files
 ///
 ////////////////////////////////////////////////////////////
-class SFML_AUDIO_API InputSoundFile : NonCopyable
+class SFML_AUDIO_API InputSoundFile
 {
 public:
 
@@ -60,6 +59,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~InputSoundFile();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    InputSoundFile(const InputSoundFile&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    InputSoundFile& operator=(const InputSoundFile&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file from the disk for reading
     ///

include/SFML/Audio/OutputSoundFile.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <string>
 
 
@@ -41,7 +40,7 @@ class SoundFileWriter;
 /// \brief Provide write access to sound files
 ///
 ////////////////////////////////////////////////////////////
-class SFML_AUDIO_API OutputSoundFile : NonCopyable
+class SFML_AUDIO_API OutputSoundFile
 {
 public:
 
@@ -59,6 +58,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~OutputSoundFile();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    OutputSoundFile(const OutputSoundFile&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    OutputSoundFile& operator=(const OutputSoundFile&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Open the sound file from the disk for writing
     ///

include/SFML/Graphics/RenderTarget.hpp

@@ -37,7 +37,6 @@
 #include <SFML/Graphics/RenderStates.hpp>
 #include <SFML/Graphics/PrimitiveType.hpp>
 #include <SFML/Graphics/Vertex.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -49,7 +48,7 @@ class VertexBuffer;
 /// \brief Base class for all render targets (window, texture, ...)
 ///
 ////////////////////////////////////////////////////////////
-class SFML_GRAPHICS_API RenderTarget : NonCopyable
+class SFML_GRAPHICS_API RenderTarget
 {
 public:
 
@@ -59,6 +58,18 @@ public:
     ////////////////////////////////////////////////////////////
     virtual ~RenderTarget();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderTarget(const RenderTarget&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderTarget& operator=(const RenderTarget&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Clear the entire target with a single color
     ///

include/SFML/Graphics/Shader.hpp

@@ -31,7 +31,6 @@
 #include <SFML/Graphics/Export.hpp>
 #include <SFML/Graphics/Glsl.hpp>
 #include <SFML/Window/GlResource.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 #include <SFML/System/Vector3.hpp>
 #include <string>
@@ -49,7 +48,7 @@ class Transform;
 /// \brief Shader class (vertex, geometry and fragment)
 ///
 ////////////////////////////////////////////////////////////
-class SFML_GRAPHICS_API Shader : GlResource, NonCopyable
+class SFML_GRAPHICS_API Shader : GlResource
 {
 public:
 
@@ -97,6 +96,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~Shader();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Shader(const Shader&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Shader& operator=(const Shader&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Load the vertex, geometry or fragment shader from a file
     ///

include/SFML/Network/Ftp.hpp

@@ -30,7 +30,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Export.hpp>
 #include <SFML/Network/TcpSocket.hpp>
-#include <SFML/System/NonCopyable.hpp>
+
 #include <SFML/System/Time.hpp>
 #include <string>
 #include <vector>
@@ -44,7 +44,7 @@ class IpAddress;
 /// \brief A FTP client
 ///
 ////////////////////////////////////////////////////////////
-class SFML_NETWORK_API Ftp : NonCopyable
+class SFML_NETWORK_API Ftp
 {
 public:
 
@@ -247,6 +247,11 @@ public:
         std::vector<std::string> m_listing; //!< Directory/file names extracted from the data
     };
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Default constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Ftp() = default;
 
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
@@ -257,6 +262,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~Ftp();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Ftp(const Ftp&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Ftp& operator=(const Ftp&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Connect to the specified FTP server
     ///

include/SFML/Network/Http.hpp

@@ -31,7 +31,6 @@
 #include <SFML/Network/Export.hpp>
 #include <SFML/Network/IpAddress.hpp>
 #include <SFML/Network/TcpSocket.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Time.hpp>
 #include <map>
 #include <string>
@@ -43,7 +42,7 @@ namespace sf
 /// \brief A HTTP client
 ///
 ////////////////////////////////////////////////////////////
-class SFML_NETWORK_API Http : NonCopyable
+class SFML_NETWORK_API Http
 {
 public:
 
@@ -367,6 +366,18 @@ public:
     ////////////////////////////////////////////////////////////
     Http(const std::string& host, unsigned short port = 0);
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Http(const Http&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Http& operator=(const Http&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Set the target host
     ///

include/SFML/Network/Socket.hpp

@@ -30,7 +30,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Export.hpp>
 #include <SFML/Network/SocketHandle.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <vector>
 
 
@@ -42,7 +41,7 @@ class SocketSelector;
 /// \brief Base class for all the socket types
 ///
 ////////////////////////////////////////////////////////////
-class SFML_NETWORK_API Socket : NonCopyable
+class SFML_NETWORK_API Socket
 {
 public:
 
@@ -76,6 +75,18 @@ public:
     ////////////////////////////////////////////////////////////
     virtual ~Socket();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Socket(const Socket&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Socket& operator=(const Socket&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Set the blocking state of the socket
     ///

include/SFML/System.hpp

@@ -35,7 +35,6 @@
 #include <SFML/System/FileInputStream.hpp>
 #include <SFML/System/InputStream.hpp>
 #include <SFML/System/MemoryInputStream.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Sleep.hpp>
 #include <SFML/System/String.hpp>
 #include <SFML/System/Time.hpp>

include/SFML/System/FileInputStream.hpp

@@ -31,7 +31,6 @@
 #include <SFML/Config.hpp>
 #include <SFML/System/Export.hpp>
 #include <SFML/System/InputStream.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <cstdio>
 #include <string>
 
@@ -52,7 +51,7 @@ namespace sf
 /// \brief Implementation of input stream based on a file
 ///
 ////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API FileInputStream : public InputStream, NonCopyable
+class SFML_SYSTEM_API FileInputStream : public InputStream
 {
 public:
     ////////////////////////////////////////////////////////////
@@ -67,6 +66,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~FileInputStream() override;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    FileInputStream(const FileInputStream&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    FileInputStream& operator=(const FileInputStream&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Open the stream from a file path
     ///

include/SFML/System/NonCopyable.hpp

@@ -1,129 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2021 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_NONCOPYABLE_HPP
-#define SFML_NONCOPYABLE_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Export.hpp>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// \brief Utility class that makes any derived
-///        class non-copyable
-///
-////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API NonCopyable
-{
-protected:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Default constructor
-    ///
-    /// Because this class has a copy constructor, the compiler
-    /// will not automatically generate the default constructor.
-    /// That's why we must define it explicitly.
-    ///
-    ////////////////////////////////////////////////////////////
-    NonCopyable() {}
-    
-    ////////////////////////////////////////////////////////////
-    /// \brief Default destructor
-    ///
-    /// By declaring a protected destructor it's impossible to
-    /// call delete on a pointer of sf::NonCopyable, thus
-    /// preventing possible resource leaks.
-    ///
-    ////////////////////////////////////////////////////////////
-    ~NonCopyable() {}
-
-private:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Disabled copy constructor
-    ///
-    /// By making the copy constructor private, the compiler will
-    /// trigger an error if anyone outside tries to use it.
-    /// To prevent NonCopyable or friend classes from using it,
-    /// we also give no definition, so that the linker will
-    /// produce an error if the first protection was inefficient.
-    ///
-    ////////////////////////////////////////////////////////////
-    NonCopyable(const NonCopyable&);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Disabled assignment operator
-    ///
-    /// By making the assignment operator private, the compiler will
-    /// trigger an error if anyone outside tries to use it.
-    /// To prevent NonCopyable or friend classes from using it,
-    /// we also give no definition, so that the linker will
-    /// produce an error if the first protection was inefficient.
-    ///
-    ////////////////////////////////////////////////////////////
-    NonCopyable& operator =(const NonCopyable&);
-};
-
-} // namespace sf
-
-
-#endif // SFML_NONCOPYABLE_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::NonCopyable
-/// \ingroup system
-///
-/// This class makes its instances non-copyable, by explicitly
-/// disabling its copy constructor and its assignment operator.
-///
-/// To create a non-copyable class, simply inherit from
-/// sf::NonCopyable.
-///
-/// The type of inheritance (public or private) doesn't matter,
-/// the copy constructor and assignment operator are declared private
-/// in sf::NonCopyable so they will end up being inaccessible in both
-/// cases. Thus you can use a shorter syntax for inheriting from it
-/// (see below).
-///
-/// Usage example:
-/// \code
-/// class MyNonCopyableClass : sf::NonCopyable
-/// {
-///     ...
-/// };
-/// \endcode
-///
-/// Deciding whether the instances of a class can be copied
-/// or not is a very important design choice. You are strongly
-/// encouraged to think about it before writing a class,
-/// and to use sf::NonCopyable when necessary to prevent
-/// many potential future errors when using it. This is also
-/// a very important indication to users of your class.
-///
-////////////////////////////////////////////////////////////

include/SFML/Window/Context.hpp

@@ -31,7 +31,6 @@
 #include <SFML/Window/Export.hpp>
 #include <SFML/Window/GlResource.hpp>
 #include <SFML/Window/ContextSettings.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -47,7 +46,7 @@ using GlFunctionPointer = void (*)();
 /// \brief Class holding a valid drawing context
 ///
 ////////////////////////////////////////////////////////////
-class SFML_WINDOW_API Context : GlResource, NonCopyable
+class SFML_WINDOW_API Context : GlResource
 {
 public:
 
@@ -67,6 +66,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~Context();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Context(const Context&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Context& operator=(const Context&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Activate or deactivate explicitly the context
     ///

include/SFML/Window/Cursor.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 
 namespace sf
@@ -43,7 +42,7 @@ namespace priv
 /// \brief Cursor defines the appearance of a system cursor
 ///
 ////////////////////////////////////////////////////////////
-class SFML_WINDOW_API Cursor : NonCopyable
+class SFML_WINDOW_API Cursor
 {
 public:
 
@@ -130,6 +129,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~Cursor();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    Cursor(const Cursor&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    Cursor& operator=(const Cursor&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///

include/SFML/Window/GlResource.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -76,7 +75,7 @@ protected:
     /// \brief RAII helper class to temporarily lock an available context for use
     ///
     ////////////////////////////////////////////////////////////
-    class SFML_WINDOW_API TransientContextLock : NonCopyable
+    class SFML_WINDOW_API TransientContextLock
     {
     public:
         ////////////////////////////////////////////////////////////
@@ -90,6 +89,18 @@ protected:
         ///
         ////////////////////////////////////////////////////////////
         ~TransientContextLock();
+
+        ////////////////////////////////////////////////////////////
+        /// \brief Deleted copy constructor
+        ///
+        ////////////////////////////////////////////////////////////
+        TransientContextLock(const TransientContextLock&) = delete;
+
+        ////////////////////////////////////////////////////////////
+        /// \brief Deleted copy assignment
+        ///
+        ////////////////////////////////////////////////////////////
+        TransientContextLock& operator=(const TransientContextLock&) = delete;
     };
 };
 

include/SFML/Window/WindowBase.hpp

@@ -35,7 +35,6 @@
 #include <SFML/Window/WindowHandle.hpp>
 #include <SFML/Window/WindowStyle.hpp>
 #include <SFML/System/Clock.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/String.hpp>
 #include <SFML/System/Vector2.hpp>
 
@@ -53,7 +52,7 @@ class Event;
 /// \brief Window that serves as a base for other windows
 ///
 ////////////////////////////////////////////////////////////
-class SFML_WINDOW_API WindowBase : NonCopyable
+class SFML_WINDOW_API WindowBase
 {
 public:
 
@@ -98,6 +97,18 @@ public:
     ////////////////////////////////////////////////////////////
     virtual ~WindowBase();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    WindowBase(const WindowBase&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    WindowBase& operator=(const WindowBase&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create (or recreate) the window
     ///

src/SFML/Graphics/ImageLoader.hpp

@@ -28,7 +28,7 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
+#include <SFML/Config.hpp>
 #include <SFML/System/Vector2.hpp>
 #include <string>
 #include <vector>
@@ -44,7 +44,7 @@ namespace priv
 /// \brief Load/save image files
 ///
 ////////////////////////////////////////////////////////////
-class ImageLoader : NonCopyable
+class ImageLoader
 {
 public:
 
@@ -131,6 +131,18 @@ private:
     ///
     ////////////////////////////////////////////////////////////
     ~ImageLoader();
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    ImageLoader(const ImageLoader&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    ImageLoader& operator=(const ImageLoader&) = delete;
 };
 
 } // namespace priv

src/SFML/Graphics/RenderTextureImpl.hpp

@@ -28,7 +28,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -42,16 +41,34 @@ namespace priv
 /// \brief Abstract base class for render-texture implementations
 ///
 ////////////////////////////////////////////////////////////
-class RenderTextureImpl : NonCopyable
+class RenderTextureImpl
 {
 public:
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Default constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderTextureImpl() = default;
+
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
     virtual ~RenderTextureImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderTextureImpl(const RenderTextureImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderTextureImpl& operator=(const RenderTextureImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create the render texture implementation
     ///

src/SFML/Graphics/Shader.cpp

@@ -177,7 +177,7 @@ Shader::CurrentTextureType Shader::CurrentTexture;
 
 
 ////////////////////////////////////////////////////////////
-struct Shader::UniformBinder : private NonCopyable
+struct Shader::UniformBinder
 {
     ////////////////////////////////////////////////////////////
     /// \brief Constructor: set up state before uniform is set
@@ -211,6 +211,18 @@ struct Shader::UniformBinder : private NonCopyable
             glCheck(GLEXT_glUseProgramObject(savedProgram));
     }
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    UniformBinder(const UniformBinder&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    UniformBinder& operator=(const UniformBinder&) = delete;
+
     TransientContextLock lock;           //!< Lock to keep context active while uniform is bound
     GLEXT_GLhandle       savedProgram;   //!< Handle to the previously active program object
     GLEXT_GLhandle       currentProgram; //!< Handle to the program object of the modified sf::Shader instance

src/SFML/Network/Ftp.cpp

@@ -39,13 +39,25 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-class Ftp::DataChannel : NonCopyable
+class Ftp::DataChannel
 {
 public:
 
     ////////////////////////////////////////////////////////////
     DataChannel(Ftp& owner);
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    DataChannel(const DataChannel&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    DataChannel& operator=(const DataChannel&) = delete;
+
     ////////////////////////////////////////////////////////////
     Ftp::Response open(Ftp::TransferMode mode);
 

src/SFML/System/CMakeLists.txt

@@ -11,7 +11,6 @@ set(SRC
     ${INCROOT}/Export.hpp
     ${INCROOT}/InputStream.hpp
     ${INCROOT}/NativeActivity.hpp
-    ${INCROOT}/NonCopyable.hpp
     ${SRCROOT}/Sleep.cpp
     ${INCROOT}/Sleep.hpp
     ${SRCROOT}/String.cpp

src/SFML/Window/Android/CursorImpl.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Cursor.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 
 
@@ -44,7 +43,7 @@ namespace priv
 /// This is a typical "not supported" implementation.
 ///
 ////////////////////////////////////////////////////////////
-class CursorImpl : NonCopyable
+class CursorImpl
 {
 public:
 
@@ -64,6 +63,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~CursorImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl(const CursorImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl& operator=(const CursorImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///

src/SFML/Window/GlContext.cpp

@@ -180,7 +180,7 @@ namespace
 
         // This structure contains all the state necessary to
         // track TransientContext usage
-        struct TransientContext : private sf::NonCopyable
+        struct TransientContext
         {
             ////////////////////////////////////////////////////////////
             /// \brief Constructor
@@ -217,6 +217,18 @@ namespace
                 delete context;
             }
 
+            ////////////////////////////////////////////////////////////
+            /// \brief Deleted copy constructor
+            ///
+            ////////////////////////////////////////////////////////////
+            TransientContext(const TransientContext&) = delete;
+
+            ////////////////////////////////////////////////////////////
+            /// \brief Deleted copy assignment
+            ///
+            ////////////////////////////////////////////////////////////
+            TransientContext& operator=(const TransientContext&) = delete;
+
             ///////////////////////////////////////////////////////////
             // Member data
             ////////////////////////////////////////////////////////////

src/SFML/Window/GlContext.hpp

@@ -32,7 +32,6 @@
 #include <SFML/Window/Context.hpp>
 #include <SFML/Window/ContextSettings.hpp>
 #include <SFML/Window/GlResource.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -45,7 +44,7 @@ class WindowImpl;
 /// \brief Abstract class representing an OpenGL context
 ///
 ////////////////////////////////////////////////////////////
-class GlContext : NonCopyable
+class GlContext
 {
 public:
 
@@ -182,6 +181,18 @@ public:
     ////////////////////////////////////////////////////////////
     virtual ~GlContext();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    GlContext(const GlContext&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    GlContext& operator=(const GlContext&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Get the settings of the context
     ///

src/SFML/Window/JoystickManager.hpp

@@ -30,7 +30,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Joystick.hpp>
 #include <SFML/Window/JoystickImpl.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -41,7 +40,7 @@ namespace priv
 /// \brief Global joystick manager
 ///
 ////////////////////////////////////////////////////////////
-class JoystickManager : NonCopyable
+class JoystickManager
 {
 public:
 
@@ -103,6 +102,18 @@ private:
     ////////////////////////////////////////////////////////////
     ~JoystickManager();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    JoystickManager(const JoystickManager&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    JoystickManager& operator=(const JoystickManager&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Joystick information and state
     ///

src/SFML/Window/OSX/CursorImpl.hpp

@@ -30,7 +30,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Cursor.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 
 ////////////////////////////////////////////////////////////
@@ -56,7 +55,7 @@ namespace priv
 /// \brief Mac OS X implementation of Cursor
 ///
 ////////////////////////////////////////////////////////////
-class CursorImpl : NonCopyable
+class CursorImpl
 {
 public:
 
@@ -76,6 +75,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~CursorImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl(const CursorImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl& operator=(const CursorImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///

src/SFML/Window/OSX/HIDInputManager.hpp

@@ -31,7 +31,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/JoystickImpl.hpp>
 #include <SFML/Window/Keyboard.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <Carbon/Carbon.h>
 #include <IOKit/hid/IOHIDDevice.h>
 #include <IOKit/hid/IOHIDManager.h>
@@ -51,7 +50,7 @@ using IOHIDElements = std::vector<IOHIDElementRef>;
 /// Its purpose is to help sf::priv::InputImpl class.
 ///
 ////////////////////////////////////////////////////////////
-class HIDInputManager : NonCopyable
+class HIDInputManager
 {
 public:
 
@@ -133,6 +132,18 @@ private:
     ////////////////////////////////////////////////////////////
     ~HIDInputManager();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    HIDInputManager(const HIDInputManager&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    HIDInputManager& operator=(const HIDInputManager&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Initialize the keyboard part of this class
     ///

src/SFML/Window/OSX/HIDJoystickManager.hpp

@@ -29,7 +29,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
 #include <IOKit/hid/IOHIDDevice.h>
 #include <IOKit/hid/IOHIDManager.h>
 
@@ -44,7 +43,7 @@ namespace priv
 /// It's only purpose is to help sf::priv::JoystickImpl class.
 ///
 ////////////////////////////////////////////////////////////
-class HIDJoystickManager : NonCopyable
+class HIDJoystickManager
 {
 public:
 
@@ -88,6 +87,18 @@ private:
     ////////////////////////////////////////////////////////////
     ~HIDJoystickManager();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    HIDJoystickManager(const HIDJoystickManager&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    HIDJoystickManager& operator=(const HIDJoystickManager&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Make sure all event have been processed in the run loop
     ///

src/SFML/Window/SensorManager.hpp

@@ -30,7 +30,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Sensor.hpp>
 #include <SFML/Window/SensorImpl.hpp>
-#include <SFML/System/NonCopyable.hpp>
 
 
 namespace sf
@@ -41,7 +40,7 @@ namespace priv
 /// \brief Global sensor manager
 ///
 ////////////////////////////////////////////////////////////
-class SensorManager : NonCopyable
+class SensorManager
 {
 public:
 
@@ -112,6 +111,18 @@ private:
     ////////////////////////////////////////////////////////////
     ~SensorManager();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    SensorManager(const SensorManager&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    SensorManager& operator=(const SensorManager&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Sensor information and state
     ///

src/SFML/Window/Unix/CursorImpl.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Cursor.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 #include <SFML/Window/WindowStyle.hpp> // Prevent conflict with macro None from Xlib
 #include <X11/Xlib.h>
@@ -43,7 +42,7 @@ namespace priv
 /// \brief Unix implementation of Cursor
 ///
 ////////////////////////////////////////////////////////////
-class CursorImpl : NonCopyable
+class CursorImpl
 {
 public:
 
@@ -63,6 +62,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~CursorImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl(const CursorImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl& operator=(const CursorImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///

src/SFML/Window/Win32/CursorImpl.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Cursor.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 
 namespace sf
@@ -41,7 +40,7 @@ namespace priv
 /// \brief Win32 implementation of Cursor
 ///
 ////////////////////////////////////////////////////////////
-class CursorImpl : NonCopyable
+class CursorImpl
 {
 public:
 
@@ -61,6 +60,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~CursorImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl(const CursorImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl& operator=(const CursorImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///

src/SFML/Window/WindowImpl.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Config.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/String.hpp>
 #include <SFML/Window/ContextSettings.hpp>
 #include <SFML/Window/CursorImpl.hpp>
@@ -53,7 +52,7 @@ namespace priv
 /// \brief Abstract base class for OS-specific window implementation
 ///
 ////////////////////////////////////////////////////////////
-class WindowImpl : NonCopyable
+class WindowImpl
 {
 public:
 
@@ -88,6 +87,18 @@ public:
     ////////////////////////////////////////////////////////////
     virtual ~WindowImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    WindowImpl(const WindowImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    WindowImpl& operator=(const WindowImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Change the joystick threshold, i.e. the value below which
     ///        no move event will be generated

src/SFML/Window/iOS/CursorImpl.hpp

@@ -29,7 +29,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Cursor.hpp>
-#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Vector2.hpp>
 
 
@@ -44,7 +43,7 @@ namespace priv
 /// This is a typical "not supported" implementation.
 ///
 ////////////////////////////////////////////////////////////
-class CursorImpl : NonCopyable
+class CursorImpl
 {
 public:
 
@@ -64,6 +63,18 @@ public:
     ////////////////////////////////////////////////////////////
     ~CursorImpl();
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl(const CursorImpl&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Deleted copy assignment
+    ///
+    ////////////////////////////////////////////////////////////
+    CursorImpl& operator=(const CursorImpl&) = delete;
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///