diff options
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/PackedGLEnums.h')
-rw-r--r-- | src/3rdparty/angle/src/libANGLE/PackedGLEnums.h | 111 |
1 files changed, 111 insertions, 0 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/PackedGLEnums.h b/src/3rdparty/angle/src/libANGLE/PackedGLEnums.h new file mode 100644 index 0000000000..70e32910fc --- /dev/null +++ b/src/3rdparty/angle/src/libANGLE/PackedGLEnums.h @@ -0,0 +1,111 @@ +// Copyright 2017 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// PackedGLEnums_autogen.h: +// Declares ANGLE-specific enums classes for GLEnum and functions operating +// on them. + +#ifndef LIBANGLE_PACKEDGLENUMS_H_ +#define LIBANGLE_PACKEDGLENUMS_H_ + +#include "libANGLE/PackedGLEnums_autogen.h" + +#include <array> +#include <cstddef> + +namespace angle +{ + +template <typename E> +class EnumIterator final +{ + private: + using UnderlyingType = typename std::underlying_type<E>::type; + + public: + EnumIterator(E value) : mValue(static_cast<UnderlyingType>(value)) {} + EnumIterator &operator++() + { + mValue++; + return *this; + } + bool operator==(const EnumIterator &other) const { return mValue == other.mValue; } + bool operator!=(const EnumIterator &other) const { return mValue != other.mValue; } + E operator*() const { return static_cast<E>(mValue); } + + private: + UnderlyingType mValue; +}; + +template <typename E> +struct AllEnums +{ + EnumIterator<E> begin() const { return {static_cast<E>(0)}; } + EnumIterator<E> end() const { return {E::InvalidEnum}; } +}; + +template <typename E, typename T> +class PackedEnumMap +{ + private: + using UnderlyingType = typename std::underlying_type<E>::type; + static constexpr size_t kSize = static_cast<UnderlyingType>(E::EnumCount); + using Storage = std::array<T, kSize>; + + Storage mData; + + public: + // types: + using value_type = T; + using pointer = T *; + using const_pointer = const T *; + using reference = T &; + using const_reference = const T &; + + using size_type = size_t; + using difference_type = ptrdiff_t; + + using iterator = typename Storage::iterator; + using const_iterator = typename Storage::const_iterator; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + + // No explicit construct/copy/destroy for aggregate type + void fill(const T &u) { mData.fill(u); } + void swap(PackedEnumMap<E, T> &a) noexcept { mData.swap(a.mData); } + + // iterators: + iterator begin() noexcept { return mData.begin(); } + const_iterator begin() const noexcept { return mData.begin(); } + iterator end() noexcept { return mData.end(); } + const_iterator end() const noexcept { return mData.end(); } + + reverse_iterator rbegin() noexcept { return mData.rbegin(); } + const_reverse_iterator rbegin() const noexcept { return mData.rbegin(); } + reverse_iterator rend() noexcept { return mData.rend(); } + const_reverse_iterator rend() const noexcept { return mData.rend(); } + + // capacity: + constexpr size_type size() const noexcept { return mData.size(); } + constexpr size_type max_size() const noexcept { return mData.max_size(); } + constexpr bool empty() const noexcept { return mData.empty(); } + + // element access: + reference operator[](E n) { return mData[static_cast<UnderlyingType>(n)]; } + const_reference operator[](E n) const { return mData[static_cast<UnderlyingType>(n)]; } + const_reference at(E n) const { return mData.at(static_cast<UnderlyingType>(n)); } + reference at(E n) { return mData.at(static_cast<UnderlyingType>(n)); } + + reference front() { return mData.front(); } + const_reference front() const { return mData.front(); } + reference back() { return mData.back(); } + const_reference back() const { return mData.back(); } + + T *data() noexcept { return mData.data(); } + const T *data() const noexcept { return mData.data(); } +}; + +} // namespace angle + +#endif // LIBANGLE_PACKEDGLENUMS_H_ |