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