1 // Position types -*- C++ -*-
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 // 2006, 2007, 2008, 2009, 2010
5 // Free Software Foundation, Inc.
7 // This file is part of the GNU ISO C++ Library. This library is free
8 // software; you can redistribute it and/or modify it under the
9 // terms of the GNU General Public License as published by the
10 // Free Software Foundation; either version 3, or (at your option)
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // Under Section 7 of GPL version 3, you are granted additional
19 // permissions described in the GCC Runtime Library Exception, version
20 // 3.1, as published by the Free Software Foundation.
22 // You should have received a copy of the GNU General Public License and
23 // a copy of the GCC Runtime Library Exception along with this program;
24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 // <http://www.gnu.org/licenses/>.
27 /** @file bits/postypes.h
28 * This is an internal header file, included by other library headers.
29 * Do not attempt to use it directly. @headername{iosfwd}
33 // ISO C++ 14882: 27.4.1 - Types
34 // ISO C++ 14882: 27.4.3 - Template class fpos
37 #ifndef _GLIBCXX_POSTYPES_H
38 #define _GLIBCXX_POSTYPES_H 1
40 #pragma GCC system_header
42 #include <cwchar> // For mbstate_t
44 // XXX If <stdint.h> is really needed, make sure to define the macros
45 // before including it, in order not to break <tr1/cstdint> (and <cstdint>
46 // in C++0x). Reconsider all this as soon as possible...
47 #if (defined(_GLIBCXX_HAVE_INT64_T) && !defined(_GLIBCXX_HAVE_INT64_T_LONG) \
48 && !defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG))
50 #ifndef __STDC_LIMIT_MACROS
51 # define _UNDEF__STDC_LIMIT_MACROS
52 # define __STDC_LIMIT_MACROS
54 #ifndef __STDC_CONSTANT_MACROS
55 # define _UNDEF__STDC_CONSTANT_MACROS
56 # define __STDC_CONSTANT_MACROS
58 #include <stdint.h> // For int64_t
59 #ifdef _UNDEF__STDC_LIMIT_MACROS
60 # undef __STDC_LIMIT_MACROS
61 # undef _UNDEF__STDC_LIMIT_MACROS
63 #ifdef _UNDEF__STDC_CONSTANT_MACROS
64 # undef __STDC_CONSTANT_MACROS
65 # undef _UNDEF__STDC_CONSTANT_MACROS
70 _GLIBCXX_BEGIN_NAMESPACE(std
)
72 // The types streamoff, streampos and wstreampos and the class
73 // template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
74 // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
75 // behaviour of these types is mostly implementation defined or
76 // unspecified. The behaviour in this implementation is as noted
80 * @brief Type used by fpos, char_traits<char>, and char_traits<wchar_t>.
82 * In clauses 21.1.3.1 and 27.4.1 streamoff is described as an
83 * implementation defined type.
84 * Note: In versions of GCC up to and including GCC 3.3, streamoff
87 #ifdef _GLIBCXX_HAVE_INT64_T_LONG
88 typedef long streamoff
;
89 #elif defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG)
90 typedef long long streamoff
;
91 #elif defined(_GLIBCXX_HAVE_INT64_T)
92 typedef int64_t streamoff
;
94 typedef long long streamoff
;
97 /// Integral type for I/O operation counts and buffer sizes.
98 typedef ptrdiff_t streamsize
; // Signed integral type
101 * @brief Class representing stream positions.
103 * The standard places no requirements upon the template parameter StateT.
104 * In this implementation StateT must be DefaultConstructible,
105 * CopyConstructible and Assignable. The standard only requires that fpos
106 * should contain a member of type StateT. In this implementation it also
107 * contains an offset stored as a signed integer.
109 * @param StateT Type passed to and returned from state().
111 template<typename _StateT
>
119 // The standard doesn't require that fpos objects can be default
120 // constructed. This implementation provides a default
121 // constructor that initializes the offset to 0 and default
122 // constructs the state.
124 : _M_off(0), _M_state() { }
126 // The standard requires that fpos objects can be constructed
127 // from streamoff objects using the constructor syntax, and
128 // fails to give any meaningful semantics. In this
129 // implementation implicit conversion is also allowed, and this
130 // constructor stores the streamoff as the offset and default
131 // constructs the state.
132 /// Construct position from offset.
133 fpos(streamoff __off
)
134 : _M_off(__off
), _M_state() { }
136 /// Convert to streamoff.
137 operator streamoff() const { return _M_off
; }
139 /// Remember the value of @a st.
144 /// Return the last set value of @a st.
149 // The standard requires that this operator must be defined, but
150 // gives no semantics. In this implementation it just adds its
151 // argument to the stored offset and returns *this.
152 /// Add offset to this position.
154 operator+=(streamoff __off
)
160 // The standard requires that this operator must be defined, but
161 // gives no semantics. In this implementation it just subtracts
162 // its argument from the stored offset and returns *this.
163 /// Subtract offset from this position.
165 operator-=(streamoff __off
)
171 // The standard requires that this operator must be defined, but
172 // defines its semantics only in terms of operator-. In this
173 // implementation it constructs a copy of *this, adds the
174 // argument to that copy using operator+= and then returns the
176 /// Add position and offset.
178 operator+(streamoff __off
) const
185 // The standard requires that this operator must be defined, but
186 // defines its semantics only in terms of operator+. In this
187 // implementation it constructs a copy of *this, subtracts the
188 // argument from that copy using operator-= and then returns the
190 /// Subtract offset from position.
192 operator-(streamoff __off
) const
199 // The standard requires that this operator must be defined, but
200 // defines its semantics only in terms of operator+. In this
201 // implementation it returns the difference between the offset
202 // stored in *this and in the argument.
203 /// Subtract position to return offset.
205 operator-(const fpos
& __other
) const
206 { return _M_off
- __other
._M_off
; }
209 // The standard only requires that operator== must be an
210 // equivalence relation. In this implementation two fpos<StateT>
211 // objects belong to the same equivalence class if the contained
212 // offsets compare equal.
213 /// Test if equivalent to another position.
214 template<typename _StateT
>
216 operator==(const fpos
<_StateT
>& __lhs
, const fpos
<_StateT
>& __rhs
)
217 { return streamoff(__lhs
) == streamoff(__rhs
); }
219 template<typename _StateT
>
221 operator!=(const fpos
<_StateT
>& __lhs
, const fpos
<_StateT
>& __rhs
)
222 { return streamoff(__lhs
) != streamoff(__rhs
); }
224 // Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos
225 // as implementation defined types, but clause 27.2 requires that
226 // they must both be typedefs for fpos<mbstate_t>
227 /// File position for char streams.
228 typedef fpos
<mbstate_t> streampos
;
229 /// File position for wchar_t streams.
230 typedef fpos
<mbstate_t> wstreampos
;
232 #ifdef __GXX_EXPERIMENTAL_CXX0X__
233 /// File position for char16_t streams.
234 typedef fpos
<mbstate_t> u16streampos
;
235 /// File position for char32_t streams.
236 typedef fpos
<mbstate_t> u32streampos
;
239 _GLIBCXX_END_NAMESPACE