Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef ARY_SCI_IMPL_HXX
21 : #define ARY_SCI_IMPL_HXX
22 :
23 :
24 :
25 : // USED SERVICES
26 : // BASE CLASSES
27 : #include <ary/stdconstiter.hxx>
28 : // COMPONENTS
29 : // PARAMETERS
30 :
31 :
32 : namespace ary
33 : {
34 :
35 :
36 : //************************* SCI_Vector **********************************//
37 :
38 : template <class ELEM>
39 : class SCI_Vector : public StdConstIterator<ELEM>
40 : {
41 : public:
42 : typedef std::vector<ELEM> source;
43 : typedef typename source::const_iterator source_iterator;
44 :
45 : SCI_Vector(
46 : const source & i_rSource );
47 : virtual ~SCI_Vector();
48 :
49 : private:
50 : // Interface StdConstIterator<>:
51 : virtual void do_Advance();
52 : virtual const ELEM *
53 : inq_CurElement() const;
54 : virtual bool inq_IsSorted() const;
55 :
56 : // DATA
57 : source_iterator itRun;
58 : source_iterator itEnd;
59 : };
60 :
61 :
62 :
63 : //************************* SCI_Map **********************************//
64 :
65 : template <class KEY, class VALUE>
66 : class SCI_Map : public StdConstIterator< typename std::map<KEY,VALUE>::value_type >
67 : {
68 : public:
69 : typedef std::map<KEY,VALUE> source;
70 : typedef typename source::const_iterator source_iterator;
71 :
72 : SCI_Map(
73 : const source & i_rSource );
74 : virtual ~SCI_Map();
75 :
76 : private:
77 : // Interface StdConstIterator<>:
78 : virtual void do_Advance();
79 : virtual const typename std::map<KEY,VALUE>::value_type *
80 : inq_CurElement() const;
81 : virtual bool inq_IsSorted() const;
82 :
83 : // DATA
84 : source_iterator itRun;
85 : source_iterator itEnd;
86 : };
87 :
88 :
89 : //************************* SCI_MultiMap **********************************//
90 :
91 : template <class KEY, class VALUE>
92 : class SCI_MultiMap : public StdConstIterator< typename std::multimap<KEY,VALUE>::value_type >
93 : {
94 : public:
95 : typedef std::multimap<KEY,VALUE> source;
96 : typedef typename source::const_iterator source_iterator;
97 :
98 : SCI_MultiMap(
99 : const source & i_rSource );
100 : SCI_MultiMap(
101 : source_iterator i_begin,
102 : source_iterator i_end );
103 : virtual ~SCI_MultiMap();
104 :
105 : private:
106 : // Interface StdConstIterator<>:
107 : virtual void do_Advance();
108 : virtual const typename std::multimap<KEY,VALUE>::value_type *
109 : inq_CurElement() const;
110 : virtual bool inq_IsSorted() const;
111 :
112 : // DATA
113 : source_iterator itRun;
114 : source_iterator itEnd;
115 : };
116 :
117 :
118 :
119 : //************************* SCI_Set **********************************//
120 :
121 :
122 : template <class TYPES>
123 : class SCI_Set : public StdConstIterator<typename TYPES::element_type>
124 : {
125 : public:
126 : typedef typename TYPES::element_type element;
127 : typedef typename TYPES::sort_type sorter;
128 : typedef std::set<element, sorter> source;
129 : typedef typename source::const_iterator source_iterator;
130 :
131 : SCI_Set(
132 : const source & i_rSource );
133 : virtual ~SCI_Set();
134 :
135 : private:
136 : // Interface StdConstIterator<>:
137 : virtual void do_Advance();
138 : virtual const element *
139 : inq_CurElement() const;
140 : virtual bool inq_IsSorted() const;
141 :
142 : // DATA
143 : source_iterator itRun;
144 : source_iterator itEnd;
145 : };
146 :
147 : //************************* SCI_DataInMap **********************************//
148 :
149 : template <class KEY, class VALUE>
150 : class SCI_DataInMap : public StdConstIterator<VALUE>
151 : {
152 : public:
153 : typedef std::map<KEY,VALUE> source;
154 : typedef typename source::const_iterator source_iterator;
155 :
156 : SCI_DataInMap(
157 : const source & i_rSource );
158 : virtual ~SCI_DataInMap();
159 :
160 : private:
161 : // Interface StdConstIterator<>:
162 : virtual void do_Advance();
163 : virtual const VALUE *
164 : inq_CurElement() const;
165 : virtual bool inq_IsSorted() const;
166 :
167 : // DATA
168 : source_iterator itRun;
169 : source_iterator itEnd;
170 : };
171 :
172 :
173 :
174 :
175 :
176 : //********************************************************************//
177 :
178 :
179 : // IMPLEMENTATION
180 :
181 : template <class ELEM>
182 73755 : SCI_Vector<ELEM>::SCI_Vector( const source & i_rSource )
183 : : itRun(i_rSource.begin()),
184 73755 : itEnd(i_rSource.end())
185 : {
186 73755 : }
187 :
188 : template <class ELEM>
189 147510 : SCI_Vector<ELEM>::~SCI_Vector()
190 : {
191 147510 : }
192 :
193 :
194 : template <class ELEM>
195 : void
196 80202 : SCI_Vector<ELEM>::do_Advance()
197 : {
198 80202 : if (itRun != itEnd)
199 80202 : ++itRun;
200 80202 : }
201 :
202 : template <class ELEM>
203 : const ELEM *
204 257517 : SCI_Vector<ELEM>::inq_CurElement() const
205 : {
206 257517 : if (itRun != itEnd)
207 182666 : return &(*itRun);
208 74851 : return 0;
209 : }
210 :
211 : template <class ELEM>
212 : bool
213 0 : SCI_Vector<ELEM>::inq_IsSorted() const
214 : {
215 0 : return false;
216 : }
217 :
218 :
219 :
220 :
221 : template <class KEY, class VALUE>
222 : SCI_Map<KEY,VALUE>::SCI_Map( const source & i_rSource )
223 : : itRun(i_rSource.begin()),
224 : itEnd(i_rSource.end())
225 : {
226 : }
227 :
228 : template <class KEY, class VALUE>
229 : SCI_Map<KEY,VALUE>::~SCI_Map()
230 : {
231 : }
232 :
233 : template <class KEY, class VALUE>
234 : void
235 : SCI_Map<KEY,VALUE>::do_Advance()
236 : {
237 : if (itRun != itEnd)
238 : ++itRun;
239 : }
240 :
241 : template <class KEY, class VALUE>
242 : const typename std::map<KEY,VALUE>::value_type *
243 : SCI_Map<KEY,VALUE>::inq_CurElement() const
244 : {
245 : if (itRun != itEnd)
246 : return &(*itRun);
247 : return 0;
248 : }
249 :
250 :
251 : template <class KEY, class VALUE>
252 : bool
253 : SCI_Map<KEY,VALUE>::inq_IsSorted() const
254 : {
255 : return true;
256 : }
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 : template <class KEY, class VALUE>
265 : SCI_MultiMap<KEY,VALUE>::SCI_MultiMap( const source & i_rSource )
266 : : itRun(i_rSource.begin()),
267 : itEnd(i_rSource.end())
268 : {
269 : }
270 :
271 : template <class KEY, class VALUE>
272 : SCI_MultiMap<KEY,VALUE>::SCI_MultiMap( source_iterator i_begin,
273 : source_iterator i_end )
274 : : itRun(i_begin),
275 : itEnd(i_end)
276 : {
277 : }
278 :
279 : template <class KEY, class VALUE>
280 : SCI_MultiMap<KEY,VALUE>::~SCI_MultiMap()
281 : {
282 : }
283 :
284 : template <class KEY, class VALUE>
285 : void
286 : SCI_MultiMap<KEY,VALUE>::do_Advance()
287 : {
288 : if (itRun != itEnd)
289 : ++itRun;
290 : }
291 :
292 : template <class KEY, class VALUE>
293 : const typename std::multimap<KEY,VALUE>::value_type *
294 : SCI_MultiMap<KEY,VALUE>::inq_CurElement() const
295 : {
296 : if (itRun != itEnd)
297 : return &(*itRun);
298 : return 0;
299 : }
300 :
301 :
302 : template <class KEY, class VALUE>
303 : bool
304 : SCI_MultiMap<KEY,VALUE>::inq_IsSorted() const
305 : {
306 : return true;
307 : }
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 : template <class ELEM>
317 : SCI_Set<ELEM>::SCI_Set( const source & i_rSource )
318 : : itRun(i_rSource.begin()),
319 : itEnd(i_rSource.end())
320 : {
321 : }
322 :
323 : template <class ELEM>
324 : SCI_Set<ELEM>::~SCI_Set()
325 : {
326 : }
327 :
328 :
329 : template <class ELEM>
330 : void
331 : SCI_Set<ELEM>::do_Advance()
332 : {
333 : if (itRun != itEnd)
334 : ++itRun;
335 : }
336 :
337 : template <class ELEM>
338 : const typename SCI_Set<ELEM>::element *
339 : SCI_Set<ELEM>::inq_CurElement() const
340 : {
341 : if (itRun != itEnd)
342 : return &(*itRun);
343 : return 0;
344 : }
345 :
346 : template <class ELEM>
347 : bool
348 : SCI_Set<ELEM>::inq_IsSorted() const
349 : {
350 : return true;
351 : }
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 : template <class KEY, class VALUE>
360 119 : SCI_DataInMap<KEY,VALUE>::SCI_DataInMap( const source & i_rSource )
361 : : itRun(i_rSource.begin()),
362 119 : itEnd(i_rSource.end())
363 : {
364 119 : }
365 :
366 : template <class KEY, class VALUE>
367 238 : SCI_DataInMap<KEY,VALUE>::~SCI_DataInMap()
368 : {
369 238 : }
370 :
371 : template <class KEY, class VALUE>
372 : void
373 4252 : SCI_DataInMap<KEY,VALUE>::do_Advance()
374 : {
375 4252 : if (itRun != itEnd)
376 4252 : ++itRun;
377 4252 : }
378 :
379 : template <class KEY, class VALUE>
380 : const VALUE *
381 8623 : SCI_DataInMap<KEY,VALUE>::inq_CurElement() const
382 : {
383 8623 : if (itRun != itEnd)
384 8504 : return &(*itRun).second;
385 119 : return 0;
386 : }
387 :
388 :
389 : template <class KEY, class VALUE>
390 : bool
391 0 : SCI_DataInMap<KEY,VALUE>::inq_IsSorted() const
392 : {
393 0 : return true;
394 : }
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 : } // namespace ary
403 :
404 :
405 : #endif
406 :
407 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
