safe_base.h

Go to the documentation of this file.

// Safe sequence/iterator base implementation  -*- C++ -*-

// Copyright (C) 2003-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// 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 General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

#ifndef _GLIBCXX_DEBUG_SAFE_BASE_H
#define _GLIBCXX_DEBUG_SAFE_BASE_H 1

#include <ext/concurrence.h>

namespace __gnu_debug
{
  class _Safe_sequence_base;

  class _Safe_iterator_base
  {
  public:
    _Safe_sequence_base* _M_sequence;

    unsigned int         _M_version;

    _Safe_iterator_base* _M_prior;

    _Safe_iterator_base* _M_next;

  protected:
    _Safe_iterator_base()
    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
    { }

    _Safe_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
    { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); }

    _Safe_iterator_base(const _Safe_iterator_base& __x, bool __constant)
    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
    { this->_M_attach(__x._M_sequence, __constant); }

    _Safe_iterator_base&
    operator=(const _Safe_iterator_base&);

    explicit
    _Safe_iterator_base(const _Safe_iterator_base&);

    ~_Safe_iterator_base() { this->_M_detach(); }

    __gnu_cxx::__mutex& _M_get_mutex() throw ();

  public:
    void _M_attach(_Safe_sequence_base* __seq, bool __constant);

    void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();

    void _M_detach();

    void _M_detach_single() throw ();

    bool _M_attached_to(const _Safe_sequence_base* __seq) const
    { return _M_sequence == __seq; }

    _GLIBCXX_PURE bool _M_singular() const throw ();

    _GLIBCXX_PURE bool _M_can_compare(const _Safe_iterator_base& __x) const throw ();

    void
    _M_invalidate()
    { _M_version = 0; }

    void
    _M_reset() throw ();

    void
    _M_unlink() throw ()
    {
      if (_M_prior)
    _M_prior->_M_next = _M_next;
      if (_M_next)
    _M_next->_M_prior = _M_prior;
    }
  };

  class _Safe_sequence_base
  {
  public:
    _Safe_iterator_base* _M_iterators;

    _Safe_iterator_base* _M_const_iterators;

    mutable unsigned int _M_version;

  protected:
    // Initialize with a version number of 1 and no iterators
    _Safe_sequence_base()
    : _M_iterators(0), _M_const_iterators(0), _M_version(1)
    { }

    ~_Safe_sequence_base()
    { this->_M_detach_all(); }

    void
    _M_detach_all();

    void
    _M_detach_singular();

    void
    _M_revalidate_singular();

    void
    _M_swap(_Safe_sequence_base& __x);

    __gnu_cxx::__mutex& _M_get_mutex() throw ();

  public:
    void
    _M_invalidate_all() const
    { if (++_M_version == 0) _M_version = 1; }

    void
    _M_attach(_Safe_iterator_base* __it, bool __constant);

    void
    _M_attach_single(_Safe_iterator_base* __it, bool __constant) throw ();

    void
    _M_detach(_Safe_iterator_base* __it);

    void
    _M_detach_single(_Safe_iterator_base* __it) throw ();
  };
} // namespace __gnu_debug

#endif