postypes.h File Reference

#include <cwchar>

Go to the source code of this file.

Functions
namespace std	_GLIBCXX_VISIBILITY (default)

Detailed Description

This is an internal header file, included by other library headers. Do not attempt to use it directly. {iosfwd}

Function Documentation

namespace std _GLIBCXX_VISIBILITY

(

default

)

Type used by fpos, char_traits<char>, and char_traits<wchar_t>.

In clauses 21.1.3.1 and 27.4.1 streamoff is described as an implementation defined type. Note: In versions of GCC up to and including GCC 3.3, streamoff was typedef long.

Integral type for I/O operation counts and buffer sizes.

Class representing stream positions.

The standard places no requirements upon the template parameter StateT. In this implementation StateT must be DefaultConstructible, CopyConstructible and Assignable. The standard only requires that fpos should contain a member of type StateT. In this implementation it also contains an offset stored as a signed integer.

Parameters

StateT

Type passed to and returned from state().

Construct position from offset.

Convert to streamoff.

Remember the value of st.

Return the last set value of st.

Add offset to this position.

Subtract offset from this position.

Add position and offset.

Subtract offset from position.

Subtract position to return offset.

Test if equivalent to another position.

File position for char streams.

File position for wchar_t streams.

{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  // The types streamoff, streampos and wstreampos and the class
  // template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
  // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
  // behaviour of these types is mostly implementation defined or
  // unspecified. The behaviour in this implementation is as noted
  // below.

#ifdef _GLIBCXX_HAVE_INT64_T_LONG
  typedef long          streamoff;
#elif defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG)
  typedef long long     streamoff;
#elif defined(_GLIBCXX_HAVE_INT64_T) 
  typedef int64_t       streamoff;
#else
  typedef long long     streamoff;
#endif

  typedef ptrdiff_t streamsize; // Signed integral type

  template<typename _StateT>
    class fpos
    {
    private:
      streamoff                 _M_off;
      _StateT           _M_state;

    public:
      // The standard doesn't require that fpos objects can be default
      // constructed. This implementation provides a default
      // constructor that initializes the offset to 0 and default
      // constructs the state.
      fpos()
      : _M_off(0), _M_state() { }

      // The standard requires that fpos objects can be constructed
      // from streamoff objects using the constructor syntax, and
      // fails to give any meaningful semantics. In this
      // implementation implicit conversion is also allowed, and this
      // constructor stores the streamoff as the offset and default
      // constructs the state.
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }

      operator streamoff() const { return _M_off; }

      void
      state(_StateT __st)
      { _M_state = __st; }

      _StateT
      state() const
      { return _M_state; }

      // The standard requires that this operator must be defined, but
      // gives no semantics. In this implementation it just adds its
      // argument to the stored offset and returns *this.
      fpos&
      operator+=(streamoff __off)
      {
    _M_off += __off;
    return *this;
      }

      // The standard requires that this operator must be defined, but
      // gives no semantics. In this implementation it just subtracts
      // its argument from the stored offset and returns *this.
      fpos&
      operator-=(streamoff __off)
      {
    _M_off -= __off;
    return *this;
      }

      // The standard requires that this operator must be defined, but
      // defines its semantics only in terms of operator-. In this
      // implementation it constructs a copy of *this, adds the
      // argument to that copy using operator+= and then returns the
      // copy.
      fpos
      operator+(streamoff __off) const
      {
    fpos __pos(*this);
    __pos += __off;
    return __pos;
      }

      // The standard requires that this operator must be defined, but
      // defines its semantics only in terms of operator+. In this
      // implementation it constructs a copy of *this, subtracts the
      // argument from that copy using operator-= and then returns the
      // copy.
      fpos
      operator-(streamoff __off) const
      {
    fpos __pos(*this);
    __pos -= __off;
    return __pos;
      }

      // The standard requires that this operator must be defined, but
      // defines its semantics only in terms of operator+. In this
      // implementation it returns the difference between the offset
      // stored in *this and in the argument.
      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };

  // The standard only requires that operator== must be an
  // equivalence relation. In this implementation two fpos<StateT>
  // objects belong to the same equivalence class if the contained
  // offsets compare equal.
  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }

  // Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos
  // as implementation defined types, but clause 27.2 requires that
  // they must both be typedefs for fpos<mbstate_t>
  typedef fpos<mbstate_t> streampos;
  typedef fpos<mbstate_t> wstreampos;

#if __cplusplus >= 201103L
  typedef fpos<mbstate_t> u16streampos;
  typedef fpos<mbstate_t> u32streampos;
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace