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> >&,
  94                complex<float>&);
  95
  96   template
  97     basic_ostream<char, char_traits<char> >&
  98     operator<<(basic_ostream< char, char_traits<char> >&,
  99                const complex<float>&);
 100
 101   template
 102     basic_istream<char, char_traits<char> >&
 103     operator>>(basic_istream< char, char_traits<char> >&,
 104                complex<double>&);
 105
 106   template
 107     basic_ostream<char, char_traits<char> >&
 108     operator<<(basic_ostream< char, char_traits<char> >&,
 109                const complex<double>&);
 110
 111   template
 112     basic_istream<char, char_traits<char> >&
 113     operator>>(basic_istream< char, char_traits<char> >&,
 114                complex<long double>&);
 115
 116   template
 117     basic_ostream<char, char_traits<char> >&
 118     operator<<(basic_ostream< char, char_traits<char> >&,
 119                const complex<long double>&);
 120
 121 #ifdef _GLIBCPP_USE_WCHAR_T
 122   template
 123     basic_istream<wchar_t, char_traits<wchar_t> >&
 124     operator>>(basic_istream< wchar_t, char_traits<wchar_t> >&,
 125                complex<float>&);
 126
 127   template
 128     basic_ostream<wchar_t, char_traits<wchar_t> >&
 129     operator<<(basic_ostream< wchar_t, char_traits<wchar_t> >&,
 130                const complex<float>&);
 131
 132   template
 133     basic_istream<wchar_t, char_traits<wchar_t> >&
 134     operator>>(basic_istream< wchar_t, char_traits<wchar_t> >&,
 135                complex<double>&);
 136
 137   template
 138     basic_ostream<wchar_t, char_traits<wchar_t> >&
 139     operator<<(basic_ostream< wchar_t, char_traits<wchar_t> >&,
 140                const complex<double>&);
 141
 142   template
 143     basic_istream<wchar_t, char_traits<wchar_t> >&
 144     operator>>(basic_istream< wchar_t, char_traits<wchar_t> >&,
 145                complex<long double>&);
 146
 147   template
 148     basic_ostream<wchar_t, char_traits<wchar_t> >&
 149     operator<<(basic_ostream< wchar_t, char_traits<wchar_t> >&,
 150                const complex<long double>&);
 151 #endif //_GLIBCPP_USE_WCHAR_T
 152 }
 153
 154
 155
 156
 157
 158
 159
 160
 161