public inbox for gcc-cvs@sourceware.org help / color / mirror / Atom feed
From: Richard Sandiford <rsandifo@gcc.gnu.org> To: gcc-cvs@gcc.gnu.org Subject: [gcc r11-6175] Add a cut-down version of std::span (array_slice) Date: Thu, 17 Dec 2020 00:16:14 +0000 (GMT) [thread overview] Message-ID: <20201217001614.277053857C65@sourceware.org> (raw) https://gcc.gnu.org/g:d4b520d88ee5b4cd446ef001c8fdddd9af8d681c commit r11-6175-gd4b520d88ee5b4cd446ef001c8fdddd9af8d681c Author: Richard Sandiford <richard.sandiford@arm.com> Date: Thu Dec 17 00:15:02 2020 +0000 Add a cut-down version of std::span (array_slice) A later patch wants to be able to pass around subarray views of an existing array. The standard class to do that is std::span, but it's a C++20 thing. This patch just adds a cut-down version of it. The intention is just to provide what's currently needed. gcc/ * vec.h (array_slice): New class. Diff: --- gcc/vec.h | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) diff --git a/gcc/vec.h b/gcc/vec.h index 31574b49c25..db725624dfa 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -2138,6 +2138,126 @@ release_vec_vec (vec<vec<T> > &vec) vec.release (); } +// Provide a subset of the std::span functionality. (We can't use std::span +// itself because it's a C++20 feature.) +// +// In addition, provide an invalid value that is distinct from all valid +// sequences (including the empty sequence). This can be used to return +// failure without having to use std::optional. +// +// There is no operator bool because it would be ambiguous whether it is +// testing for a valid value or an empty sequence. +template<typename T> +class array_slice +{ + template<typename OtherT> friend class array_slice; + +public: + using value_type = T; + using iterator = T *; + using const_iterator = const T *; + + array_slice () : m_base (nullptr), m_size (0) {} + + template<typename OtherT> + array_slice (array_slice<OtherT> other) + : m_base (other.m_base), m_size (other.m_size) {} + + array_slice (iterator base, unsigned int size) + : m_base (base), m_size (size) {} + + template<size_t N> + array_slice (T (&array)[N]) : m_base (array), m_size (N) {} + + template<typename OtherT> + array_slice (const vec<OtherT> &v) + : m_base (v.address ()), m_size (v.length ()) {} + + iterator begin () { return m_base; } + iterator end () { return m_base + m_size; } + + const_iterator begin () const { return m_base; } + const_iterator end () const { return m_base + m_size; } + + value_type &front (); + value_type &back (); + value_type &operator[] (unsigned int i); + + const value_type &front () const; + const value_type &back () const; + const value_type &operator[] (unsigned int i) const; + + size_t size () const { return m_size; } + size_t size_bytes () const { return m_size * sizeof (T); } + bool empty () const { return m_size == 0; } + + // An invalid array_slice that represents a failed operation. This is + // distinct from an empty slice, which is a valid result in some contexts. + static array_slice invalid () { return { nullptr, ~0U }; } + + // True if the array is valid, false if it is an array like INVALID. + bool is_valid () const { return m_base || m_size == 0; } + +private: + iterator m_base; + unsigned int m_size; +}; + +template<typename T> +inline typename array_slice<T>::value_type & +array_slice<T>::front () +{ + gcc_checking_assert (m_size); + return m_base[0]; +} + +template<typename T> +inline const typename array_slice<T>::value_type & +array_slice<T>::front () const +{ + gcc_checking_assert (m_size); + return m_base[0]; +} + +template<typename T> +inline typename array_slice<T>::value_type & +array_slice<T>::back () +{ + gcc_checking_assert (m_size); + return m_base[m_size - 1]; +} + +template<typename T> +inline const typename array_slice<T>::value_type & +array_slice<T>::back () const +{ + gcc_checking_assert (m_size); + return m_base[m_size - 1]; +} + +template<typename T> +inline typename array_slice<T>::value_type & +array_slice<T>::operator[] (unsigned int i) +{ + gcc_checking_assert (i < m_size); + return m_base[i]; +} + +template<typename T> +inline const typename array_slice<T>::value_type & +array_slice<T>::operator[] (unsigned int i) const +{ + gcc_checking_assert (i < m_size); + return m_base[i]; +} + +template<typename T> +array_slice<T> +make_array_slice (T *base, unsigned int size) +{ + return array_slice<T> (base, size); +} + #if (GCC_VERSION >= 3000) # pragma GCC poison m_vec m_vecpfx m_vecdata #endif
reply other threads:[~2020-12-17 0:16 UTC|newest] Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20201217001614.277053857C65@sourceware.org \ --to=rsandifo@gcc.gnu.org \ --cc=gcc-cvs@gcc.gnu.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).