File Coverage

/usr/include/c++/5/bits/move.h
Criterion Covered Total %
statement 9 9 100.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 9 9 100.0


line stmt bran cond sub pod time code
1             // Move, forward and identity for C++0x + swap -*- C++ -*-
2              
3             // Copyright (C) 2007-2015 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             // .
24              
25             /** @file bits/move.h
26             * This is an internal header file, included by other library headers.
27             * Do not attempt to use it directly. @headername{utility}
28             */
29              
30             #ifndef _MOVE_H
31             #define _MOVE_H 1
32              
33             #include
34             #include
35              
36             namespace std _GLIBCXX_VISIBILITY(default)
37             {
38             _GLIBCXX_BEGIN_NAMESPACE_VERSION
39              
40             // Used, in C++03 mode too, by allocators, etc.
41             /**
42             * @brief Same as C++11 std::addressof
43             * @ingroup utilities
44             */
45             template
46             inline _Tp*
47             __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
48             {
49             return reinterpret_cast<_Tp*>
50             (&const_cast(reinterpret_cast(__r)));
51             }
52              
53             _GLIBCXX_END_NAMESPACE_VERSION
54             } // namespace
55              
56             #if __cplusplus >= 201103L
57             #include // Brings in std::declval too.
58              
59             namespace std _GLIBCXX_VISIBILITY(default)
60             {
61             _GLIBCXX_BEGIN_NAMESPACE_VERSION
62              
63             /**
64             * @addtogroup utilities
65             * @{
66             */
67              
68             /**
69             * @brief Forward an lvalue.
70             * @return The parameter cast to the specified type.
71             *
72             * This function is used to implement "perfect forwarding".
73             */
74             template
75             constexpr _Tp&&
76 15           forward(typename std::remove_reference<_Tp>::type& __t) noexcept
77 15           { return static_cast<_Tp&&>(__t); }
78              
79             /**
80             * @brief Forward an rvalue.
81             * @return The parameter cast to the specified type.
82             *
83             * This function is used to implement "perfect forwarding".
84             */
85             template
86             constexpr _Tp&&
87             forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
88             {
89             static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
90             " substituting _Tp is an lvalue reference type");
91             return static_cast<_Tp&&>(__t);
92             }
93              
94             /**
95             * @brief Convert a value to an rvalue.
96             * @param __t A thing of arbitrary type.
97             * @return The parameter cast to an rvalue-reference to allow moving it.
98             */
99             template
100             constexpr typename std::remove_reference<_Tp>::type&&
101 97           move(_Tp&& __t) noexcept
102 97           { return static_cast::type&&>(__t); }
103              
104              
105             template
106             struct __move_if_noexcept_cond
107             : public __and_<__not_>,
108             is_copy_constructible<_Tp>>::type { };
109              
110             /**
111             * @brief Conditionally convert a value to an rvalue.
112             * @param __x A thing of arbitrary type.
113             * @return The parameter, possibly cast to an rvalue-reference.
114             *
115             * Same as std::move unless the type's move constructor could throw and the
116             * type is copyable, in which case an lvalue-reference is returned instead.
117             */
118             template
119             constexpr typename
120             conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
121             move_if_noexcept(_Tp& __x) noexcept
122             { return std::move(__x); }
123              
124             // declval, from type_traits.
125              
126             /**
127             * @brief Returns the actual address of the object or function
128             * referenced by r, even in the presence of an overloaded
129             * operator&.
130             * @param __r Reference to an object or function.
131             * @return The actual address.
132             */
133             template
134             inline _Tp*
135             addressof(_Tp& __r) noexcept
136             { return std::__addressof(__r); }
137              
138             // C++11 version of std::exchange for internal use.
139             template
140             inline _Tp
141             __exchange(_Tp& __obj, _Up&& __new_val)
142             {
143             _Tp __old_val = std::move(__obj);
144             __obj = std::forward<_Up>(__new_val);
145             return __old_val;
146             }
147              
148             /// @} group utilities
149             _GLIBCXX_END_NAMESPACE_VERSION
150             } // namespace
151              
152             #define _GLIBCXX_MOVE(__val) std::move(__val)
153             #define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val)
154             #else
155             #define _GLIBCXX_MOVE(__val) (__val)
156             #define _GLIBCXX_FORWARD(_Tp, __val) (__val)
157             #endif
158              
159             namespace std _GLIBCXX_VISIBILITY(default)
160             {
161             _GLIBCXX_BEGIN_NAMESPACE_VERSION
162              
163             /**
164             * @addtogroup utilities
165             * @{
166             */
167              
168             /**
169             * @brief Swaps two values.
170             * @param __a A thing of arbitrary type.
171             * @param __b Another thing of arbitrary type.
172             * @return Nothing.
173             */
174             template
175             inline void
176 9           swap(_Tp& __a, _Tp& __b)
177             #if __cplusplus >= 201103L
178             noexcept(__and_,
179             is_nothrow_move_assignable<_Tp>>::value)
180             #endif
181             {
182             // concept requirements
183             __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
184              
185 9           _Tp __tmp = _GLIBCXX_MOVE(__a);
186 9           __a = _GLIBCXX_MOVE(__b);
187 9           __b = _GLIBCXX_MOVE(__tmp);
188 9           }
189              
190             // _GLIBCXX_RESOLVE_LIB_DEFECTS
191             // DR 809. std::swap should be overloaded for array types.
192             /// Swap the contents of two arrays.
193             template
194             inline void
195             swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
196             #if __cplusplus >= 201103L
197             noexcept(noexcept(swap(*__a, *__b)))
198             #endif
199             {
200             for (size_t __n = 0; __n < _Nm; ++__n)
201             swap(__a[__n], __b[__n]);
202             }
203              
204             /// @} group utilities
205             _GLIBCXX_END_NAMESPACE_VERSION
206             } // namespace
207              
208             #endif /* _MOVE_H */