xref: /aoo41x/main/soltools/inc/st_list.hxx (revision 7ee1d29c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #ifndef SOLTOOLS_ST_LIST_HXX
25 #define SOLTOOLS_ST_LIST_HXX
26 
27 #include <string.h>
28 #include <iostream>
29 #include <stdlib.h>
30 
31 template <class XX>
32 class ST_List            /// Soltools-List.
33 {
34   public :
35 	typedef XX * 		iterator;
36 	typedef const XX *	const_iterator;
37 
38 	// LIFECYCLE
39 						ST_List();
40                         ST_List(
41                             const ST_List<XX> & i_rList );
~ST_List()42 	virtual				~ST_List() { }
43 
44 	// OPERATORS
45 	ST_List<XX> &       operator=(
46 							const ST_List<XX> & i_rList );
47 
operator [](unsigned n) const48 	const XX &        	operator[](
49 							unsigned 			n) const
50 												{ return elem(n); }
operator [](unsigned n)51 	XX &              	operator[](
52 							unsigned 			n)
53 												{ return elem(n); }
54 	// OPERATIONS
reserve(unsigned i_nSize)55 	void	            reserve(
56 							unsigned			i_nSize )
57 												{ alloc(i_nSize,true); }
insert(iterator i_aPos,const XX & elem_)58 	void  	 	        insert(
59                             iterator            i_aPos,
60 							const XX &          elem_ )
61                                                 { Insert(i_aPos-begin(), elem_); }
62 	virtual	void  	 	Insert(
63 							unsigned 			pos,
64 							const XX &          elem );
push_back(const XX & elem_)65 	void              	push_back(
66 							const XX & 			elem_)
67 												{ Insert(size(),elem_); }
remove(iterator i_aPos)68 	void  	 	        remove(
69 							iterator            i_aPos )
70                                                 { Remove(i_aPos-begin()); }
71 	virtual	void  	 	Remove(
72 							unsigned 			pos );
pop_back()73 	void              	pop_back()				{ Remove(size()-1); }
erase_all()74 	void 				erase_all()            	{ while (size()) Remove(size()-1); }
75 
76 	// INQUIRY
begin() const77     const_iterator      begin() const           { return &inhalt[0]; }
end() const78     const_iterator      end() const             { return &inhalt[len]; }
79 
front() const80 	const XX &          front() const       	{ return elem(0); }
back() const81 	const XX &          back() const        	{ return elem(len-1); }
82 
size() const83 	unsigned			size() const            { return len; }
space() const84 	unsigned			space() const           { return allocated; }
is_valid_index(unsigned n) const85 	bool              	is_valid_index(
86 							unsigned			n) const
87 												{ return n < len; }
88 	// ACCESS
begin()89     iterator            begin()                 { return &inhalt[0]; }
end()90     iterator            end()                   { return &inhalt[len]; }
91 
front()92 	XX &                front()                 { return elem(0); }
back()93 	XX &                back()                  { return elem(len-1); }
94 
95   protected:
96 	void  				checkSize(
97 							unsigned 			newLength);
98 	void				alloc(
99 							unsigned			newSpace,
100 							bool                re = false );
101 
elem(unsigned n) const102 	const XX &		   	elem(
103 							unsigned 			n ) const
104 												{ return inhalt[n]; }
elem(unsigned n)105 	XX &				elem(
106 							unsigned 			n )
107 												{ return inhalt[n]; }
108   // DATA
109 	XX *				inhalt;
110 	unsigned            len;
111     unsigned			allocated;
112 };
113 
114 
115 
116 template <class XY>
117 class DynamicList : public ST_List< XY* >
118 {
119   public:
120                         DynamicList();
121                         DynamicList(
122                             const DynamicList<XY> &
123                                                 i_rList );
124 	virtual				~DynamicList();         /// Deletes all member pointers
125 
126 	DynamicList<XY> &   operator=(
127 							const DynamicList<XY> &
128                                                 i_rList );
129 
130 	virtual	void  	 	Insert(
131 							unsigned 			pos,
132 							XY * const &        elem );
133 	virtual	void  	 	Remove(
134 							unsigned 			pos );
135 };
136 
137 
138 
139 template <class XX>
ST_List()140 ST_List<XX>::ST_List()
141 	:	inhalt(0),
142 		len(0),
143         allocated(0)
144 {
145     alloc(1);
146 }
147 
148 template <class XX>
ST_List(const ST_List<XX> & i_rList)149 ST_List<XX>::ST_List( const ST_List<XX> & i_rList )
150 	:	inhalt(0),
151 		len(0),
152         allocated(0)
153 {
154 	alloc(i_rList.size());
155 
156     for ( const_iterator it = i_rList.begin();
157           it != i_rList.end();
158           ++it )
159     {
160      	push_back(*it);
161     }
162 }
163 
164 template <class XX>
165 ST_List<XX> &
operator =(const ST_List<XX> & i_rList)166 ST_List<XX>::operator=( const ST_List<XX> & i_rList )
167 {
168     for ( const_iterator it = i_rList.begin();
169           it != i_rList.end();
170           ++it )
171     {
172      	push_back(*it);
173     }
174     return *this;
175 }
176 
177 template <class XX>
178 void
Insert(unsigned pos,const XX & elem_)179 ST_List<XX>::Insert(unsigned pos, const XX & elem_)
180 {
181 	if ( pos > len )
182 	  return;
183 
184 	checkSize(len+2);
185 	for ( unsigned p = len; p > pos; --p)
186 	{
187 		inhalt[p] = inhalt[p-1];
188 	}
189 	inhalt[pos] = elem_;
190 	len++;
191 }
192 
193 
194 template <class XX>
195 void
Remove(unsigned pos)196 ST_List<XX>::Remove(unsigned pos)
197 {
198 	if ( pos >= len )
199 	  return;
200 	len--;
201 	for ( unsigned p = pos; p < len; ++p)
202 	{
203 		inhalt[p] = inhalt[p+1];
204 	}
205 }
206 
207 
208 // Protected:
209 template <class XX>
210 void
checkSize(unsigned newLength)211 ST_List<XX>::checkSize(unsigned newLength)
212 {
213    // neuen Platzbedarf pruefen:
214    unsigned newSpace = space();
215    if (newLength >= newSpace)
216    {
217 	  if (!newSpace)
218 		 newSpace = 1;
219 	  const unsigned nBorder = 2000000000;
220 	  while(newLength >= newSpace)
221 	  {
222 		if (newSpace < nBorder)
223 			newSpace <<= 1;
224 		else
225 		{
226 			std::cerr << "List becomes too big" << std::endl;
227 			exit(1);
228 		}
229 	  }
230    }
231 
232    // Veraenderung ?:
233    if (newSpace != space())
234 	  alloc(newSpace,true);
235 }
236 
237 template <class XX>
238 void
alloc(unsigned newSpace,bool re)239 ST_List<XX>::alloc( unsigned			newSpace,
240 				    bool               re )
241 {
242 	XX * pNew = new XX[newSpace];
243 
244 	if (inhalt != 0)
245 	{
246 		if (re)
247 		{
248 			for (unsigned i = 0; i < len; ++i)
249 			{
250 				pNew[i] = inhalt[i];
251 			}  // end for
252 		}
253 		delete [] inhalt;
254 	}
255 
256 	inhalt = pNew;
257 	allocated = newSpace;
258 }
259 
260 
261 template <class XY>
DynamicList()262 DynamicList<XY>::DynamicList()
263 {
264 }
265 
266 template <class XY>
DynamicList(const DynamicList<XY> & i_rList)267 DynamicList<XY>::DynamicList( const DynamicList<XY> & i_rList )
268     :   ST_List< XY* >(i_rList)
269 {
270     for ( typename DynamicList<XY>::iterator it = this->begin();
271           it != DynamicList<XY>::end();
272           ++it )
273     {
274         // Copying the contents the pointers point at:
275      	(*it) = new XY( *(*it) );
276     }
277 }
278 
279 template <class XY>
~DynamicList()280 DynamicList<XY>::~DynamicList()
281 {
282 	this->erase_all();
283 }
284 
285 template <class XY>
286 DynamicList<XY> &
operator =(const DynamicList<XY> & i_rList)287 DynamicList<XY>::operator=( const DynamicList<XY> & i_rList )
288 {
289     for ( typename DynamicList<XY>::const_iterator it = i_rList.begin();
290           it != i_rList.end();
291           ++it )
292     {
293         this->push_back( new XY(*(*it)) );
294     }
295     return *this;
296 }
297 
298 
299 template <class XY>
300 void
Insert(unsigned pos,XY * const & elem_)301 DynamicList<XY>::Insert(unsigned pos, XY * const & elem_)
302 {
303 	if ( pos > this->len )
304 	  return;
305 
306 	this->checkSize(DynamicList<XY>::len+2);
307 	memmove( DynamicList<XY>::inhalt+pos+1, DynamicList<XY>::inhalt+pos, (DynamicList<XY>::len-pos) * sizeof(XY*) );
308 	this->inhalt[pos] = elem_;
309 	this->len++;
310 }
311 
312 template <class XY>
313 void
Remove(unsigned pos)314 DynamicList<XY>::Remove( unsigned pos )
315 {
316 	if (!this->is_valid_index(pos) )
317 		return;
318 	this->len--;
319 	delete DynamicList<XY>::inhalt[pos];
320 	memmove(DynamicList<XY>::inhalt+pos, DynamicList<XY>::inhalt+pos+1, (DynamicList<XY>::len-pos) * sizeof(XY*) );
321 }
322 
323 
324 
325 #endif
326 
327