File Coverage

/usr/include/c++/5/bits/move.h
Criterion Covered Total %
statement 11 11 100.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 11 11 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             // <http://www.gnu.org/licenses/>.
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 <bits/c++config.h>
34             #include <bits/concept_check.h>
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<typename _Tp>
46             inline _Tp*
47 1251983           __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
48             {
49             return reinterpret_cast<_Tp*>
50 1251983           (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
51             }
52              
53             _GLIBCXX_END_NAMESPACE_VERSION
54             } // namespace
55              
56             #if __cplusplus >= 201103L
57             #include <type_traits> // 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<typename _Tp>
75             constexpr _Tp&&
76 804418468           forward(typename std::remove_reference<_Tp>::type& __t) noexcept
77 804418468           { 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<typename _Tp>
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<typename _Tp>
100             constexpr typename std::remove_reference<_Tp>::type&&
101 373810463           move(_Tp&& __t) noexcept
102 373810463           { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
103              
104              
105             template<typename _Tp>
106             struct __move_if_noexcept_cond
107             : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
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<typename _Tp>
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<typename _Tp>
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 <typename _Tp, typename _Up = _Tp>
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<typename _Tp>
175             inline void
176 63575           swap(_Tp& __a, _Tp& __b)
177             #if __cplusplus >= 201103L
178             noexcept(__and_<is_nothrow_move_constructible<_Tp>,
179             is_nothrow_move_assignable<_Tp>>::value)
180             #endif
181             {
182             // concept requirements
183             __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
184              
185 63575           _Tp __tmp = _GLIBCXX_MOVE(__a);
186 63575           __a = _GLIBCXX_MOVE(__b);
187 63575           __b = _GLIBCXX_MOVE(__tmp);
188 63575           }
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<typename _Tp, size_t _Nm>
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 */