home *** CD-ROM | disk | FTP | other *** search
/ Beginning C++ Through Gam…rogramming (2nd Edition) / BCGP2E.ISO / bloodshed / devcpp-4.9.9.2_setup.exe / safe_iterator.tcc < prev    next >
Text File  |  2005-01-29  |  5KB  |  141 lines
  1. // Debugging iterator implementation (out of line) -*- C++ -*-
  2.  
  3. // Copyright (C) 2003, 2004
  4. // Free Software Foundation, Inc.
  5. //
  6. // This file is part of the GNU ISO C++ Library.  This library is free
  7. // software; you can redistribute it and/or modify it under the
  8. // terms of the GNU General Public License as published by the
  9. // Free Software Foundation; either version 2, or (at your option)
  10. // any later version.
  11.  
  12. // This library is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. // GNU General Public License for more details.
  16.  
  17. // You should have received a copy of the GNU General Public License along
  18. // with this library; see the file COPYING.  If not, write to the Free
  19. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20. // USA.
  21.  
  22. // As a special exception, you may use this file as part of a free software
  23. // library without restriction.  Specifically, if other files instantiate
  24. // templates or use macros or inline functions from this file, or you compile
  25. // this file and link it with other files to produce an executable, this
  26. // file does not by itself cause the resulting executable to be covered by
  27. // the GNU General Public License.  This exception does not however
  28. // invalidate any other reasons why the executable file might be covered by
  29. // the GNU General Public License.
  30.  
  31. /** @file safe_iterator.tcc
  32.  *  This is an internal header file, included by other library headers.
  33.  *  You should not attempt to use it directly.
  34.  */
  35.  
  36. #ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC
  37. #define _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC 1
  38.  
  39. namespace __gnu_debug
  40. {
  41.   template<typename _Iterator, typename _Sequence>
  42.     bool
  43.     _Safe_iterator<_Iterator, _Sequence>::
  44.     _M_can_advance(const difference_type& __n) const
  45.     {
  46.       typedef typename _Sequence::const_iterator const_iterator;
  47.  
  48.       if (this->_M_singular())
  49.     return false;
  50.       if (__n == 0)
  51.     return true;
  52.       if (__n < 0)
  53.     {
  54.       const_iterator __begin =
  55.         static_cast<const _Sequence*>(_M_sequence)->begin();
  56.       pair<difference_type, _Distance_precision> __dist =
  57.         this->_M_get_distance(__begin, *this);
  58.       bool __ok =  (__dist.second == __dp_exact && __dist.first >= -__n
  59.             || __dist.second != __dp_exact && __dist.first > 0);
  60.       return __ok;
  61.     }
  62.       else
  63.     {
  64.       const_iterator __end =
  65.         static_cast<const _Sequence*>(_M_sequence)->end();
  66.       pair<difference_type, _Distance_precision> __dist =
  67.         this->_M_get_distance(*this, __end);
  68.       bool __ok = (__dist.second == __dp_exact && __dist.first >= __n
  69.                || __dist.second != __dp_exact && __dist.first > 0);
  70.       return __ok;
  71.     }
  72.     }
  73.  
  74.   template<typename _Iterator, typename _Sequence>
  75.     template<typename _Other>
  76.       bool
  77.       _Safe_iterator<_Iterator, _Sequence>::
  78.       _M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const
  79.       {
  80.     if (!_M_can_compare(__rhs))
  81.       return false;
  82.  
  83.     /* Determine if we can order the iterators without the help of
  84.        the container */
  85.     pair<difference_type, _Distance_precision> __dist =
  86.       this->_M_get_distance(*this, __rhs);
  87.     switch (__dist.second) {
  88.     case __dp_equality:
  89.       if (__dist.first == 0)
  90.         return true;
  91.       break;
  92.  
  93.     case __dp_sign:
  94.     case __dp_exact:
  95.       return __dist.first >= 0;
  96.     }
  97.  
  98.     /* We can only test for equality, but check if one of the
  99.        iterators is at an extreme. */
  100.     if (_M_is_begin() || __rhs._M_is_end())
  101.       return true;
  102.     else if (_M_is_end() || __rhs._M_is_begin())
  103.       return false;
  104.  
  105.     // Assume that this is a valid range; we can't check anything else
  106.     return true;
  107.       }
  108.  
  109.   template<typename _Iterator, typename _Sequence>
  110.     void
  111.     _Safe_iterator<_Iterator, _Sequence>::
  112.     _M_invalidate()
  113.     {
  114.       typedef typename _Sequence::iterator iterator;
  115.       typedef typename _Sequence::const_iterator const_iterator;
  116.  
  117.       if (!this->_M_singular())
  118.     {
  119.       for (_Safe_iterator_base* iter = _M_sequence->_M_iterators; iter; )
  120.         {
  121.           iterator* __victim = static_cast<iterator*>(iter);
  122.           iter = iter->_M_next;
  123.           if (this->base() == __victim->base())
  124.         __victim->_M_version = 0;
  125.         }
  126.       for (_Safe_iterator_base* iter2 = _M_sequence->_M_const_iterators;
  127.            iter2; /* increment in loop */)
  128.         {
  129.           const_iterator* __victim = static_cast<const_iterator*>(iter2);
  130.           iter2 = iter2->_M_next;
  131.           if (this->base() == __victim->base())
  132.         __victim->_M_version = 0;
  133.         }
  134.       _M_version = 0;
  135.     }
  136.     }
  137. } // namespace __gnu_debug
  138.  
  139. #endif
  140.  
  141.