office-gobmx/soltools/inc/st_list.hxx
Jens-Heiner Rechtien c66df7c098 INTEGRATION: CWS warnings01 (1.5.4); FILE MERGED
2005/11/07 12:08:32 sb 1.5.4.1: #i53898# Made code warning-free (additional -W switches for GCC).
2006-06-20 04:08:02 +00:00

338 lines
9 KiB
C++

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: st_list.hxx,v $
*
* $Revision: 1.6 $
*
* last change: $Author: hr $ $Date: 2006-06-20 05:08:02 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#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 )
{
push_back( new XY(*(*it)) );
}
return *this;
}
template <class XY>
void
DynamicList<XY>::Insert(unsigned pos, XY * const & elem_)
{
if ( pos > this->len )
return;
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