ADT: Add OwningArrayRef class.

[pcc]

Summary

This is a MutableArrayRef that owns its array.
I plan to use this in D22296.

[rjmccall]

LGTM. Things like this ArrayRef constructor really make me wish that C++ had labelled arguments, though.

[Eugene.Zelenko]

llvm/trunk/include/llvm/ADT/ArrayRef.h

419 ↗

(On Diff #81283)

Please use = default;

[rsmith]

This doesn't make any sense to me at all. The whole point of ArrayRef is as a non-owning handle to an externally-owned array. Why would someone use this rather than, say, vector or SmallVector? (The only real difference I can see compared to vector is that you save one pointer by not allowing the size and capacity to differ, at the cost of tying together allocation and initialization.)

If this genuinely is useful, please update http://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task to explain when this container should be used.

llvm/include/llvm/ADT/ArrayRef.h

public:
     /// @name Operator Overloads
     /// @{
     T &operator[](size_t Index) const {
       assert(Index < this->size() && "Invalid index!");
       return data()[Index];
     }
   };
 
+  /// This is a MutableArrayRef that owns its array.
+  template <typename T> class OwningArrayRef : public MutableArrayRef<T> {
+  public:
+    OwningArrayRef() {}
+    OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {}
+    OwningArrayRef(ArrayRef<T> Data)
+        : MutableArrayRef<T>(new T[Data.size()], Data.size()) {
+      std::copy(Data.begin(), Data.end(), this->begin());
+    }
+    OwningArrayRef(OwningArrayRef &&Other) { *this = Other; }
+    OwningArrayRef &operator=(OwningArrayRef &&Other) {
+      delete this->data();
+      this->MutableArrayRef<T>::operator=(Other);
+      Other.MutableArrayRef<T>::operator=(MutableArrayRef<T>());
+      return *this;
+    }
+    ~OwningArrayRef() { delete this->data(); }
+  };
+
   /// @name ArrayRef Convenience constructors
   /// @{
 
   /// Construct an ArrayRef from a single element.
   template<typename T>
   ArrayRef<T> makeArrayRef(const T &OneElt) {
     return OneElt;
   }