libstdc++-v3/src/complex_io.cc

   1 // The template and inlines for the -*- C++ -*- complex number classes.
   2
   3 // Copyright (C) 2000 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 #include <bits/std_complex.h>
  31 #include <bits/std_istream.h>
  32 #include <bits/std_ostream.h>
  33 #include <bits/std_sstream.h>
  34
  35 namespace std
  36 {
  37
  38   template<typename _Tp, typename _CharT, class _Traits>
  39     basic_istream <_CharT, _Traits> &
  40     operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
  41     {
  42 #if !defined(_GLIBCPP_BUGGY_FLOAT_COMPLEX) && !defined(_GLIBCPP_BUGGY_COMPLEX)
  43       _Tp __re_x, __im_x;
  44       _CharT __ch;
  45       __is >> __ch;
  46       if (__ch == '(')
  47         {
  48           __is >> __re_x >> __ch;
  49           if (__ch == ',')
  50             {
  51               __is >> __im_x >> __ch;
  52               if (__ch == ')')
  53                 {
  54                   __x = complex<_Tp>(__re_x, __im_x);
  55                   return __is;
  56                 }
  57             }
  58           else if (__ch == ')')
  59             {
  60               __x = complex<_Tp>(__re_x, _Tp(0));
  61               return __is;
  62             }
  63         }
  64       else
  65         {
  66           __is.putback(__ch);
  67           __is >> __re_x;
  68           __x = complex<_Tp>(__re_x, _Tp(0));
  69           return __is;
  70         }
  71       __is.setstate(ios_base::failbit);
  72 #else
  73       __x = complex<_Tp>(_Tp(0), _Tp(0));
  74 #endif
  75       return __is;
  76     }
  77
  78   template<typename _Tp, typename _CharT, class _Traits>
  79     basic_ostream<_CharT, _Traits>&
  80     operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
  81     {
  82       basic_ostringstream<_CharT, _Traits> __s;
  83       __s.flags(__os.flags());
  84       __s.imbue(__os.getloc());
  85       __s.precision (__os.precision());
  86       __s << '(' << __x.real() << "," << __x.imag() << ')' << ends;
  87       return __os << __s.str();
  88     }
  89
  90
  91   template
  92     basic_istream<char, char_traits<char> >&
  93     operator>>(basic_istream<char, char_traits<char> >&, complex<float>&);
  94
  95   template
  96     basic_ostream<char, char_traits<char> >&
  97     operator<<(basic_ostream<char, char_traits<char> >&,
  98                const complex<float>&);
  99
 100   template
 101     basic_istream<char, char_traits<char> >&
 102     operator>>(basic_istream<char, char_traits<char> >&, complex<double>&);
 103
 104   template
 105     basic_ostream<char, char_traits<char> >&
 106     operator<<(basic_ostream<char, char_traits<char> >&,
 107                const complex<double>&);
 108
 109   template
 110     basic_istream<char, char_traits<char> >&
 111     operator>>(basic_istream<char, char_traits<char> >&,
 112                complex<long double>&);
 113
 114   template
 115     basic_ostream<char, char_traits<char> >&
 116     operator<<(basic_ostream<char, char_traits<char> >&,
 117                const complex<long double>&);
 118
 119 #ifdef _GLIBCPP_USE_WCHAR_T
 120   template
 121     basic_istream<wchar_t, char_traits<wchar_t> >&
 122     operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&,
 123                complex<float>&);
 124
 125   template
 126     basic_ostream<wchar_t, char_traits<wchar_t> >&
 127     operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&,
 128                const complex<float>&);
 129
 130   template
 131     basic_istream<wchar_t, char_traits<wchar_t> >&
 132     operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&,
 133                complex<double>&);
 134
 135   template
 136     basic_ostream<wchar_t, char_traits<wchar_t> >&
 137     operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&,
 138                const complex<double>&);
 139
 140   template
 141     basic_istream<wchar_t, char_traits<wchar_t> >&
 142     operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&,
 143                complex<long double>&);
 144
 145   template
 146     basic_ostream<wchar_t, char_traits<wchar_t> >&
 147     operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&,
 148                const complex<long double>&);
 149 #endif //_GLIBCPP_USE_WCHAR_T
 150 }
 151
 152
 153
 154
 155
 156
 157
 158
 159