LCOV - code coverage report
Current view: top level - src/zone - zone-containers.h (source / functions) Hit Total Coverage
Test: app.info Lines: 12 12 100.0 %
Date: 2017-04-26 Functions: 18 18 100.0 %

          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_SRC_ZONE_ZONE_CONTAINERS_H_
       6             : #define V8_SRC_ZONE_ZONE_CONTAINERS_H_
       7             : 
       8             : #include <deque>
       9             : #include <list>
      10             : #include <map>
      11             : #include <queue>
      12             : #include <set>
      13             : #include <stack>
      14             : #include <vector>
      15             : 
      16             : #include "src/zone/zone-allocator.h"
      17             : 
      18             : namespace v8 {
      19             : namespace internal {
      20             : 
      21             : // A wrapper subclass for std::vector to make it easy to construct one
      22             : // that uses a zone allocator.
      23             : template <typename T>
      24     5625947 : class ZoneVector : public std::vector<T, ZoneAllocator<T>> {
      25             :  public:
      26             :   // Constructs an empty vector.
      27         982 :   explicit ZoneVector(Zone* zone)
      28         982 :       : std::vector<T, ZoneAllocator<T>>(ZoneAllocator<T>(zone)) {}
      29             : 
      30             :   // Constructs a new vector and fills it with {size} elements, each
      31             :   // constructed via the default constructor.
      32      395303 :   ZoneVector(size_t size, Zone* zone)
      33    20894929 :       : std::vector<T, ZoneAllocator<T>>(size, T(), ZoneAllocator<T>(zone)) {}
      34             : 
      35             :   // Constructs a new vector and fills it with {size} elements, each
      36             :   // having the value {def}.
      37             :   ZoneVector(size_t size, T def, Zone* zone)
      38    16265432 :       : std::vector<T, ZoneAllocator<T>>(size, def, ZoneAllocator<T>(zone)) {}
      39             : 
      40             :   // Constructs a new vector and fills it with the contents of the range
      41             :   // [first, last).
      42             :   template <class InputIt>
      43             :   ZoneVector(InputIt first, InputIt last, Zone* zone)
      44      641693 :       : std::vector<T, ZoneAllocator<T>>(first, last, ZoneAllocator<T>(zone)) {}
      45             : };
      46             : 
      47             : // A wrapper subclass std::deque to make it easy to construct one
      48             : // that uses a zone allocator.
      49             : template <typename T>
      50             : class ZoneDeque : public std::deque<T, RecyclingZoneAllocator<T>> {
      51             :  public:
      52             :   // Constructs an empty deque.
      53             :   explicit ZoneDeque(Zone* zone)
      54             :       : std::deque<T, RecyclingZoneAllocator<T>>(
      55    23135919 :             RecyclingZoneAllocator<T>(zone)) {}
      56             : };
      57             : 
      58             : // A wrapper subclass std::list to make it easy to construct one
      59             : // that uses a zone allocator.
      60             : // TODO(mstarzinger): This should be renamed to ZoneList once we got rid of our
      61             : // own home-grown ZoneList that actually is a ZoneVector.
      62             : template <typename T>
      63             : class ZoneLinkedList : public std::list<T, ZoneAllocator<T>> {
      64             :  public:
      65             :   // Constructs an empty list.
      66             :   explicit ZoneLinkedList(Zone* zone)
      67             :       : std::list<T, ZoneAllocator<T>>(ZoneAllocator<T>(zone)) {}
      68             : };
      69             : 
      70             : // A wrapper subclass std::priority_queue to make it easy to construct one
      71             : // that uses a zone allocator.
      72             : template <typename T, typename Compare = std::less<T>>
      73             : class ZonePriorityQueue
      74             :     : public std::priority_queue<T, ZoneVector<T>, Compare> {
      75             :  public:
      76             :   // Constructs an empty list.
      77             :   explicit ZonePriorityQueue(Zone* zone)
      78             :       : std::priority_queue<T, ZoneVector<T>, Compare>(Compare(),
      79             :                                                        ZoneVector<T>(zone)) {}
      80             : };
      81             : 
      82             : // A wrapper subclass for std::queue to make it easy to construct one
      83             : // that uses a zone allocator.
      84             : template <typename T>
      85             : class ZoneQueue : public std::queue<T, ZoneDeque<T>> {
      86             :  public:
      87             :   // Constructs an empty queue.
      88     6577566 :   explicit ZoneQueue(Zone* zone)
      89     6577627 :       : std::queue<T, ZoneDeque<T>>(ZoneDeque<T>(zone)) {}
      90             : };
      91             : 
      92             : // A wrapper subclass for std::stack to make it easy to construct one that uses
      93             : // a zone allocator.
      94             : template <typename T>
      95             : class ZoneStack : public std::stack<T, ZoneDeque<T>> {
      96             :  public:
      97             :   // Constructs an empty stack.
      98    10352046 :   explicit ZoneStack(Zone* zone)
      99    10352175 :       : std::stack<T, ZoneDeque<T>>(ZoneDeque<T>(zone)) {}
     100             : };
     101             : 
     102             : // A wrapper subclass for std::set to make it easy to construct one that uses
     103             : // a zone allocator.
     104             : template <typename K, typename Compare = std::less<K>>
     105             : class ZoneSet : public std::set<K, Compare, ZoneAllocator<K>> {
     106             :  public:
     107             :   // Constructs an empty set.
     108             :   explicit ZoneSet(Zone* zone)
     109             :       : std::set<K, Compare, ZoneAllocator<K>>(Compare(),
     110             :                                                ZoneAllocator<K>(zone)) {}
     111             : };
     112             : 
     113             : // A wrapper subclass for std::map to make it easy to construct one that uses
     114             : // a zone allocator.
     115             : template <typename K, typename V, typename Compare = std::less<K>>
     116             : class ZoneMap
     117             :     : public std::map<K, V, Compare, ZoneAllocator<std::pair<const K, V>>> {
     118             :  public:
     119             :   // Constructs an empty map.
     120             :   explicit ZoneMap(Zone* zone)
     121             :       : std::map<K, V, Compare, ZoneAllocator<std::pair<const K, V>>>(
     122             :             Compare(), ZoneAllocator<std::pair<const K, V>>(zone)) {}
     123             : };
     124             : 
     125             : // A wrapper subclass for std::multimap to make it easy to construct one that
     126             : // uses a zone allocator.
     127             : template <typename K, typename V, typename Compare = std::less<K>>
     128             : class ZoneMultimap
     129             :     : public std::multimap<K, V, Compare,
     130             :                            ZoneAllocator<std::pair<const K, V>>> {
     131             :  public:
     132             :   // Constructs an empty multimap.
     133             :   explicit ZoneMultimap(Zone* zone)
     134             :       : std::multimap<K, V, Compare, ZoneAllocator<std::pair<const K, V>>>(
     135             :             Compare(), ZoneAllocator<std::pair<const K, V>>(zone)) {}
     136             : };
     137             : 
     138             : // Typedefs to shorten commonly used vectors.
     139             : typedef ZoneVector<bool> BoolVector;
     140             : typedef ZoneVector<int> IntVector;
     141             : 
     142             : }  // namespace internal
     143             : }  // namespace v8
     144             : 
     145             : #endif  // V8_SRC_ZONE_ZONE_CONTAINERS_H_

Generated by: LCOV version 1.10