Iterator.h

Go to the documentation of this file.
00001 //
00002 //  Copyright (c) 2003-2006 by Autodesk, Inc.
00003 //
00004 //  By using this code, you are agreeing to the terms and conditions of
00005 //  the License Agreement included in the documentation for this code.
00006 //
00007 //  AUTODESK MAKES NO WARRANTIES, EXPRESS OR IMPLIED,
00008 //  AS TO THE CORRECTNESS OF THIS CODE OR ANY DERIVATIVE
00009 //  WORKS WHICH INCORPORATE IT.
00010 //
00011 //  AUTODESK PROVIDES THE CODE ON AN "AS-IS" BASIS
00012 //  AND EXPLICITLY DISCLAIMS ANY LIABILITY, INCLUDING
00013 //  CONSEQUENTIAL AND INCIDENTAL DAMAGES FOR ERRORS,
00014 //  OMISSIONS, AND OTHER PROBLEMS IN THE CODE.
00015 //
00016 //  Use, duplication, or disclosure by the U.S. Government is subject to
00017 //  restrictions set forth in FAR 52.227-19 (Commercial Computer Software
00018 //  Restricted Rights) and DFAR 252.227-7013(c)(1)(ii) (Rights in Technical
00019 //  Data and Computer Software), as applicable.
00020 //
00021 
00022 
00023 #ifndef _DWFCORE_ITERATOR_H
00024 #define _DWFCORE_ITERATOR_H
00025 
00026 
00027 
00032 
00033 
00034 #include "dwfcore/Core.h"
00035 #include "dwfcore/STL.h"
00036 #include "dwfcore/String.h"
00037 #include "dwfcore/Exception.h"
00038 
00039 
00040 namespace DWFCore
00041 {
00042 
00043 
00072 template<class T>
00073 class DWFIterator
00074 {
00075 
00076 public:
00077 
00083     virtual ~DWFIterator()
00084         throw()
00085     {;}
00086 
00092     virtual void reset()
00093         throw() = 0;
00094 
00102     virtual bool valid()
00103         throw() = 0;
00104 
00112     virtual bool next()
00113         throw() = 0;
00114 
00121     virtual T& get()
00122         throw( DWFException ) = 0;
00123 
00124 protected:
00125 
00131     DWFIterator()
00132         throw()
00133     {;}
00134 };
00135 
00166 template<class T>
00167 class DWFConstIterator
00168 {
00169 
00170 public:
00171 
00177     virtual ~DWFConstIterator()
00178         throw()
00179     {;}
00180 
00186     virtual void reset()
00187         throw() = 0;
00188 
00196     virtual bool valid() const
00197         throw() = 0;
00198 
00206     virtual bool next()
00207         throw() = 0;
00208 
00215     virtual const T& get() const
00216         throw( DWFException ) = 0;
00217 
00218 protected:
00219 
00225     DWFConstIterator()
00226         throw()
00227     {;}
00228 };
00229 
00230 
00231 
00240 template<class T, class A=std::allocator<T> >
00241 class DWFVectorIterator : virtual public DWFCoreMemory
00242                         , public DWFIterator<T>
00243 {
00244 
00245 public:
00246 
00253     DWFVectorIterator( std::vector<T, A>& rVector )
00254         throw()
00255         : _rVector( rVector )
00256         , _iCurrent( 0 )
00257     {;}
00258 
00267     DWFVectorIterator( const DWFVectorIterator& i )
00268         throw()
00269         : _rVector( i._rVector )
00270         , _iCurrent( i._iCurrent )
00271     {;}
00272 
00281     DWFVectorIterator& operator=( const DWFVectorIterator& i )
00282         throw()
00283     {
00284         if (this==&i)
00285             return *this;
00286 
00287         _iCurrent = i._iCurrent;
00288         _rVector = i._rVector;
00289 
00290         return *this;
00291     }
00292 
00298     virtual ~DWFVectorIterator()
00299         throw()
00300     {;}
00301 
00305     void reset()
00306         throw()
00307     {
00308         _iCurrent = 0;
00309     }
00310 
00314     bool valid()
00315         throw()
00316     {
00317         return (_iCurrent < _rVector.size());
00318     }
00319 
00323     bool next()
00324         throw()
00325     {
00326         if (valid())
00327         {
00328             _iCurrent++;
00329             return valid();
00330         }
00331         else
00332         {
00333             return false;
00334         }
00335     }
00336 
00340     T& get()
00341         throw( DWFException )
00342     {
00343         if (valid())
00344         {
00345             return _rVector[_iCurrent];
00346         }
00347         else
00348         {
00349             _DWFCORE_THROW( DWFDoesNotExistException, /*NOXLATE*/L"No more elements" );
00350         }
00351     }
00352 
00353 private:
00354 
00355     std::vector<T, A> _rVector;
00356     size_t  _iCurrent;
00357 };
00358 
00359 
00368 template<class T, class A=std::allocator<T> >
00369 class DWFVectorConstIterator : virtual public DWFCoreMemory
00370                              , public DWFConstIterator<T>
00371 {
00372 
00373 public:
00374 
00381     DWFVectorConstIterator( const std::vector<T, A>& rVector )
00382         throw()
00383         : _rVector( rVector )
00384         , _iCurrent( 0 )
00385     {;}
00386 
00395     DWFVectorConstIterator( const DWFVectorConstIterator& i )
00396         throw()
00397         : _rVector( i._rVector )
00398         , _iCurrent( i._iCurrent )
00399     {;}
00400 
00409     DWFVectorConstIterator& operator=( const DWFVectorConstIterator& i )
00410         throw()
00411     {
00412         _iCurrent = i._iCurrent;
00413         _rVector = i._rVector;
00414 
00415         return *this;
00416     }
00417 
00423     virtual ~DWFVectorConstIterator()
00424         throw()
00425     {;}
00426 
00430     void reset()
00431         throw()
00432     {
00433         _iCurrent = 0;
00434     }
00435 
00439     bool valid() const
00440         throw()
00441     {
00442         return (_iCurrent < _rVector.size());
00443     }
00444 
00448     bool next()
00449         throw()
00450     {
00451         if (valid())
00452         {
00453             _iCurrent++;
00454             return valid();
00455         }
00456         else
00457         {
00458             return false;
00459         }
00460     }
00461 
00465     const T& get() const
00466         throw( DWFException )
00467     {
00468         if (valid())
00469         {
00470             return _rVector[_iCurrent];
00471         }
00472         else
00473         {
00474             _DWFCORE_THROW( DWFDoesNotExistException, /*NOXLATE*/L"No more elements" );
00475         }
00476     }
00477 
00478 private:
00479 
00480     const std::vector<T, A> _rVector;
00481     size_t  _iCurrent;
00482 };
00483 
00484 
00493 template< class A=std::allocator<DWFString> >
00494 class DWFStringVectorIterator : virtual public DWFCoreMemory
00495                               , public DWFIterator<DWFString>
00496 {
00497 
00498 public:
00499 
00506     DWFStringVectorIterator( std::vector<DWFString, A>& rVector )
00507         throw()
00508         : _rVector( rVector )
00509         , _iCurrent( 0 )
00510     {;}
00511 
00520     DWFStringVectorIterator( const DWFStringVectorIterator& i )
00521         throw()
00522         : _rVector( i._rVector )
00523         , _iCurrent( i._iCurrent )
00524     {;}
00525 
00534     DWFStringVectorIterator& operator=( const DWFStringVectorIterator& i )
00535         throw()
00536     {
00537         _iCurrent = i._iCurrent;
00538 
00539         size_t n = 0;
00540         for (; n < i._rVector.size(); n++)
00541         {
00542             _rVector.push_back( i._rVector[n] );
00543         }
00544 
00545         return *this;
00546     }
00547 
00553     virtual ~DWFStringVectorIterator()
00554         throw()
00555     {;}
00556 
00560     void reset()
00561         throw()
00562     {
00563         _iCurrent = 0;
00564     }
00565 
00569     bool valid()
00570         throw()
00571     {
00572         return (_iCurrent < _rVector.size());
00573     }
00574 
00578     bool next()
00579         throw()
00580     {
00581         if (valid())
00582         {
00583             _iCurrent++;
00584             return valid();
00585         }
00586         else
00587         {
00588             return false;
00589         }
00590     }
00591 
00595     DWFString& get()
00596         throw( DWFException )
00597     {
00598         if (valid())
00599         {
00600             return _rVector[_iCurrent];
00601         }
00602         else
00603         {
00604             _DWFCORE_THROW( DWFDoesNotExistException, /*NOXLATE*/L"No more elements" );
00605         }
00606     }
00607 
00608 private:
00609 
00610     std::vector<DWFString, A>& _rVector;
00611     size_t  _iCurrent;
00612 };
00613 
00637 template<class T>
00638 class DWFBasicIteratorImpl : virtual public DWFCoreMemory
00639                            , public DWFIterator<T>
00640 {
00641 
00642 public:
00643 
00652     DWFBasicIteratorImpl( uint16_t nHint = 16 )
00653         throw()
00654         : _ppT( NULL )
00655         , _nCount( 0 )
00656         , _nAlloc( 0 )
00657         , _nHint( nHint )
00658         , _iCurrent( -1 )
00659     {;}
00660 
00666     virtual ~DWFBasicIteratorImpl()
00667         throw()
00668     {
00669         if (_ppT)
00670         {
00671             DWFCORE_FREE_MEMORY( _ppT );
00672         }
00673     }
00674 
00678     virtual void reset()
00679         throw()
00680     {
00681         _iCurrent = (_nCount > 0) ? 0 : -1;
00682     }
00683 
00687     virtual bool valid()
00688         throw()
00689     {
00690         return (_iCurrent != -1);
00691     }
00692 
00696     virtual bool next()
00697         throw()
00698     {
00699         if (_iCurrent != -1)
00700         {
00701                 //
00702                 // cast ok - _iCurrent never less than -1
00703                 //
00704             if ((size_t)(++_iCurrent) == _nCount)
00705             {
00706                 _iCurrent = -1;
00707             }
00708         }
00709 
00710         return (_iCurrent != -1);
00711     }
00712 
00716     virtual T& get()
00717         throw( DWFException )
00718     {
00719         if (_iCurrent != -1)
00720         {
00721             return *(_ppT[_iCurrent]);
00722         }
00723         else
00724         {
00725             _DWFCORE_THROW( DWFDoesNotExistException, /*NOXLATE*/L"No element" );
00726         }
00727     }
00728 
00737     virtual void add( T& rT )
00738         throw( DWFException )
00739     {
00740         if ((_nAlloc - _nCount) == 0)
00741         {
00742             _nAlloc = max(2*_nAlloc, _nAlloc + _nHint);
00743             T** ppNew = (T**) DWFCORE_ALLOC_MEMORY( T*, _nAlloc );
00744             if (ppNew == NULL)
00745             {
00746                 _DWFCORE_THROW( DWFMemoryException, /*NOXLATE*/L"Failed to allocate buffer" );
00747             }
00748 
00749             DWFCORE_COPY_MEMORY( ppNew, _ppT, _nCount*sizeof(T*) );
00750             DWFCORE_FREE_MEMORY( _ppT );
00751 
00752             _ppT = ppNew;
00753         }
00754 
00755         _ppT[_nCount++] = &rT;
00756 
00757         if (_iCurrent == -1)
00758         {
00759             _iCurrent = 0;
00760         }
00761     }
00762 
00763 private:
00764 
00765     T**         _ppT;
00766     size_t      _nCount;
00767     size_t      _nAlloc;
00768     uint16_t    _nHint;
00769 
00770     off_t       _iCurrent;
00771 };
00772 
00778 template<class T>
00779 class DWFCachingIterator : virtual public DWFCoreMemory
00780                          , public DWFIterator<T>
00781 {
00782 
00783 public:
00784 
00793     DWFCachingIterator( uint16_t nHint = 16 )
00794         throw()
00795         : _pT( NULL )
00796         , _nCount( 0 )
00797         , _nAlloc( 0 )
00798         , _nHint( nHint )
00799         , _iCurrent( -1 )
00800     {;}
00801 
00807     virtual ~DWFCachingIterator()
00808         throw()
00809     {
00810         if (_pT)
00811         {
00812             DWFCORE_FREE_MEMORY( _pT );
00813         }
00814     }
00815 
00819     virtual void reset()
00820         throw()
00821     {
00822         _iCurrent = (_nCount > 0) ? 0 : -1;
00823     }
00824 
00828     virtual bool valid()
00829         throw()
00830     {
00831         return (_iCurrent != -1);
00832     }
00833 
00837     virtual bool next()
00838         throw()
00839     {
00840         if (_iCurrent != -1)
00841         {
00842                 //
00843                 // cast ok - _iCurrent never less than -1
00844                 //
00845             if ((size_t)(++_iCurrent) == _nCount)
00846             {
00847                 _iCurrent = -1;
00848             }
00849         }
00850 
00851         return (_iCurrent != -1);
00852     }
00853 
00857     virtual T& get()
00858         throw( DWFException )
00859     {
00860         if (_iCurrent != -1)
00861         {
00862             return (_pT[_iCurrent]);
00863         }
00864         else
00865         {
00866             _DWFCORE_THROW( DWFDoesNotExistException, /*NOXLATE*/L"No element" );
00867         }
00868     }
00869 
00878     virtual void add( const T& rT )
00879         throw( DWFException )
00880     {
00881         if ((_nAlloc - _nCount) == 0)
00882         {
00883             _nAlloc = max(2*_nAlloc, _nAlloc + _nHint);
00884             T* pNew = (T*) DWFCORE_ALLOC_MEMORY( T, _nAlloc );
00885             if (pNew == NULL)
00886             {
00887                 _DWFCORE_THROW( DWFMemoryException, /*NOXLATE*/L"Failed to allocate buffer" );
00888             }
00889 
00890             DWFCORE_COPY_MEMORY( pNew, _pT, _nCount*sizeof(T*) );
00891             DWFCORE_FREE_MEMORY( _pT );
00892 
00893             _pT = pNew;
00894         }
00895 
00896         _pT[_nCount++] = rT;
00897 
00898         if (_iCurrent == -1)
00899         {
00900             _iCurrent = 0;
00901         }
00902     }
00903 
00904 private:
00905 
00906     T*          _pT;
00907     size_t      _nCount;
00908     size_t      _nAlloc;
00909     uint16_t    _nHint;
00910 
00911     off_t       _iCurrent;
00912 };
00913 
00914 
00924 template<class K, class V>
00925 class DWFKVIterator
00926 {
00927 
00928 public:
00929 
00935     virtual ~DWFKVIterator()
00936         throw()
00937     {;}
00938 
00942     virtual void reset()
00943         throw() = 0;
00944 
00948     virtual bool valid()
00949         throw() = 0;
00950 
00954     virtual bool next()
00955         throw() = 0;
00956 
00963     virtual K& key()
00964         throw( DWFException ) = 0;
00965 
00972     virtual V& value()
00973         throw( DWFException ) = 0;
00974 
00975 protected:
00976 
00982     DWFKVIterator()
00983         throw()
00984     {;}
00985 };
00986 
00996 template<class K, class V>
00997 class DWFKVConstIterator
00998 {
00999 
01000 public:
01001 
01007     virtual ~DWFKVConstIterator()
01008         throw()
01009     {;}
01010 
01014     virtual void reset()
01015         throw() = 0;
01016 
01020     virtual bool valid()
01021         throw() = 0;
01022 
01026     virtual bool next()
01027         throw() = 0;
01028 
01035     virtual const K& key()
01036         throw( DWFException ) = 0;
01037 
01044     virtual const V& value()
01045         throw( DWFException ) = 0;
01046 
01047 protected:
01048 
01054     DWFKVConstIterator()
01055         throw()
01056     {;}
01057 };
01058 
01059 }
01060 
01061 
01062 #endif

Generated on Tue Jan 6 22:39:29 2009 for Autodesk DWF Core Library by  doxygen 1.4.5