| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef SOLTOOLS_ST_LIST_HXX |
| #define SOLTOOLS_ST_LIST_HXX |
| |
| #include <string.h> |
| #include <iostream> |
| #include <stdlib.h> |
| |
| template <class XX> |
| class ST_List /// Soltools-List. |
| { |
| public : |
| typedef XX * iterator; |
| typedef const XX * const_iterator; |
| |
| // LIFECYCLE |
| ST_List(); |
| ST_List( |
| const ST_List<XX> & i_rList ); |
| virtual ~ST_List() { } |
| |
| // OPERATORS |
| ST_List<XX> & operator=( |
| const ST_List<XX> & i_rList ); |
| |
| const XX & operator[]( |
| unsigned n) const |
| { return elem(n); } |
| XX & operator[]( |
| unsigned n) |
| { return elem(n); } |
| // OPERATIONS |
| void reserve( |
| unsigned i_nSize ) |
| { alloc(i_nSize,true); } |
| void insert( |
| iterator i_aPos, |
| const XX & elem_ ) |
| { Insert(i_aPos-begin(), elem_); } |
| virtual void Insert( |
| unsigned pos, |
| const XX & elem ); |
| void push_back( |
| const XX & elem_) |
| { Insert(size(),elem_); } |
| void remove( |
| iterator i_aPos ) |
| { Remove(i_aPos-begin()); } |
| virtual void Remove( |
| unsigned pos ); |
| void pop_back() { Remove(size()-1); } |
| void erase_all() { while (size()) Remove(size()-1); } |
| |
| // INQUIRY |
| const_iterator begin() const { return &inhalt[0]; } |
| const_iterator end() const { return &inhalt[len]; } |
| |
| const XX & front() const { return elem(0); } |
| const XX & back() const { return elem(len-1); } |
| |
| unsigned size() const { return len; } |
| unsigned space() const { return allocated; } |
| bool is_valid_index( |
| unsigned n) const |
| { return n < len; } |
| // ACCESS |
| iterator begin() { return &inhalt[0]; } |
| iterator end() { return &inhalt[len]; } |
| |
| XX & front() { return elem(0); } |
| XX & back() { return elem(len-1); } |
| |
| protected: |
| void checkSize( |
| unsigned newLength); |
| void alloc( |
| unsigned newSpace, |
| bool re = false ); |
| |
| const XX & elem( |
| unsigned n ) const |
| { return inhalt[n]; } |
| XX & elem( |
| unsigned n ) |
| { return inhalt[n]; } |
| // DATA |
| XX * inhalt; |
| unsigned len; |
| unsigned allocated; |
| }; |
| |
| |
| |
| template <class XY> |
| class DynamicList : public ST_List< XY* > |
| { |
| public: |
| DynamicList(); |
| DynamicList( |
| const DynamicList<XY> & |
| i_rList ); |
| virtual ~DynamicList(); /// Deletes all member pointers |
| |
| DynamicList<XY> & operator=( |
| const DynamicList<XY> & |
| i_rList ); |
| |
| virtual void Insert( |
| unsigned pos, |
| XY * const & elem ); |
| virtual void Remove( |
| unsigned pos ); |
| }; |
| |
| |
| |
| template <class XX> |
| ST_List<XX>::ST_List() |
| : inhalt(0), |
| len(0), |
| allocated(0) |
| { |
| alloc(1); |
| } |
| |
| template <class XX> |
| ST_List<XX>::ST_List( const ST_List<XX> & i_rList ) |
| : inhalt(0), |
| len(0), |
| allocated(0) |
| { |
| alloc(i_rList.size()); |
| |
| for ( const_iterator it = i_rList.begin(); |
| it != i_rList.end(); |
| ++it ) |
| { |
| push_back(*it); |
| } |
| } |
| |
| template <class XX> |
| ST_List<XX> & |
| ST_List<XX>::operator=( const ST_List<XX> & i_rList ) |
| { |
| for ( const_iterator it = i_rList.begin(); |
| it != i_rList.end(); |
| ++it ) |
| { |
| push_back(*it); |
| } |
| return *this; |
| } |
| |
| template <class XX> |
| void |
| ST_List<XX>::Insert(unsigned pos, const XX & elem_) |
| { |
| if ( pos > len ) |
| return; |
| |
| checkSize(len+2); |
| for ( unsigned p = len; p > pos; --p) |
| { |
| inhalt[p] = inhalt[p-1]; |
| } |
| inhalt[pos] = elem_; |
| len++; |
| } |
| |
| |
| template <class XX> |
| void |
| ST_List<XX>::Remove(unsigned pos) |
| { |
| if ( pos >= len ) |
| return; |
| len--; |
| for ( unsigned p = pos; p < len; ++p) |
| { |
| inhalt[p] = inhalt[p+1]; |
| } |
| } |
| |
| |
| // Protected: |
| template <class XX> |
| void |
| ST_List<XX>::checkSize(unsigned newLength) |
| { |
| // neuen Platzbedarf pruefen: |
| unsigned newSpace = space(); |
| if (newLength >= newSpace) |
| { |
| if (!newSpace) |
| newSpace = 1; |
| const unsigned nBorder = 2000000000; |
| while(newLength >= newSpace) |
| { |
| if (newSpace < nBorder) |
| newSpace <<= 1; |
| else |
| { |
| std::cerr << "List becomes too big" << std::endl; |
| exit(1); |
| } |
| } |
| } |
| |
| // Veraenderung ?: |
| if (newSpace != space()) |
| alloc(newSpace,true); |
| } |
| |
| template <class XX> |
| void |
| ST_List<XX>::alloc( unsigned newSpace, |
| bool re ) |
| { |
| XX * pNew = new XX[newSpace]; |
| |
| if (inhalt != 0) |
| { |
| if (re) |
| { |
| for (unsigned i = 0; i < len; ++i) |
| { |
| pNew[i] = inhalt[i]; |
| } // end for |
| } |
| delete [] inhalt; |
| } |
| |
| inhalt = pNew; |
| allocated = newSpace; |
| } |
| |
| |
| template <class XY> |
| DynamicList<XY>::DynamicList() |
| { |
| } |
| |
| template <class XY> |
| DynamicList<XY>::DynamicList( const DynamicList<XY> & i_rList ) |
| : ST_List< XY* >(i_rList) |
| { |
| for ( typename DynamicList<XY>::iterator it = this->begin(); |
| it != DynamicList<XY>::end(); |
| ++it ) |
| { |
| // Copying the contents the pointers point at: |
| (*it) = new XY( *(*it) ); |
| } |
| } |
| |
| template <class XY> |
| DynamicList<XY>::~DynamicList() |
| { |
| this->erase_all(); |
| } |
| |
| template <class XY> |
| DynamicList<XY> & |
| DynamicList<XY>::operator=( const DynamicList<XY> & i_rList ) |
| { |
| for ( typename DynamicList<XY>::const_iterator it = i_rList.begin(); |
| it != i_rList.end(); |
| ++it ) |
| { |
| this->push_back( new XY(*(*it)) ); |
| } |
| return *this; |
| } |
| |
| |
| template <class XY> |
| void |
| DynamicList<XY>::Insert(unsigned pos, XY * const & elem_) |
| { |
| if ( pos > this->len ) |
| return; |
| |
| this->checkSize(DynamicList<XY>::len+2); |
| memmove( DynamicList<XY>::inhalt+pos+1, DynamicList<XY>::inhalt+pos, (DynamicList<XY>::len-pos) * sizeof(XY*) ); |
| this->inhalt[pos] = elem_; |
| this->len++; |
| } |
| |
| template <class XY> |
| void |
| DynamicList<XY>::Remove( unsigned pos ) |
| { |
| if (!this->is_valid_index(pos) ) |
| return; |
| this->len--; |
| delete DynamicList<XY>::inhalt[pos]; |
| memmove(DynamicList<XY>::inhalt+pos, DynamicList<XY>::inhalt+pos+1, (DynamicList<XY>::len-pos) * sizeof(XY*) ); |
| } |
| |
| |
| |
| #endif |
| |