Lucene++ - a full-featured, c++ search engine
API Documentation


Collection.h
Go to the documentation of this file.
1
2// Copyright (c) 2009-2014 Alan Wright. All rights reserved.
3// Distributable under the terms of either the Apache License (Version 2.0)
4// or the GNU Lesser General Public License.
6
7#ifndef COLLECTION_H
8#define COLLECTION_H
9
10#include <vector>
11#include "LuceneSync.h"
12
13namespace Lucene {
14
16template <class TYPE>
17class Collection : public LuceneSync {
18public:
20 typedef boost::shared_ptr<this_type> shared_ptr;
21 typedef std::vector<TYPE> collection_type;
22 typedef typename collection_type::iterator iterator;
23 typedef typename collection_type::const_iterator const_iterator;
24 typedef TYPE value_type;
25
26 virtual ~Collection() {
27 }
28
29protected:
30 boost::shared_ptr<collection_type> container;
31
32public:
33 static this_type newInstance(int32_t size = 0) {
34 this_type instance;
35 instance.container = Lucene::newInstance<collection_type>(size);
36 return instance;
37 }
38
39 template <class ITER>
40 static this_type newInstance(ITER first, ITER last) {
41 this_type instance;
42 instance.container = Lucene::newInstance<collection_type>(first, last);
43 return instance;
44 }
45
46 void reset() {
47 resize(0);
48 }
49
50 void resize(int32_t size) {
51 if (size == 0) {
52 container.reset();
53 } else {
54 container->resize(size);
55 }
56 }
57
58 int32_t size() const {
59 return (int32_t)container->size();
60 }
61
62 bool empty() const {
63 return container->empty();
64 }
65
66 void clear() {
67 container->clear();
68 }
69
71 return container->begin();
72 }
73
75 return container->end();
76 }
77
79 return container->begin();
80 }
81
83 return container->end();
84 }
85
86 void add(const TYPE& type) {
87 container->push_back(type);
88 }
89
90 void add(int32_t pos, const TYPE& type) {
91 container->insert(container->begin() + pos, type);
92 }
93
94 template <class ITER>
95 void addAll(ITER first, ITER last) {
96 container->insert(container->end(), first, last);
97 }
98
99 template <class ITER>
100 void insert(ITER pos, const TYPE& type) {
101 container->insert(pos, type);
102 }
103
104 template <class ITER>
105 ITER remove(ITER pos) {
106 return container->erase(pos);
107 }
108
109 template <class ITER>
110 ITER remove(ITER first, ITER last) {
111 return container->erase(first, last);
112 }
113
114 void remove(const TYPE& type) {
115 container->erase(std::remove(container->begin(), container->end(), type), container->end());
116 }
117
118 template <class PRED>
119 void remove_if(PRED comp) {
120 container->erase(std::remove_if(container->begin(), container->end(), comp), container->end());
121 }
122
123 TYPE removeFirst() {
124 TYPE front = container->front();
125 container->erase(container->begin());
126 return front;
127 }
128
129 TYPE removeLast() {
130 TYPE back = container->back();
131 container->pop_back();
132 return back;
133 }
134
135 iterator find(const TYPE& type) {
136 return std::find(container->begin(), container->end(), type);
137 }
138
139 template <class PRED>
140 iterator find_if(PRED comp) {
141 return std::find_if(container->begin(), container->end(), comp);
142 }
143
144 bool contains(const TYPE& type) const {
145 return (std::find(container->begin(), container->end(), type) != container->end());
146 }
147
148 template <class PRED>
149 bool contains_if(PRED comp) const {
150 return (std::find_if(container->begin(), container->end(), comp) != container->end());
151 }
152
153 bool equals(const this_type& other) const {
154 return equals(other, std::equal_to<TYPE>());
155 }
156
157 template <class PRED>
158 bool equals(const this_type& other, PRED comp) const {
159 if (container->size() != other.container->size()) {
160 return false;
161 }
162 return std::equal(container->begin(), container->end(), other.container->begin(), comp);
163 }
164
165 int32_t hashCode() {
166 return (int32_t)(int64_t)container.get();
167 }
168
169 void swap(this_type& other) {
170 container.swap(other->container);
171 }
172
173 TYPE& operator[] (int32_t pos) {
174 return (*container)[pos];
175 }
176
177 const TYPE& operator[] (int32_t pos) const {
178 return (*container)[pos];
179 }
180
181 operator bool() const {
182 return container.get() != NULL;
183 }
184
185 bool operator! () const {
186 return !container;
187 }
188
189 bool operator== (const this_type& other) {
190 return (container == other.container);
191 }
192
193 bool operator!= (const this_type& other) {
194 return (container != other.container);
195 }
196};
197
198template <typename TYPE>
201 result.add(a1);
202 return result;
203}
204
205template <typename TYPE>
206Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2) {
207 Collection<TYPE> result = newCollection(a1);
208 result.add(a2);
209 return result;
210}
211
212template <typename TYPE>
213Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3) {
214 Collection<TYPE> result = newCollection(a1, a2);
215 result.add(a3);
216 return result;
217}
218
219template <typename TYPE>
220Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4) {
221 Collection<TYPE> result = newCollection(a1, a2, a3);
222 result.add(a4);
223 return result;
224}
225
226template <typename TYPE>
227Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5) {
228 Collection<TYPE> result = newCollection(a1, a2, a3, a4);
229 result.add(a5);
230 return result;
231}
232
233template <typename TYPE>
234Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5, const TYPE& a6) {
235 Collection<TYPE> result = newCollection(a1, a2, a3, a4, a5);
236 result.add(a6);
237 return result;
238}
239
240template <typename TYPE>
241Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5, const TYPE& a6, const TYPE& a7) {
242 Collection<TYPE> result = newCollection(a1, a2, a3, a4, a5, a6);
243 result.add(a7);
244 return result;
245}
246
247template <typename TYPE>
248Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5, const TYPE& a6, const TYPE& a7, const TYPE& a8) {
249 Collection<TYPE> result = newCollection(a1, a2, a3, a4, a5, a6, a7);
250 result.add(a8);
251 return result;
252}
253
254template <typename TYPE>
255Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5, const TYPE& a6, const TYPE& a7, const TYPE& a8, const TYPE& a9) {
256 Collection<TYPE> result = newCollection(a1, a2, a3, a4, a5, a6, a7, a8);
257 result.add(a9);
258 return result;
259}
260
261template <typename TYPE>
262Collection<TYPE> newCollection(const TYPE& a1, const TYPE& a2, const TYPE& a3, const TYPE& a4, const TYPE& a5, const TYPE& a6, const TYPE& a7, const TYPE& a8, const TYPE& a9, const TYPE& a10) {
263 Collection<TYPE> result = newCollection(a1, a2, a3, a4, a5, a6, a7, a8, a9);
264 result.add(a10);
265 return result;
266}
267
268}
269
270#endif
Utility template class to handle collections that can be safely copied and shared.
Definition: Collection.h:17
void remove_if(PRED comp)
Definition: Collection.h:119
void add(int32_t pos, const TYPE &type)
Definition: Collection.h:90
bool equals(const this_type &other) const
Definition: Collection.h:153
void reset()
Definition: Collection.h:46
ITER remove(ITER first, ITER last)
Definition: Collection.h:110
bool operator!() const
Definition: Collection.h:185
bool contains(const TYPE &type) const
Definition: Collection.h:144
void add(const TYPE &type)
Definition: Collection.h:86
void insert(ITER pos, const TYPE &type)
Definition: Collection.h:100
ITER remove(ITER pos)
Definition: Collection.h:105
iterator begin()
Definition: Collection.h:70
void remove(const TYPE &type)
Definition: Collection.h:114
const_iterator end() const
Definition: Collection.h:82
TYPE removeFirst()
Definition: Collection.h:123
static this_type newInstance(ITER first, ITER last)
Definition: Collection.h:40
void addAll(ITER first, ITER last)
Definition: Collection.h:95
Collection< TYPE > this_type
Definition: Collection.h:19
iterator find_if(PRED comp)
Definition: Collection.h:140
collection_type::const_iterator const_iterator
Definition: Collection.h:23
TYPE & operator[](int32_t pos)
Definition: Collection.h:173
boost::shared_ptr< this_type > shared_ptr
Definition: Collection.h:20
iterator end()
Definition: Collection.h:74
const_iterator begin() const
Definition: Collection.h:78
int32_t size() const
Definition: Collection.h:58
int32_t hashCode()
Definition: Collection.h:165
bool operator!=(const this_type &other)
Definition: Collection.h:193
TYPE removeLast()
Definition: Collection.h:129
void clear()
Definition: Collection.h:66
bool empty() const
Definition: Collection.h:62
bool contains_if(PRED comp) const
Definition: Collection.h:149
std::vector< TYPE > collection_type
Definition: Collection.h:21
boost::shared_ptr< collection_type > container
Definition: Collection.h:30
bool operator==(const this_type &other)
Definition: Collection.h:189
void resize(int32_t size)
Definition: Collection.h:50
virtual ~Collection()
Definition: Collection.h:26
static this_type newInstance(int32_t size=0)
Definition: Collection.h:33
iterator find(const TYPE &type)
Definition: Collection.h:135
void swap(this_type &other)
Definition: Collection.h:169
TYPE value_type
Definition: Collection.h:24
collection_type::iterator iterator
Definition: Collection.h:22
bool equals(const this_type &other, PRED comp) const
Definition: Collection.h:158
Base class for all Lucene synchronised classes.
Definition: LuceneSync.h:15
Definition: AbstractAllTermDocs.h:12
Collection< TYPE > newCollection(const TYPE &a1)
Definition: Collection.h:199

clucene.sourceforge.net