Stefan Scholz
Containers (STL-compatible) StateMachines MessageBus and more for Embedded Systems. See www.etlcpp.com
Diff: array_view.h
- Revision:
- 0:b47c2a7920c2
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/array_view.h Fri Mar 16 16:34:18 2018 +0000
@@ -0,0 +1,874 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2017 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef __ETL_ARRAY_VIEW__
+#define __ETL_ARRAY_VIEW__
+
+#include "platform.h"
+#include "memory.h"
+#include "iterator.h"
+#include "error_handler.h"
+#include "exception.h"
+#include "nullptr.h"
+#include "hash.h"
+
+#include <algorithm>
+
+///\defgroup array array
+/// A wrapper for arrays
+///\ingroup containers
+
+#undef ETL_FILE
+#define ETL_FILE "41"
+
+namespace etl
+{
+ //***************************************************************************
+ /// The base class for array_view exceptions.
+ //***************************************************************************
+ class array_view_exception : public exception
+ {
+ public:
+
+ array_view_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
+ : exception(reason_, file_name_, line_number_)
+ {
+ }
+ };
+
+ //***************************************************************************
+ ///\ingroup stack
+ /// The exception thrown when the index is out of bounds.
+ //***************************************************************************
+ class array_view_bounds : public array_view_exception
+ {
+ public:
+
+ array_view_bounds(string_type file_name_, numeric_type line_number_)
+ : array_view_exception(ETL_ERROR_TEXT("array_view:bounds", ETL_FILE"A"), file_name_, line_number_)
+ {
+ }
+ };
+
+ //***************************************************************************
+ ///\ingroup stack
+ /// The exception thrown when the view is uninitialised.
+ //***************************************************************************
+ class array_view_uninitialised : public array_view_exception
+ {
+ public:
+
+ array_view_uninitialised(string_type file_name_, numeric_type line_number_)
+ : array_view_exception(ETL_ERROR_TEXT("array_view:uninitialised", ETL_FILE"B"), file_name_, line_number_)
+ {
+ }
+ };
+
+ //***************************************************************************
+ /// Array view.
+ //***************************************************************************
+ template <typename T>
+ class array_view
+ {
+ public:
+
+ typedef T value_type;
+ typedef std::size_t size_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T* iterator;
+ typedef const T* const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ //*************************************************************************
+ /// Default constructor.
+ //*************************************************************************
+ array_view()
+ : mbegin(std::nullptr),
+ mend(std::nullptr)
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from std::array or etl::array or other type that supports
+ /// data() and size() member functions.
+ //*************************************************************************
+ template <typename TArray,
+ typename TDummy = typename etl::enable_if<!etl::is_same<T, TArray>::value, void>::type>
+ explicit array_view(TArray& a)
+ : mbegin(a.data()),
+ mend(a.data() + a.size())
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from iterators
+ //*************************************************************************
+ template <typename TIterator,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ array_view(TIterator begin_, TIterator end_)
+ : mbegin(etl::addressof(*begin_)),
+ mend(etl::addressof(*begin_) + std::distance(begin_, end_))
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from C array
+ //*************************************************************************
+ template <typename TIterator,
+ typename TSize,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ array_view(TIterator begin_, TSize size_)
+ : mbegin(etl::addressof(*begin_)),
+ mend(etl::addressof(*begin_) + size_)
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from C array
+ //*************************************************************************
+ template<const size_t ARRAY_SIZE>
+ explicit array_view(T(&begin_)[ARRAY_SIZE])
+ : mbegin(begin_),
+ mend(begin_ + ARRAY_SIZE)
+ {
+ }
+
+ //*************************************************************************
+ /// Copy constructor
+ //*************************************************************************
+ array_view(const array_view& other)
+ : mbegin(other.mbegin),
+ mend(other.mend)
+ {
+ }
+
+ //*************************************************************************
+ /// Returns a reference to the first element.
+ //*************************************************************************
+ reference front()
+ {
+ return *mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the first element.
+ //*************************************************************************
+ const_reference front() const
+ {
+ return *mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a reference to the last element.
+ //*************************************************************************
+ reference back()
+ {
+ return *(mend - 1);
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the last element.
+ //*************************************************************************
+ const_reference back() const
+ {
+ return *(mend - 1);
+ }
+
+ //*************************************************************************
+ /// Returns a pointer to the first element of the internal storage.
+ //*************************************************************************
+ pointer data()
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const pointer to the first element of the internal storage.
+ //*************************************************************************
+ const_pointer data() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns an iterator to the beginning of the array.
+ //*************************************************************************
+ iterator begin()
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the beginning of the array.
+ //*************************************************************************
+ const_iterator begin() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the beginning of the array.
+ //*************************************************************************
+ const_iterator cbegin() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns an iterator to the end of the array.
+ //*************************************************************************
+ iterator end()
+ {
+ return mend;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the end of the array.
+ //*************************************************************************
+ const_iterator end() const
+ {
+ return mend;
+ }
+
+ //*************************************************************************
+ // Returns a const iterator to the end of the array.
+ //*************************************************************************
+ const_iterator cend() const
+ {
+ return mend;
+ }
+
+ //*************************************************************************
+ // Returns an reverse iterator to the reverse beginning of the array.
+ //*************************************************************************
+ reverse_iterator rbegin()
+ {
+ return reverse_iterator(mend);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the reverse beginning of the array.
+ //*************************************************************************
+ const_reverse_iterator rbegin() const
+ {
+ return const_reverse_iterator(mend);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the reverse beginning of the array.
+ //*************************************************************************
+ const_reverse_iterator crbegin() const
+ {
+ return const_reverse_iterator(mend);
+ }
+
+ //*************************************************************************
+ /// Returns a reverse iterator to the end of the array.
+ //*************************************************************************
+ reverse_iterator rend()
+ {
+ return reverse_iterator(mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the end of the array.
+ //*************************************************************************
+ const_reverse_iterator rend() const
+ {
+ return const_reverse_iterator(mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the end of the array.
+ //*************************************************************************
+ const_reverse_iterator crend() const
+ {
+ return const_reverse_iterator(mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns <b>true</b> if the array size is zero.
+ //*************************************************************************
+ bool empty() const
+ {
+ return (mbegin == mend);
+ }
+
+ //*************************************************************************
+ /// Returns the size of the array.
+ //*************************************************************************
+ size_t size() const
+ {
+ return (mend - mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns the maximum possible size of the array.
+ //*************************************************************************
+ size_t max_size() const
+ {
+ return size();
+ }
+
+ //*************************************************************************
+ /// Assign from a view.
+ //*************************************************************************
+ array_view& operator=(const array_view& other)
+ {
+ mbegin = other.mbegin;
+ mend = other.mend;
+ return *this;
+ }
+
+ //*************************************************************************
+ /// Assign from iterators
+ //*************************************************************************
+ template <typename TIterator,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ void assign(TIterator begin_, TIterator end_)
+ {
+ mbegin = etl::addressof(*begin_);
+ mend = etl::addressof(*begin_) + std::distance(begin_, end_);
+ }
+
+ //*************************************************************************
+ /// Assign from iterator and size.
+ //*************************************************************************
+ template <typename TIterator,
+ typename TSize,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ void assign(TIterator begin_, TSize size_)
+ {
+ mbegin = etl::addressof(*begin_);
+ mend = etl::addressof(*begin_) + size_;
+ }
+
+ //*************************************************************************
+ /// Returns a reference to the indexed value.
+ //*************************************************************************
+ reference operator[](size_t i)
+ {
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the indexed value.
+ //*************************************************************************
+ const_reference operator[](size_t i) const
+ {
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Returns a reference to the indexed value.
+ //*************************************************************************
+ reference at(size_t i)
+ {
+ ETL_ASSERT((mbegin != std::nullptr && mend != std::nullptr), ETL_ERROR(array_view_uninitialised));
+ ETL_ASSERT(i < size(), ETL_ERROR(array_view_bounds));
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the indexed value.
+ //*************************************************************************
+ const_reference at(size_t i) const
+ {
+ ETL_ASSERT((mbegin != std::nullptr && mend != std::nullptr), ETL_ERROR(array_view_uninitialised));
+ ETL_ASSERT(i < size(), ETL_ERROR(array_view_bounds));
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Swaps with another array_view.
+ //*************************************************************************
+ void swap(array_view& other)
+ {
+ std::swap(mbegin, other.mbegin);
+ std::swap(mend, other.mend);
+ }
+
+ //*************************************************************************
+ /// Shrinks the view by moving its start forward.
+ //*************************************************************************
+ void remove_prefix(size_type n)
+ {
+ mbegin += n;
+ }
+
+ //*************************************************************************
+ /// Shrinks the view by moving its end backward.
+ //*************************************************************************
+ void remove_suffix(size_type n)
+ {
+ mend -= n;
+ }
+
+ //*************************************************************************
+ /// Equality for array views.
+ //*************************************************************************
+ friend bool operator == (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return (lhs.size() == rhs.size()) &&
+ std::equal(lhs.begin(), lhs.end(), rhs.begin());
+ }
+
+ //*************************************************************************
+ /// Inequality for array views.
+ //*************************************************************************
+ friend bool operator != (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return !(lhs == rhs);
+ }
+
+ //*************************************************************************
+ /// Less-than for array views.
+ //*************************************************************************
+ friend bool operator < (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+ }
+
+ //*************************************************************************
+ /// Greater-than for array views.
+ //*************************************************************************
+ friend bool operator > (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return rhs < lhs;
+ }
+
+ //*************************************************************************
+ /// Less-than-equal for array views.
+ //*************************************************************************
+ friend bool operator <= (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return !(lhs > rhs);
+ }
+
+ //*************************************************************************
+ /// Greater-than-equal for array views.
+ //*************************************************************************
+ friend bool operator >= (const array_view<T>& lhs, const array_view<T>& rhs)
+ {
+ return !(lhs < rhs);
+ }
+
+ private:
+
+ T* mbegin;
+ T* mend;
+ };
+
+ //***************************************************************************
+ /// Constant array view.
+ //***************************************************************************
+ template <typename T>
+ class const_array_view
+ {
+ public:
+
+ typedef T value_type;
+ typedef std::size_t size_type;
+ typedef const T& const_reference;
+ typedef const T* const_pointer;
+ typedef const T* const_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ //*************************************************************************
+ /// Default constructor.
+ //*************************************************************************
+ const_array_view()
+ : mbegin(std::nullptr),
+ mend(std::nullptr)
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from std::array or etl::array or other type that supports
+ /// data() and size() member functions.
+ //*************************************************************************
+ template <typename TArray,
+ typename TDummy = typename etl::enable_if<!etl::is_same<T, TArray>::value, void>::type>
+ explicit const_array_view(TArray& a)
+ : mbegin(a.data()),
+ mend(a.data() + a.size())
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from iterators
+ //*************************************************************************
+ template <typename TIterator,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ const_array_view(TIterator begin_, TIterator end_)
+ : mbegin(etl::addressof(*begin_)),
+ mend(etl::addressof(*begin_) + std::distance(begin_, end_))
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from C array
+ //*************************************************************************
+ template <typename TIterator,
+ typename TSize, typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ const_array_view(TIterator begin_, TSize size_)
+ : mbegin(etl::addressof(*begin_)),
+ mend(etl::addressof(*begin_) + size_)
+ {
+ }
+
+ //*************************************************************************
+ /// Construct from C array
+ //*************************************************************************
+ template<const size_t ARRAY_SIZE>
+ explicit const_array_view(const T(&begin_)[ARRAY_SIZE])
+ : mbegin(begin_),
+ mend(begin_ + ARRAY_SIZE)
+ {
+ }
+
+ //*************************************************************************
+ /// Copy constructor
+ //*************************************************************************
+ const_array_view(const array_view<T>& other)
+ : mbegin(other.begin()),
+ mend(other.end())
+ {
+ }
+
+ //*************************************************************************
+ /// Copy constructor
+ //*************************************************************************
+ const_array_view(const const_array_view& other)
+ : mbegin(other.mbegin),
+ mend(other.mend)
+ {
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the first element.
+ //*************************************************************************
+ const_reference front() const
+ {
+ return *mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the last element.
+ //*************************************************************************
+ const_reference back() const
+ {
+ return *(mend - 1);
+ }
+
+ //*************************************************************************
+ /// Returns a const pointer to the first element of the internal storage.
+ //*************************************************************************
+ const_pointer data() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the beginning of the array.
+ //*************************************************************************
+ const_iterator begin() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the beginning of the array.
+ //*************************************************************************
+ const_iterator cbegin() const
+ {
+ return mbegin;
+ }
+
+ //*************************************************************************
+ /// Returns a const iterator to the end of the array.
+ //*************************************************************************
+ const_iterator end() const
+ {
+ return mend;
+ }
+
+ //*************************************************************************
+ // Returns a const iterator to the end of the array.
+ //*************************************************************************
+ const_iterator cend() const
+ {
+ return mend;
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the reverse beginning of the array.
+ //*************************************************************************
+ const_reverse_iterator rbegin() const
+ {
+ return const_reverse_iterator(mend);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the reverse beginning of the array.
+ //*************************************************************************
+ const_reverse_iterator crbegin() const
+ {
+ return const_reverse_iterator(mend);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the end of the array.
+ //*************************************************************************
+ const_reverse_iterator rend() const
+ {
+ return const_reverse_iterator(mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns a const reverse iterator to the end of the array.
+ //*************************************************************************
+ const_reverse_iterator crend() const
+ {
+ return const_reverse_iterator(mbegin);
+ }
+
+ //*************************************************************************
+ // Capacity
+ //*************************************************************************
+
+ //*************************************************************************
+ /// Returns <b>true</b> if the array size is zero.
+ //*************************************************************************
+ bool empty() const
+ {
+ return (mbegin == mend);
+ }
+
+ //*************************************************************************
+ /// Returns the size of the array.
+ //*************************************************************************
+ size_t size() const
+ {
+ return (mend - mbegin);
+ }
+
+ //*************************************************************************
+ /// Returns the maximum possible size of the array.
+ //*************************************************************************
+ size_t max_size() const
+ {
+ return size();
+ }
+
+ //*************************************************************************
+ /// Assign from a view.
+ //*************************************************************************
+ const_array_view<T>& operator=(const const_array_view<T>& other)
+ {
+ mbegin = other.mbegin;
+ mend = other.mend;
+ return *this;
+ }
+
+ //*************************************************************************
+ /// Assign from iterators
+ //*************************************************************************
+ template <typename TIterator,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ void assign(TIterator begin_, TIterator end_)
+ {
+ mbegin = etl::addressof(*begin_);
+ mend = etl::addressof(*begin_) + std::distance(begin_, end_);
+ }
+
+ //*************************************************************************
+ /// Assign from iterator and size.
+ //*************************************************************************
+ template <typename TIterator,
+ typename TSize,
+ typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
+ void assign(TIterator begin_, TSize size_)
+ {
+ mbegin = etl::addressof(*begin_);
+ mend = etl::addressof(*begin_) + size_;
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the indexed value.
+ //*************************************************************************
+ const_reference operator[](size_t i) const
+ {
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Returns a const reference to the indexed value.
+ //*************************************************************************
+ const_reference at(size_t i) const
+ {
+ ETL_ASSERT((mbegin != std::nullptr && mend != std::nullptr), ETL_ERROR(array_view_uninitialised));
+ ETL_ASSERT(i < size(), ETL_ERROR(array_view_bounds));
+ return mbegin[i];
+ }
+
+ //*************************************************************************
+ /// Swaps with another array_view.
+ //*************************************************************************
+ void swap(const_array_view& other)
+ {
+ std::swap(mbegin, other.mbegin);
+ std::swap(mend, other.mend);
+ }
+
+ //*************************************************************************
+ /// Shrinks the view by moving its start forward.
+ //*************************************************************************
+ void remove_prefix(size_type n)
+ {
+ mbegin += n;
+ }
+
+ //*************************************************************************
+ /// Shrinks the view by moving its end backward.
+ //*************************************************************************
+ void remove_suffix(size_type n)
+ {
+ mend -= n;
+ }
+
+ //*************************************************************************
+ /// Equality for array views.
+ //*************************************************************************
+ friend bool operator == (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return (lhs.size() == rhs.size()) &&
+ std::equal(lhs.begin(), lhs.end(), rhs.begin());
+ }
+
+ //*************************************************************************
+ /// Inequality for array views.
+ //*************************************************************************
+ friend bool operator != (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return !(lhs == rhs);
+ }
+
+ //*************************************************************************
+ /// Less-than for array views.
+ //*************************************************************************
+ friend bool operator < (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+ }
+
+ //*************************************************************************
+ /// Greater-than for array views.
+ //*************************************************************************
+ friend bool operator > (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return rhs < lhs;
+ }
+
+ //*************************************************************************
+ /// Less-than-equal for array views.
+ //*************************************************************************
+ friend bool operator <= (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return !(lhs > rhs);
+ }
+
+ //*************************************************************************
+ /// Greater-than-equal for array views.
+ //*************************************************************************
+ friend bool operator >= (const const_array_view<T>& lhs, const const_array_view<T>& rhs)
+ {
+ return !(lhs < rhs);
+ }
+
+ private:
+
+ const T* mbegin;
+ const T* mend;
+ };
+
+ //*************************************************************************
+ /// Hash function.
+ //*************************************************************************
+#if ETL_8BIT_SUPPORT
+ template <typename T>
+ struct hash<etl::array_view<T> >
+ {
+ size_t operator()(const etl::array_view<T>& view) const
+ {
+ return etl::__private_hash__::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
+ reinterpret_cast<const uint8_t*>(&view[view.size()]));
+ }
+ };
+
+ template <typename T>
+ struct hash<etl::const_array_view<T> >
+ {
+ size_t operator()(const etl::const_array_view<T>& view) const
+ {
+ return etl::__private_hash__::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
+ reinterpret_cast<const uint8_t*>(&view[view.size()]));
+ }
+ };
+#endif
+}
+
+//*************************************************************************
+/// Swaps the values.
+//*************************************************************************
+template <typename T>
+void swap(etl::array_view<T>& lhs, etl::array_view<T>& rhs)
+{
+ lhs.swap(rhs);
+}
+
+//*************************************************************************
+/// Swaps the values.
+//*************************************************************************
+template <typename T>
+void swap(etl::const_array_view<T>& lhs, etl::const_array_view<T>& rhs)
+{
+ lhs.swap(rhs);
+}
+
+#undef ETL_FILE
+
+#endif
+
+