Struct template basic_stream

Boost C++ Libraries

Struct template basic_stream

boost::cnv::basic_stream

Synopsis

// In header: <boost/convert/stream.hpp>

template<typename Char> 
struct basic_stream : public noncopyable {
  // types
  typedef Char                                  char_type;       
  typedef boost::cnv::basic_stream< char_type > this_type;       
  typedef std::basic_stringstream< char_type >  stream_type;     
  typedef std::basic_istream< char_type >       istream_type;    
  typedef std::basic_streambuf< char_type >     buffer_type;     
  typedef std::basic_string< char_type >        stdstr_type;     
  typedef std::ios_base &(*                     manipulator_type;

  // member classes/structs/unions

  struct ibuffer_type : public buffer_type {
    // construct/copy/destruct
    ibuffer_type(char_type const *, std::size_t);
  };

  struct obuffer_type : public buffer_type {
  };

  // construct/copy/destruct
  basic_stream();
  basic_stream(this_type &&);

  // public member functions
   BOOST_CNV_STRING_ENABLE(type const &, optional< string_type > &) const;
   BOOST_CNV_STRING_ENABLE(string_type const &, optional< type > &) const;
  template<typename type> 
    void operator()(char_type const *, optional< type > &) const;
  template<typename type> 
    void operator()(stdstr_type const &, optional< type > &) const;
  template<typename manipulator> this_type & operator()(manipulator);
  this_type & operator()(manipulator_type);
  this_type & operator()(std::locale const &);
   BOOST_CNV_PARAM(locale, std::locale);
   BOOST_CNV_PARAM(precision, int);
   BOOST_CNV_PARAM(precision, int);
   BOOST_CNV_PARAM(width, int);
   BOOST_CNV_PARAM(fill, char);
   BOOST_CNV_PARAM(uppercase, bool);
   BOOST_CNV_PARAM(skipws, bool);
   BOOST_CNV_PARAM(adjust, boost::cnv::adjust::type);
   BOOST_CNV_PARAM(base, boost::cnv::base::type);
   BOOST_CNV_PARAM(notation, boost::cnv::notation::type);
  template<typename string_type, typename in_type> 
    void to_str(in_type const &, boost::optional< string_type > &) const;
  template<typename string_type, typename out_type> 
    void str_to(boost::cnv::range< string_type >, 
                boost::optional< out_type > &) const;

  // private member functions
  template<typename string_type, typename out_type> 
    void str_to(cnv::range< string_type >, optional< out_type > &) const;
  template<typename string_type, typename in_type> 
    void to_str(in_type const &, optional< string_type > &) const;
};

Description

`basic_stream` public construct/copy/destruct

```
basic_stream();
```
```
basic_stream(this_type && other);
```

`basic_stream` public member functions

 BOOST_CNV_STRING_ENABLE(type const & v, optional< string_type > & s) const;

 BOOST_CNV_STRING_ENABLE(string_type const & s, optional< type > & r) const;

template<typename type> 
  void operator()(char_type const * s, optional< type > & r) const;

template<typename type> 
  void operator()(stdstr_type const & s, optional< type > & r) const;

template<typename manipulator> this_type & operator()(manipulator m);

this_type & operator()(manipulator_type m);

this_type & operator()(std::locale const & l);

 BOOST_CNV_PARAM(locale, std::locale const);

```
 BOOST_CNV_PARAM(precision, int const);
```
```
 BOOST_CNV_PARAM(precision, int);
```
```
 BOOST_CNV_PARAM(width, int const);
```
```
 BOOST_CNV_PARAM(fill, char const);
```

 BOOST_CNV_PARAM(uppercase, bool const);

```
 BOOST_CNV_PARAM(skipws, bool const);
```

 BOOST_CNV_PARAM(adjust, boost::cnv::adjust::type const);

 BOOST_CNV_PARAM(base, boost::cnv::base::type const);

 BOOST_CNV_PARAM(notation, boost::cnv::notation::type const);

template<typename string_type, typename in_type> 
  void to_str(in_type const & value_in, 
              boost::optional< string_type > & string_out) const;

template<typename string_type, typename out_type> 
  void str_to(boost::cnv::range< string_type > string_in, 
              boost::optional< out_type > & result_out) const;

`basic_stream` private member functions

template<typename string_type, typename out_type> 
  void str_to(cnv::range< string_type >, optional< out_type > &) const;

template<typename string_type, typename in_type> 
  void to_str(in_type const &, optional< string_type > &) const;