LCOV - code coverage report
Current view: top level - src - vector.h (source / functions) Hit Total Coverage
Test: app.info Lines: 42 44 95.5 %
Date: 2017-04-26 Functions: 31 35 88.6 %

          Line data    Source code
       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.
       4             : 
       5             : #ifndef V8_VECTOR_H_
       6             : #define V8_VECTOR_H_
       7             : 
       8             : #include <string.h>
       9             : #include <algorithm>
      10             : 
      11             : #include "src/allocation.h"
      12             : #include "src/checks.h"
      13             : #include "src/globals.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : 
      19             : template <typename T>
      20             : class Vector {
      21             :  public:
      22    34793829 :   Vector() : start_(NULL), length_(0) {}
      23   152253800 :   Vector(T* data, int length) : start_(data), length_(length) {
      24             :     DCHECK(length == 0 || (length > 0 && data != NULL));
      25        8280 :   }
      26             : 
      27             :   template <int N>
      28           0 :   explicit Vector(T (&arr)[N]) : start_(arr), length_(N) {}
      29             : 
      30             :   static Vector<T> New(int length) {
      31    12074220 :     return Vector<T>(NewArray<T>(length), length);
      32             :   }
      33             : 
      34             :   // Returns a vector using the same backing storage as this one,
      35             :   // spanning from and including 'from', to but not including 'to'.
      36      123106 :   Vector<T> SubVector(int from, int to) const {
      37             :     DCHECK(0 <= from);
      38             :     SLOW_DCHECK(from <= to);
      39             :     SLOW_DCHECK(static_cast<unsigned>(to) <= static_cast<unsigned>(length_));
      40     2802229 :     return Vector<T>(start() + from, to - from);
      41             :   }
      42             : 
      43             :   // Returns the length of the vector.
      44  1637311939 :   int length() const { return length_; }
      45             : 
      46             :   // Returns whether or not the vector is empty.
      47             :   bool is_empty() const { return length_ == 0; }
      48             : 
      49             :   // Returns the pointer to the start of the data in the vector.
      50       10885 :   T* start() const { return start_; }
      51             : 
      52             :   // Access individual vector elements - checks bounds in debug mode.
      53  1634619426 :   T& operator[](int index) const {
      54             :     DCHECK_LE(0, index);
      55             :     DCHECK_LT(index, length_);
      56  6999898498 :     return start_[index];
      57             :   }
      58             : 
      59   100165945 :   const T& at(int index) const { return operator[](index); }
      60             : 
      61             :   T& first() { return start_[0]; }
      62             : 
      63             :   T& last() { return start_[length_ - 1]; }
      64             : 
      65             :   typedef T* iterator;
      66             :   inline iterator begin() const { return &start_[0]; }
      67     1954683 :   inline iterator end() const { return &start_[length_]; }
      68             : 
      69             :   // Returns a clone of this vector with a new backing store.
      70             :   Vector<T> Clone() const {
      71             :     T* result = NewArray<T>(length_);
      72             :     for (int i = 0; i < length_; i++) result[i] = start_[i];
      73             :     return Vector<T>(result, length_);
      74             :   }
      75             : 
      76             :   template <typename CompareFunction>
      77     1136610 :   void Sort(CompareFunction cmp, size_t s, size_t l) {
      78      568305 :     std::sort(start() + s, start() + s + l, RawComparer<CompareFunction>(cmp));
      79      568305 :   }
      80             : 
      81             :   template <typename CompareFunction>
      82             :   void Sort(CompareFunction cmp) {
      83             :     std::sort(start(), start() + length(), RawComparer<CompareFunction>(cmp));
      84             :   }
      85             : 
      86             :   void Sort() {
      87             :     std::sort(start(), start() + length());
      88             :   }
      89             : 
      90             :   template <typename CompareFunction>
      91       22814 :   void StableSort(CompareFunction cmp, size_t s, size_t l) {
      92       22814 :     std::stable_sort(start() + s, start() + s + l,
      93       22814 :                      RawComparer<CompareFunction>(cmp));
      94       11407 :   }
      95             : 
      96             :   template <typename CompareFunction>
      97             :   void StableSort(CompareFunction cmp) {
      98             :     std::stable_sort(start(), start() + length(),
      99             :                      RawComparer<CompareFunction>(cmp));
     100             :   }
     101             : 
     102             :   void StableSort() { std::stable_sort(start(), start() + length()); }
     103             : 
     104             :   void Truncate(int length) {
     105             :     DCHECK(length <= length_);
     106        1369 :     length_ = length;
     107             :   }
     108             : 
     109             :   // Releases the array underlying this vector. Once disposed the
     110             :   // vector is empty.
     111             :   void Dispose() {
     112    36078520 :     DeleteArray(start_);
     113    36075995 :     start_ = NULL;
     114    36075995 :     length_ = 0;
     115             :   }
     116             : 
     117             :   inline Vector<T> operator+(int offset) {
     118             :     DCHECK(offset < length_);
     119           0 :     return Vector<T>(start_ + offset, length_ - offset);
     120             :   }
     121             : 
     122             :   // Implicit conversion from Vector<T> to Vector<const T>.
     123        1369 :   inline operator Vector<const T>() { return Vector<const T>::cast(*this); }
     124             : 
     125             :   // Factory method for creating empty vectors.
     126             :   static Vector<T> empty() { return Vector<T>(NULL, 0); }
     127             : 
     128             :   template<typename S>
     129             :   static Vector<T> cast(Vector<S> input) {
     130             :     return Vector<T>(reinterpret_cast<T*>(input.start()),
     131      137386 :                      input.length() * sizeof(S) / sizeof(T));
     132             :   }
     133             : 
     134             :   bool operator==(const Vector<T>& other) const {
     135        2758 :     if (length_ != other.length_) return false;
     136        2538 :     if (start_ == other.start_) return true;
     137       23971 :     for (int i = 0; i < length_; ++i) {
     138       23998 :       if (start_[i] != other.start_[i]) {
     139             :         return false;
     140             :       }
     141             :     }
     142             :     return true;
     143             :   }
     144             : 
     145             :  protected:
     146             :   void set_start(T* start) { start_ = start; }
     147             : 
     148             :  private:
     149             :   T* start_;
     150             :   int length_;
     151             : 
     152             :   template <typename CookedComparer>
     153             :   class RawComparer {
     154             :    public:
     155      579712 :     explicit RawComparer(CookedComparer cmp) : cmp_(cmp) {}
     156             :     bool operator()(const T& a, const T& b) {
     157    48208642 :       return cmp_(&a, &b) < 0;
     158             :     }
     159             : 
     160             :    private:
     161             :     CookedComparer cmp_;
     162             :   };
     163             : };
     164             : 
     165             : 
     166             : template <typename T>
     167             : class ScopedVector : public Vector<T> {
     168             :  public:
     169      492572 :   explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { }
     170        5852 :   ~ScopedVector() {
     171        5876 :     DeleteArray(this->start());
     172        5852 :   }
     173             : 
     174             :  private:
     175             :   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector);
     176             : };
     177             : 
     178             : 
     179          75 : inline int StrLength(const char* string) {
     180   203343628 :   size_t length = strlen(string);
     181             :   DCHECK(length == static_cast<size_t>(static_cast<int>(length)));
     182   203343628 :   return static_cast<int>(length);
     183             : }
     184             : 
     185             : 
     186             : #define STATIC_CHAR_VECTOR(x)                                              \
     187             :   v8::internal::Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(x), \
     188             :                                       arraysize(x) - 1)
     189             : 
     190        7660 : inline Vector<const char> CStrVector(const char* data) {
     191        7660 :   return Vector<const char>(data, StrLength(data));
     192             : }
     193             : 
     194             : inline Vector<const uint8_t> OneByteVector(const char* data, int length) {
     195             :   return Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), length);
     196             : }
     197             : 
     198             : inline Vector<const uint8_t> OneByteVector(const char* data) {
     199             :   return OneByteVector(data, StrLength(data));
     200             : }
     201             : 
     202             : inline Vector<char> MutableCStrVector(char* data) {
     203             :   return Vector<char>(data, StrLength(data));
     204             : }
     205             : 
     206             : inline Vector<char> MutableCStrVector(char* data, int max) {
     207             :   int length = StrLength(data);
     208             :   return Vector<char>(data, (length < max) ? length : max);
     209             : }
     210             : 
     211             : template <typename T, int N>
     212      817419 : inline Vector<T> ArrayVector(T (&arr)[N]) {
     213      817419 :   return Vector<T>(arr);
     214             : }
     215             : 
     216             : }  // namespace internal
     217             : }  // namespace v8
     218             : 
     219             : #endif  // V8_VECTOR_H_

Generated by: LCOV version 1.10