[Usd] Boost Noncopyable

pxr/base/lib/plug/plugin.h

@@ -32,7 +32,6 @@
 #include "pxr/base/tf/refPtr.h"
 #include "pxr/base/tf/weakPtr.h"
 
-#include <boost/noncopyable.hpp>
 #include <atomic>
 #include <string>
 #include <utility>

pxr/base/lib/tf/atomicOfstreamWrapper.h

@@ -30,8 +30,6 @@
 #include "pxr/pxr.h"
 #include "pxr/base/tf/api.h"
 
-#include <boost/noncopyable.hpp>
-
 #include <fstream>
 #include <string>
 
@@ -76,12 +74,16 @@ PXR_NAMESPACE_OPEN_SCOPE
 /// // called, and the temporary file is removed.
 /// \endcode
 ///
-class TfAtomicOfstreamWrapper : boost::noncopyable
+class TfAtomicOfstreamWrapper
 {
 public:
     /// Constructor.
     TF_API explicit TfAtomicOfstreamWrapper(const std::string& filePath);
 
+    // Disallow copies
+    TfAtomicOfstreamWrapper(const TfAtomicOfstreamWrapper&) = delete;
+    TfAtomicOfstreamWrapper& operator=(const TfAtomicOfstreamWrapper&) = delete;
+
     /// Destructor. Calls Cancel().
     TF_API ~TfAtomicOfstreamWrapper();
 

pxr/base/lib/tf/debug.cpp

@@ -79,8 +79,12 @@ static const char* _helpMsg =
     "enables debugging for any symbol in STAF, all symbols in SIC except for\n"
     "SIC_REGISTRY_ENUMS and the symbol GPT_IK.\n";
 
-class ARCH_HIDDEN Tf_DebugSymbolRegistry : boost::noncopyable {
+class ARCH_HIDDEN Tf_DebugSymbolRegistry {
 public:
+    // Disallow copies
+    Tf_DebugSymbolRegistry(const Tf_DebugSymbolRegistry&) = delete;
+    Tf_DebugSymbolRegistry& operator=(const Tf_DebugSymbolRegistry&) = delete;
+
     static Tf_DebugSymbolRegistry& _GetInstance() {
         return TfSingleton<Tf_DebugSymbolRegistry>::GetInstance();
     }

pxr/base/lib/tf/enum.cpp

@@ -37,7 +37,6 @@
 
 #include "pxr/base/arch/demangle.h"
 
-#include <boost/noncopyable.hpp>
 #include "pxr/base/tf/hashmap.h"
 
 #include <tbb/spin_mutex.h>
@@ -62,8 +61,12 @@ typedef TfHashMap<string, TfEnum, TfHash> _NameToEnumTableType;
 typedef TfHashMap<string, vector<string>, TfHash> _TypeNameToNameVectorTableType;
 typedef TfHashMap<string, const type_info *, TfHash> _TypeNameToTypeTableType;
 
-class Tf_EnumRegistry : boost::noncopyable {
+class Tf_EnumRegistry {
 private:
+    // Disallow copies
+    Tf_EnumRegistry(const Tf_EnumRegistry&) = delete;
+    Tf_EnumRegistry& operator=(const Tf_EnumRegistry&) = delete;
+
     static Tf_EnumRegistry& _GetInstance() {
         return TfSingleton<Tf_EnumRegistry>::GetInstance();
     }

pxr/base/lib/tf/errorMark.h

@@ -31,8 +31,6 @@
 #include "pxr/base/tf/errorTransport.h"
 #include "pxr/base/tf/api.h"
 
-#include <boost/noncopyable.hpp>
-
 PXR_NAMESPACE_OPEN_SCOPE
 
 /// \class TfErrorMark
@@ -63,10 +61,9 @@ PXR_NAMESPACE_OPEN_SCOPE
 ///      }
 /// \endcode
 ///
-class TfErrorMark : boost::noncopyable
+class TfErrorMark
 {
   public:
-
     typedef TfDiagnosticMgr::ErrorIterator Iterator;
 
     /// Default constructor.
@@ -75,6 +72,10 @@ class TfErrorMark : boost::noncopyable
     /// of declaration.
     TF_API TfErrorMark();
 
+    // Disallow copies
+    TfErrorMark(const TfErrorMark&) = delete;
+    TfErrorMark& operator=(const TfErrorMark&) = delete;
+
     /// Destroy this ErrorMark.
     ///
     /// If this is the last ErrorMark on this thread of execution and there

pxr/base/lib/tf/fileUtils.cpp

@@ -36,7 +36,6 @@
 
 #include <boost/assign.hpp>
 #include <boost/functional/hash.hpp>
-#include <boost/noncopyable.hpp>
 #include "pxr/base/tf/hashset.h"
 
 #include <set>

pxr/base/lib/tf/noticeRegistry.h

@@ -36,8 +36,6 @@
 #include "pxr/base/tf/singleton.h"
 #include "pxr/base/tf/type.h"
 
-#include <boost/noncopyable.hpp>
-
 #include <tbb/enumerable_thread_specific.h>
 #include <tbb/spin_mutex.h>
 #include <atomic>
@@ -68,8 +66,12 @@ PXR_NAMESPACE_OPEN_SCOPE
 /// registry, since multiple active traversals (either by different threads,
 /// or because of reentrancy) should be rare.
 ///
-class Tf_NoticeRegistry : boost::noncopyable {
+class Tf_NoticeRegistry {
 public:
+    // Disallow copies
+    Tf_NoticeRegistry(const Tf_NoticeRegistry&) = delete;
+    Tf_NoticeRegistry& operator=(const Tf_NoticeRegistry&) = delete;
+
     TF_API
     void _BeginDelivery(const TfNotice &notice,
                         const TfWeakBase *sender,

pxr/base/lib/tf/patternMatcher.h

@@ -47,7 +47,6 @@ PXR_NAMESPACE_OPEN_SCOPE
 ///
 class TfPatternMatcher
 {
-
   public:
 
     /// Construct an empty (invalid) TfPatternMatcher.

pxr/imaging/lib/cameraUtil/pch.h

@@ -81,7 +81,6 @@
 #include <boost/mpl/pop_front.hpp>
 #include <boost/mpl/remove.hpp>
 #include <boost/mpl/vector.hpp>
-#include <boost/noncopyable.hpp>
 #include <boost/operators.hpp>
 #include <boost/optional.hpp>
 #include <boost/preprocessor/arithmetic/add.hpp>

pxr/imaging/lib/glf/baseTextureData.h

@@ -33,21 +33,25 @@
 #include "pxr/base/tf/refPtr.h"
 #include "pxr/base/tf/weakPtr.h"
 
-#include <boost/noncopyable.hpp>
-
 PXR_NAMESPACE_OPEN_SCOPE
 
 
 TF_DECLARE_WEAK_AND_REF_PTRS(GlfBaseTextureData);
 
 class GlfBaseTextureData : public TfRefBase,
-                           public TfWeakBase,
-                           boost::noncopyable
+                           public TfWeakBase
 {
 public:
     GLF_API
     virtual ~GlfBaseTextureData();
 
+    GLF_API
+    GlfBaseTextureData() = default;
+
+    // Disallow copies
+    GlfBaseTextureData(const GlfBaseTextureData&) = delete;
+    GlfBaseTextureData& operator=(const GlfBaseTextureData&) = delete;
+
     struct WrapInfo {
         WrapInfo() :
           hasWrapModeS(false), hasWrapModeT(false),

pxr/imaging/lib/glf/contextCaps.h

@@ -28,8 +28,6 @@
 #include "pxr/imaging/glf/api.h"
 #include "pxr/base/tf/singleton.h"
 
-#include <boost/noncopyable.hpp>
-
 PXR_NAMESPACE_OPEN_SCOPE
 
 
@@ -56,7 +54,7 @@ PXR_NAMESPACE_OPEN_SCOPE
 ///     subscribe to when the caps changes, so they can
 ///     update and invalidate.
 ///
-class GlfContextCaps : boost::noncopyable {
+class GlfContextCaps {
 public:
 
     /// InitInstance queries the GL context for its capabilities.
@@ -74,6 +72,10 @@ class GlfContextCaps : boost::noncopyable {
 
 
 
+    // Disallow copies
+    GlfContextCaps(const GlfContextCaps&) = delete;
+    GlfContextCaps& operator=(const GlfContextCaps&) = delete;
+
     // GL version
     int glVersion;                    // 400 (4.0), 410 (4.1), ...
 

pxr/imaging/lib/glf/glContext.h

@@ -27,7 +27,6 @@
 #include "pxr/pxr.h"
 #include "pxr/imaging/glf/api.h"
 #include "pxr/base/arch/threads.h"
-#include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
 
 PXR_NAMESPACE_OPEN_SCOPE
@@ -49,11 +48,15 @@ typedef boost::shared_ptr<class GlfGLContext> GlfGLContextSharedPtr;
 /// This mechanism depends on the application code registering callbacks to
 /// provide access to its GL contexts.
 ///
-class GlfGLContext : public boost::noncopyable {
+class GlfGLContext {
 public:
     GLF_API
     virtual ~GlfGLContext();
 
+    // Disallow copies
+    GlfGLContext(const GlfGLContext&) = delete;
+    GlfGLContext& operator=(const GlfGLContext&) = delete;
+
     /// Returns an instance for the current GL context.
     GLF_API
     static GlfGLContextSharedPtr GetCurrentGLContext();
@@ -162,13 +165,17 @@ class GlfGLContext : public boost::noncopyable {
 /// The underlying calls to make GL contexts current can be moderately
 /// expensive.  So, this mechanism should be used carefully.
 ///
-class GlfGLContextScopeHolder : boost::noncopyable {
+class GlfGLContextScopeHolder {
 public:
     /// Make the given context current and restore the current context
     /// when this object is destroyed.
     GLF_API
     explicit GlfGLContextScopeHolder(const GlfGLContextSharedPtr& newContext);
 
+    // Disallow copies
+    GlfGLContextScopeHolder(const GlfGLContextScopeHolder&) = delete;
+    GlfGLContextScopeHolder& operator=(const GlfGLContextScopeHolder&) = delete;
+
     GLF_API
     ~GlfGLContextScopeHolder();
 
@@ -249,11 +256,17 @@ class GlfSharedGLContextScopeHolder : private GlfGLContextScopeHolder {
 /// If you subclass GlfGLContext you should subclass this type and
 /// instantiate an instance on the heap.  It will be cleaned up
 /// automatically.
-class GlfGLContextRegistrationInterface : boost::noncopyable {
+class GlfGLContextRegistrationInterface {
 public:
     GLF_API
     virtual ~GlfGLContextRegistrationInterface();
 
+    // Disallow copies
+    GlfGLContextRegistrationInterface(
+        const GlfGLContextRegistrationInterface&) = delete;
+    GlfGLContextRegistrationInterface& operator=(
+        const GlfGLContextRegistrationInterface&) = delete;
+
     /// If this GLContext system supports a shared context this should
     /// return it.  This will be called at most once.
     virtual GlfGLContextSharedPtr GetShared() = 0;

pxr/imaging/lib/glf/glContextRegistry.h

@@ -29,7 +29,6 @@
 #include "pxr/pxr.h"
 #include "pxr/imaging/glf/glContext.h"
 #include "pxr/base/tf/singleton.h"
-#include <boost/noncopyable.hpp>
 #include <boost/optional.hpp>
 #include <boost/ptr_container/ptr_vector.hpp>
 #include <boost/scoped_ptr.hpp>
@@ -46,8 +45,12 @@ typedef boost::shared_ptr<class GlfGLContext> GlfGLContextSharedPtr;
 ///
 /// Registry of GlfGLContexts.
 ///
-class GlfGLContextRegistry : boost::noncopyable {
+class GlfGLContextRegistry {
 public:
+    // Disallow copies
+    GlfGLContextRegistry(const GlfGLContextRegistry&) = delete;
+    GlfGLContextRegistry& operator=(const GlfGLContextRegistry&) = delete;
+
     static GlfGLContextRegistry& GetInstance()
     {
         return TfSingleton<GlfGLContextRegistry>::GetInstance();

pxr/imaging/lib/glf/image.h

@@ -35,7 +35,6 @@
 #include "pxr/base/vt/dictionary.h"
 #include "pxr/base/vt/value.h"
 
-#include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
 
 #include <string>
@@ -51,18 +50,23 @@ typedef boost::shared_ptr<class GlfImage> GlfImageSharedPtr;
 ///
 /// The class allows basic access to texture image file data.
 ///
-class GlfImage : public boost::noncopyable {
-
+class GlfImage {
 public:
+    GLF_API
+    GlfImage() = default;
+
+    // Disallow copies
+    GlfImage(const GlfImage&) = delete;
+    GlfImage& operator=(const GlfImage&) = delete;
 
     /// Specifies whether to treat the image origin as the upper-left corner
     /// or the lower left
     enum ImageOriginLocation
     {
-        OriginUpperLeft, 
+        OriginUpperLeft,
         OriginLowerLeft
-    }; 
-   
+    };
+
     /// \class StorageSpec
     ///
     /// Describes the memory layout and storage of a texture image

pxr/imaging/lib/glf/simpleShadowArray.h

@@ -36,21 +36,23 @@
 #include "pxr/base/gf/vec4d.h"
 #include "pxr/imaging/garch/gl.h"
 
-#include <boost/noncopyable.hpp>
 #include <vector>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
 
 class GlfSimpleShadowArray : public TfRefBase,
-                             public TfWeakBase,
-                             boost::noncopyable {
+                             public TfWeakBase {
 public:
     GLF_API
     GlfSimpleShadowArray(GfVec2i const & size, size_t numLayers);
     GLF_API
     virtual ~GlfSimpleShadowArray();
 
+    // Disallow copies
+    GlfSimpleShadowArray(const GlfSimpleShadowArray&) = delete;
+    GlfSimpleShadowArray& operator=(const GlfSimpleShadowArray&) = delete;
+
     GLF_API
     GfVec2i GetSize() const;
     GLF_API

pxr/imaging/lib/glf/texture.h

@@ -40,7 +40,6 @@
 #include <map>
 #include <string>
 #include <vector>
-#include <boost/noncopyable.hpp>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -60,7 +59,7 @@ TF_DECLARE_WEAK_AND_REF_PTRS(GlfTexture);
 /// A texture is typically defined by reading texture image data from an image
 /// file but a texture might also represent an attachment of a draw target.
 ///
-class GlfTexture : public TfRefBase, public TfWeakBase, boost::noncopyable {
+class GlfTexture : public TfRefBase, public TfWeakBase {
 public:
     /// \class Binding
     ///
@@ -90,6 +89,10 @@ class GlfTexture : public TfRefBase, public TfWeakBase, boost::noncopyable {
     GLF_API
     virtual ~GlfTexture() = 0;
 
+    // Disallow copies
+    GlfTexture(const GlfTexture&) = delete;
+    GlfTexture& operator=(const GlfTexture&) = delete;
+
     /// Returns the bindings to use this texture for the shader resource
     /// named \a identifier. If \a samplerId is specified, the bindings
     /// returned will use this samplerId for resources which can be sampled.