takashi kadono / Mbed OS Nucleo446_SSD1331

Color Oled(SSD1331) connect to STMicroelectronics Nucleo-F466

Dependencies:   ssd1331

mbed-os/platform/Span.h@3:f3764f852aa8, 2018-10-11 (annotated)

Committer:
kadonotakashi
Date:
Thu Oct 11 02:27:46 2018 +0000
Revision:
3:f3764f852aa8
Parent:
0:8fdf9a60065b 
Nucreo 446 + SSD1331 test version;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kadonotakashi 0:8fdf9a60065b 1 /* mbed Microcontroller Library
kadonotakashi 0:8fdf9a60065b 2 * Copyright (c) 2018-2018 ARM Limited
kadonotakashi 0:8fdf9a60065b 3 *
kadonotakashi 0:8fdf9a60065b 4 * Licensed under the Apache License, Version 2.0 (the "License");
kadonotakashi 0:8fdf9a60065b 5 * you may not use this file except in compliance with the License.
kadonotakashi 0:8fdf9a60065b 6 * You may obtain a copy of the License at
kadonotakashi 0:8fdf9a60065b 7 *
kadonotakashi 0:8fdf9a60065b 8 * http://www.apache.org/licenses/LICENSE-2.0
kadonotakashi 0:8fdf9a60065b 9 *
kadonotakashi 0:8fdf9a60065b 10 * Unless required by applicable law or agreed to in writing, software
kadonotakashi 0:8fdf9a60065b 11 * distributed under the License is distributed on an "AS IS" BASIS,
kadonotakashi 0:8fdf9a60065b 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
kadonotakashi 0:8fdf9a60065b 13 * See the License for the specific language governing permissions and
kadonotakashi 0:8fdf9a60065b 14 * limitations under the License.
kadonotakashi 0:8fdf9a60065b 15 */
kadonotakashi 0:8fdf9a60065b 16
kadonotakashi 0:8fdf9a60065b 17 #ifndef MBED_PLATFORM_SPAN_H_
kadonotakashi 0:8fdf9a60065b 18 #define MBED_PLATFORM_SPAN_H_
kadonotakashi 0:8fdf9a60065b 19
kadonotakashi 0:8fdf9a60065b 20 #include <algorithm>
kadonotakashi 0:8fdf9a60065b 21 #include <stddef.h>
kadonotakashi 0:8fdf9a60065b 22 #include <stdint.h>
kadonotakashi 0:8fdf9a60065b 23
kadonotakashi 0:8fdf9a60065b 24 #include "platform/mbed_assert.h"
kadonotakashi 0:8fdf9a60065b 25
kadonotakashi 0:8fdf9a60065b 26 namespace mbed {
kadonotakashi 0:8fdf9a60065b 27
kadonotakashi 0:8fdf9a60065b 28 // Internal details of Span
kadonotakashi 0:8fdf9a60065b 29 // It is used construct Span from Span of convertible types (non const -> const)
kadonotakashi 0:8fdf9a60065b 30 namespace span_detail {
kadonotakashi 0:8fdf9a60065b 31
kadonotakashi 0:8fdf9a60065b 32 // If From type is convertible to To type, then the compilation constant value is
kadonotakashi 0:8fdf9a60065b 33 // true; otherwise, it is false.
kadonotakashi 0:8fdf9a60065b 34 template<typename From, typename To>
kadonotakashi 0:8fdf9a60065b 35 class is_convertible
kadonotakashi 0:8fdf9a60065b 36 {
kadonotakashi 0:8fdf9a60065b 37 struct true_type { char x[512]; };
kadonotakashi 0:8fdf9a60065b 38 struct false_type { };
kadonotakashi 0:8fdf9a60065b 39
kadonotakashi 0:8fdf9a60065b 40 static const From& generator();
kadonotakashi 0:8fdf9a60065b 41 static true_type sink(const To &);
kadonotakashi 0:8fdf9a60065b 42 static false_type sink(...);
kadonotakashi 0:8fdf9a60065b 43
kadonotakashi 0:8fdf9a60065b 44 public:
kadonotakashi 0:8fdf9a60065b 45 static const bool value = sizeof(true_type) == sizeof(sink(generator()));
kadonotakashi 0:8fdf9a60065b 46 };
kadonotakashi 0:8fdf9a60065b 47
kadonotakashi 0:8fdf9a60065b 48 }
kadonotakashi 0:8fdf9a60065b 49
kadonotakashi 0:8fdf9a60065b 50 /**
kadonotakashi 0:8fdf9a60065b 51 * Special value for the Extent parameter of Span.
kadonotakashi 0:8fdf9a60065b 52 * If the type uses this value, then the size of the array is stored in the object
kadonotakashi 0:8fdf9a60065b 53 * at runtime.
kadonotakashi 0:8fdf9a60065b 54 */
kadonotakashi 0:8fdf9a60065b 55 #define SPAN_DYNAMIC_EXTENT -1
kadonotakashi 0:8fdf9a60065b 56
kadonotakashi 0:8fdf9a60065b 57 /**
kadonotakashi 0:8fdf9a60065b 58 * Nonowning view to a sequence of contiguous elements.
kadonotakashi 0:8fdf9a60065b 59 *
kadonotakashi 0:8fdf9a60065b 60 * Spans encapsulate a pointer to a sequence of contiguous elements and its size
kadonotakashi 0:8fdf9a60065b 61 * into a single object. Span can replace the traditional pair of pointer and
kadonotakashi 0:8fdf9a60065b 62 * size arguments passed as array definitions in function calls.
kadonotakashi 0:8fdf9a60065b 63 *
kadonotakashi 0:8fdf9a60065b 64 * @par Operations
kadonotakashi 0:8fdf9a60065b 65 *
kadonotakashi 0:8fdf9a60065b 66 * Span objects can be copied and assigned like regular value types with the help
kadonotakashi 0:8fdf9a60065b 67 * of the copy constructor or the copy assignment (=) operator.
kadonotakashi 0:8fdf9a60065b 68 *
kadonotakashi 0:8fdf9a60065b 69 * You can retrieve elements of the object with the subscript ([]) operator. You can access the
kadonotakashi 0:8fdf9a60065b 70 * pointer to the first element of the sequence viewed with data().
kadonotakashi 0:8fdf9a60065b 71 * The function size() returns the number of elements in the sequence, and
kadonotakashi 0:8fdf9a60065b 72 * empty() informs whether there is any element in the sequence.
kadonotakashi 0:8fdf9a60065b 73 *
kadonotakashi 0:8fdf9a60065b 74 * You can slice Span from the beginning of the sequence (first()), from the end
kadonotakashi 0:8fdf9a60065b 75 * of the sequence (last()) or from an arbitrary point of the sequence (subspan()).
kadonotakashi 0:8fdf9a60065b 76 *
kadonotakashi 0:8fdf9a60065b 77 * @par Size encoding
kadonotakashi 0:8fdf9a60065b 78 *
kadonotakashi 0:8fdf9a60065b 79 * The size of the sequence can be encoded in the type itself or in the value of
kadonotakashi 0:8fdf9a60065b 80 * the instance with the help of the template parameter Extent:
kadonotakashi 0:8fdf9a60065b 81 *
kadonotakashi 0:8fdf9a60065b 82 * - Span<uint8_t, 6>: Span over a sequence of 6 elements.
kadonotakashi 0:8fdf9a60065b 83 * - Span<uint8_t>: Span over an arbitrary long sequence.
kadonotakashi 0:8fdf9a60065b 84 *
kadonotakashi 0:8fdf9a60065b 85 * When the size is encoded in the type itself, it is guaranteed that the Span
kadonotakashi 0:8fdf9a60065b 86 * view is a valid sequence (not empty() and not NULL) - unless Extent equals 0.
kadonotakashi 0:8fdf9a60065b 87 * The type system also prevents automatic conversion from Span of different
kadonotakashi 0:8fdf9a60065b 88 * sizes. Finally, the Span object is internally represented as a single pointer.
kadonotakashi 0:8fdf9a60065b 89 *
kadonotakashi 0:8fdf9a60065b 90 * When the size of the sequence viewed is encoded in the Span value, Span
kadonotakashi 0:8fdf9a60065b 91 * instances can view an empty sequence. The function empty() helps client code
kadonotakashi 0:8fdf9a60065b 92 * decide whether Span is viewing valid content or not.
kadonotakashi 0:8fdf9a60065b 93 *
kadonotakashi 0:8fdf9a60065b 94 * @par Example
kadonotakashi 0:8fdf9a60065b 95 *
kadonotakashi 0:8fdf9a60065b 96 * - Encoding fixed size array: Array values in parameter decays automatically
kadonotakashi 0:8fdf9a60065b 97 * to pointer, which leaves room for subtitle bugs:
kadonotakashi 0:8fdf9a60065b 98 *
kadonotakashi 0:8fdf9a60065b 99 * @code
kadonotakashi 0:8fdf9a60065b 100 typedef uint8_t mac_address_t[6];
kadonotakashi 0:8fdf9a60065b 101 void process_mac(mac_address_t);
kadonotakashi 0:8fdf9a60065b 102
kadonotakashi 0:8fdf9a60065b 103 // compile just fine
kadonotakashi 0:8fdf9a60065b 104 uint8_t *invalid_value = NULL;
kadonotakashi 0:8fdf9a60065b 105 process_mac(invalid_value);
kadonotakashi 0:8fdf9a60065b 106
kadonotakashi 0:8fdf9a60065b 107
kadonotakashi 0:8fdf9a60065b 108 // correct way
kadonotakashi 0:8fdf9a60065b 109 typedef Span<uint8_t, 6> mac_address_t;
kadonotakashi 0:8fdf9a60065b 110 void process_mac(mac_address_t);
kadonotakashi 0:8fdf9a60065b 111
kadonotakashi 0:8fdf9a60065b 112 // compilation error
kadonotakashi 0:8fdf9a60065b 113 uint8_t *invalid_value = NULL;
kadonotakashi 0:8fdf9a60065b 114 process_mac(invalid_value);
kadonotakashi 0:8fdf9a60065b 115
kadonotakashi 0:8fdf9a60065b 116 // compilation ok
kadonotakashi 0:8fdf9a60065b 117 uint8_t valid_value[6];
kadonotakashi 0:8fdf9a60065b 118 process_mac(valid_value);
kadonotakashi 0:8fdf9a60065b 119 * @endcode
kadonotakashi 0:8fdf9a60065b 120 *
kadonotakashi 0:8fdf9a60065b 121 * - Arbitrary buffer: When dealing with multiple buffers, it becomes painful to
kadonotakashi 0:8fdf9a60065b 122 * keep track of every buffer size and pointer.
kadonotakashi 0:8fdf9a60065b 123 *
kadonotakashi 0:8fdf9a60065b 124 * @code
kadonotakashi 0:8fdf9a60065b 125 const uint8_t options_tag[OPTIONS_TAG_SIZE];
kadonotakashi 0:8fdf9a60065b 126
kadonotakashi 0:8fdf9a60065b 127 struct parsed_value_t {
kadonotakashi 0:8fdf9a60065b 128 uint8_t *header;
kadonotakashi 0:8fdf9a60065b 129 uint8_t *options;
kadonotakashi 0:8fdf9a60065b 130 uint8_t *payload;
kadonotakashi 0:8fdf9a60065b 131 size_t payload_size;
kadonotakashi 0:8fdf9a60065b 132 }
kadonotakashi 0:8fdf9a60065b 133
kadonotakashi 0:8fdf9a60065b 134 parsed_value_t parse(uint8_t *buffer, size_t buffer_size)
kadonotakashi 0:8fdf9a60065b 135 {
kadonotakashi 0:8fdf9a60065b 136 parsed_value_t parsed_value { 0 };
kadonotakashi 0:8fdf9a60065b 137
kadonotakashi 0:8fdf9a60065b 138 if (buffer != NULL && buffer_size <= MINIMAL_BUFFER_SIZE) {
kadonotakashi 0:8fdf9a60065b 139 return parsed_value;
kadonotakashi 0:8fdf9a60065b 140 }
kadonotakashi 0:8fdf9a60065b 141
kadonotakashi 0:8fdf9a60065b 142 parsed_value.header = buffer;
kadonotakashi 0:8fdf9a60065b 143 parsed_value.header_size = BUFFER_HEADER_SIZE;
kadonotakashi 0:8fdf9a60065b 144
kadonotakashi 0:8fdf9a60065b 145 if (memcmp(buffer + HEADER_OPTIONS_INDEX, options_tag, sizeof(options_tag)) == 0) {
kadonotakashi 0:8fdf9a60065b 146 options = buffer + BUFFER_HEADER_SIZE;
kadonotakashi 0:8fdf9a60065b 147 payload = buffer + BUFFER_HEADER_SIZE + OPTIONS_SIZE;
kadonotakashi 0:8fdf9a60065b 148 payload_size = buffer_size - BUFFER_HEADER_SIZE + OPTIONS_SIZE;
kadonotakashi 0:8fdf9a60065b 149 } else {
kadonotakashi 0:8fdf9a60065b 150 payload = buffer + BUFFER_HEADER_SIZE;
kadonotakashi 0:8fdf9a60065b 151 payload_size = buffer_size - BUFFER_HEADER_SIZE;
kadonotakashi 0:8fdf9a60065b 152 }
kadonotakashi 0:8fdf9a60065b 153
kadonotakashi 0:8fdf9a60065b 154 return parsed_value;
kadonotakashi 0:8fdf9a60065b 155 }
kadonotakashi 0:8fdf9a60065b 156
kadonotakashi 0:8fdf9a60065b 157
kadonotakashi 0:8fdf9a60065b 158 //with Span
kadonotakashi 0:8fdf9a60065b 159 struct parsed_value_t {
kadonotakashi 0:8fdf9a60065b 160 Span<uint8_t> header;
kadonotakashi 0:8fdf9a60065b 161 Span<uint8_t> options;
kadonotakashi 0:8fdf9a60065b 162 Span<uint8_t> payload;
kadonotakashi 0:8fdf9a60065b 163 }
kadonotakashi 0:8fdf9a60065b 164
kadonotakashi 0:8fdf9a60065b 165 parsed_value_t parse(const Span<uint8_t> &buffer)
kadonotakashi 0:8fdf9a60065b 166 {
kadonotakashi 0:8fdf9a60065b 167 parsed_value_t parsed_value;
kadonotakashi 0:8fdf9a60065b 168
kadonotakashi 0:8fdf9a60065b 169 if (buffer.size() <= MINIMAL_BUFFER_SIZE) {
kadonotakashi 0:8fdf9a60065b 170 return parsed_value;
kadonotakashi 0:8fdf9a60065b 171 }
kadonotakashi 0:8fdf9a60065b 172
kadonotakashi 0:8fdf9a60065b 173 parsed_value.header = buffer.first(BUFFER_HEADER_SIZE);
kadonotakashi 0:8fdf9a60065b 174
kadonotakashi 0:8fdf9a60065b 175 if (buffer.subspan<HEADER_OPTIONS_INDEX, sizeof(options_tag)>() == option_tag) {
kadonotakashi 0:8fdf9a60065b 176 options = buffer.supspan(parsed_value.header.size(), OPTIONS_SIZE);
kadonotakashi 0:8fdf9a60065b 177 }
kadonotakashi 0:8fdf9a60065b 178
kadonotakashi 0:8fdf9a60065b 179 payload = buffer.subspan(parsed_value.header.size() + parsed_value.options.size());
kadonotakashi 0:8fdf9a60065b 180
kadonotakashi 0:8fdf9a60065b 181 return parsed_value;
kadonotakashi 0:8fdf9a60065b 182 }
kadonotakashi 0:8fdf9a60065b 183 * @endcode
kadonotakashi 0:8fdf9a60065b 184 *
kadonotakashi 0:8fdf9a60065b 185 * @note You can create Span instances with the help of the function template
kadonotakashi 0:8fdf9a60065b 186 * make_Span() and make_const_Span().
kadonotakashi 0:8fdf9a60065b 187 *
kadonotakashi 0:8fdf9a60065b 188 * @note Span<T, Extent> objects can be implicitly converted to Span<T> objects
kadonotakashi 0:8fdf9a60065b 189 * where required.
kadonotakashi 0:8fdf9a60065b 190 *
kadonotakashi 0:8fdf9a60065b 191 * @tparam ElementType type of objects the Span views.
kadonotakashi 0:8fdf9a60065b 192 *
kadonotakashi 0:8fdf9a60065b 193 * @tparam Extent The size of the contiguous sequence viewed. The default value
kadonotakashi 0:8fdf9a60065b 194 * SPAN_DYNAMIC_SIZE is special because it allows construction of Span objects of
kadonotakashi 0:8fdf9a60065b 195 * any size (set at runtime).
kadonotakashi 0:8fdf9a60065b 196 */
kadonotakashi 0:8fdf9a60065b 197 template<typename ElementType, ptrdiff_t Extent = SPAN_DYNAMIC_EXTENT>
kadonotakashi 0:8fdf9a60065b 198 struct Span {
kadonotakashi 0:8fdf9a60065b 199
kadonotakashi 0:8fdf9a60065b 200 /**
kadonotakashi 0:8fdf9a60065b 201 * Type of the element contained
kadonotakashi 0:8fdf9a60065b 202 */
kadonotakashi 0:8fdf9a60065b 203 typedef ElementType element_type;
kadonotakashi 0:8fdf9a60065b 204
kadonotakashi 0:8fdf9a60065b 205 /**
kadonotakashi 0:8fdf9a60065b 206 * Type of the index.
kadonotakashi 0:8fdf9a60065b 207 */
kadonotakashi 0:8fdf9a60065b 208 typedef ptrdiff_t index_type;
kadonotakashi 0:8fdf9a60065b 209
kadonotakashi 0:8fdf9a60065b 210 /**
kadonotakashi 0:8fdf9a60065b 211 * Pointer to an ElementType
kadonotakashi 0:8fdf9a60065b 212 */
kadonotakashi 0:8fdf9a60065b 213 typedef element_type *pointer;
kadonotakashi 0:8fdf9a60065b 214
kadonotakashi 0:8fdf9a60065b 215 /**
kadonotakashi 0:8fdf9a60065b 216 * Reference to an ElementType
kadonotakashi 0:8fdf9a60065b 217 */
kadonotakashi 0:8fdf9a60065b 218 typedef element_type &reference;
kadonotakashi 0:8fdf9a60065b 219
kadonotakashi 0:8fdf9a60065b 220 /**
kadonotakashi 0:8fdf9a60065b 221 * Size of the Extent; -1 if dynamic.
kadonotakashi 0:8fdf9a60065b 222 */
kadonotakashi 0:8fdf9a60065b 223 static const index_type extent = Extent;
kadonotakashi 0:8fdf9a60065b 224
kadonotakashi 0:8fdf9a60065b 225 MBED_STATIC_ASSERT(Extent >= 0, "Invalid extent for a Span");
kadonotakashi 0:8fdf9a60065b 226
kadonotakashi 0:8fdf9a60065b 227 /**
kadonotakashi 0:8fdf9a60065b 228 * Construct an empty Span.
kadonotakashi 0:8fdf9a60065b 229 *
kadonotakashi 0:8fdf9a60065b 230 * @post a call to size() returns 0, and data() returns NULL.
kadonotakashi 0:8fdf9a60065b 231 *
kadonotakashi 0:8fdf9a60065b 232 * @note This function is not accessible if Extent != SPAN_DYNAMIC_EXTENT or
kadonotakashi 0:8fdf9a60065b 233 * Extent != 0 .
kadonotakashi 0:8fdf9a60065b 234 */
kadonotakashi 0:8fdf9a60065b 235 Span() :
kadonotakashi 0:8fdf9a60065b 236 _data(NULL)
kadonotakashi 0:8fdf9a60065b 237 {
kadonotakashi 0:8fdf9a60065b 238 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 239 Extent == 0,
kadonotakashi 0:8fdf9a60065b 240 "Cannot default construct a static-extent Span (unless Extent is 0)"
kadonotakashi 0:8fdf9a60065b 241 );
kadonotakashi 0:8fdf9a60065b 242 }
kadonotakashi 0:8fdf9a60065b 243
kadonotakashi 0:8fdf9a60065b 244 /**
kadonotakashi 0:8fdf9a60065b 245 * Construct a Span from a pointer to a buffer and its size.
kadonotakashi 0:8fdf9a60065b 246 *
kadonotakashi 0:8fdf9a60065b 247 * @param ptr Pointer to the beginning of the data viewed.
kadonotakashi 0:8fdf9a60065b 248 *
kadonotakashi 0:8fdf9a60065b 249 * @param count Number of elements viewed.
kadonotakashi 0:8fdf9a60065b 250 *
kadonotakashi 0:8fdf9a60065b 251 * @pre [ptr, ptr + count) must be be a valid range.
kadonotakashi 0:8fdf9a60065b 252 * @pre count must be equal to Extent.
kadonotakashi 0:8fdf9a60065b 253 *
kadonotakashi 0:8fdf9a60065b 254 * @post a call to size() returns Extent, and data() returns @p ptr.
kadonotakashi 0:8fdf9a60065b 255 */
kadonotakashi 0:8fdf9a60065b 256 Span(pointer ptr, index_type count) :
kadonotakashi 0:8fdf9a60065b 257 _data(ptr)
kadonotakashi 0:8fdf9a60065b 258 {
kadonotakashi 0:8fdf9a60065b 259 MBED_ASSERT(count == Extent);
kadonotakashi 0:8fdf9a60065b 260 MBED_ASSERT(Extent == 0 || ptr != NULL);
kadonotakashi 0:8fdf9a60065b 261 }
kadonotakashi 0:8fdf9a60065b 262
kadonotakashi 0:8fdf9a60065b 263 /**
kadonotakashi 0:8fdf9a60065b 264 * Construct a Span from the range [first, last).
kadonotakashi 0:8fdf9a60065b 265 *
kadonotakashi 0:8fdf9a60065b 266 * @param first Pointer to the beginning of the data viewed.
kadonotakashi 0:8fdf9a60065b 267 * @param last End of the range (element after the last element).
kadonotakashi 0:8fdf9a60065b 268 *
kadonotakashi 0:8fdf9a60065b 269 * @pre [first, last) must be be a valid range.
kadonotakashi 0:8fdf9a60065b 270 * @pre first <= last.
kadonotakashi 0:8fdf9a60065b 271 * @pre last - first must be equal to Extent.
kadonotakashi 0:8fdf9a60065b 272 *
kadonotakashi 0:8fdf9a60065b 273 * @post a call to size() returns Extent, and data() returns @p first.
kadonotakashi 0:8fdf9a60065b 274 */
kadonotakashi 0:8fdf9a60065b 275 Span(pointer first, pointer last) :
kadonotakashi 0:8fdf9a60065b 276 _data(first)
kadonotakashi 0:8fdf9a60065b 277 {
kadonotakashi 0:8fdf9a60065b 278 MBED_ASSERT(first <= last);
kadonotakashi 0:8fdf9a60065b 279 MBED_ASSERT((last - first) == Extent);
kadonotakashi 0:8fdf9a60065b 280 MBED_ASSERT(Extent == 0 || first != NULL);
kadonotakashi 0:8fdf9a60065b 281 }
kadonotakashi 0:8fdf9a60065b 282
kadonotakashi 0:8fdf9a60065b 283 /**
kadonotakashi 0:8fdf9a60065b 284 * Construct a Span from the reference to an array.
kadonotakashi 0:8fdf9a60065b 285 *
kadonotakashi 0:8fdf9a60065b 286 * @param elements Reference to the array viewed.
kadonotakashi 0:8fdf9a60065b 287 *
kadonotakashi 0:8fdf9a60065b 288 * @post a call to size() returns Extent, and data() returns a
kadonotakashi 0:8fdf9a60065b 289 * pointer to elements.
kadonotakashi 0:8fdf9a60065b 290 */
kadonotakashi 0:8fdf9a60065b 291 Span(element_type (&elements)[Extent]):
kadonotakashi 0:8fdf9a60065b 292 _data(elements) { }
kadonotakashi 0:8fdf9a60065b 293
kadonotakashi 0:8fdf9a60065b 294 /**
kadonotakashi 0:8fdf9a60065b 295 * Construct a Span object from another Span of the same size.
kadonotakashi 0:8fdf9a60065b 296 *
kadonotakashi 0:8fdf9a60065b 297 * @param other The Span object used to construct this.
kadonotakashi 0:8fdf9a60065b 298 *
kadonotakashi 0:8fdf9a60065b 299 * @note For Span with a positive extent, this function is not accessible.
kadonotakashi 0:8fdf9a60065b 300 *
kadonotakashi 0:8fdf9a60065b 301 * @note OtherElementType(*)[] must be convertible to ElementType(*)[].
kadonotakashi 0:8fdf9a60065b 302 */
kadonotakashi 0:8fdf9a60065b 303 template<typename OtherElementType>
kadonotakashi 0:8fdf9a60065b 304 Span(const Span<OtherElementType, Extent> &other):
kadonotakashi 0:8fdf9a60065b 305 _data(other.data())
kadonotakashi 0:8fdf9a60065b 306 {
kadonotakashi 0:8fdf9a60065b 307 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 308 (span_detail::is_convertible<OtherElementType (*)[1], ElementType (*)[1]>::value),
kadonotakashi 0:8fdf9a60065b 309 "OtherElementType(*)[] should be convertible to ElementType (*)[]"
kadonotakashi 0:8fdf9a60065b 310 );
kadonotakashi 0:8fdf9a60065b 311 }
kadonotakashi 0:8fdf9a60065b 312
kadonotakashi 0:8fdf9a60065b 313 /**
kadonotakashi 0:8fdf9a60065b 314 * Return the size of the sequence viewed.
kadonotakashi 0:8fdf9a60065b 315 *
kadonotakashi 0:8fdf9a60065b 316 * @return The size of the sequence viewed.
kadonotakashi 0:8fdf9a60065b 317 */
kadonotakashi 0:8fdf9a60065b 318 index_type size() const
kadonotakashi 0:8fdf9a60065b 319 {
kadonotakashi 0:8fdf9a60065b 320 return Extent;
kadonotakashi 0:8fdf9a60065b 321 }
kadonotakashi 0:8fdf9a60065b 322
kadonotakashi 0:8fdf9a60065b 323 /**
kadonotakashi 0:8fdf9a60065b 324 * Return if the sequence is empty or not.
kadonotakashi 0:8fdf9a60065b 325 *
kadonotakashi 0:8fdf9a60065b 326 * @return true if the sequence is empty and false otherwise.
kadonotakashi 0:8fdf9a60065b 327 */
kadonotakashi 0:8fdf9a60065b 328 bool empty() const
kadonotakashi 0:8fdf9a60065b 329 {
kadonotakashi 0:8fdf9a60065b 330 return size() == 0;
kadonotakashi 0:8fdf9a60065b 331 }
kadonotakashi 0:8fdf9a60065b 332
kadonotakashi 0:8fdf9a60065b 333 /**
kadonotakashi 0:8fdf9a60065b 334 * Returns a reference to the element at position @p index.
kadonotakashi 0:8fdf9a60065b 335 *
kadonotakashi 0:8fdf9a60065b 336 * @param index Index of the element to access.
kadonotakashi 0:8fdf9a60065b 337 *
kadonotakashi 0:8fdf9a60065b 338 * @return A reference to the element at the index specified in input.
kadonotakashi 0:8fdf9a60065b 339 *
kadonotakashi 0:8fdf9a60065b 340 * @pre 0 <= index < Extent.
kadonotakashi 0:8fdf9a60065b 341 */
kadonotakashi 0:8fdf9a60065b 342 reference operator[](index_type index) const
kadonotakashi 0:8fdf9a60065b 343 {
kadonotakashi 0:8fdf9a60065b 344 #ifdef MBED_DEBUG
kadonotakashi 0:8fdf9a60065b 345 MBED_ASSERT(0 <= index && index < Extent);
kadonotakashi 0:8fdf9a60065b 346 #endif
kadonotakashi 0:8fdf9a60065b 347 return _data[index];
kadonotakashi 0:8fdf9a60065b 348 }
kadonotakashi 0:8fdf9a60065b 349
kadonotakashi 0:8fdf9a60065b 350 /**
kadonotakashi 0:8fdf9a60065b 351 * Return a pointer to the first element of the sequence or NULL if the Span
kadonotakashi 0:8fdf9a60065b 352 * is empty().
kadonotakashi 0:8fdf9a60065b 353 *
kadonotakashi 0:8fdf9a60065b 354 * @return The pointer to the first element of the Span.
kadonotakashi 0:8fdf9a60065b 355 */
kadonotakashi 0:8fdf9a60065b 356 pointer data() const
kadonotakashi 0:8fdf9a60065b 357 {
kadonotakashi 0:8fdf9a60065b 358 return _data;
kadonotakashi 0:8fdf9a60065b 359 }
kadonotakashi 0:8fdf9a60065b 360
kadonotakashi 0:8fdf9a60065b 361 /**
kadonotakashi 0:8fdf9a60065b 362 * Create a new Span over the first @p Count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 363 *
kadonotakashi 0:8fdf9a60065b 364 * @tparam Count The number of element viewed by the new Span
kadonotakashi 0:8fdf9a60065b 365 *
kadonotakashi 0:8fdf9a60065b 366 * @return A new Span over the first @p Count elements.
kadonotakashi 0:8fdf9a60065b 367 *
kadonotakashi 0:8fdf9a60065b 368 * @pre Count >= 0 && Count <= size().
kadonotakashi 0:8fdf9a60065b 369 */
kadonotakashi 0:8fdf9a60065b 370 template<ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 371 Span<element_type, Count> first() const
kadonotakashi 0:8fdf9a60065b 372 {
kadonotakashi 0:8fdf9a60065b 373 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 374 (0 <= Count) && (Count <= Extent),
kadonotakashi 0:8fdf9a60065b 375 "Invalid subspan extent"
kadonotakashi 0:8fdf9a60065b 376 );
kadonotakashi 0:8fdf9a60065b 377 return Span<element_type, Count>(_data, Count);
kadonotakashi 0:8fdf9a60065b 378 }
kadonotakashi 0:8fdf9a60065b 379
kadonotakashi 0:8fdf9a60065b 380 /**
kadonotakashi 0:8fdf9a60065b 381 * Create a new Span over the last @p Count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 382 *
kadonotakashi 0:8fdf9a60065b 383 * @tparam Count The number of element viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 384 *
kadonotakashi 0:8fdf9a60065b 385 * @return A new Span over the last @p Count elements.
kadonotakashi 0:8fdf9a60065b 386 *
kadonotakashi 0:8fdf9a60065b 387 * @pre Count >= 0 && Count <= size().
kadonotakashi 0:8fdf9a60065b 388 */
kadonotakashi 0:8fdf9a60065b 389 template<ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 390 Span<element_type, Count> last() const
kadonotakashi 0:8fdf9a60065b 391 {
kadonotakashi 0:8fdf9a60065b 392 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 393 (0 <= Count) && (Count <= Extent),
kadonotakashi 0:8fdf9a60065b 394 "Invalid subspan extent"
kadonotakashi 0:8fdf9a60065b 395 );
kadonotakashi 0:8fdf9a60065b 396 return Span<element_type, Count>(_data + (Extent - Count), Count);
kadonotakashi 0:8fdf9a60065b 397 }
kadonotakashi 0:8fdf9a60065b 398
kadonotakashi 0:8fdf9a60065b 399 /**
kadonotakashi 0:8fdf9a60065b 400 * Create a subspan that is a view of other Count elements; the view starts at
kadonotakashi 0:8fdf9a60065b 401 * element Offset.
kadonotakashi 0:8fdf9a60065b 402 *
kadonotakashi 0:8fdf9a60065b 403 * @tparam Offset The offset of the first element viewed by the subspan.
kadonotakashi 0:8fdf9a60065b 404 *
kadonotakashi 0:8fdf9a60065b 405 * @tparam Count The number of elements present in the subspan. If Count
kadonotakashi 0:8fdf9a60065b 406 * is equal to SPAN_DYNAMIC_EXTENT, then a Span starting at offset and
kadonotakashi 0:8fdf9a60065b 407 * containing the rest of the elements is returned.
kadonotakashi 0:8fdf9a60065b 408 *
kadonotakashi 0:8fdf9a60065b 409 * @return A subspan of this starting at Offset and Count long.
kadonotakashi 0:8fdf9a60065b 410 */
kadonotakashi 0:8fdf9a60065b 411 template<std::ptrdiff_t Offset, std::ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 412 Span<element_type, Count == SPAN_DYNAMIC_EXTENT ? Extent - Offset : Count>
kadonotakashi 0:8fdf9a60065b 413 subspan() const
kadonotakashi 0:8fdf9a60065b 414 {
kadonotakashi 0:8fdf9a60065b 415 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 416 0 <= Offset && Offset <= Extent,
kadonotakashi 0:8fdf9a60065b 417 "Invalid subspan offset"
kadonotakashi 0:8fdf9a60065b 418 );
kadonotakashi 0:8fdf9a60065b 419 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 420 (Count == SPAN_DYNAMIC_EXTENT) ||
kadonotakashi 0:8fdf9a60065b 421 (0 <= Count && (Count + Offset) <= Extent),
kadonotakashi 0:8fdf9a60065b 422 "Invalid subspan count"
kadonotakashi 0:8fdf9a60065b 423 );
kadonotakashi 0:8fdf9a60065b 424 return Span<element_type, Count == SPAN_DYNAMIC_EXTENT ? Extent - Offset : Count>(
kadonotakashi 0:8fdf9a60065b 425 _data + Offset,
kadonotakashi 0:8fdf9a60065b 426 Count == SPAN_DYNAMIC_EXTENT ? Extent - Offset : Count
kadonotakashi 0:8fdf9a60065b 427 );
kadonotakashi 0:8fdf9a60065b 428 }
kadonotakashi 0:8fdf9a60065b 429
kadonotakashi 0:8fdf9a60065b 430 /**
kadonotakashi 0:8fdf9a60065b 431 * Create a new Span over the first @p count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 432 *
kadonotakashi 0:8fdf9a60065b 433 * @param count The number of element viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 434 *
kadonotakashi 0:8fdf9a60065b 435 * @return A new Span over the first @p count elements.
kadonotakashi 0:8fdf9a60065b 436 */
kadonotakashi 0:8fdf9a60065b 437 Span<element_type, SPAN_DYNAMIC_EXTENT> first(index_type count) const
kadonotakashi 0:8fdf9a60065b 438 {
kadonotakashi 0:8fdf9a60065b 439 MBED_ASSERT(0 <= count && count <= Extent);
kadonotakashi 0:8fdf9a60065b 440 return Span<element_type, SPAN_DYNAMIC_EXTENT>(_data, count);
kadonotakashi 0:8fdf9a60065b 441 }
kadonotakashi 0:8fdf9a60065b 442
kadonotakashi 0:8fdf9a60065b 443 /**
kadonotakashi 0:8fdf9a60065b 444 * Create a new Span over the last @p count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 445 *
kadonotakashi 0:8fdf9a60065b 446 * @param count The number of elements viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 447 *
kadonotakashi 0:8fdf9a60065b 448 * @return A new Span over the last @p count elements.
kadonotakashi 0:8fdf9a60065b 449 */
kadonotakashi 0:8fdf9a60065b 450 Span<element_type, SPAN_DYNAMIC_EXTENT> last(index_type count) const
kadonotakashi 0:8fdf9a60065b 451 {
kadonotakashi 0:8fdf9a60065b 452 MBED_ASSERT(0 <= count && count <= Extent);
kadonotakashi 0:8fdf9a60065b 453 return Span<element_type, SPAN_DYNAMIC_EXTENT>(
kadonotakashi 0:8fdf9a60065b 454 _data + (Extent - count),
kadonotakashi 0:8fdf9a60065b 455 count
kadonotakashi 0:8fdf9a60065b 456 );
kadonotakashi 0:8fdf9a60065b 457 }
kadonotakashi 0:8fdf9a60065b 458
kadonotakashi 0:8fdf9a60065b 459 /**
kadonotakashi 0:8fdf9a60065b 460 * Create a subspan that is a view of other count elements; the view starts at
kadonotakashi 0:8fdf9a60065b 461 * element offset.
kadonotakashi 0:8fdf9a60065b 462 *
kadonotakashi 0:8fdf9a60065b 463 * @param offset The offset of the first element viewed by the subspan.
kadonotakashi 0:8fdf9a60065b 464 *
kadonotakashi 0:8fdf9a60065b 465 * @param count The number of elements present in the subspan. If Count
kadonotakashi 0:8fdf9a60065b 466 * is equal to SPAN_DYNAMIC_EXTENT, then a span starting at offset and
kadonotakashi 0:8fdf9a60065b 467 * containing the rest of the elements is returned.
kadonotakashi 0:8fdf9a60065b 468 *
kadonotakashi 0:8fdf9a60065b 469 * @return
kadonotakashi 0:8fdf9a60065b 470 */
kadonotakashi 0:8fdf9a60065b 471 Span<element_type, SPAN_DYNAMIC_EXTENT> subspan(
kadonotakashi 0:8fdf9a60065b 472 index_type offset, index_type count = SPAN_DYNAMIC_EXTENT
kadonotakashi 0:8fdf9a60065b 473 ) const
kadonotakashi 0:8fdf9a60065b 474 {
kadonotakashi 0:8fdf9a60065b 475 MBED_ASSERT(0 <= offset && offset <= Extent);
kadonotakashi 0:8fdf9a60065b 476 MBED_ASSERT(
kadonotakashi 0:8fdf9a60065b 477 (count == SPAN_DYNAMIC_EXTENT) ||
kadonotakashi 0:8fdf9a60065b 478 (0 <= count && (count + offset) <= Extent)
kadonotakashi 0:8fdf9a60065b 479 );
kadonotakashi 0:8fdf9a60065b 480 return Span<element_type, SPAN_DYNAMIC_EXTENT>(
kadonotakashi 0:8fdf9a60065b 481 _data + offset,
kadonotakashi 0:8fdf9a60065b 482 count == SPAN_DYNAMIC_EXTENT ? Extent - offset : count
kadonotakashi 0:8fdf9a60065b 483 );
kadonotakashi 0:8fdf9a60065b 484 }
kadonotakashi 0:8fdf9a60065b 485
kadonotakashi 0:8fdf9a60065b 486 private:
kadonotakashi 0:8fdf9a60065b 487 pointer _data;
kadonotakashi 0:8fdf9a60065b 488 };
kadonotakashi 0:8fdf9a60065b 489
kadonotakashi 0:8fdf9a60065b 490 /**
kadonotakashi 0:8fdf9a60065b 491 * Span specialization that handle dynamic size.
kadonotakashi 0:8fdf9a60065b 492 */
kadonotakashi 0:8fdf9a60065b 493 template<typename ElementType>
kadonotakashi 0:8fdf9a60065b 494 struct Span<ElementType, SPAN_DYNAMIC_EXTENT> {
kadonotakashi 0:8fdf9a60065b 495 /**
kadonotakashi 0:8fdf9a60065b 496 * Type of the element contained.
kadonotakashi 0:8fdf9a60065b 497 */
kadonotakashi 0:8fdf9a60065b 498 typedef ElementType element_type;
kadonotakashi 0:8fdf9a60065b 499
kadonotakashi 0:8fdf9a60065b 500 /**
kadonotakashi 0:8fdf9a60065b 501 * Type of the index.
kadonotakashi 0:8fdf9a60065b 502 */
kadonotakashi 0:8fdf9a60065b 503 typedef ptrdiff_t index_type;
kadonotakashi 0:8fdf9a60065b 504
kadonotakashi 0:8fdf9a60065b 505 /**
kadonotakashi 0:8fdf9a60065b 506 * Pointer to an ElementType.
kadonotakashi 0:8fdf9a60065b 507 */
kadonotakashi 0:8fdf9a60065b 508 typedef element_type *pointer;
kadonotakashi 0:8fdf9a60065b 509
kadonotakashi 0:8fdf9a60065b 510 /**
kadonotakashi 0:8fdf9a60065b 511 * Reference to an ElementType.
kadonotakashi 0:8fdf9a60065b 512 */
kadonotakashi 0:8fdf9a60065b 513 typedef element_type &reference;
kadonotakashi 0:8fdf9a60065b 514
kadonotakashi 0:8fdf9a60065b 515 /**
kadonotakashi 0:8fdf9a60065b 516 * Size of the Extent; -1 if dynamic.
kadonotakashi 0:8fdf9a60065b 517 */
kadonotakashi 0:8fdf9a60065b 518 static const index_type extent = SPAN_DYNAMIC_EXTENT;
kadonotakashi 0:8fdf9a60065b 519
kadonotakashi 0:8fdf9a60065b 520 /**
kadonotakashi 0:8fdf9a60065b 521 * Construct an empty Span.
kadonotakashi 0:8fdf9a60065b 522 *
kadonotakashi 0:8fdf9a60065b 523 * @post a call to size() returns 0, and data() returns NULL.
kadonotakashi 0:8fdf9a60065b 524 *
kadonotakashi 0:8fdf9a60065b 525 * @note This function is not accessible if Extent != SPAN_DYNAMIC_EXTENT or
kadonotakashi 0:8fdf9a60065b 526 * Extent != 0 .
kadonotakashi 0:8fdf9a60065b 527 */
kadonotakashi 0:8fdf9a60065b 528 Span() :
kadonotakashi 0:8fdf9a60065b 529 _data(NULL), _size(0) { }
kadonotakashi 0:8fdf9a60065b 530
kadonotakashi 0:8fdf9a60065b 531 /**
kadonotakashi 0:8fdf9a60065b 532 * Construct a Span from a pointer to a buffer and its size.
kadonotakashi 0:8fdf9a60065b 533 *
kadonotakashi 0:8fdf9a60065b 534 * @param ptr Pointer to the beginning of the data viewed.
kadonotakashi 0:8fdf9a60065b 535 *
kadonotakashi 0:8fdf9a60065b 536 * @param count Number of elements viewed.
kadonotakashi 0:8fdf9a60065b 537 *
kadonotakashi 0:8fdf9a60065b 538 * @pre [ptr, ptr + count) must be be a valid range.
kadonotakashi 0:8fdf9a60065b 539 * @pre count must be equal to extent.
kadonotakashi 0:8fdf9a60065b 540 *
kadonotakashi 0:8fdf9a60065b 541 * @post a call to size() returns count, and data() returns @p ptr.
kadonotakashi 0:8fdf9a60065b 542 */
kadonotakashi 0:8fdf9a60065b 543 Span(pointer ptr, index_type count) :
kadonotakashi 0:8fdf9a60065b 544 _data(ptr), _size(count)
kadonotakashi 0:8fdf9a60065b 545 {
kadonotakashi 0:8fdf9a60065b 546 MBED_ASSERT(count >= 0);
kadonotakashi 0:8fdf9a60065b 547 MBED_ASSERT(ptr != NULL || count == 0);
kadonotakashi 0:8fdf9a60065b 548 }
kadonotakashi 0:8fdf9a60065b 549
kadonotakashi 0:8fdf9a60065b 550 /**
kadonotakashi 0:8fdf9a60065b 551 * Construct a Span from the range [first, last).
kadonotakashi 0:8fdf9a60065b 552 *
kadonotakashi 0:8fdf9a60065b 553 * @param first Pointer to the beginning of the data viewed.
kadonotakashi 0:8fdf9a60065b 554 * @param last End of the range (element after the last element).
kadonotakashi 0:8fdf9a60065b 555 *
kadonotakashi 0:8fdf9a60065b 556 * @pre [first, last) must be be a valid range.
kadonotakashi 0:8fdf9a60065b 557 * @pre first <= last.
kadonotakashi 0:8fdf9a60065b 558 *
kadonotakashi 0:8fdf9a60065b 559 * @post a call to size() returns the result of (last - first), and
kadonotakashi 0:8fdf9a60065b 560 * data() returns @p first.
kadonotakashi 0:8fdf9a60065b 561 */
kadonotakashi 0:8fdf9a60065b 562 Span(pointer first, pointer last) :
kadonotakashi 0:8fdf9a60065b 563 _data(first), _size(last - first)
kadonotakashi 0:8fdf9a60065b 564 {
kadonotakashi 0:8fdf9a60065b 565 MBED_ASSERT(first <= last);
kadonotakashi 0:8fdf9a60065b 566 MBED_ASSERT(first != NULL || (last - first) == 0);
kadonotakashi 0:8fdf9a60065b 567 }
kadonotakashi 0:8fdf9a60065b 568
kadonotakashi 0:8fdf9a60065b 569 /**
kadonotakashi 0:8fdf9a60065b 570 * Construct a Span from the reference to an array.
kadonotakashi 0:8fdf9a60065b 571 *
kadonotakashi 0:8fdf9a60065b 572 * @param elements Reference to the array viewed.
kadonotakashi 0:8fdf9a60065b 573 *
kadonotakashi 0:8fdf9a60065b 574 * @tparam Count Number of elements of T presents in the array.
kadonotakashi 0:8fdf9a60065b 575 *
kadonotakashi 0:8fdf9a60065b 576 * @post a call to size() returns Count, and data() returns a
kadonotakashi 0:8fdf9a60065b 577 * pointer to elements.
kadonotakashi 0:8fdf9a60065b 578 */
kadonotakashi 0:8fdf9a60065b 579 template<size_t Count>
kadonotakashi 0:8fdf9a60065b 580 Span(element_type (&elements)[Count]):
kadonotakashi 0:8fdf9a60065b 581 _data(elements), _size(Count) { }
kadonotakashi 0:8fdf9a60065b 582
kadonotakashi 0:8fdf9a60065b 583 /**
kadonotakashi 0:8fdf9a60065b 584 * Construct a Span object from another Span.
kadonotakashi 0:8fdf9a60065b 585 *
kadonotakashi 0:8fdf9a60065b 586 * @param other The Span object used to construct this.
kadonotakashi 0:8fdf9a60065b 587 *
kadonotakashi 0:8fdf9a60065b 588 * @note For Span with a positive extent, this function is not accessible.
kadonotakashi 0:8fdf9a60065b 589 *
kadonotakashi 0:8fdf9a60065b 590 * @note OtherElementType(*)[] must be convertible to ElementType(*)[].
kadonotakashi 0:8fdf9a60065b 591 */
kadonotakashi 0:8fdf9a60065b 592 template<typename OtherElementType, ptrdiff_t OtherExtent>
kadonotakashi 0:8fdf9a60065b 593 Span(const Span<OtherElementType, OtherExtent> &other):
kadonotakashi 0:8fdf9a60065b 594 _data(other.data()), _size(other.size())
kadonotakashi 0:8fdf9a60065b 595 {
kadonotakashi 0:8fdf9a60065b 596 MBED_STATIC_ASSERT(
kadonotakashi 0:8fdf9a60065b 597 (span_detail::is_convertible<OtherElementType (*)[1], ElementType (*)[1]>::value),
kadonotakashi 0:8fdf9a60065b 598 "OtherElementType(*)[] should be convertible to ElementType (*)[]"
kadonotakashi 0:8fdf9a60065b 599 );
kadonotakashi 0:8fdf9a60065b 600 }
kadonotakashi 0:8fdf9a60065b 601
kadonotakashi 0:8fdf9a60065b 602 /**
kadonotakashi 0:8fdf9a60065b 603 * Return the size of the array viewed.
kadonotakashi 0:8fdf9a60065b 604 *
kadonotakashi 0:8fdf9a60065b 605 * @return The number of elements present in the array viewed.
kadonotakashi 0:8fdf9a60065b 606 */
kadonotakashi 0:8fdf9a60065b 607 index_type size() const
kadonotakashi 0:8fdf9a60065b 608 {
kadonotakashi 0:8fdf9a60065b 609 return _size;
kadonotakashi 0:8fdf9a60065b 610 }
kadonotakashi 0:8fdf9a60065b 611
kadonotakashi 0:8fdf9a60065b 612 /**
kadonotakashi 0:8fdf9a60065b 613 * Return if the sequence viewed is empty or not.
kadonotakashi 0:8fdf9a60065b 614 *
kadonotakashi 0:8fdf9a60065b 615 * @return true if the sequence is empty and false otherwise.
kadonotakashi 0:8fdf9a60065b 616 */
kadonotakashi 0:8fdf9a60065b 617 bool empty() const
kadonotakashi 0:8fdf9a60065b 618 {
kadonotakashi 0:8fdf9a60065b 619 return size() == 0;
kadonotakashi 0:8fdf9a60065b 620 }
kadonotakashi 0:8fdf9a60065b 621
kadonotakashi 0:8fdf9a60065b 622 /**
kadonotakashi 0:8fdf9a60065b 623 * Access to an element of the sequence.
kadonotakashi 0:8fdf9a60065b 624 *
kadonotakashi 0:8fdf9a60065b 625 * @param index Element index to access.
kadonotakashi 0:8fdf9a60065b 626 *
kadonotakashi 0:8fdf9a60065b 627 * @return A reference to the element at the index specified in input.
kadonotakashi 0:8fdf9a60065b 628 *
kadonotakashi 0:8fdf9a60065b 629 * @pre index is less than size().
kadonotakashi 0:8fdf9a60065b 630 */
kadonotakashi 0:8fdf9a60065b 631 reference operator[](index_type index) const
kadonotakashi 0:8fdf9a60065b 632 {
kadonotakashi 0:8fdf9a60065b 633 #ifdef MBED_DEBUG
kadonotakashi 0:8fdf9a60065b 634 MBED_ASSERT(0 <= index && index < _size);
kadonotakashi 0:8fdf9a60065b 635 #endif
kadonotakashi 0:8fdf9a60065b 636 return _data[index];
kadonotakashi 0:8fdf9a60065b 637 }
kadonotakashi 0:8fdf9a60065b 638
kadonotakashi 0:8fdf9a60065b 639 /**
kadonotakashi 0:8fdf9a60065b 640 * Get the raw pointer to the sequence viewed.
kadonotakashi 0:8fdf9a60065b 641 *
kadonotakashi 0:8fdf9a60065b 642 * @return The raw pointer to the first element viewed.
kadonotakashi 0:8fdf9a60065b 643 */
kadonotakashi 0:8fdf9a60065b 644 pointer data() const
kadonotakashi 0:8fdf9a60065b 645 {
kadonotakashi 0:8fdf9a60065b 646 return _data;
kadonotakashi 0:8fdf9a60065b 647 }
kadonotakashi 0:8fdf9a60065b 648
kadonotakashi 0:8fdf9a60065b 649 /**
kadonotakashi 0:8fdf9a60065b 650 * Create a new Span over the first @p Count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 651 *
kadonotakashi 0:8fdf9a60065b 652 * @tparam Count The number of elements viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 653 *
kadonotakashi 0:8fdf9a60065b 654 * @return A new Span over the first @p Count elements.
kadonotakashi 0:8fdf9a60065b 655 *
kadonotakashi 0:8fdf9a60065b 656 * @pre Count >= 0 && Count <= size().
kadonotakashi 0:8fdf9a60065b 657 */
kadonotakashi 0:8fdf9a60065b 658 template<ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 659 Span<element_type, Count> first() const
kadonotakashi 0:8fdf9a60065b 660 {
kadonotakashi 0:8fdf9a60065b 661 MBED_ASSERT((Count >= 0) && (Count <= _size));
kadonotakashi 0:8fdf9a60065b 662 return Span<element_type, Count>(_data, Count);
kadonotakashi 0:8fdf9a60065b 663 }
kadonotakashi 0:8fdf9a60065b 664
kadonotakashi 0:8fdf9a60065b 665 /**
kadonotakashi 0:8fdf9a60065b 666 * Create a new Span over the last @p Count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 667 *
kadonotakashi 0:8fdf9a60065b 668 * @tparam Count The number of elements viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 669 *
kadonotakashi 0:8fdf9a60065b 670 * @return A new Span over the last @p Count elements.
kadonotakashi 0:8fdf9a60065b 671 *
kadonotakashi 0:8fdf9a60065b 672 * @pre Count >= 0 && Count <= size().
kadonotakashi 0:8fdf9a60065b 673 */
kadonotakashi 0:8fdf9a60065b 674 template<ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 675 Span<element_type, Count> last() const
kadonotakashi 0:8fdf9a60065b 676 {
kadonotakashi 0:8fdf9a60065b 677 MBED_ASSERT((0 <= Count) && (Count <= _size));
kadonotakashi 0:8fdf9a60065b 678 return Span<element_type, Count>(_data + (_size - Count), Count);
kadonotakashi 0:8fdf9a60065b 679 }
kadonotakashi 0:8fdf9a60065b 680
kadonotakashi 0:8fdf9a60065b 681 /**
kadonotakashi 0:8fdf9a60065b 682 * Create a subspan that is a view other Count elements; the view starts at
kadonotakashi 0:8fdf9a60065b 683 * element Offset.
kadonotakashi 0:8fdf9a60065b 684 *
kadonotakashi 0:8fdf9a60065b 685 * @tparam Offset The offset of the first element viewed by the subspan.
kadonotakashi 0:8fdf9a60065b 686 *
kadonotakashi 0:8fdf9a60065b 687 * @tparam Count The number of elements present in the subspan. If Count
kadonotakashi 0:8fdf9a60065b 688 * is equal to SPAN_DYNAMIC_EXTENT, then a Span starting at offset and
kadonotakashi 0:8fdf9a60065b 689 * containing the rest of the elements is returned.
kadonotakashi 0:8fdf9a60065b 690 *
kadonotakashi 0:8fdf9a60065b 691 * @return A subspan of this starting at Offset and Count long.
kadonotakashi 0:8fdf9a60065b 692 */
kadonotakashi 0:8fdf9a60065b 693 template<std::ptrdiff_t Offset, std::ptrdiff_t Count>
kadonotakashi 0:8fdf9a60065b 694 Span<element_type, Count == SPAN_DYNAMIC_EXTENT ? SPAN_DYNAMIC_EXTENT : Count>
kadonotakashi 0:8fdf9a60065b 695 subspan() const
kadonotakashi 0:8fdf9a60065b 696 {
kadonotakashi 0:8fdf9a60065b 697 MBED_ASSERT(0 <= Offset && Offset <= _size);
kadonotakashi 0:8fdf9a60065b 698 MBED_ASSERT(
kadonotakashi 0:8fdf9a60065b 699 (Count == SPAN_DYNAMIC_EXTENT) ||
kadonotakashi 0:8fdf9a60065b 700 (0 <= Count && (Count + Offset) <= _size)
kadonotakashi 0:8fdf9a60065b 701 );
kadonotakashi 0:8fdf9a60065b 702 return Span<element_type, Count == SPAN_DYNAMIC_EXTENT ? SPAN_DYNAMIC_EXTENT : Count>(
kadonotakashi 0:8fdf9a60065b 703 _data + Offset,
kadonotakashi 0:8fdf9a60065b 704 Count == SPAN_DYNAMIC_EXTENT ? _size - Offset : Count
kadonotakashi 0:8fdf9a60065b 705 );
kadonotakashi 0:8fdf9a60065b 706 }
kadonotakashi 0:8fdf9a60065b 707
kadonotakashi 0:8fdf9a60065b 708 /**
kadonotakashi 0:8fdf9a60065b 709 * Create a new Span over the first @p count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 710 *
kadonotakashi 0:8fdf9a60065b 711 * @param count The number of elements viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 712 *
kadonotakashi 0:8fdf9a60065b 713 * @return A new Span over the first @p count elements.
kadonotakashi 0:8fdf9a60065b 714 */
kadonotakashi 0:8fdf9a60065b 715 Span<element_type, SPAN_DYNAMIC_EXTENT> first(index_type count) const
kadonotakashi 0:8fdf9a60065b 716 {
kadonotakashi 0:8fdf9a60065b 717 MBED_ASSERT(0 <= count && count <= _size);
kadonotakashi 0:8fdf9a60065b 718 return Span<element_type, SPAN_DYNAMIC_EXTENT>(_data, count);
kadonotakashi 0:8fdf9a60065b 719 }
kadonotakashi 0:8fdf9a60065b 720
kadonotakashi 0:8fdf9a60065b 721 /**
kadonotakashi 0:8fdf9a60065b 722 * Create a new Span over the last @p count elements of the existing view.
kadonotakashi 0:8fdf9a60065b 723 *
kadonotakashi 0:8fdf9a60065b 724 * @param count The number of elements viewed by the new Span.
kadonotakashi 0:8fdf9a60065b 725 *
kadonotakashi 0:8fdf9a60065b 726 * @return A new Span over the last @p count elements.
kadonotakashi 0:8fdf9a60065b 727 */
kadonotakashi 0:8fdf9a60065b 728 Span<element_type, SPAN_DYNAMIC_EXTENT> last(index_type count) const
kadonotakashi 0:8fdf9a60065b 729 {
kadonotakashi 0:8fdf9a60065b 730 MBED_ASSERT(0 <= count && count <= _size);
kadonotakashi 0:8fdf9a60065b 731 return Span<element_type, SPAN_DYNAMIC_EXTENT>(
kadonotakashi 0:8fdf9a60065b 732 _data + (_size - count),
kadonotakashi 0:8fdf9a60065b 733 count
kadonotakashi 0:8fdf9a60065b 734 );
kadonotakashi 0:8fdf9a60065b 735 }
kadonotakashi 0:8fdf9a60065b 736
kadonotakashi 0:8fdf9a60065b 737 /**
kadonotakashi 0:8fdf9a60065b 738 * Create a subspan that is a view of other count elements; the view starts at
kadonotakashi 0:8fdf9a60065b 739 * element offset.
kadonotakashi 0:8fdf9a60065b 740 *
kadonotakashi 0:8fdf9a60065b 741 * @param offset The offset of the first element viewed by the subspan.
kadonotakashi 0:8fdf9a60065b 742 *
kadonotakashi 0:8fdf9a60065b 743 * @param count The number of elements present in the subspan. If Count
kadonotakashi 0:8fdf9a60065b 744 * is equal to SPAN_DYNAMIC_EXTENT, then a Span starting at offset and
kadonotakashi 0:8fdf9a60065b 745 * containing the rest of the elements is returned.
kadonotakashi 0:8fdf9a60065b 746 *
kadonotakashi 0:8fdf9a60065b 747 * @return A subspan of this starting at offset and count long.
kadonotakashi 0:8fdf9a60065b 748 */
kadonotakashi 0:8fdf9a60065b 749 Span<element_type, SPAN_DYNAMIC_EXTENT> subspan(
kadonotakashi 0:8fdf9a60065b 750 index_type offset, index_type count = SPAN_DYNAMIC_EXTENT
kadonotakashi 0:8fdf9a60065b 751 ) const
kadonotakashi 0:8fdf9a60065b 752 {
kadonotakashi 0:8fdf9a60065b 753 MBED_ASSERT(0 <= offset && offset <= _size);
kadonotakashi 0:8fdf9a60065b 754 MBED_ASSERT(
kadonotakashi 0:8fdf9a60065b 755 (count == SPAN_DYNAMIC_EXTENT) ||
kadonotakashi 0:8fdf9a60065b 756 (0 <= count && (count + offset) <= _size)
kadonotakashi 0:8fdf9a60065b 757 );
kadonotakashi 0:8fdf9a60065b 758 return Span<element_type, SPAN_DYNAMIC_EXTENT>(
kadonotakashi 0:8fdf9a60065b 759 _data + offset,
kadonotakashi 0:8fdf9a60065b 760 count == SPAN_DYNAMIC_EXTENT ? _size - offset : count
kadonotakashi 0:8fdf9a60065b 761 );
kadonotakashi 0:8fdf9a60065b 762 }
kadonotakashi 0:8fdf9a60065b 763
kadonotakashi 0:8fdf9a60065b 764 private:
kadonotakashi 0:8fdf9a60065b 765 pointer _data;
kadonotakashi 0:8fdf9a60065b 766 index_type _size;
kadonotakashi 0:8fdf9a60065b 767 };
kadonotakashi 0:8fdf9a60065b 768
kadonotakashi 0:8fdf9a60065b 769 /**
kadonotakashi 0:8fdf9a60065b 770 * Equality operator between two Span objects.
kadonotakashi 0:8fdf9a60065b 771 *
kadonotakashi 0:8fdf9a60065b 772 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 773 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 774 *
kadonotakashi 0:8fdf9a60065b 775 * @return True if Spans in input have the same size and the same content and
kadonotakashi 0:8fdf9a60065b 776 * false otherwise.
kadonotakashi 0:8fdf9a60065b 777 */
kadonotakashi 0:8fdf9a60065b 778 template<typename T, typename U, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 779 bool operator==(const Span<T, LhsExtent> &lhs, const Span<U, RhsExtent> &rhs)
kadonotakashi 0:8fdf9a60065b 780 {
kadonotakashi 0:8fdf9a60065b 781 if (lhs.size() != rhs.size()) {
kadonotakashi 0:8fdf9a60065b 782 return false;
kadonotakashi 0:8fdf9a60065b 783 }
kadonotakashi 0:8fdf9a60065b 784
kadonotakashi 0:8fdf9a60065b 785 if (lhs.data() == rhs.data()) {
kadonotakashi 0:8fdf9a60065b 786 return true;
kadonotakashi 0:8fdf9a60065b 787 }
kadonotakashi 0:8fdf9a60065b 788
kadonotakashi 0:8fdf9a60065b 789 return std::equal(lhs.data(), lhs.data() + lhs.size(), rhs.data());
kadonotakashi 0:8fdf9a60065b 790 }
kadonotakashi 0:8fdf9a60065b 791
kadonotakashi 0:8fdf9a60065b 792 /**
kadonotakashi 0:8fdf9a60065b 793 * Equality operation between a Span and a reference to a C++ array.
kadonotakashi 0:8fdf9a60065b 794 *
kadonotakashi 0:8fdf9a60065b 795 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 796 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 797 *
kadonotakashi 0:8fdf9a60065b 798 * @return True if elements in input have the same size and the same content and
kadonotakashi 0:8fdf9a60065b 799 * false otherwise.
kadonotakashi 0:8fdf9a60065b 800 */
kadonotakashi 0:8fdf9a60065b 801 template<typename T, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 802 bool operator==(const Span<T, LhsExtent> &lhs, T (&rhs)[RhsExtent])
kadonotakashi 0:8fdf9a60065b 803 {
kadonotakashi 0:8fdf9a60065b 804 return lhs == Span<T>(rhs);
kadonotakashi 0:8fdf9a60065b 805 }
kadonotakashi 0:8fdf9a60065b 806
kadonotakashi 0:8fdf9a60065b 807 /**
kadonotakashi 0:8fdf9a60065b 808 * Equality operation between a Span and a reference to a C++ array.
kadonotakashi 0:8fdf9a60065b 809 *
kadonotakashi 0:8fdf9a60065b 810 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 811 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 812 *
kadonotakashi 0:8fdf9a60065b 813 * @return True if elements in input have the same size and the same content
kadonotakashi 0:8fdf9a60065b 814 * and false otherwise.
kadonotakashi 0:8fdf9a60065b 815 */
kadonotakashi 0:8fdf9a60065b 816 template<typename T, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 817 bool operator==(T (&lhs)[LhsExtent], const Span<T, RhsExtent> &rhs)
kadonotakashi 0:8fdf9a60065b 818 {
kadonotakashi 0:8fdf9a60065b 819 return Span<T>(lhs) == rhs;
kadonotakashi 0:8fdf9a60065b 820 }
kadonotakashi 0:8fdf9a60065b 821
kadonotakashi 0:8fdf9a60065b 822 /**
kadonotakashi 0:8fdf9a60065b 823 * Not equal operator
kadonotakashi 0:8fdf9a60065b 824 *
kadonotakashi 0:8fdf9a60065b 825 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 826 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 827 *
kadonotakashi 0:8fdf9a60065b 828 * @return True if arrays in input do not have the same size or the same content
kadonotakashi 0:8fdf9a60065b 829 * and false otherwise.
kadonotakashi 0:8fdf9a60065b 830 */
kadonotakashi 0:8fdf9a60065b 831 template<typename T, typename U, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 832 bool operator!=(const Span<T, LhsExtent> &lhs, const Span<U, RhsExtent> &rhs)
kadonotakashi 0:8fdf9a60065b 833 {
kadonotakashi 0:8fdf9a60065b 834 return !(lhs == rhs);
kadonotakashi 0:8fdf9a60065b 835 }
kadonotakashi 0:8fdf9a60065b 836
kadonotakashi 0:8fdf9a60065b 837 /**
kadonotakashi 0:8fdf9a60065b 838 * Not Equal operation between a Span and a reference to a C++ array.
kadonotakashi 0:8fdf9a60065b 839 *
kadonotakashi 0:8fdf9a60065b 840 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 841 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 842 *
kadonotakashi 0:8fdf9a60065b 843 * @return True if elements in input have the same size and the same content
kadonotakashi 0:8fdf9a60065b 844 * and false otherwise.
kadonotakashi 0:8fdf9a60065b 845 */
kadonotakashi 0:8fdf9a60065b 846 template<typename T, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 847 bool operator!=(const Span<T, LhsExtent> &lhs, T (&rhs)[RhsExtent])
kadonotakashi 0:8fdf9a60065b 848 {
kadonotakashi 0:8fdf9a60065b 849 return !(lhs == Span<T, RhsExtent>(rhs));
kadonotakashi 0:8fdf9a60065b 850 }
kadonotakashi 0:8fdf9a60065b 851
kadonotakashi 0:8fdf9a60065b 852 /**
kadonotakashi 0:8fdf9a60065b 853 * Not Equal operation between a Span and a reference to a C++ array.
kadonotakashi 0:8fdf9a60065b 854 *
kadonotakashi 0:8fdf9a60065b 855 * @param lhs Left side of the binary operation.
kadonotakashi 0:8fdf9a60065b 856 * @param rhs Right side of the binary operation.
kadonotakashi 0:8fdf9a60065b 857 *
kadonotakashi 0:8fdf9a60065b 858 * @return True if elements in input have the same size and the same content
kadonotakashi 0:8fdf9a60065b 859 * and false otherwise.
kadonotakashi 0:8fdf9a60065b 860 */
kadonotakashi 0:8fdf9a60065b 861 template<typename T, ptrdiff_t LhsExtent, ptrdiff_t RhsExtent>
kadonotakashi 0:8fdf9a60065b 862 bool operator!=(T (&lhs)[LhsExtent], const Span<T, RhsExtent> &rhs)
kadonotakashi 0:8fdf9a60065b 863 {
kadonotakashi 0:8fdf9a60065b 864 return !(Span<T, LhsExtent>(lhs) == rhs);
kadonotakashi 0:8fdf9a60065b 865 }
kadonotakashi 0:8fdf9a60065b 866
kadonotakashi 0:8fdf9a60065b 867 /**
kadonotakashi 0:8fdf9a60065b 868 * Generate a Span from a reference to a C/C++ array.
kadonotakashi 0:8fdf9a60065b 869 *
kadonotakashi 0:8fdf9a60065b 870 * @tparam T Type of elements held in elements.
kadonotakashi 0:8fdf9a60065b 871 * @tparam Extent Number of items held in elements.
kadonotakashi 0:8fdf9a60065b 872 *
kadonotakashi 0:8fdf9a60065b 873 * @param elements The reference to the array viewed.
kadonotakashi 0:8fdf9a60065b 874 *
kadonotakashi 0:8fdf9a60065b 875 * @return The Span to elements.
kadonotakashi 0:8fdf9a60065b 876 *
kadonotakashi 0:8fdf9a60065b 877 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 878 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 879 */
kadonotakashi 0:8fdf9a60065b 880 template<typename T, size_t Size>
kadonotakashi 0:8fdf9a60065b 881 Span<T, Size> make_Span(T (&elements)[Size])
kadonotakashi 0:8fdf9a60065b 882 {
kadonotakashi 0:8fdf9a60065b 883 return Span<T, Size>(elements);
kadonotakashi 0:8fdf9a60065b 884 }
kadonotakashi 0:8fdf9a60065b 885
kadonotakashi 0:8fdf9a60065b 886 /**
kadonotakashi 0:8fdf9a60065b 887 * Generate a Span from a pointer to a C/C++ array.
kadonotakashi 0:8fdf9a60065b 888 *
kadonotakashi 0:8fdf9a60065b 889 * @tparam Extent Number of items held in elements.
kadonotakashi 0:8fdf9a60065b 890 * @tparam T Type of elements held in elements.
kadonotakashi 0:8fdf9a60065b 891 *
kadonotakashi 0:8fdf9a60065b 892 * @param elements The reference to the array viewed.
kadonotakashi 0:8fdf9a60065b 893 *
kadonotakashi 0:8fdf9a60065b 894 * @return The Span to elements.
kadonotakashi 0:8fdf9a60065b 895 *
kadonotakashi 0:8fdf9a60065b 896 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 897 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 898 */
kadonotakashi 0:8fdf9a60065b 899 template<ptrdiff_t Extent, typename T>
kadonotakashi 0:8fdf9a60065b 900 Span<T, Extent> make_Span(T *elements)
kadonotakashi 0:8fdf9a60065b 901 {
kadonotakashi 0:8fdf9a60065b 902 return Span<T, Extent>(elements, Extent);
kadonotakashi 0:8fdf9a60065b 903 }
kadonotakashi 0:8fdf9a60065b 904
kadonotakashi 0:8fdf9a60065b 905 /**
kadonotakashi 0:8fdf9a60065b 906 * Generate a Span from a C/C++ pointer and the size of the array.
kadonotakashi 0:8fdf9a60065b 907 *
kadonotakashi 0:8fdf9a60065b 908 * @tparam T Type of elements held in array_ptr.
kadonotakashi 0:8fdf9a60065b 909 *
kadonotakashi 0:8fdf9a60065b 910 * @param array_ptr The pointer to the array viewed.
kadonotakashi 0:8fdf9a60065b 911 * @param array_size The number of T elements in the array.
kadonotakashi 0:8fdf9a60065b 912 *
kadonotakashi 0:8fdf9a60065b 913 * @return The Span to array_ptr with a size of array_size.
kadonotakashi 0:8fdf9a60065b 914 *
kadonotakashi 0:8fdf9a60065b 915 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 916 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 917 */
kadonotakashi 0:8fdf9a60065b 918 template<typename T>
kadonotakashi 0:8fdf9a60065b 919 Span<T> make_Span(T *array_ptr, ptrdiff_t array_size)
kadonotakashi 0:8fdf9a60065b 920 {
kadonotakashi 0:8fdf9a60065b 921 return Span<T>(array_ptr, array_size);
kadonotakashi 0:8fdf9a60065b 922 }
kadonotakashi 0:8fdf9a60065b 923
kadonotakashi 0:8fdf9a60065b 924 /**
kadonotakashi 0:8fdf9a60065b 925 * Generate a Span to a const content from a reference to a C/C++ array.
kadonotakashi 0:8fdf9a60065b 926 *
kadonotakashi 0:8fdf9a60065b 927 * @tparam T Type of elements held in elements.
kadonotakashi 0:8fdf9a60065b 928 * @tparam Extent Number of items held in elements.
kadonotakashi 0:8fdf9a60065b 929 *
kadonotakashi 0:8fdf9a60065b 930 * @param elements The array viewed.
kadonotakashi 0:8fdf9a60065b 931 * @return The Span to elements.
kadonotakashi 0:8fdf9a60065b 932 *
kadonotakashi 0:8fdf9a60065b 933 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 934 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 935 */
kadonotakashi 0:8fdf9a60065b 936 template<typename T, size_t Extent>
kadonotakashi 0:8fdf9a60065b 937 Span<const T, Extent> make_const_Span(const T (&elements)[Extent])
kadonotakashi 0:8fdf9a60065b 938 {
kadonotakashi 0:8fdf9a60065b 939 return Span<const T, Extent>(elements);
kadonotakashi 0:8fdf9a60065b 940 }
kadonotakashi 0:8fdf9a60065b 941
kadonotakashi 0:8fdf9a60065b 942 /**
kadonotakashi 0:8fdf9a60065b 943 * Generate a Span to a const content from a pointer to a C/C++ array.
kadonotakashi 0:8fdf9a60065b 944 *
kadonotakashi 0:8fdf9a60065b 945 * @tparam Extent Number of items held in elements.
kadonotakashi 0:8fdf9a60065b 946 * @tparam T Type of elements held in elements.
kadonotakashi 0:8fdf9a60065b 947 *
kadonotakashi 0:8fdf9a60065b 948 * @param elements The reference to the array viewed.
kadonotakashi 0:8fdf9a60065b 949 *
kadonotakashi 0:8fdf9a60065b 950 * @return The Span to elements.
kadonotakashi 0:8fdf9a60065b 951 *
kadonotakashi 0:8fdf9a60065b 952 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 953 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 954 */
kadonotakashi 0:8fdf9a60065b 955 template<size_t Extent, typename T>
kadonotakashi 0:8fdf9a60065b 956 Span<const T, Extent> make_const_Span(const T *elements)
kadonotakashi 0:8fdf9a60065b 957 {
kadonotakashi 0:8fdf9a60065b 958 return Span<const T, Extent>(elements, Extent);
kadonotakashi 0:8fdf9a60065b 959 }
kadonotakashi 0:8fdf9a60065b 960
kadonotakashi 0:8fdf9a60065b 961 /**
kadonotakashi 0:8fdf9a60065b 962 * Generate a Span to a const content from a C/C++ pointer and the size of the
kadonotakashi 0:8fdf9a60065b 963 * array.
kadonotakashi 0:8fdf9a60065b 964 *
kadonotakashi 0:8fdf9a60065b 965 * @tparam T Type of elements held in array_ptr.
kadonotakashi 0:8fdf9a60065b 966 *
kadonotakashi 0:8fdf9a60065b 967 * @param array_ptr The pointer to the array to viewed.
kadonotakashi 0:8fdf9a60065b 968 * @param array_size The number of T elements in the array.
kadonotakashi 0:8fdf9a60065b 969 *
kadonotakashi 0:8fdf9a60065b 970 * @return The Span to array_ptr with a size of array_size.
kadonotakashi 0:8fdf9a60065b 971 *
kadonotakashi 0:8fdf9a60065b 972 * @note This helper avoids the typing of template parameter when Span is
kadonotakashi 0:8fdf9a60065b 973 * created 'inline'.
kadonotakashi 0:8fdf9a60065b 974 */
kadonotakashi 0:8fdf9a60065b 975 template<typename T>
kadonotakashi 0:8fdf9a60065b 976 Span<const T> make_const_Span(T *array_ptr, size_t array_size)
kadonotakashi 0:8fdf9a60065b 977 {
kadonotakashi 0:8fdf9a60065b 978 return Span<const T>(array_ptr, array_size);
kadonotakashi 0:8fdf9a60065b 979 }
kadonotakashi 0:8fdf9a60065b 980
kadonotakashi 0:8fdf9a60065b 981 } // namespace mbed
kadonotakashi 0:8fdf9a60065b 982
kadonotakashi 0:8fdf9a60065b 983 #endif /* MBED_PLATFORM_SPAN_H_ */