diff --git a/Builds/VisualStudio2013/RippleD.vcxproj b/Builds/VisualStudio2013/RippleD.vcxproj index 78ac8aedd..f0cbd65f5 100644 --- a/Builds/VisualStudio2013/RippleD.vcxproj +++ b/Builds/VisualStudio2013/RippleD.vcxproj @@ -965,10 +965,6 @@ True - - - - diff --git a/Builds/VisualStudio2013/RippleD.vcxproj.filters b/Builds/VisualStudio2013/RippleD.vcxproj.filters index dc7ffcfbd..e66ff772a 100644 --- a/Builds/VisualStudio2013/RippleD.vcxproj.filters +++ b/Builds/VisualStudio2013/RippleD.vcxproj.filters @@ -1698,12 +1698,6 @@ beast\net\tests - - beast\smart_ptr - - - beast\smart_ptr - beast\smart_ptr diff --git a/src/beast/beast/Memory.h b/src/beast/beast/Memory.h index e84e0e682..49ff62c89 100644 --- a/src/beast/beast/Memory.h +++ b/src/beast/beast/Memory.h @@ -43,7 +43,7 @@ void zerostruct (Type& structure) noexcept /** Delete an object pointer, and sets the pointer to null. - Remember that it's not good c++ practice to use delete directly - always try to use a ScopedPointer + Remember that it's not good c++ practice to use delete directly - always try to use a std::unique_ptr or other automatic lifetime-management system rather than resorting to deleting raw pointers! */ template diff --git a/src/beast/beast/SmartPtr.h b/src/beast/beast/SmartPtr.h index c1f91ff0c..a76a5850c 100644 --- a/src/beast/beast/SmartPtr.h +++ b/src/beast/beast/SmartPtr.h @@ -22,9 +22,7 @@ #include -#include #include #include -#include #endif diff --git a/src/beast/beast/module/core/files/DirectoryIterator.cpp b/src/beast/beast/module/core/files/DirectoryIterator.cpp index ead47f250..4c5edbc89 100644 --- a/src/beast/beast/module/core/files/DirectoryIterator.cpp +++ b/src/beast/beast/module/core/files/DirectoryIterator.cpp @@ -21,8 +21,9 @@ */ //============================================================================== -namespace beast -{ +#include // + +namespace beast { static StringArray parseWildcards (const String& pattern) { @@ -97,8 +98,9 @@ bool DirectoryIterator::next (bool* const isDirResult, bool* const isHiddenResul if (isDirectory) { if (isRecursive && ((whatToLookFor & File::ignoreHiddenFiles) == 0 || ! isHidden)) - subIterator = new DirectoryIterator (File::createFileWithoutCheckingPath (path + filename), - true, wildCard, whatToLookFor); + subIterator = std::make_unique ( + File::createFileWithoutCheckingPath (path + filename), + true, wildCard, whatToLookFor); matches = (whatToLookFor & File::findDirectories) != 0; } diff --git a/src/beast/beast/module/core/files/DirectoryIterator.h b/src/beast/beast/module/core/files/DirectoryIterator.h index ebe168d2b..10b9cc8b9 100644 --- a/src/beast/beast/module/core/files/DirectoryIterator.h +++ b/src/beast/beast/module/core/files/DirectoryIterator.h @@ -24,8 +24,9 @@ #ifndef BEAST_DIRECTORYITERATOR_H_INCLUDED #define BEAST_DIRECTORYITERATOR_H_INCLUDED -namespace beast -{ +#include + +namespace beast { //============================================================================== /** @@ -129,11 +130,9 @@ private: private: friend class DirectoryIterator; - friend class ScopedPointer; - ScopedPointer pimpl; + std::unique_ptr pimpl; }; - friend class ScopedPointer; StringArray wildCards; NativeIterator fileFinder; String wildCard, path; @@ -142,7 +141,7 @@ private: const int whatToLookFor; const bool isRecursive; bool hasBeenAdvanced; - ScopedPointer subIterator; + std::unique_ptr subIterator; File currentFile; }; diff --git a/src/beast/beast/module/core/files/File.cpp b/src/beast/beast/module/core/files/File.cpp index f613ba009..9bf40a1d7 100644 --- a/src/beast/beast/module/core/files/File.cpp +++ b/src/beast/beast/module/core/files/File.cpp @@ -22,6 +22,7 @@ //============================================================================== #include +#include namespace beast { @@ -674,7 +675,7 @@ bool File::startAsProcess (const String& parameters) const //============================================================================== FileInputStream* File::createInputStream() const { - ScopedPointer fin (new FileInputStream (*this)); + std::unique_ptr fin (new FileInputStream (*this)); if (fin->openedOk()) return fin.release(); @@ -684,7 +685,7 @@ FileInputStream* File::createInputStream() const FileOutputStream* File::createOutputStream (const size_t bufferSize) const { - ScopedPointer out (new FileOutputStream (*this, bufferSize)); + std::unique_ptr out (new FileOutputStream (*this, bufferSize)); return out->failedToOpen() ? nullptr : out.release(); diff --git a/src/beast/beast/module/core/files/TemporaryFile.h b/src/beast/beast/module/core/files/TemporaryFile.h index e11c04ac0..1c47c7ccc 100644 --- a/src/beast/beast/module/core/files/TemporaryFile.h +++ b/src/beast/beast/module/core/files/TemporaryFile.h @@ -45,7 +45,7 @@ namespace beast TemporaryFile temp (myTargetFile); // create a stream to the temporary file, and write some data to it... - ScopedPointer out (temp.getFile().createOutputStream()); + std::unique_ptr out (temp.getFile().createOutputStream()); if (out != nullptr) { diff --git a/src/beast/beast/smart_ptr/ContainerDeletePolicy.h b/src/beast/beast/smart_ptr/ContainerDeletePolicy.h deleted file mode 100644 index 9d65bf11a..000000000 --- a/src/beast/beast/smart_ptr/ContainerDeletePolicy.h +++ /dev/null @@ -1,52 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of Beast: https://github.com/vinniefalco/Beast - Copyright 2013, Vinnie Falco - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -#ifndef BEAST_SMARTPTR_CONTAINERDELETEPOLICY_H_INCLUDED -#define BEAST_SMARTPTR_CONTAINERDELETEPOLICY_H_INCLUDED - -namespace beast { - -/** The DeletePolicy provides a way to destroy objects stored in containers. - - This is a specialized class. The default implementation - calls operator delete. You can customize it for your classes - by providing a suitable specialization. - - A DeletePolicy must support these concepts: - DefaultConstructible - MoveConstructible (C++11) - CopyConstructible - MoveAssignable (C++11) - Destructible -*/ - -/** The DefaultDeletePolicy simply calls operator delete. -*/ -template -struct ContainerDeletePolicy -{ - static inline void destroy (T* t) - { - delete t; - } -}; - -} - -#endif diff --git a/src/beast/beast/smart_ptr/ScopedPointer.h b/src/beast/beast/smart_ptr/ScopedPointer.h deleted file mode 100644 index 52eb1c70d..000000000 --- a/src/beast/beast/smart_ptr/ScopedPointer.h +++ /dev/null @@ -1,271 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of Beast: https://github.com/vinniefalco/Beast - Copyright 2013, Vinnie Falco - - Portions of this file are from JUCE. - Copyright (c) 2013 - Raw Material Software Ltd. - Please visit http://www.juce.com - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -#ifndef BEAST_SMARTPTR_SCOPEDPOINTER_H_INCLUDED -#define BEAST_SMARTPTR_SCOPEDPOINTER_H_INCLUDED - -#include -#include -#include -#include -#include - -namespace beast { - -//============================================================================== -/** - This class holds a pointer which is automatically deleted when this object goes - out of scope. - - Once a pointer has been passed to a ScopedPointer, it will make sure that the pointer - gets deleted when the ScopedPointer is deleted. Using the ScopedPointer on the stack or - as member variables is a good way to use RAII to avoid accidentally leaking dynamically - created objects. - - A ScopedPointer can be used in pretty much the same way that you'd use a normal pointer - to an object. If you use the assignment operator to assign a different object to a - ScopedPointer, the old one will be automatically deleted. - - Important note: The class is designed to hold a pointer to an object, NOT to an array! - It calls delete on its payload, not delete[], so do not give it an array to hold! For - that kind of purpose, you should be using HeapBlock or Array instead. - - A const ScopedPointer is guaranteed not to lose ownership of its object or change the - object to which it points during its lifetime. This means that making a copy of a const - ScopedPointer is impossible, as that would involve the new copy taking ownership from the - old one. - - If you need to get a pointer out of a ScopedPointer without it being deleted, you - can use the release() method. - - Something to note is the main difference between this class and the std::auto_ptr class, - which is that ScopedPointer provides a cast-to-object operator, wheras std::auto_ptr - requires that you always call get() to retrieve the pointer. The advantages of providing - the cast is that you don't need to call get(), so can use the ScopedPointer in pretty much - exactly the same way as a raw pointer. The disadvantage is that the compiler is free to - use the cast in unexpected and sometimes dangerous ways - in particular, it becomes difficult - to return a ScopedPointer as the result of a function. To avoid this causing errors, - ScopedPointer contains an overloaded constructor that should cause a syntax error in these - circumstances, but it does mean that instead of returning a ScopedPointer from a function, - you'd need to return a raw pointer (or use a std::auto_ptr instead). -*/ -template -class ScopedPointer : public Uncopyable -{ -public: - //============================================================================== - /** Creates a ScopedPointer containing a null pointer. */ - inline ScopedPointer() - : object (nullptr) - { - } - - /** Creates a ScopedPointer that owns the specified object. */ - inline ScopedPointer (ObjectType* const objectToTakePossessionOf) - : object (objectToTakePossessionOf) - { - } - - /** Creates a ScopedPointer that takes its pointer from another ScopedPointer. - - Because a pointer can only belong to one ScopedPointer, this transfers - the pointer from the other object to this one, and the other object is reset to - be a null pointer. - */ - ScopedPointer (ScopedPointer& objectToTransferFrom) - : object (objectToTransferFrom.object) - { - objectToTransferFrom.object = nullptr; - } - - /** Destructor. - This will delete the object that this ScopedPointer currently refers to. - */ - inline ~ScopedPointer() - { - ContainerDeletePolicy ::destroy (object); - } - - /** Changes this ScopedPointer to point to a new object. - - Because a pointer can only belong to one ScopedPointer, this transfers - the pointer from the other object to this one, and the other object is reset to - be a null pointer. - - If this ScopedPointer already points to an object, that object - will first be deleted. - */ - ScopedPointer& operator= (ScopedPointer& objectToTransferFrom) - { - if (this != objectToTransferFrom.getAddress()) - { - // Two ScopedPointers should never be able to refer to the same object - if - // this happens, you must have done something dodgy! - bassert (object == nullptr || object != objectToTransferFrom.object); - - ObjectType* const oldObject = object; - object = objectToTransferFrom.object; - objectToTransferFrom.object = nullptr; - ContainerDeletePolicy ::destroy (oldObject); - } - - return *this; - } - - /** Changes this ScopedPointer to point to a new object. - - If this ScopedPointer already points to an object, that object - will first be deleted. - - The pointer that you pass in may be a nullptr. - */ - ScopedPointer& operator= (ObjectType* const newObjectToTakePossessionOf) - { - if (object != newObjectToTakePossessionOf) - { - ObjectType* const oldObject = object; - object = newObjectToTakePossessionOf; - ContainerDeletePolicy ::destroy (oldObject); - } - - return *this; - } - - #if BEAST_COMPILER_SUPPORTS_MOVE_SEMANTICS - ScopedPointer (ScopedPointer&& other) - : object (other.object) - { - other.object = nullptr; - } - - ScopedPointer& operator= (ScopedPointer&& other) - { - object = other.object; - other.object = nullptr; - return *this; - } - #endif - - //============================================================================== - /** Returns the object that this ScopedPointer refers to. */ - inline operator ObjectType*() const { return object; } - - /** Returns the object that this ScopedPointer refers to. */ - inline ObjectType* get() const { return object; } - - /** Returns the object that this ScopedPointer refers to. */ - inline ObjectType& operator*() const { return *object; } - - /** Lets you access methods and properties of the object that this ScopedPointer refers to. */ - inline ObjectType* operator->() const { return object; } - - //============================================================================== - /** Removes the current object from this ScopedPointer without deleting it. - This will return the current object, and set the ScopedPointer to a null pointer. - */ - ObjectType* release() { ObjectType* const o = object; object = nullptr; return o; } - - void reset (ObjectType* object_) - { - if (object != object_) - { - ContainerDeletePolicy ::destroy (object); - object = object_; - } - } - - //============================================================================== - /** Swaps this object with that of another ScopedPointer. - The two objects simply exchange their pointers. - */ - void swapWith (ScopedPointer & other) - { - // Two ScopedPointers should never be able to refer to the same object - if - // this happens, you must have done something dodgy! - bassert (object != other.object || this == other.getAddress()); - - std::swap (object, other.object); - } - - /** If the pointer is non-null, this will attempt to return a new copy of the object that is pointed to. - If the pointer is null, this will safely return a nullptr. - */ - inline ObjectType* createCopy() const { return createCopyIfNotNull (object); } - -private: - //============================================================================== - ObjectType* object; - - // (Required as an alternative to the overloaded & operator). - const ScopedPointer* getAddress() const { return this; } - - #if ! BEAST_MSVC // (MSVC can't deal with multiple copy constructors) - /* The copy constructors are private to stop people accidentally copying a const ScopedPointer - (the compiler would let you do so by implicitly casting the source to its raw object pointer). - - A side effect of this is that in a compiler that doesn't support C++11, you may hit an - error when you write something like this: - - ScopedPointer m = new MyClass(); // Compile error: copy constructor is private. - - Even though the compiler would normally ignore the assignment here, it can't do so when the - copy constructor is private. It's very easy to fix though - just write it like this: - - ScopedPointer m (new MyClass()); // Compiles OK - - It's probably best to use the latter form when writing your object declarations anyway, as - this is a better representation of the code that you actually want the compiler to produce. - */ - #endif -}; - -//============================================================================== -/** Compares a ScopedPointer with another pointer. - This can be handy for checking whether this is a null pointer. -*/ -template -bool operator== (const ScopedPointer& pointer1, ObjectType* const pointer2) -{ - return static_cast (pointer1) == pointer2; -} - -/** Compares a ScopedPointer with another pointer. - This can be handy for checking whether this is a null pointer. -*/ -template -bool operator!= (const ScopedPointer& pointer1, ObjectType* const pointer2) -{ - return static_cast (pointer1) != pointer2; -} - -//============================================================================== -#ifndef DOXYGEN -// NB: This is just here to prevent any silly attempts to call deleteAndZero() on a ScopedPointer. -template -void deleteAndZero (ScopedPointer&) { static_bassert (sizeof (Type) == 12345); } -#endif - -} - -#endif - diff --git a/src/beast/beast/smart_ptr/SharedObject.h b/src/beast/beast/smart_ptr/SharedObject.h index 1ceca91dd..12f21b213 100644 --- a/src/beast/beast/smart_ptr/SharedObject.h +++ b/src/beast/beast/smart_ptr/SharedObject.h @@ -77,15 +77,7 @@ public: ++refCount; } - /** Decreases the object's reference count. - - If doDelete is true the object will be deleted when the reference - count drops to zero. The delete is performed using the regular - operator and does NOT go through the ContainerDeletePolicy. - - The return value indicates if the reference count dropped to zero, - so callers who know the derived type can use the ContainerDeletePolicy. - */ + /** Decreases the object's reference count. */ void decReferenceCount () const { bassert (getReferenceCount() > 0);