1/*------------------------------------------------------------------------------
2* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
3*
4* Distributable under the terms of either the Apache License (Version 2.0) or
5* the GNU Lesser General Public License, as specified in the COPYING file.
6------------------------------------------------------------------------------*/
7#ifndef _lucene_util_VoidList_
8#define _lucene_util_VoidList_
9
10#if defined(_LUCENE_PRAGMA_ONCE)
11# pragma once
12#endif
13
14#include "Equators.h"
15
16CL_NS_DEF(util)
17
18/**
19* A template to encapsulate various list type classes
20* @internal
21*/
22template<typename _kt,typename base,typename _valueDeletor>
23class __CLList:public base,LUCENE_BASE {
24private:
25 bool dv;
26public:
27 DEFINE_MUTEX(THIS_LOCK)
28
29 typedef typename base::const_iterator const_iterator;
30 typedef typename base::iterator iterator;
31
32 virtual ~__CLList(){
33 clear();
34 }
35
36 __CLList ( const bool deleteValue ):
37 dv(deleteValue)
38 {
39 }
40
41 void setDoDelete(bool val){ dv=val; }
42
43 //sets array to the contents of this array.
44 //array must be size+1, otherwise memory may be overwritten
45 void toArray(_kt* into) const{
46 int i=0;
47 for ( const_iterator itr=base::begin();itr!=base::end();itr++ ){
48 into[i] = *itr;
49 i++;
50 }
51 into[i] = NULL;
52 }
53
54 void set(int32_t i, _kt val) {
55 if ( dv )
56 _valueDeletor::doDelete((*this)[i]);
57 (*this)[i] = val;
58 }
59
60 //todo: check this
61 void delete_back(){
62 if ( base::size() > 0 ){
63 iterator itr = base::end();
64 if ( itr != base::begin())
65 itr --;
66 _kt key = *itr;
67 base::erase(itr);
68 if ( dv )
69 _valueDeletor::doDelete(key);
70 }
71 }
72
73 void delete_front(){
74 if ( base::size() > 0 ){
75 iterator itr = base::begin();
76 _kt key = *itr;
77 base::erase(itr);
78 if ( dv )
79 _valueDeletor::doDelete(key);
80 }
81 }
82
83 void clear(){
84 if ( dv ){
85 iterator itr = base::begin();
86 while ( itr != base::end() ){
87 _valueDeletor::doDelete(*itr);
88 ++itr;
89 }
90 }
91 base::clear();
92 }
93
94 void remove(int32_t i, bool dontDelete=false){
95 iterator itr=base::begin();
96 itr+=i;
97 _kt key = *itr;
98 base::erase( itr );
99 if ( dv && !dontDelete )
100 _valueDeletor::doDelete(key);
101 }
102 void remove(iterator itr, bool dontDelete=false){
103 _kt key = *itr;
104 base::erase( itr );
105 if ( dv && !dontDelete )
106 _valueDeletor::doDelete(key);
107 }
108
109};
110
111//growable arrays of Objects (like a collection or list)
112//a list, so can contain duplicates
113//it grows in chunks... todo: check jlucene for initial size of array, and growfactors
114template<typename _kt, typename _valueDeletor=CL_NS(util)::Deletor::Dummy>
115class CLVector:public __CLList<_kt, CL_NS_STD(vector)<_kt> , _valueDeletor>
116{
117public:
118 CLVector ( const bool deleteValue=true ):
119 __CLList<_kt, CL_NS_STD(vector)<_kt> , _valueDeletor>(deleteValue)
120 {
121 }
122};
123
124//An array-backed implementation of the List interface
125//a list, so can contain duplicates
126//*** a very simple list - use <valarray>
127//(This class is roughly equivalent to Vector, except that it is unsynchronized.)
128#define CLArrayList CLVector
129#define CLHashSet CLHashList
130
131//implementation of the List interface, provides access to the first and last list elements in O(1)
132//no comparator is required... and so can contain duplicates
133//a simple list with no comparator
134//*** a very simple list - use <list>
135#ifdef LUCENE_DISABLE_HASHING
136 #define CLHashList CLSetList
137#else
138
139template<typename _kt,
140 typename _Comparator=CL_NS(util)::Compare::TChar,
141 typename _valueDeletor=CL_NS(util)::Deletor::Dummy>
142class CLHashList:public __CLList<_kt, CL_NS_HASHING(hash_set)<_kt,_Comparator> , _valueDeletor>
143{
144public:
145 CLHashList ( const bool deleteValue=true ):
146 __CLList<_kt, CL_NS_HASHING(hash_set)<_kt,_Comparator> , _valueDeletor>(deleteValue)
147 {
148 }
149};
150#endif
151
152template<typename _kt, typename _valueDeletor=CL_NS(util)::Deletor::Dummy>
153class CLLinkedList:public __CLList<_kt, CL_NS_STD(list)<_kt> , _valueDeletor>
154{
155public:
156 CLLinkedList ( const bool deleteValue=true ):
157 __CLList<_kt, CL_NS_STD(list)<_kt> , _valueDeletor>(deleteValue)
158 {
159 }
160};
161template<typename _kt,
162 typename _Comparator=CL_NS(util)::Compare::TChar,
163 typename _valueDeletor=CL_NS(util)::Deletor::Dummy>
164class CLSetList:public __CLList<_kt, CL_NS_STD(set)<_kt,_Comparator> , _valueDeletor>
165{
166public:
167 CLSetList ( const bool deleteValue=true ):
168 __CLList<_kt, CL_NS_STD(set)<_kt,_Comparator> , _valueDeletor>(deleteValue)
169 {
170 }
171};
172
173CL_NS_END
174#endif
175