span.h 3.02 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_CRDTP_SPAN_H_
#define V8_CRDTP_SPAN_H_

#include <cstdint>
#include <cstring>
#include <string>
11 12

#include "export.h"
13 14 15 16 17 18 19 20 21 22 23 24

namespace v8_crdtp {
// =============================================================================
// span - sequence of bytes
// =============================================================================

// This template is similar to std::span, which will be included in C++20.
template <typename T>
class span {
 public:
  using index_type = size_t;

25 26
  constexpr span() : data_(nullptr), size_(0) {}
  constexpr span(const T* data, index_type size) : data_(data), size_(size) {}
27

28
  constexpr const T* data() const { return data_; }
29

30 31
  constexpr const T* begin() const { return data_; }
  constexpr const T* end() const { return data_ + size_; }
32

33
  constexpr const T& operator[](index_type idx) const { return data_[idx]; }
34

35
  constexpr span<T> subspan(index_type offset, index_type count) const {
36 37 38
    return span(data_ + offset, count);
  }

39
  constexpr span<T> subspan(index_type offset) const {
40 41 42
    return span(data_ + offset, size_ - offset);
  }

43
  constexpr bool empty() const { return size_ == 0; }
44

45 46
  constexpr index_type size() const { return size_; }
  constexpr index_type size_bytes() const { return size_ * sizeof(T); }
47 48 49 50 51 52

 private:
  const T* data_;
  index_type size_;
};

53 54 55 56 57
template <size_t N>
constexpr span<char> MakeSpan(const char (&str)[N]) {
  return span<char>(str, N - 1);
}

58
template <size_t N>
59
constexpr span<uint8_t> SpanFrom(const char (&str)[N]) {
60 61 62
  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
}

63
constexpr inline span<uint8_t> SpanFrom(const char* str) {
64 65 66 67 68 69 70 71
  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
             : span<uint8_t>();
}

inline span<uint8_t> SpanFrom(const std::string& v) {
  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
}

72 73 74 75 76 77 78 79 80 81
// This SpanFrom routine works for std::vector<uint8_t> and
// std::vector<uint16_t>, but also for base::span<const uint8_t> in Chromium.
template <typename C,
          typename = std::enable_if_t<
              std::is_unsigned<typename C::value_type>{} &&
              std::is_member_function_pointer<decltype(&C::size)>{}>>
inline span<typename C::value_type> SpanFrom(const C& v) {
  return span<typename C::value_type>(v.data(), v.size());
}

82
// Less than / equality comparison functions for sorting / searching for byte
83
// spans.
84 85 86
bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept;
bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept;

87 88 89 90 91
// Less than / equality comparison functions for sorting / searching for byte
// spans.
bool SpanLessThan(span<char> x, span<char> y) noexcept;
bool SpanEquals(span<char> x, span<char> y) noexcept;

92 93 94 95 96
struct SpanLt {
  bool operator()(span<uint8_t> l, span<uint8_t> r) const {
    return SpanLessThan(l, r);
  }
};
97 98 99
}  // namespace v8_crdtp

#endif  // V8_CRDTP_SPAN_H_