1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkSpan_DEFINED
#define SkSpan_DEFINED
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <utility>
#include "include/private/SkTLogic.h"
/**
* An SkSpan is a view of a contiguous collection of elements of type T. It can be directly
* constructed from a pointer and size. SkMakeSpan can be used to construct one from an array,
* or a container (like std::vector).
*
* With C++17, we could add template deduction guides that eliminate the need for SkMakeSpan:
* https://skia-review.googlesource.com/c/skia/+/320264
*/
template <typename T>
class SkSpan {
public:
constexpr SkSpan() : fPtr{nullptr}, fSize{0} {}
constexpr SkSpan(T* ptr, size_t size) : fPtr{ptr}, fSize{size} {
SkASSERT(size < kMaxSize);
}
template <typename U, typename = typename std::enable_if<std::is_same<const U, T>::value>::type>
constexpr SkSpan(const SkSpan<U>& that) : fPtr(that.data()), fSize{that.size()} {}
constexpr SkSpan(const SkSpan& o) = default;
constexpr SkSpan& operator=(const SkSpan& that) {
fPtr = that.fPtr;
fSize = that.fSize;
return *this;
}
constexpr T& operator [] (size_t i) const {
SkASSERT(i < this->size());
return fPtr[i];
}
constexpr T& front() const { return fPtr[0]; }
constexpr T& back() const { return fPtr[fSize - 1]; }
constexpr T* begin() const { return fPtr; }
constexpr T* end() const { return fPtr + fSize; }
constexpr auto rbegin() const { return std::make_reverse_iterator(this->end()); }
constexpr auto rend() const { return std::make_reverse_iterator(this->begin()); }
constexpr T* data() const { return this->begin(); }
constexpr size_t size() const { return fSize; }
constexpr bool empty() const { return fSize == 0; }
constexpr size_t size_bytes() const { return fSize * sizeof(T); }
constexpr SkSpan<T> first(size_t prefixLen) const {
SkASSERT(prefixLen <= this->size());
return SkSpan{fPtr, prefixLen};
}
constexpr SkSpan<T> last(size_t postfixLen) const {
SkASSERT(postfixLen <= this->size());
return SkSpan{fPtr + (this->size() - postfixLen), postfixLen};
}
constexpr SkSpan<T> subspan(size_t offset, size_t count) const {
SkASSERT(offset <= this->size());
SkASSERT(count <= this->size() - offset);
return SkSpan{fPtr + offset, count};
}
private:
static constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
T* fPtr;
size_t fSize;
};
template <typename T, typename S> inline constexpr SkSpan<T> SkMakeSpan(T* p, S s) {
return SkSpan<T>{p, SkTo<size_t>(s)};
}
template <size_t N, typename T> inline constexpr SkSpan<T> SkMakeSpan(T (&a)[N]) {
return SkSpan<T>{a, N};
}
template <typename Container>
inline auto SkMakeSpan(Container& c)
-> SkSpan<typename std::remove_reference<decltype(*(c.data()))>::type> {
return {c.data(), c.size()};
}
#endif // SkSpan_DEFINED
|
