1 // Copyright 2014 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
11 #include "src/allocation.h"
12 #include "src/checks.h"
13 #include "src/globals.h"
22 Vector() : start_(NULL), length_(0) {}
23 Vector(T* data, int length) : start_(data), length_(length) {
24 DCHECK(length == 0 || (length > 0 && data != NULL));
27 static Vector<T> New(int length) {
28 return Vector<T>(NewArray<T>(length), length);
31 // Returns a vector using the same backing storage as this one,
32 // spanning from and including 'from', to but not including 'to'.
33 Vector<T> SubVector(int from, int to) {
35 SLOW_DCHECK(from < to);
36 SLOW_DCHECK(static_cast<unsigned>(to) <= static_cast<unsigned>(length_));
37 return Vector<T>(start() + from, to - from);
40 // Returns the length of the vector.
41 int length() const { return length_; }
43 // Returns whether or not the vector is empty.
44 bool is_empty() const { return length_ == 0; }
46 // Returns the pointer to the start of the data in the vector.
47 T* start() const { return start_; }
49 // Access individual vector elements - checks bounds in debug mode.
50 T& operator[](int index) const {
51 DCHECK(0 <= index && index < length_);
55 const T& at(int index) const { return operator[](index); }
57 T& first() { return start_[0]; }
59 T& last() { return start_[length_ - 1]; }
62 inline iterator begin() const { return &start_[0]; }
63 inline iterator end() const { return &start_[length_]; }
65 // Returns a clone of this vector with a new backing store.
66 Vector<T> Clone() const {
67 T* result = NewArray<T>(length_);
68 for (int i = 0; i < length_; i++) result[i] = start_[i];
69 return Vector<T>(result, length_);
72 template <typename CompareFunction>
73 void Sort(CompareFunction cmp, size_t s, size_t l) {
74 std::sort(start() + s, start() + s + l, RawComparer<CompareFunction>(cmp));
77 template <typename CompareFunction>
78 void Sort(CompareFunction cmp) {
79 std::sort(start(), start() + length(), RawComparer<CompareFunction>(cmp));
83 std::sort(start(), start() + length());
86 template <typename CompareFunction>
87 void StableSort(CompareFunction cmp, size_t s, size_t l) {
88 std::stable_sort(start() + s, start() + s + l,
89 RawComparer<CompareFunction>(cmp));
92 template <typename CompareFunction>
93 void StableSort(CompareFunction cmp) {
94 std::stable_sort(start(), start() + length(),
95 RawComparer<CompareFunction>(cmp));
98 void StableSort() { std::stable_sort(start(), start() + length()); }
100 void Truncate(int length) {
101 DCHECK(length <= length_);
105 // Releases the array underlying this vector. Once disposed the
113 inline Vector<T> operator+(int offset) {
114 DCHECK(offset < length_);
115 return Vector<T>(start_ + offset, length_ - offset);
118 // Factory method for creating empty vectors.
119 static Vector<T> empty() { return Vector<T>(NULL, 0); }
122 static Vector<T> cast(Vector<S> input) {
123 return Vector<T>(reinterpret_cast<T*>(input.start()),
124 input.length() * sizeof(S) / sizeof(T));
127 bool operator==(const Vector<T>& other) const {
128 if (length_ != other.length_) return false;
129 if (start_ == other.start_) return true;
130 for (int i = 0; i < length_; ++i) {
131 if (start_[i] != other.start_[i]) {
139 void set_start(T* start) { start_ = start; }
145 template <typename CookedComparer>
148 explicit RawComparer(CookedComparer cmp) : cmp_(cmp) {}
149 bool operator()(const T& a, const T& b) {
150 return cmp_(&a, &b) < 0;
159 template <typename T>
160 class ScopedVector : public Vector<T> {
162 explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { }
164 DeleteArray(this->start());
168 DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector);
172 inline int StrLength(const char* string) {
173 size_t length = strlen(string);
174 DCHECK(length == static_cast<size_t>(static_cast<int>(length)));
175 return static_cast<int>(length);
179 #define STATIC_CHAR_VECTOR(x) \
180 v8::internal::Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(x), \
183 inline Vector<const char> CStrVector(const char* data) {
184 return Vector<const char>(data, StrLength(data));
187 inline Vector<const uint8_t> OneByteVector(const char* data, int length) {
188 return Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), length);
191 inline Vector<const uint8_t> OneByteVector(const char* data) {
192 return OneByteVector(data, StrLength(data));
195 inline Vector<char> MutableCStrVector(char* data) {
196 return Vector<char>(data, StrLength(data));
199 inline Vector<char> MutableCStrVector(char* data, int max) {
200 int length = StrLength(data);
201 return Vector<char>(data, (length < max) ? length : max);
205 } // namespace internal
208 #endif // V8_VECTOR_H_