forked from OSchip/llvm-project
96 lines
2.8 KiB
C++
96 lines
2.8 KiB
C++
//===-- Self contained ArrayRef type ----------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIBC_UTILS_CPP_ARRAYREF_H
|
|
#define LLVM_LIBC_UTILS_CPP_ARRAYREF_H
|
|
|
|
#include "Array.h"
|
|
|
|
#include <stddef.h> // For size_t.
|
|
|
|
namespace __llvm_libc {
|
|
namespace cpp {
|
|
|
|
// The implementations of ArrayRef and MutualArrayRef in this file are based
|
|
// on the implementations of the types with the same names in
|
|
// llvm/ADT/ArrayRef.h. The implementations in this file are of a limited
|
|
// functionality, but can be extended in an as needed basis.
|
|
|
|
template <typename T> class ArrayRef {
|
|
public:
|
|
using iterator = const T *;
|
|
|
|
private:
|
|
const T *Data = nullptr;
|
|
size_t Length = 0;
|
|
|
|
public:
|
|
ArrayRef() = default;
|
|
|
|
// From Array.
|
|
template <size_t N>
|
|
ArrayRef(const Array<T, N> &Arr) : Data(Arr.Data), Length(N) {}
|
|
|
|
// Construct an ArrayRef from a single element.
|
|
explicit ArrayRef(const T &OneElt) : Data(&OneElt), Length(1) {}
|
|
|
|
// Construct an ArrayRef from a pointer and length.
|
|
ArrayRef(const T *data, size_t length) : Data(data), Length(length) {}
|
|
|
|
// Construct an ArrayRef from a range.
|
|
ArrayRef(const T *begin, const T *end) : Data(begin), Length(end - begin) {}
|
|
|
|
// Construct an ArrayRef from a C array.
|
|
template <size_t N>
|
|
constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
|
|
|
|
iterator begin() const { return Data; }
|
|
iterator end() const { return Data + Length; }
|
|
|
|
bool empty() const { return Length == 0; }
|
|
|
|
const T *data() const { return Data; }
|
|
|
|
size_t size() const { return Length; }
|
|
|
|
const T &operator[](size_t Index) const { return Data[Index]; }
|
|
};
|
|
|
|
template <typename T> class MutableArrayRef : public ArrayRef<T> {
|
|
public:
|
|
using iterator = T *;
|
|
|
|
// From Array.
|
|
template <size_t N> MutableArrayRef(Array<T, N> &Arr) : ArrayRef<T>(Arr) {}
|
|
|
|
// Construct from a single element.
|
|
explicit MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
|
|
|
|
// Construct from a pointer and length.
|
|
MutableArrayRef(T *data, size_t length) : ArrayRef<T>(data, length) {}
|
|
|
|
// Construct from a range.
|
|
MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
|
|
|
|
// Construct from a C array.
|
|
template <size_t N>
|
|
constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
|
|
|
|
T *data() const { return const_cast<T *>(ArrayRef<T>::data()); }
|
|
|
|
iterator begin() const { return data(); }
|
|
iterator end() const { return data() + this->size(); }
|
|
|
|
T &operator[](size_t Index) const { return data()[Index]; }
|
|
};
|
|
|
|
} // namespace cpp
|
|
} // namespace __llvm_libc
|
|
|
|
#endif // LLVM_LIBC_UTILS_CPP_ARRAYREF_H
|