chromium/v8/src/base/vector.h

// Copyright 2014 the V8 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.

#ifndef V8_BASE_VECTOR_H_
#define V8_BASE_VECTOR_H_

#include <algorithm>
#include <cstring>
#include <iterator>
#include <limits>
#include <memory>
#include <type_traits>

#include "src/base/functional.h"
#include "src/base/logging.h"
#include "src/base/macros.h"

namespace v8 {
namespace base {

template <typename T>
class Vector { … };

template <typename T>
V8_INLINE size_t hash_value(base::Vector<T> v) { … }

template <typename T>
class V8_NODISCARD ScopedVector : public Vector<T> { … };

template <typename T>
class OwnedVector { … };

// The vectors returned by {StaticCharVector}, {CStrVector}, or {OneByteVector}
// do not contain a null-termination byte. If you want the null byte, use
// {ArrayVector}.

// Known length, constexpr.
template <size_t N>
constexpr Vector<const char> StaticCharVector(const char (&array)[N]) { … }

// Unknown length, not constexpr.
inline Vector<const char> CStrVector(const char* data) { … }

// OneByteVector is never constexpr because the data pointer is
// {reinterpret_cast}ed.
inline Vector<const uint8_t> OneByteVector(const char* data, size_t length) { … }

inline Vector<const uint8_t> OneByteVector(const char* data) { … }

template <size_t N>
Vector<const uint8_t> StaticOneByteVector(const char (&array)[N]) { … }

// For string literals, ArrayVector("foo") returns a vector ['f', 'o', 'o', \0]
// with length 4 and null-termination.
// If you want ['f', 'o', 'o'], use CStrVector("foo").
template <typename T, size_t N>
inline constexpr Vector<T> ArrayVector(T (&arr)[N]) { … }

// Construct a Vector from a start pointer and a size.
template <typename T>
inline constexpr Vector<T> VectorOf(T* start, size_t size) { … }

// Construct a Vector from anything compatible with std::data and std::size (ie,
// an array, or a container providing a {data()} and {size()} accessor).
template <typename Container>
inline constexpr auto VectorOf(Container&& c)
    -> decltype(VectorOf(std::data(c), std::size(c))) { … }

// Construct a Vector from an initializer list. The vector can obviously only be
// used as long as the initializer list is live. Valid uses include direct use
// in parameter lists: F(VectorOf({1, 2, 3}));
template <typename T>
inline constexpr Vector<const T> VectorOf(std::initializer_list<T> list) { … }

template <typename T, size_t kSize>
class EmbeddedVector : public Vector<T> { … };

}  // namespace base
}  // namespace v8

#endif  // V8_BASE_VECTOR_H_