Class StringifyStream

absl/strings/internal/stringify_stream.h:60–112

namespace strings_internal {

class StringifyStream {
 public:
  // Constructor: adapts (but does not take ownership of) some underlying
  // std::ostream instance.
  explicit StringifyStream(std::ostream& os) : sink_{os} {}

  // Stream insertion: delegate to an overload of operator<< if defined for type
  // T, otherwise fall back to AbslStringify for T.
  template <typename T>
  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
    if constexpr (HasStreamInsertion<T>::value) {
      stream.sink_.os << t;
    } else {
      AbslStringify(stream.sink_, t);
    }
    return stream;
  }

  // Rvalue-ref overload, required when the StringifyStream parameter hasn't
  // been bound to a variable.
  template <typename T>
  friend StringifyStream& operator<<(StringifyStream&& stream, const T& t) {
    return stream << t;
  }

  // Overload for things like << std::endl which need an explicit type in order
  // to resolve to the appropriate overload or template instantiation.
  StringifyStream& operator<<(std::ostream& (*func)(std::ostream&)) {
    sink_.os << func;
    return *this;
  }

 private:
  // Abseil "stringify sink" concept (stringify_sink.h)
  struct Sink {
    std::ostream& os;
    void Append(size_t count, char ch) { os << std::string(count, ch); }
    void Append(absl::string_view v) { os << v; }
    friend void AbslFormatFlush(Sink* sink, absl::string_view v) {
      sink->Append(v);
    }
  } sink_;

  // SFINAE helper to identify types with a defined operator<< overload.
  template <typename T, typename = void>
  struct HasStreamInsertion : std::false_type {};

  template <typename T>
  struct HasStreamInsertion<T,
                            std::void_t<decltype(std::declval<std::ostream&>()
                                                 << std::declval<const T&>())>>
      : std::true_type {};
};

}  // namespace strings_internal