safe_unordered_base.h

Go to the documentation of this file.

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

// Copyright (C) 2011-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_UNORDERED_BASE_H
#define _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H 1

#include <debug/safe_base.h>

namespace __gnu_debug
{
  class _Safe_unordered_container_base;

  class _Safe_local_iterator_base : public _Safe_iterator_base
  {
  protected:
    _Safe_local_iterator_base()
    { }

    _Safe_local_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
    { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); }

    _Safe_local_iterator_base(const _Safe_local_iterator_base& __x,
                  bool __constant)
    { this->_M_attach(__x._M_sequence, __constant); }

    _Safe_local_iterator_base&
    operator=(const _Safe_local_iterator_base&);

    explicit
    _Safe_local_iterator_base(const _Safe_local_iterator_base&);

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

    _Safe_unordered_container_base*
    _M_get_container() const _GLIBCXX_NOEXCEPT;

  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 ();
  };

  class _Safe_unordered_container_base : public _Safe_sequence_base
  {
    typedef _Safe_sequence_base _Base;
  public:
    _Safe_iterator_base* _M_local_iterators;

    _Safe_iterator_base* _M_const_local_iterators;

  protected:
    // Initialize with a version number of 1 and no iterators
    _Safe_unordered_container_base()
    : _M_local_iterators(nullptr), _M_const_local_iterators(nullptr)
    { }

    // Initialize with a version number of 1 and no iterators
    _Safe_unordered_container_base(const _Safe_unordered_container_base&)
    noexcept
    : _Safe_unordered_container_base() { }

    _Safe_unordered_container_base(_Safe_unordered_container_base&& __x)
    noexcept
    : _Safe_unordered_container_base()
    { this->_M_swap(__x); }

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

    void
    _M_detach_all();

    void
    _M_swap(_Safe_unordered_container_base& __x);

  public:
    void
    _M_attach_local(_Safe_iterator_base* __it, bool __constant);

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

    void
    _M_detach_local(_Safe_iterator_base* __it);

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

#endif