[llvm-commits] [llvm] r148463 - /llvm/trunk/include/llvm/ADT/ArrayRef.h

[David Blaikie]

On Wed, Jan 18, 2012 at 10:34 PM, Chris Lattner <sabre at nondot.org> wrote:
> Author: lattner
> Date: Thu Jan 19 00:34:52 2012
> New Revision: 148463
>
> URL: http://llvm.org/viewvc/llvm-project?rev=148463&view=rev
> Log:
> Introduce a new MutableArrayRef class, which refers to a series of mutable
> T's that are consequtively in memory.

Just forwarding a brief discussion I had with Chris on IRC for the
email record - I'm pretty sure this could be implemented by switching
things around & migrating existing ArrayRef<T> code to ArrayRef<const
T> (& making his MutableArrayRef be the basic/generic ArrayRef
template and partially specializing ArrayRef<const T> using the old
ArrayRef implementation). Just thought I'd mention this in case anyone
else had a similar thought.

I'll try to whip up this as a prototype when I get a chance. (painful
bit is it'll require migrating existing code
"s/ArrayRef<T>/ArrayRef<const T>/" across the codebase... but I don't
mind if you guys don't)

- David

>
> Modified:
>    llvm/trunk/include/llvm/ADT/ArrayRef.h
>
> Modified: llvm/trunk/include/llvm/ADT/ArrayRef.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/ArrayRef.h?rev=148463&r1=148462&r2=148463&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/ArrayRef.h (original)
> +++ llvm/trunk/include/llvm/ADT/ArrayRef.h Thu Jan 19 00:34:52 2012
> @@ -147,6 +147,88 @@
>     /// @}
>   };
>
> +  /// MutableArrayRef - Represent a mutable reference to an array (0 or more
> +  /// elements consecutively in memory), i.e. a start pointer and a length.  It
> +  /// allows various APIs to take and modify consecutive elements easily and
> +  /// conveniently.
> +  ///
> +  /// This class does not own the underlying data, it is expected to be used in
> +  /// situations where the data resides in some other buffer, whose lifetime
> +  /// extends past that of the MutableArrayRef. For this reason, it is not in
> +  /// general safe to store a MutableArrayRef.
> +  ///
> +  /// This is intended to be trivially copyable, so it should be passed by
> +  /// value.
> +  template<typename T>
> +  class MutableArrayRef : public ArrayRef<T> {
> +  public:
> +    typedef T *iterator;
> +
> +    /// Construct an empty ArrayRef.
> +    /*implicit*/ MutableArrayRef() : ArrayRef<T>() {}
> +
> +    /// Construct an MutableArrayRef from a single element.
> +    /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
> +
> +    /// Construct an MutableArrayRef from a pointer and length.
> +    /*implicit*/ MutableArrayRef(T *data, size_t length)
> +      : ArrayRef<T>(data, length) {}
> +
> +    /// Construct an MutableArrayRef from a range.
> +    MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
> +
> +    /// Construct an MutableArrayRef from a SmallVector.
> +    /*implicit*/ MutableArrayRef(SmallVectorImpl<T> &Vec)
> +    : ArrayRef<T>(Vec) {}
> +
> +    /// Construct a MutableArrayRef from a std::vector.
> +    /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
> +    : ArrayRef<T>(Vec) {}
> +
> +    /// Construct an MutableArrayRef from a C array.
> +    template <size_t N>
> +    /*implicit*/ MutableArrayRef(T (&Arr)[N])
> +      : ArrayRef<T>(Arr) {}
> +
> +    T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
> +
> +    iterator begin() const { return data(); }
> +    iterator end() const { return data() + this->size(); }
> +
> +    /// front - Get the first element.
> +    T &front() const {
> +      assert(!this->empty());
> +      return data()[0];
> +    }
> +
> +    /// back - Get the last element.
> +    T &back() const {
> +      assert(!this->empty());
> +      return data()[this->size()-1];
> +    }
> +
> +    /// slice(n) - Chop off the first N elements of the array.
> +    MutableArrayRef<T> slice(unsigned N) const {
> +      assert(N <= this->size() && "Invalid specifier");
> +      return MutableArrayRef<T>(data()+N, this->size()-N);
> +    }
> +
> +    /// slice(n, m) - Chop off the first N elements of the array, and keep M
> +    /// elements in the array.
> +    MutableArrayRef<T> slice(unsigned N, unsigned M) const {
> +      assert(N+M <= this->size() && "Invalid specifier");
> +      return MutableArrayRef<T>(data()+N, M);
> +    }
> +
> +    /// @}
> +    /// @name Operator Overloads
> +    /// @{
> +    T &operator[](size_t Index) const {
> +      assert(Index < this->size() && "Invalid index!");
> +      return data()[Index];
> +    }
> +  };
> +
>   /// @name ArrayRef Convenience constructors
>   /// @{
>
> @@ -214,5 +296,5 @@
>     static const bool value = true;
>   };
>  }
> -
> +
>  #endif
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits