Blame view

3rdparty/boost_1_81_0/boost/io/ostream_joiner.hpp 2.68 KB
63e88f80   Hu Chunming   提交三方库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
  /*
  Copyright 2019 Glen Joseph Fernandes
  (glenjofe@gmail.com)
  
  Distributed under the Boost Software License, Version 1.0.
  (http://www.boost.org/LICENSE_1_0.txt)
  */
  #ifndef BOOST_IO_OSTREAM_JOINER_HPP
  #define BOOST_IO_OSTREAM_JOINER_HPP
  
  #include <boost/config.hpp>
  #include <ostream>
  #include <string>
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  #if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
  #include <type_traits>
  #endif
  #include <utility>
  #endif
  
  namespace boost {
  namespace io {
  namespace detail {
  
  #if !defined(BOOST_NO_CXX11_ADDRESSOF)
  template<class T>
  inline T*
  osj_address(T& o)
  {
      return std::addressof(o);
  }
  #else
  template<class T>
  inline T*
  osj_address(T& obj)
  {
      return &obj;
  }
  #endif
  
  } /* detail */
  
  template<class Delim, class Char = char,
      class Traits = std::char_traits<Char> >
  class ostream_joiner {
  public:
      typedef Char char_type;
      typedef Traits traits_type;
      typedef std::basic_ostream<Char, Traits> ostream_type;
      typedef std::output_iterator_tag iterator_category;
      typedef void value_type;
      typedef void difference_type;
      typedef void pointer;
      typedef void reference;
  
      ostream_joiner(ostream_type& output, const Delim& delim)
          : output_(detail::osj_address(output))
          , delim_(delim)
          , first_(true) { }
  
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
      ostream_joiner(ostream_type& output, Delim&& delim)
          : output_(detail::osj_address(output))
          , delim_(std::move(delim))
          , first_(true) { }
  #endif
  
      template<class T>
      ostream_joiner& operator=(const T& value) {
          if (!first_) {
              *output_ << delim_;
          }
          first_ = false;
          *output_ << value;
          return *this;
      }
  
      ostream_joiner& operator*() BOOST_NOEXCEPT {
          return *this;
      }
  
      ostream_joiner& operator++() BOOST_NOEXCEPT {
          return *this;
      }
  
      ostream_joiner& operator++(int) BOOST_NOEXCEPT {
          return *this;
      }
  
  private:
      ostream_type* output_;
      Delim delim_;
      bool first_;
  };
  
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
      !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
  template<class Char, class Traits, class Delim>
  inline ostream_joiner<typename std::decay<Delim>::type, Char, Traits>
  make_ostream_joiner(std::basic_ostream<Char, Traits>& output, Delim&& delim)
  {
      return ostream_joiner<typename std::decay<Delim>::type, Char,
          Traits>(output, std::forward<Delim>(delim));
  }
  #else
  template<class Char, class Traits, class Delim>
  inline ostream_joiner<Delim, Char, Traits>
  make_ostream_joiner(std::basic_ostream<Char, Traits>& output,
      const Delim& delim)
  {
      return ostream_joiner<Delim, Char, Traits>(output, delim);
  }
  #endif
  
  } /* io */
  } /* boost */
  
  #endif