OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [debug/] [safe_unordered_base.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// Safe container/iterator base implementation  -*- C++ -*-
2
 
3
// Copyright (C) 2011 Free Software Foundation, Inc.
4
//
5
// This file is part of the GNU ISO C++ Library.  This library is free
6
// software; you can redistribute it and/or modify it under the
7
// terms of the GNU General Public License as published by the
8
// Free Software Foundation; either version 3, or (at your option)
9
// any later version.
10
 
11
// This library is distributed in the hope that it will be useful,
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
// GNU General Public License for more details.
15
 
16
// Under Section 7 of GPL version 3, you are granted additional
17
// permissions described in the GCC Runtime Library Exception, version
18
// 3.1, as published by the Free Software Foundation.
19
 
20
// You should have received a copy of the GNU General Public License and
21
// a copy of the GCC Runtime Library Exception along with this program;
22
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
// <http://www.gnu.org/licenses/>.
24
 
25
/** @file debug/safe_unordered_base.h
26
 *  This file is a GNU debug extension to the Standard C++ Library.
27
 */
28
 
29
#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H
30
#define _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H 1
31
 
32
#include <debug/safe_base.h>
33
 
34
namespace __gnu_debug
35
{
36
  class _Safe_unordered_container_base;
37
 
38
  /** \brief Basic functionality for a @a safe iterator.
39
   *
40
   *  The %_Safe_local_iterator_base base class implements the functionality
41
   *  of a safe local iterator that is not specific to a particular iterator
42
   *  type. It contains a pointer back to the container it references
43
   *  along with iterator version information and pointers to form a
44
   *  doubly-linked list of local iterators referenced by the container.
45
   *
46
   *  This class must not perform any operations that can throw an
47
   *  exception, or the exception guarantees of derived iterators will
48
   *  be broken.
49
   */
50
  class _Safe_local_iterator_base : public _Safe_iterator_base
51
  {
52
  protected:
53
    /** Initializes the iterator and makes it singular. */
54
    _Safe_local_iterator_base()
55
    { }
56
 
57
    /** Initialize the iterator to reference the container pointed to
58
     *  by @p __seq. @p __constant is true when we are initializing a
59
     *  constant local iterator, and false if it is a mutable local iterator.
60
     *  Note that @p __seq may be NULL, in which case the iterator will be
61
     *  singular. Otherwise, the iterator will reference @p __seq and
62
     *  be nonsingular.
63
     */
64
    _Safe_local_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
65
    { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); }
66
 
67
    /** Initializes the iterator to reference the same container that
68
        @p __x does. @p __constant is true if this is a constant
69
        iterator, and false if it is mutable. */
70
    _Safe_local_iterator_base(const _Safe_local_iterator_base& __x,
71
                              bool __constant)
72
    { this->_M_attach(__x._M_sequence, __constant); }
73
 
74
    _Safe_local_iterator_base&
75
    operator=(const _Safe_local_iterator_base&);
76
 
77
    explicit
78
    _Safe_local_iterator_base(const _Safe_local_iterator_base&);
79
 
80
    ~_Safe_local_iterator_base() { this->_M_detach(); }
81
 
82
    _Safe_unordered_container_base*
83
    _M_get_container() const _GLIBCXX_NOEXCEPT;
84
 
85
  public:
86
    /** Attaches this iterator to the given container, detaching it
87
     *  from whatever container it was attached to originally. If the
88
     *  new container is the NULL pointer, the iterator is left
89
     *  unattached.
90
     */
91
    void _M_attach(_Safe_sequence_base* __seq, bool __constant);
92
 
93
    /** Likewise, but not thread-safe. */
94
    void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();
95
 
96
    /** Detach the iterator for whatever container it is attached to,
97
     *  if any.
98
    */
99
    void _M_detach();
100
 
101
    /** Likewise, but not thread-safe. */
102
    void _M_detach_single() throw ();
103
  };
104
 
105
  /**
106
   * @brief Base class that supports tracking of local iterators that
107
   * reference an unordered container.
108
   *
109
   * The %_Safe_unordered_container_base class provides basic support for
110
   * tracking iterators into an unordered container. Containers that track
111
   * iterators must derived from %_Safe_unordered_container_base publicly, so
112
   * that safe iterators (which inherit _Safe_iterator_base) can
113
   * attach to them. This class contains four linked lists of
114
   * iterators, one for constant iterators, one for mutable
115
   * iterators, one for constant local iterators, one for mutable local
116
   * iterators and a version number that allows very fast
117
   * invalidation of all iterators that reference the container.
118
   *
119
   * This class must ensure that no operation on it may throw an
120
   * exception, otherwise @a safe containers may fail to provide the
121
   * exception-safety guarantees required by the C++ standard.
122
   */
123
  class _Safe_unordered_container_base : public _Safe_sequence_base
124
  {
125
    typedef _Safe_sequence_base _Base;
126
  public:
127
    /// The list of mutable local iterators that reference this container
128
    _Safe_iterator_base* _M_local_iterators;
129
 
130
    /// The list of constant local iterators that reference this container
131
    _Safe_iterator_base* _M_const_local_iterators;
132
 
133
  protected:
134
    // Initialize with a version number of 1 and no iterators
135
    _Safe_unordered_container_base()
136
    : _M_local_iterators(0), _M_const_local_iterators(0)
137
    { }
138
 
139
    /** Notify all iterators that reference this container that the
140
        container is being destroyed. */
141
    ~_Safe_unordered_container_base()
142
    { this->_M_detach_all(); }
143
 
144
    /** Detach all iterators, leaving them singular. */
145
    void
146
    _M_detach_all();
147
 
148
    /** Swap this container with the given container. This operation
149
     *  also swaps ownership of the iterators, so that when the
150
     *  operation is complete all iterators that originally referenced
151
     *  one container now reference the other container.
152
     */
153
    void
154
    _M_swap(_Safe_unordered_container_base& __x);
155
 
156
  public:
157
    /** Attach an iterator to this container. */
158
    void
159
    _M_attach_local(_Safe_iterator_base* __it, bool __constant);
160
 
161
    /** Likewise but not thread safe. */
162
    void
163
    _M_attach_local_single(_Safe_iterator_base* __it, bool __constant) throw ();
164
 
165
    /** Detach an iterator from this container */
166
    void
167
    _M_detach_local(_Safe_iterator_base* __it);
168
 
169
    /** Likewise but not thread safe. */
170
    void
171
    _M_detach_local_single(_Safe_iterator_base* __it) throw ();
172
  };
173
} // namespace __gnu_debug
174
 
175
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.