KXStudio
/
Repository
mirror of https://github.com/KXStudio/Repository
1
0
Fork 0
Code Releases 2 Activity
External, Non-PPA KXStudio Repository
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
158 Commits
1 Branch
2.4MB
Tree: f072b7f155
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f072b7f155'
${ noResults }
Repository/sources/libs/kxstudio-build-scripts/carla-fixes.patch

990 lines
35KB
Raw Blame History 

  1. diff --git a/source/modules/water/buffers/AudioSampleBuffer.h b/source/modules/water/buffers/AudioSampleBuffer.h

  2. index 1716c5efd..8ae1e6388 100644

  3. --- a/source/modules/water/buffers/AudioSampleBuffer.h

  4. +++ b/source/modules/water/buffers/AudioSampleBuffer.h

  5. @@ -205,39 +205,6 @@ public:

  6.      */

  7.      ~AudioSampleBuffer() noexcept {}

  8.  

  9. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  10. -    /** Move constructor */

  11. -    AudioSampleBuffer (AudioSampleBuffer&& other) noexcept

  12. -        : numChannels (other.numChannels),

  13. -          size (other.size),

  14. -          allocatedBytes (other.allocatedBytes),

  15. -          channels (other.channels),

  16. -          allocatedData (static_cast<HeapBlock<char>&&> (other.allocatedData)),

  17. -          isClear (other.isClear)

  18. -    {

  19. -        std::memcpy (preallocatedChannelSpace, other.preallocatedChannelSpace, sizeof (preallocatedChannelSpace));

  20. -        other.numChannels = 0;

  21. -        other.size = 0;

  22. -        other.allocatedBytes = 0;

  23. -    }

  24. -

  25. -    /** Move assignment */

  26. -    AudioSampleBuffer& operator= (AudioSampleBuffer&& other) noexcept

  27. -    {

  28. -        numChannels = other.numChannels;

  29. -        size = other.size;

  30. -        allocatedBytes = other.allocatedBytes;

  31. -        channels = other.channels;

  32. -        allocatedData = static_cast<HeapBlock<char>&&> (other.allocatedData);

  33. -        isClear = other.isClear;

  34. -        memcpy (preallocatedChannelSpace, other.preallocatedChannelSpace, sizeof (preallocatedChannelSpace));

  35. -        other.numChannels = 0;

  36. -        other.size = 0;

  37. -        other.allocatedBytes = 0;

  38. -        return *this;

  39. -    }

  40. -   #endif

  41. -

  42.      //==============================================================================

  43.      /** Returns the number of channels of audio data that this buffer contains.

  44.          @see getSampleData

  45. diff --git a/source/modules/water/containers/Array.h b/source/modules/water/containers/Array.h

  46. index a03857e55..e4367c9f2 100644

  47. --- a/source/modules/water/containers/Array.h

  48. +++ b/source/modules/water/containers/Array.h

  49. @@ -81,15 +81,6 @@ public:

  50.              new (data.elements + i) ElementType (other.data.elements[i]);

  51.      }

  52.  

  53. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  54. -    Array (Array<ElementType>&& other) noexcept

  55. -        : data (static_cast<ArrayAllocationBase<ElementType>&&> (other.data)),

  56. -          numUsed (other.numUsed)

  57. -    {

  58. -        other.numUsed = 0;

  59. -    }

  60. -   #endif

  61. -

  62.      /** Initalises from a null-terminated C array of values.

  63.  

  64.          @param values   the array to copy from

  65. @@ -137,17 +128,6 @@ public:

  66.          return *this;

  67.      }

  68.  

  69. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  70. -    Array& operator= (Array&& other) noexcept

  71. -    {

  72. -        deleteAllElements();

  73. -        data = static_cast<ArrayAllocationBase<ElementType>&&> (other.data);

  74. -        numUsed = other.numUsed;

  75. -        other.numUsed = 0;

  76. -        return *this;

  77. -    }

  78. -   #endif

  79. -

  80.      //==============================================================================

  81.      /** Compares this array to another one.

  82.          Two arrays are considered equal if they both contain the same set of

  83. @@ -380,22 +360,6 @@ public:

  84.          return true;

  85.      }

  86.  

  87. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  88. -    /** Appends a new element at the end of the array.

  89. -

  90. -        @param newElement       the new object to add to the array

  91. -        @see set, insert, addIfNotAlreadyThere, addSorted, addUsingDefaultSort, addArray

  92. -    */

  93. -    bool add (ElementType&& newElement) noexcept

  94. -    {

  95. -        if (! data.ensureAllocatedSize (static_cast<size_t>(numUsed + 1)))

  96. -            return false;

  97. -

  98. -        new (data.elements + numUsed++) ElementType (static_cast<ElementType&&> (newElement));

  99. -        return true;

  100. -    }

  101. -   #endif

  102. -

  103.      /** Inserts a new element into the array at a given position.

  104.  

  105.          If the index is less than 0 or greater than the size of the array, the

  106. diff --git a/source/modules/water/containers/ArrayAllocationBase.h b/source/modules/water/containers/ArrayAllocationBase.h

  107. index f3049d8e5..878ad81fc 100644

  108. --- a/source/modules/water/containers/ArrayAllocationBase.h

  109. +++ b/source/modules/water/containers/ArrayAllocationBase.h

  110. @@ -44,29 +44,6 @@ namespace water {

  111.  template <class ElementType>

  112.  class ArrayAllocationBase

  113.  {

  114. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  115. -private:

  116. -   #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5

  117. -    template <typename T>

  118. -    struct IsTriviallyCopyable : std::integral_constant<bool, false> {};

  119. -   #else

  120. -    template <typename T>

  121. -    using IsTriviallyCopyable = std::is_trivially_copyable<T>;

  122. -   #endif

  123. -

  124. -    template <typename T>

  125. -    using TriviallyCopyableVoid = typename std::enable_if<IsTriviallyCopyable<T>::value, void>::type;

  126. -

  127. -    template <typename T>

  128. -    using TriviallyCopyableBool = typename std::enable_if<IsTriviallyCopyable<T>::value, bool>::type;

  129. -

  130. -    template <typename T>

  131. -    using NonTriviallyCopyableVoid = typename std::enable_if<! IsTriviallyCopyable<T>::value, void>::type;

  132. -

  133. -    template <typename T>

  134. -    using NonTriviallyCopyableBool = typename std::enable_if<! IsTriviallyCopyable<T>::value, bool>::type;

  135. -#endif // WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  136. -

  137.  public:

  138.      //==============================================================================

  139.      /** Creates an empty array. */

  140. @@ -81,19 +58,6 @@ public:

  141.      {

  142.      }

  143.  

  144. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  145. -    ArrayAllocationBase (ArrayAllocationBase<ElementType>&& other) noexcept

  146. -        : elements (static_cast<HeapBlock<ElementType>&&> (other.elements)),

  147. -          numAllocated (other.numAllocated) {}

  148. -

  149. -    ArrayAllocationBase& operator= (ArrayAllocationBase<ElementType>&& other) noexcept

  150. -    {

  151. -        elements = static_cast<HeapBlock<ElementType>&&> (other.elements);

  152. -        numAllocated = other.numAllocated;

  153. -        return *this;

  154. -    }

  155. -   #endif

  156. -

  157.      //==============================================================================

  158.      /** Changes the amount of storage allocated.

  159.  

  160. @@ -102,12 +66,7 @@ public:

  161.  

  162.          @param numNewElements  the number of elements that are needed

  163.      */

  164. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  165. -    template <typename T = ElementType> TriviallyCopyableBool<T>

  166. -   #else

  167. -    bool

  168. -   #endif

  169. -    setAllocatedSize (const size_t numNewElements) noexcept

  170. +    bool setAllocatedSize (const size_t numNewElements) noexcept

  171.      {

  172.          if (numAllocated != numNewElements)

  173.          {

  174. @@ -127,43 +86,6 @@ public:

  175.          return true;

  176.      }

  177.  

  178. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  179. -    template <typename T = ElementType>

  180. -    NonTriviallyCopyableBool<T> setAllocatedSize (const size_t numNewElements) noexcept

  181. -    {

  182. -        if (numAllocated == numNewElements)

  183. -            return true;

  184. -

  185. -        if (numNewElements > 0)

  186. -        {

  187. -            HeapBlock<ElementType> newElements;

  188. -

  189. -            if (! newElements.malloc (numNewElements))

  190. -                return false;

  191. -

  192. -            size_t i = 0;

  193. -

  194. -            for (; i < numAllocated && i < numNewElements; ++i)

  195. -            {

  196. -                new (newElements + i) ElementType (std::move (elements[i]));

  197. -                elements[i].~ElementType();

  198. -            }

  199. -

  200. -            for (; i < numNewElements; ++i)

  201. -                new (newElements + i) ElementType ();

  202. -

  203. -            elements = std::move (newElements);

  204. -        }

  205. -        else

  206. -        {

  207. -            elements.free();

  208. -        }

  209. -

  210. -        numAllocated = numNewElements;

  211. -        return true;

  212. -    }

  213. -   #endif

  214. -

  215.      /** Increases the amount of storage allocated if it is less than a given amount.

  216.  

  217.          This will retain any data currently held in the array, but will add

  218. @@ -198,12 +120,7 @@ public:

  219.          std::swap (numAllocated, other.numAllocated);

  220.      }

  221.  

  222. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  223. -    template <typename T = ElementType> TriviallyCopyableVoid<T>

  224. -   #else

  225. -    void

  226. -   #endif

  227. -    moveMemory (ElementType* target, const ElementType* source, const size_t numElements) noexcept

  228. +    void moveMemory (ElementType* target, const ElementType* source, const size_t numElements) noexcept

  229.      {

  230.          CARLA_SAFE_ASSERT_RETURN(target != nullptr,);

  231.          CARLA_SAFE_ASSERT_RETURN(source != nullptr,);

  232. @@ -213,42 +130,6 @@ public:

  233.          std::memmove (target, source, ((size_t) numElements) * sizeof (ElementType));

  234.      }

  235.  

  236. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  237. -    template <typename T = ElementType>

  238. -    NonTriviallyCopyableVoid<T> moveMemory (ElementType* target, const ElementType* source, const size_t numElements) noexcept

  239. -    {

  240. -        CARLA_SAFE_ASSERT_RETURN(target != nullptr,);

  241. -        CARLA_SAFE_ASSERT_RETURN(source != nullptr,);

  242. -        CARLA_SAFE_ASSERT_RETURN(target != source,);

  243. -        CARLA_SAFE_ASSERT_RETURN(numElements != 0,);

  244. -

  245. -        if (target > source)

  246. -        {

  247. -            for (size_t i = 0; i < numElements; ++i)

  248. -            {

  249. -                moveElement (target, std::move (*source));

  250. -                ++target;

  251. -                ++source;

  252. -            }

  253. -        }

  254. -        else

  255. -        {

  256. -            for (size_t i = 0; i < numElements; ++i)

  257. -            {

  258. -                moveElement (target, std::move (*source));

  259. -                --target;

  260. -                --source;

  261. -            }

  262. -        }

  263. -    }

  264. -

  265. -    void moveElement (ElementType* destination, const ElementType&& source)

  266. -    {

  267. -        destination->~ElementType();

  268. -        new (destination) ElementType (std::move (source));

  269. -    }

  270. -   #endif

  271. -

  272.      //==============================================================================

  273.      HeapBlock<ElementType> elements;

  274.      size_t numAllocated;

  275. diff --git a/source/modules/water/containers/LinkedListPointer.h b/source/modules/water/containers/LinkedListPointer.h

  276. index c71d52d23..ed75fc268 100644

  277. --- a/source/modules/water/containers/LinkedListPointer.h

  278. +++ b/source/modules/water/containers/LinkedListPointer.h

  279. @@ -81,23 +81,6 @@ public:

  280.          return *this;

  281.      }

  282.  

  283. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  284. -    LinkedListPointer (LinkedListPointer&& other) noexcept

  285. -        : item (other.item)

  286. -    {

  287. -        other.item = nullptr;

  288. -    }

  289. -

  290. -    LinkedListPointer& operator= (LinkedListPointer&& other) noexcept

  291. -    {

  292. -        wassert (this != &other); // hopefully the compiler should make this situation impossible!

  293. -

  294. -        item = other.item;

  295. -        other.item = nullptr;

  296. -        return *this;

  297. -    }

  298. -   #endif

  299. -

  300.      //==============================================================================

  301.      /** Returns the item which this pointer points to. */

  302.      inline operator ObjectType*() const noexcept

  303. diff --git a/source/modules/water/containers/NamedValueSet.cpp b/source/modules/water/containers/NamedValueSet.cpp

  304. index 9302e1691..7543af158 100644

  305. --- a/source/modules/water/containers/NamedValueSet.cpp

  306. +++ b/source/modules/water/containers/NamedValueSet.cpp

  307. @@ -44,19 +44,6 @@ NamedValueSet& NamedValueSet::operator= (const NamedValueSet& other)

  308.      return *this;

  309.  }

  310.  

  311. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  312. -NamedValueSet::NamedValueSet (NamedValueSet&& other) noexcept

  313. -    : values (static_cast<Array<NamedValue>&&> (other.values))

  314. -{

  315. -}

  316. -

  317. -NamedValueSet& NamedValueSet::operator= (NamedValueSet&& other) noexcept

  318. -{

  319. -    other.values.swapWith (values);

  320. -    return *this;

  321. -}

  322. -#endif

  323. -

  324.  NamedValueSet::~NamedValueSet() noexcept

  325.  {

  326.  }

  327. @@ -117,23 +104,6 @@ var* NamedValueSet::getVarPointer (const Identifier& name) const noexcept

  328.      return nullptr;

  329.  }

  330.  

  331. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  332. -bool NamedValueSet::set (const Identifier& name, var&& newValue)

  333. -{

  334. -    if (var* const v = getVarPointer (name))

  335. -    {

  336. -        if (v->equalsWithSameType (newValue))

  337. -            return false;

  338. -

  339. -        *v = static_cast<var&&> (newValue);

  340. -        return true;

  341. -    }

  342. -

  343. -    values.add (NamedValue (name, static_cast<var&&> (newValue)));

  344. -    return true;

  345. -}

  346. -#endif

  347. -

  348.  bool NamedValueSet::set (const Identifier& name, const var& newValue)

  349.  {

  350.      if (var* const v = getVarPointer (name))

  351. diff --git a/source/modules/water/containers/NamedValueSet.h b/source/modules/water/containers/NamedValueSet.h

  352. index 7d0caa02e..ea4ef421d 100644

  353. --- a/source/modules/water/containers/NamedValueSet.h

  354. +++ b/source/modules/water/containers/NamedValueSet.h

  355. @@ -50,11 +50,6 @@ public:

  356.      /** Replaces this set with a copy of another set. */

  357.      NamedValueSet& operator= (const NamedValueSet&);

  358.  

  359. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  360. -    NamedValueSet (NamedValueSet&&) noexcept;

  361. -    NamedValueSet& operator= (NamedValueSet&&) noexcept;

  362. -   #endif

  363. -

  364.      /** Destructor. */

  365.      ~NamedValueSet() noexcept;

  366.  

  367. @@ -68,27 +63,6 @@ public:

  368.          NamedValue (const Identifier& n, const var& v) : name (n), value (v) {}

  369.          NamedValue (const NamedValue& other) : name (other.name), value (other.value) {}

  370.  

  371. -    #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  372. -        NamedValue (NamedValue&& other) noexcept

  373. -        : name (static_cast<Identifier&&> (other.name)),

  374. -          value (static_cast<var&&> (other.value))

  375. -        {

  376. -        }

  377. -

  378. -        NamedValue (Identifier&& n, var&& v) noexcept

  379. -        : name (static_cast<Identifier&&> (n)),

  380. -          value (static_cast<var&&> (v))

  381. -        {

  382. -        }

  383. -

  384. -        NamedValue& operator= (NamedValue&& other) noexcept

  385. -        {

  386. -            name = static_cast<Identifier&&> (other.name);

  387. -            value = static_cast<var&&> (other.value);

  388. -            return *this;

  389. -        }

  390. -     #endif

  391. -

  392.          bool operator== (const NamedValue& other) const noexcept   { return name == other.name && value == other.value; }

  393.          bool operator!= (const NamedValue& other) const noexcept   { return ! operator== (other); }

  394.  

  395. @@ -124,14 +98,6 @@ public:

  396.      */

  397.      bool set (const Identifier& name, const var& newValue);

  398.  

  399. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  400. -    /** Changes or adds a named value.

  401. -        @returns    true if a value was changed or added; false if the

  402. -                    value was already set the value passed-in.

  403. -    */

  404. -    bool set (const Identifier& name, var&& newValue);

  405. -   #endif

  406. -

  407.      /** Returns true if the set contains an item with the specified name. */

  408.      bool contains (const Identifier& name) const noexcept;

  409.  

  410. diff --git a/source/modules/water/containers/OwnedArray.h b/source/modules/water/containers/OwnedArray.h

  411. index 1a90100cd..ffa89203f 100644

  412. --- a/source/modules/water/containers/OwnedArray.h

  413. +++ b/source/modules/water/containers/OwnedArray.h

  414. @@ -73,25 +73,6 @@ public:

  415.          deleteAllObjects();

  416.      }

  417.  

  418. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  419. -    OwnedArray (OwnedArray&& other) noexcept

  420. -        : data (static_cast<ArrayAllocationBase <ObjectClass*>&&> (other.data)),

  421. -          numUsed (other.numUsed)

  422. -    {

  423. -        other.numUsed = 0;

  424. -    }

  425. -

  426. -    OwnedArray& operator= (OwnedArray&& other) noexcept

  427. -    {

  428. -        deleteAllObjects();

  429. -

  430. -        data = static_cast<ArrayAllocationBase <ObjectClass*>&&> (other.data);

  431. -        numUsed = other.numUsed;

  432. -        other.numUsed = 0;

  433. -        return *this;

  434. -    }

  435. -   #endif

  436. -

  437.      //==============================================================================

  438.      /** Clears the array, optionally deleting the objects inside it first. */

  439.      void clear (bool deleteObjects = true)

  440. diff --git a/source/modules/water/containers/Variant.cpp b/source/modules/water/containers/Variant.cpp

  441. index a93dba9fb..0472b10e3 100644

  442. --- a/source/modules/water/containers/Variant.cpp

  443. +++ b/source/modules/water/containers/Variant.cpp

  444. @@ -265,34 +265,6 @@ var& var::operator= (const double v)             { type->cleanUp (value); type =

  445.  var& var::operator= (const char* const v)        { type->cleanUp (value); type = &VariantType_String::instance; new (value.stringValue) String (v); return *this; }

  446.  var& var::operator= (const String& v)            { type->cleanUp (value); type = &VariantType_String::instance; new (value.stringValue) String (v); return *this; }

  447.  

  448. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  449. -var::var (var&& other) noexcept

  450. -    : type (other.type),

  451. -      value (other.value)

  452. -{

  453. -    other.type = &VariantType_Void::instance;

  454. -}

  455. -

  456. -var& var::operator= (var&& other) noexcept

  457. -{

  458. -    swapWith (other);

  459. -    return *this;

  460. -}

  461. -

  462. -var::var (String&& v)  : type (&VariantType_String::instance)

  463. -{

  464. -    new (value.stringValue) String (static_cast<String&&> (v));

  465. -}

  466. -

  467. -var& var::operator= (String&& v)

  468. -{

  469. -    type->cleanUp (value);

  470. -    type = &VariantType_String::instance;

  471. -    new (value.stringValue) String (static_cast<String&&> (v));

  472. -    return *this;

  473. -}

  474. -#endif

  475. -

  476.  //==============================================================================

  477.  bool var::equals (const var& other) const noexcept

  478.  {

  479. diff --git a/source/modules/water/containers/Variant.h b/source/modules/water/containers/Variant.h

  480. index 0e181712a..c1472a733 100644

  481. --- a/source/modules/water/containers/Variant.h

  482. +++ b/source/modules/water/containers/Variant.h

  483. @@ -69,13 +69,6 @@ public:

  484.      var& operator= (const char* value);

  485.      var& operator= (const String& value);

  486.  

  487. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  488. -    var (var&&) noexcept;

  489. -    var (String&&);

  490. -    var& operator= (var&&) noexcept;

  491. -    var& operator= (String&&);

  492. -   #endif

  493. -

  494.      void swapWith (var& other) noexcept;

  495.  

  496.      /** Returns a var object that can be used where you need the javascript "undefined" value. */

  497. diff --git a/source/modules/water/files/File.cpp b/source/modules/water/files/File.cpp

  498. index 2ce0f6f8e..8c74854f0 100644

  499. --- a/source/modules/water/files/File.cpp

  500. +++ b/source/modules/water/files/File.cpp

  501. @@ -86,19 +86,6 @@ File& File::operator= (const File& other)

  502.      return *this;

  503.  }

  504.  

  505. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  506. -File::File (File&& other) noexcept

  507. -    : fullPath (static_cast<String&&> (other.fullPath))

  508. -{

  509. -}

  510. -

  511. -File& File::operator= (File&& other) noexcept

  512. -{

  513. -    fullPath = static_cast<String&&> (other.fullPath);

  514. -    return *this;

  515. -}

  516. -#endif

  517. -

  518.  bool File::isNull() const

  519.  {

  520.      return fullPath.isEmpty();

  521. diff --git a/source/modules/water/files/File.h b/source/modules/water/files/File.h

  522. index 1fa1a7c3e..2c8077963 100644

  523. --- a/source/modules/water/files/File.h

  524. +++ b/source/modules/water/files/File.h

  525. @@ -89,11 +89,6 @@ public:

  526.      /** Copies from another file object. */

  527.      File& operator= (const File& otherFile);

  528.  

  529. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  530. -    File (File&&) noexcept;

  531. -    File& operator= (File&&) noexcept;

  532. -   #endif

  533. -

  534.      //==============================================================================

  535.      /** Checks whether the file actually exists.

  536.  

  537. diff --git a/source/modules/water/memory/HeapBlock.h b/source/modules/water/memory/HeapBlock.h

  538. index b8c232e11..98656e872 100644

  539. --- a/source/modules/water/memory/HeapBlock.h

  540. +++ b/source/modules/water/memory/HeapBlock.h

  541. @@ -94,20 +94,6 @@ public:

  542.          std::free (data);

  543.      }

  544.  

  545. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  546. -    HeapBlock (HeapBlock&& other) noexcept

  547. -        : data (other.data)

  548. -    {

  549. -        other.data = nullptr;

  550. -    }

  551. -

  552. -    HeapBlock& operator= (HeapBlock&& other) noexcept

  553. -    {

  554. -        std::swap (data, other.data);

  555. -        return *this;

  556. -    }

  557. -   #endif

  558. -

  559.      //==============================================================================

  560.      /** Returns a raw pointer to the allocated data.

  561.          This may be a null pointer if the data hasn't yet been allocated, or if it has been

  562. diff --git a/source/modules/water/memory/MemoryBlock.cpp b/source/modules/water/memory/MemoryBlock.cpp

  563. index 6e83b8dfc..8b380da88 100644

  564. --- a/source/modules/water/memory/MemoryBlock.cpp

  565. +++ b/source/modules/water/memory/MemoryBlock.cpp

  566. @@ -87,22 +87,6 @@ MemoryBlock& MemoryBlock::operator= (const MemoryBlock& other)

  567.      return *this;

  568.  }

  569.  

  570. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  571. -MemoryBlock::MemoryBlock (MemoryBlock&& other) noexcept

  572. -    : data (static_cast<HeapBlock<char>&&> (other.data)),

  573. -      size (other.size)

  574. -{

  575. -}

  576. -

  577. -MemoryBlock& MemoryBlock::operator= (MemoryBlock&& other) noexcept

  578. -{

  579. -    data = static_cast<HeapBlock<char>&&> (other.data);

  580. -    size = other.size;

  581. -    return *this;

  582. -}

  583. -#endif

  584. -

  585. -

  586.  //==============================================================================

  587.  bool MemoryBlock::operator== (const MemoryBlock& other) const noexcept

  588.  {

  589. diff --git a/source/modules/water/memory/MemoryBlock.h b/source/modules/water/memory/MemoryBlock.h

  590. index 4383139d6..701120cfa 100644

  591. --- a/source/modules/water/memory/MemoryBlock.h

  592. +++ b/source/modules/water/memory/MemoryBlock.h

  593. @@ -68,11 +68,6 @@ public:

  594.      */

  595.      MemoryBlock& operator= (const MemoryBlock&);

  596.  

  597. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  598. -    MemoryBlock (MemoryBlock&&) noexcept;

  599. -    MemoryBlock& operator= (MemoryBlock&&) noexcept;

  600. -   #endif

  601. -

  602.      //==============================================================================

  603.      /** Compares two memory blocks.

  604.          @returns true only if the two blocks are the same size and have identical contents.

  605. diff --git a/source/modules/water/memory/ReferenceCountedObject.h b/source/modules/water/memory/ReferenceCountedObject.h

  606. index 4f5a256ee..b23ed914d 100644

  607. --- a/source/modules/water/memory/ReferenceCountedObject.h

  608. +++ b/source/modules/water/memory/ReferenceCountedObject.h

  609. @@ -301,22 +301,6 @@ public:

  610.          return *this;

  611.      }

  612.  

  613. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  614. -    /** Takes-over the object from another pointer. */

  615. -    ReferenceCountedObjectPtr (ReferenceCountedObjectPtr&& other) noexcept

  616. -        : referencedObject (other.referencedObject)

  617. -    {

  618. -        other.referencedObject = nullptr;

  619. -    }

  620. -

  621. -    /** Takes-over the object from another pointer. */

  622. -    ReferenceCountedObjectPtr& operator= (ReferenceCountedObjectPtr&& other)

  623. -    {

  624. -        std::swap (referencedObject, other.referencedObject);

  625. -        return *this;

  626. -    }

  627. -   #endif

  628. -

  629.      /** Destructor.

  630.          This will decrement the object's reference-count, which will cause the

  631.          object to be deleted when the ref-count hits zero.

  632. diff --git a/source/modules/water/midi/MidiMessage.cpp b/source/modules/water/midi/MidiMessage.cpp

  633. index 21c90f508..a4354222e 100644

  634. --- a/source/modules/water/midi/MidiMessage.cpp

  635. +++ b/source/modules/water/midi/MidiMessage.cpp

  636. @@ -286,24 +286,6 @@ MidiMessage& MidiMessage::operator= (const MidiMessage& other)

  637.      return *this;

  638.  }

  639.  

  640. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  641. -MidiMessage::MidiMessage (MidiMessage&& other) noexcept

  642. -   : timeStamp (other.timeStamp), size (other.size)

  643. -{

  644. -    packedData.allocatedData = other.packedData.allocatedData;

  645. -    other.size = 0;

  646. -}

  647. -

  648. -MidiMessage& MidiMessage::operator= (MidiMessage&& other) noexcept

  649. -{

  650. -    packedData.allocatedData = other.packedData.allocatedData;

  651. -    timeStamp = other.timeStamp;

  652. -    size = other.size;

  653. -    other.size = 0;

  654. -    return *this;

  655. -}

  656. -#endif

  657. -

  658.  MidiMessage::~MidiMessage() noexcept

  659.  {

  660.      if (isHeapAllocated())

  661. diff --git a/source/modules/water/midi/MidiMessage.h b/source/modules/water/midi/MidiMessage.h

  662. index 07f15c467..6b78d55f8 100644

  663. --- a/source/modules/water/midi/MidiMessage.h

  664. +++ b/source/modules/water/midi/MidiMessage.h

  665. @@ -113,11 +113,6 @@ public:

  666.      /** Copies this message from another one. */

  667.      MidiMessage& operator= (const MidiMessage& other);

  668.  

  669. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  670. -    MidiMessage (MidiMessage&&) noexcept;

  671. -    MidiMessage& operator= (MidiMessage&&) noexcept;

  672. -   #endif

  673. -

  674.      //==============================================================================

  675.      /** Returns a pointer to the raw midi data.

  676.          @see getRawDataSize

  677. diff --git a/source/modules/water/midi/MidiMessageSequence.h b/source/modules/water/midi/MidiMessageSequence.h

  678. index f85f5fd05..bfe27d061 100644

  679. --- a/source/modules/water/midi/MidiMessageSequence.h

  680. +++ b/source/modules/water/midi/MidiMessageSequence.h

  681. @@ -55,18 +55,6 @@ public:

  682.      /** Replaces this sequence with another one. */

  683.      MidiMessageSequence& operator= (const MidiMessageSequence&);

  684.  

  685. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  686. -    MidiMessageSequence (MidiMessageSequence&& other) noexcept

  687. -        : list (static_cast<OwnedArray<MidiEventHolder>&&> (other.list))

  688. -    {}

  689. -

  690. -    MidiMessageSequence& operator= (MidiMessageSequence&& other) noexcept

  691. -    {

  692. -        list = static_cast<OwnedArray<MidiEventHolder>&&> (other.list);

  693. -        return *this;

  694. -    }

  695. -   #endif

  696. -

  697.      /** Destructor. */

  698.      ~MidiMessageSequence();

  699.  

  700. diff --git a/source/modules/water/misc/Result.cpp b/source/modules/water/misc/Result.cpp

  701. index b8706e771..49f1f85e1 100644

  702. --- a/source/modules/water/misc/Result.cpp

  703. +++ b/source/modules/water/misc/Result.cpp

  704. @@ -45,19 +45,6 @@ Result& Result::operator= (const Result& other)

  705.      return *this;

  706.  }

  707.  

  708. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  709. -Result::Result (Result&& other) noexcept

  710. -    : errorMessage (static_cast<String&&> (other.errorMessage))

  711. -{

  712. -}

  713. -

  714. -Result& Result::operator= (Result&& other) noexcept

  715. -{

  716. -    errorMessage = static_cast<String&&> (other.errorMessage);

  717. -    return *this;

  718. -}

  719. -#endif

  720. -

  721.  bool Result::operator== (const Result& other) const noexcept

  722.  {

  723.      return errorMessage == other.errorMessage;

  724. diff --git a/source/modules/water/misc/Result.h b/source/modules/water/misc/Result.h

  725. index ab4cf9bf1..495a19fc9 100644

  726. --- a/source/modules/water/misc/Result.h

  727. +++ b/source/modules/water/misc/Result.h

  728. @@ -100,11 +100,6 @@ public:

  729.      Result (const Result&);

  730.      Result& operator= (const Result&);

  731.  

  732. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  733. -    Result (Result&&) noexcept;

  734. -    Result& operator= (Result&&) noexcept;

  735. -   #endif

  736. -

  737.      bool operator== (const Result& other) const noexcept;

  738.      bool operator!= (const Result& other) const noexcept;

  739.  

  740. diff --git a/source/modules/water/text/Identifier.cpp b/source/modules/water/text/Identifier.cpp

  741. index e542d6eeb..3f1850369 100644

  742. --- a/source/modules/water/text/Identifier.cpp

  743. +++ b/source/modules/water/text/Identifier.cpp

  744. @@ -32,16 +32,6 @@ Identifier::~Identifier() noexcept {}

  745.  

  746.  Identifier::Identifier (const Identifier& other) noexcept  : name (other.name) {}

  747.  

  748. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  749. -Identifier::Identifier (Identifier&& other) noexcept : name (static_cast<String&&> (other.name)) {}

  750. -

  751. -Identifier& Identifier::operator= (Identifier&& other) noexcept

  752. -{

  753. -    name = static_cast<String&&> (other.name);

  754. -    return *this;

  755. -}

  756. -#endif

  757. -

  758.  Identifier& Identifier::operator= (const Identifier& other) noexcept

  759.  {

  760.      name = other.name;

  761. diff --git a/source/modules/water/text/Identifier.h b/source/modules/water/text/Identifier.h

  762. index a044b3a3a..ab768cd10 100644

  763. --- a/source/modules/water/text/Identifier.h

  764. +++ b/source/modules/water/text/Identifier.h

  765. @@ -70,14 +70,6 @@ public:

  766.      /** Creates a copy of another identifier. */

  767.      Identifier& operator= (const Identifier& other) noexcept;

  768.  

  769. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  770. -    /** Creates a copy of another identifier. */

  771. -    Identifier (Identifier&& other) noexcept;

  772. -

  773. -    /** Creates a copy of another identifier. */

  774. -    Identifier& operator= (Identifier&& other) noexcept;

  775. -   #endif

  776. -

  777.      /** Destructor */

  778.      ~Identifier() noexcept;

  779.  

  780. diff --git a/source/modules/water/text/String.cpp b/source/modules/water/text/String.cpp

  781. index 51b20bc25..1dd593468 100644

  782. --- a/source/modules/water/text/String.cpp

  783. +++ b/source/modules/water/text/String.cpp

  784. @@ -247,19 +247,6 @@ String& String::operator= (const String& other) noexcept

  785.      return *this;

  786.  }

  787.  

  788. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  789. -String::String (String&& other) noexcept   : text (other.text)

  790. -{

  791. -    other.text = &(emptyString.text);

  792. -}

  793. -

  794. -String& String::operator= (String&& other) noexcept

  795. -{

  796. -    std::swap (text, other.text);

  797. -    return *this;

  798. -}

  799. -#endif

  800. -

  801.  inline String::PreallocationBytes::PreallocationBytes (const size_t num) noexcept : numBytes (num) {}

  802.  

  803.  String::String (const PreallocationBytes& preallocationSize)

  804. diff --git a/source/modules/water/text/String.h b/source/modules/water/text/String.h

  805. index 0a0ba99f1..ffa8ecf3b 100644

  806. --- a/source/modules/water/text/String.h

  807. +++ b/source/modules/water/text/String.h

  808. @@ -56,10 +56,6 @@ public:

  809.      /** Creates a copy of another string. */

  810.      String (const String& other) noexcept;

  811.  

  812. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  813. -    String (String&& other) noexcept;

  814. -   #endif

  815. -

  816.      /** Creates a string from a zero-terminated ascii text string.

  817.  

  818.          The string passed-in must not contain any characters with a value above 127, because

  819. @@ -139,10 +135,6 @@ public:

  820.      /** Replaces this string's contents with another string. */

  821.      String& operator= (const String& other) noexcept;

  822.  

  823. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  824. -    String& operator= (String&& other) noexcept;

  825. -   #endif

  826. -

  827.      /** Appends another string at the end of this one. */

  828.      String& operator+= (const String& stringToAppend);

  829.      /** Appends another string at the end of this one. */

  830. diff --git a/source/modules/water/text/StringArray.cpp b/source/modules/water/text/StringArray.cpp

  831. index c0fddb5db..36856f4a7 100644

  832. --- a/source/modules/water/text/StringArray.cpp

  833. +++ b/source/modules/water/text/StringArray.cpp

  834. @@ -36,13 +36,6 @@ StringArray::StringArray (const StringArray& other)

  835.  {

  836.  }

  837.  

  838. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  839. -StringArray::StringArray (StringArray&& other) noexcept

  840. -    : strings (static_cast<Array <String>&&> (other.strings))

  841. -{

  842. -}

  843. -#endif

  844. -

  845.  StringArray::StringArray (const String& firstValue)

  846.  {

  847.      strings.add (firstValue);

  848. @@ -69,14 +62,6 @@ StringArray& StringArray::operator= (const StringArray& other)

  849.      return *this;

  850.  }

  851.  

  852. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  853. -StringArray& StringArray::operator= (StringArray&& other) noexcept

  854. -{

  855. -    strings = static_cast<Array<String>&&> (other.strings);

  856. -    return *this;

  857. -}

  858. -#endif

  859. -

  860.  StringArray::~StringArray()

  861.  {

  862.  }

  863. @@ -125,13 +110,6 @@ bool StringArray::add (const String& newString)

  864.      return strings.add (newString);

  865.  }

  866.  

  867. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  868. -bool StringArray::add (String&& stringToAdd)

  869. -{

  870. -    return strings.add (static_cast<String&&> (stringToAdd));

  871. -}

  872. -#endif

  873. -

  874.  bool StringArray::insert (const int index, const String& newString)

  875.  {

  876.      return strings.insert (index, newString);

  877. diff --git a/source/modules/water/text/StringArray.h b/source/modules/water/text/StringArray.h

  878. index 57ed5d300..d7244a066 100644

  879. --- a/source/modules/water/text/StringArray.h

  880. +++ b/source/modules/water/text/StringArray.h

  881. @@ -47,10 +47,6 @@ public:

  882.      /** Creates a copy of another string array */

  883.      StringArray (const StringArray&);

  884.  

  885. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  886. -    StringArray (StringArray&&) noexcept;

  887. -   #endif

  888. -

  889.      /** Creates an array containing a single string. */

  890.      explicit StringArray (const String& firstValue);

  891.  

  892. @@ -80,10 +76,6 @@ public:

  893.      /** Copies the contents of another string array into this one */

  894.      StringArray& operator= (const StringArray&);

  895.  

  896. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  897. -    StringArray& operator= (StringArray&&) noexcept;

  898. -   #endif

  899. -

  900.      /** Swaps the contents of this and another StringArray. */

  901.      void swapWith (StringArray&) noexcept;

  902.  

  903. @@ -159,11 +151,6 @@ public:

  904.      /** Appends a string at the end of the array. */

  905.      bool add (const String& stringToAdd);

  906.  

  907. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  908. -    /** Appends a string at the end of the array. */

  909. -    bool add (String&& stringToAdd);

  910. -   #endif

  911. -

  912.      /** Inserts a string into the array.

  913.  

  914.          This will insert a string into the array at the given index, moving

  915. diff --git a/source/modules/water/water.h b/source/modules/water/water.h

  916. index 33b908c27..d8305a0ee 100644

  917. --- a/source/modules/water/water.h

  918. +++ b/source/modules/water/water.h

  919. @@ -32,18 +32,12 @@

  920.  // Compiler support

  921.  

  922.  #if (__cplusplus >= 201103L || defined (__GXX_EXPERIMENTAL_CXX0X__)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 405

  923. - #define WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS 1

  924. -

  925.   #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && ! defined (WATER_DELETED_FUNCTION)

  926.    #define WATER_DELETED_FUNCTION = delete

  927.   #endif

  928.  #endif

  929.  

  930.  #ifdef __clang__

  931. - #if __has_feature (cxx_implicit_moves) && __clang_major__ >= 9

  932. -  #define WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS 1

  933. - #endif

  934. -

  935.   #if __has_feature (cxx_deleted_functions)

  936.    #define WATER_DELETED_FUNCTION = delete

  937.   #endif

  938. diff --git a/source/modules/water/xml/XmlElement.cpp b/source/modules/water/xml/XmlElement.cpp

  939. index 2de0fa34e..92bfecc7e 100644

  940. --- a/source/modules/water/xml/XmlElement.cpp

  941. +++ b/source/modules/water/xml/XmlElement.cpp

  942. @@ -133,31 +133,6 @@ XmlElement& XmlElement::operator= (const XmlElement& other)

  943.      return *this;

  944.  }

  945.  

  946. -#if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  947. -XmlElement::XmlElement (XmlElement&& other) noexcept

  948. -    : nextListItem      (static_cast<LinkedListPointer<XmlElement>&&> (other.nextListItem)),

  949. -      firstChildElement (static_cast<LinkedListPointer<XmlElement>&&> (other.firstChildElement)),

  950. -      attributes        (static_cast<LinkedListPointer<XmlAttributeNode>&&> (other.attributes)),

  951. -      tagName           (static_cast<String&&> (other.tagName))

  952. -{

  953. -}

  954. -

  955. -XmlElement& XmlElement::operator= (XmlElement&& other) noexcept

  956. -{

  957. -    wassert (this != &other); // hopefully the compiler should make this situation impossible!

  958. -

  959. -    removeAllAttributes();

  960. -    deleteAllChildElements();

  961. -

  962. -    nextListItem      = static_cast<LinkedListPointer<XmlElement>&&> (other.nextListItem);

  963. -    firstChildElement = static_cast<LinkedListPointer<XmlElement>&&> (other.firstChildElement);

  964. -    attributes        = static_cast<LinkedListPointer<XmlAttributeNode>&&> (other.attributes);

  965. -    tagName           = static_cast<String&&> (other.tagName);

  966. -

  967. -    return *this;

  968. -}

  969. -#endif

  970. -

  971.  void XmlElement::copyChildrenAndAttributesFrom (const XmlElement& other)

  972.  {

  973.      wassert (firstChildElement.get() == nullptr);

  974. diff --git a/source/modules/water/xml/XmlElement.h b/source/modules/water/xml/XmlElement.h

  975. index d27b7d98d..273d28e4c 100644

  976. --- a/source/modules/water/xml/XmlElement.h

  977. +++ b/source/modules/water/xml/XmlElement.h

  978. @@ -166,11 +166,6 @@ public:

  979.      /** Creates a (deep) copy of another element. */

  980.      XmlElement& operator= (const XmlElement&);

  981.  

  982. -   #if WATER_COMPILER_SUPPORTS_MOVE_SEMANTICS

  983. -    XmlElement (XmlElement&&) noexcept;

  984. -    XmlElement& operator= (XmlElement&&) noexcept;

  985. -   #endif

  986. -

  987.      /** Deleting an XmlElement will also delete all of its child elements. */

  988.      ~XmlElement() noexcept;

  989.