1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 #ifndef SOLTOOLS_ST_LIST_HXX 29 #define SOLTOOLS_ST_LIST_HXX 30 31 #include <string.h> 32 #include <iostream> 33 #include <stdlib.h> 34 35 template <class XX> 36 class ST_List /// Soltools-List. 37 { 38 public : 39 typedef XX * iterator; 40 typedef const XX * const_iterator; 41 42 // LIFECYCLE 43 ST_List(); 44 ST_List( 45 const ST_List<XX> & i_rList ); 46 virtual ~ST_List() { } 47 48 // OPERATORS 49 ST_List<XX> & operator=( 50 const ST_List<XX> & i_rList ); 51 52 const XX & operator[]( 53 unsigned n) const 54 { return elem(n); } 55 XX & operator[]( 56 unsigned n) 57 { return elem(n); } 58 // OPERATIONS 59 void reserve( 60 unsigned i_nSize ) 61 { alloc(i_nSize,true); } 62 void insert( 63 iterator i_aPos, 64 const XX & elem_ ) 65 { Insert(i_aPos-begin(), elem_); } 66 virtual void Insert( 67 unsigned pos, 68 const XX & elem ); 69 void push_back( 70 const XX & elem_) 71 { Insert(size(),elem_); } 72 void remove( 73 iterator i_aPos ) 74 { Remove(i_aPos-begin()); } 75 virtual void Remove( 76 unsigned pos ); 77 void pop_back() { Remove(size()-1); } 78 void erase_all() { while (size()) Remove(size()-1); } 79 80 // INQUIRY 81 const_iterator begin() const { return &inhalt[0]; } 82 const_iterator end() const { return &inhalt[len]; } 83 84 const XX & front() const { return elem(0); } 85 const XX & back() const { return elem(len-1); } 86 87 unsigned size() const { return len; } 88 unsigned space() const { return allocated; } 89 bool is_valid_index( 90 unsigned n) const 91 { return n < len; } 92 // ACCESS 93 iterator begin() { return &inhalt[0]; } 94 iterator end() { return &inhalt[len]; } 95 96 XX & front() { return elem(0); } 97 XX & back() { return elem(len-1); } 98 99 protected: 100 void checkSize( 101 unsigned newLength); 102 void alloc( 103 unsigned newSpace, 104 bool re = false ); 105 106 const XX & elem( 107 unsigned n ) const 108 { return inhalt[n]; } 109 XX & elem( 110 unsigned n ) 111 { return inhalt[n]; } 112 // DATA 113 XX * inhalt; 114 unsigned len; 115 unsigned allocated; 116 }; 117 118 119 120 template <class XY> 121 class DynamicList : public ST_List< XY* > 122 { 123 public: 124 DynamicList(); 125 DynamicList( 126 const DynamicList<XY> & 127 i_rList ); 128 virtual ~DynamicList(); /// Deletes all member pointers 129 130 DynamicList<XY> & operator=( 131 const DynamicList<XY> & 132 i_rList ); 133 134 virtual void Insert( 135 unsigned pos, 136 XY * const & elem ); 137 virtual void Remove( 138 unsigned pos ); 139 }; 140 141 142 143 template <class XX> 144 ST_List<XX>::ST_List() 145 : inhalt(0), 146 len(0), 147 allocated(0) 148 { 149 alloc(1); 150 } 151 152 template <class XX> 153 ST_List<XX>::ST_List( const ST_List<XX> & i_rList ) 154 : inhalt(0), 155 len(0), 156 allocated(0) 157 { 158 alloc(i_rList.size()); 159 160 for ( const_iterator it = i_rList.begin(); 161 it != i_rList.end(); 162 ++it ) 163 { 164 push_back(*it); 165 } 166 } 167 168 template <class XX> 169 ST_List<XX> & 170 ST_List<XX>::operator=( const ST_List<XX> & i_rList ) 171 { 172 for ( const_iterator it = i_rList.begin(); 173 it != i_rList.end(); 174 ++it ) 175 { 176 push_back(*it); 177 } 178 return *this; 179 } 180 181 template <class XX> 182 void 183 ST_List<XX>::Insert(unsigned pos, const XX & elem_) 184 { 185 if ( pos > len ) 186 return; 187 188 checkSize(len+2); 189 for ( unsigned p = len; p > pos; --p) 190 { 191 inhalt[p] = inhalt[p-1]; 192 } 193 inhalt[pos] = elem_; 194 len++; 195 } 196 197 198 template <class XX> 199 void 200 ST_List<XX>::Remove(unsigned pos) 201 { 202 if ( pos >= len ) 203 return; 204 len--; 205 for ( unsigned p = pos; p < len; ++p) 206 { 207 inhalt[p] = inhalt[p+1]; 208 } 209 } 210 211 212 // Protected: 213 template <class XX> 214 void 215 ST_List<XX>::checkSize(unsigned newLength) 216 { 217 // neuen Platzbedarf pruefen: 218 unsigned newSpace = space(); 219 if (newLength >= newSpace) 220 { 221 if (!newSpace) 222 newSpace = 1; 223 const unsigned nBorder = 2000000000; 224 while(newLength >= newSpace) 225 { 226 if (newSpace < nBorder) 227 newSpace <<= 1; 228 else 229 { 230 std::cerr << "List becomes too big" << std::endl; 231 exit(1); 232 } 233 } 234 } 235 236 // Veraenderung ?: 237 if (newSpace != space()) 238 alloc(newSpace,true); 239 } 240 241 template <class XX> 242 void 243 ST_List<XX>::alloc( unsigned newSpace, 244 bool re ) 245 { 246 XX * pNew = new XX[newSpace]; 247 248 if (inhalt != 0) 249 { 250 if (re) 251 { 252 for (unsigned i = 0; i < len; ++i) 253 { 254 pNew[i] = inhalt[i]; 255 } // end for 256 } 257 delete [] inhalt; 258 } 259 260 inhalt = pNew; 261 allocated = newSpace; 262 } 263 264 265 template <class XY> 266 DynamicList<XY>::DynamicList() 267 { 268 } 269 270 template <class XY> 271 DynamicList<XY>::DynamicList( const DynamicList<XY> & i_rList ) 272 : ST_List< XY* >(i_rList) 273 { 274 for ( typename DynamicList<XY>::iterator it = this->begin(); 275 it != DynamicList<XY>::end(); 276 ++it ) 277 { 278 // Copying the contents the pointers point at: 279 (*it) = new XY( *(*it) ); 280 } 281 } 282 283 template <class XY> 284 DynamicList<XY>::~DynamicList() 285 { 286 this->erase_all(); 287 } 288 289 template <class XY> 290 DynamicList<XY> & 291 DynamicList<XY>::operator=( const DynamicList<XY> & i_rList ) 292 { 293 for ( typename DynamicList<XY>::const_iterator it = i_rList.begin(); 294 it != i_rList.end(); 295 ++it ) 296 { 297 push_back( new XY(*(*it)) ); 298 } 299 return *this; 300 } 301 302 303 template <class XY> 304 void 305 DynamicList<XY>::Insert(unsigned pos, XY * const & elem_) 306 { 307 if ( pos > this->len ) 308 return; 309 310 checkSize(DynamicList<XY>::len+2); 311 memmove( DynamicList<XY>::inhalt+pos+1, DynamicList<XY>::inhalt+pos, (DynamicList<XY>::len-pos) * sizeof(XY*) ); 312 this->inhalt[pos] = elem_; 313 this->len++; 314 } 315 316 template <class XY> 317 void 318 DynamicList<XY>::Remove( unsigned pos ) 319 { 320 if (!this->is_valid_index(pos) ) 321 return; 322 this->len--; 323 delete DynamicList<XY>::inhalt[pos]; 324 memmove(DynamicList<XY>::inhalt+pos, DynamicList<XY>::inhalt+pos+1, (DynamicList<XY>::len-pos) * sizeof(XY*) ); 325 } 326 327 328 329 #endif 330 331