2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
\r
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
\r
5 This file is part of GtkRadiant.
\r
7 GtkRadiant is free software; you can redistribute it and/or modify
\r
8 it under the terms of the GNU General Public License as published by
\r
9 the Free Software Foundation; either version 2 of the License, or
\r
10 (at your option) any later version.
\r
12 GtkRadiant is distributed in the hope that it will be useful,
\r
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
15 GNU General Public License for more details.
\r
17 You should have received a copy of the GNU General Public License
\r
18 along with GtkRadiant; if not, write to the Free Software
\r
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\r
22 #ifndef __UTIL_LIST_H__
\r
23 #define __UTIL_LIST_H__
\r
28 template< class type >
\r
37 idList( int granularity = 16 );
\r
41 void SetNum( int num );
\r
42 void SetGranularity( int granularity );
\r
43 void Condense( void );
\r
45 void Resize( int size );
\r
46 type operator[]( int index ) const;
\r
47 type &operator[]( int index );
\r
48 int Append( type const & obj );
\r
49 int AddUnique( type const & obj );
\r
50 type *Find( type const & obj, int *index = NULL );
\r
51 bool RemoveIndex( int index );
\r
52 bool Remove( type const & obj );
\r
53 typedef int cmp_t(const void *, const void *);
\r
54 void Sort( cmp_t *compare );
\r
59 idList<type>::idList( int )
\r
62 template< class type >
\r
63 inline idList<type>::idList( int granularity ) {
\r
64 assert( granularity > 0 );
\r
67 m_granularity = granularity;
\r
73 idList<type>::~idList<type>
\r
76 template< class type >
\r
77 inline idList<type>::~idList() {
\r
86 template< class type >
\r
87 inline void idList<type>::Clear( void ) {
\r
102 template< class type >
\r
103 inline int idList<type>::Num( void ) {
\r
109 idList<type>::SetNum
\r
112 template< class type >
\r
113 inline void idList<type>::SetNum( int num ) {
\r
114 assert( num >= 0 );
\r
115 if ( num > m_size ) {
\r
116 // resize it up to the closest level of granularity
\r
117 Resize( ( ( num + m_granularity - 1 ) / m_granularity ) * m_granularity );
\r
124 idList<type>::SetGranularity
\r
127 template< class type >
\r
128 inline void idList<type>::SetGranularity( int granularity ) {
\r
131 assert( granularity > 0 );
\r
132 m_granularity = granularity;
\r
135 // resize it to the closest level of granularity
\r
136 newsize = ( ( m_num + m_granularity - 1 ) / m_granularity ) * m_granularity;
\r
137 if ( newsize != m_size ) {
\r
145 idList<type>::Condense
\r
147 Resizes the array to exactly the number of elements it contains
\r
150 template< class type >
\r
151 inline void idList<type>::Condense( void ) {
\r
166 template< class type >
\r
167 inline int idList<type>::Size( void ) {
\r
173 idList<type>::Resize
\r
176 template< class type >
\r
177 inline void idList<type>::Resize( int size ) {
\r
181 assert( size > 0 );
\r
190 if ( m_size < m_num ) {
\r
194 m_list = new type[ m_size ];
\r
195 for( i = 0; i < m_num; i++ ) {
\r
196 m_list[ i ] = temp[ i ];
\r
206 idList<type>::operator[] const
\r
209 template< class type >
\r
210 inline type idList<type>::operator[]( int index ) const {
\r
211 assert( index >= 0 );
\r
212 assert( index < m_num );
\r
214 return m_list[ index ];
\r
219 idList<type>::operator[]
\r
222 template< class type >
\r
223 inline type &idList<type>::operator[]( int index ) {
\r
224 assert( index >= 0 );
\r
225 assert( index < m_num );
\r
227 return m_list[ index ];
\r
232 idList<type>::Append
\r
235 template< class type >
\r
236 inline int idList<type>::Append( type const & obj ) {
\r
238 Resize( m_granularity );
\r
241 if ( m_num == m_size ) {
\r
242 Resize( m_size + m_granularity );
\r
245 m_list[ m_num ] = obj;
\r
253 idList<type>::AddUnique
\r
256 template< class type >
\r
257 inline int idList<type>::AddUnique( type const & obj ) {
\r
260 if ( !Find( obj, &index ) ) {
\r
261 index = Append( obj );
\r
272 template< class type >
\r
273 inline type *idList<type>::Find( type const & obj, int *index ) {
\r
276 for( i = 0; i < m_num; i++ ) {
\r
277 if ( m_list[ i ] == obj ) {
\r
281 return &m_list[ i ];
\r
290 idList<type>::RemoveIndex
\r
293 template< class type >
\r
294 inline bool idList<type>::RemoveIndex( int index ) {
\r
297 if ( !m_list || !m_num ) {
\r
301 assert( index >= 0 );
\r
302 assert( index < m_num );
\r
304 if ( ( index < 0 ) || ( index >= m_num ) ) {
\r
309 for( i = index; i < m_num; i++ ) {
\r
310 m_list[ i ] = m_list[ i + 1 ];
\r
318 idList<type>::Remove
\r
321 template< class type >
\r
322 inline bool idList<type>::Remove( type const & obj ) {
\r
325 if ( Find( obj, &index ) ) {
\r
326 return RemoveIndex( index );
\r
337 template< class type >
\r
338 inline void idList<type>::Sort( cmp_t *compare ) {
\r
343 qsort( ( void * )m_list, ( size_t )m_num, sizeof( type ), compare );
\r
346 #endif /* !__UTIL_LIST_H__ */
\r