src/tint/utils/text/string_stream.h - dawn - Git at Google


            
            // Copyright 2023 The Dawn & Tint Authors

            
            //

            
            // Redistribution and use in source and binary forms, with or without

            
            // modification, are permitted provided that the following conditions are met:

            
            //

            
            // 1. Redistributions of source code must retain the above copyright notice, this

            
            //    list of conditions and the following disclaimer.

            
            //

            
            // 2. Redistributions in binary form must reproduce the above copyright notice,

            
            //    this list of conditions and the following disclaimer in the documentation

            
            //    and/or other materials provided with the distribution.

            
            //

            
            // 3. Neither the name of the copyright holder nor the names of its

            
            //    contributors may be used to endorse or promote products derived from

            
            //    this software without specific prior written permission.

            
            //

            
            // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

            
            // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

            
            // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

            
            // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

            
            // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

            
            // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

            
            // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

            
            // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

            
            // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

            
            // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


            #ifndef SRC_TINT_UTILS_TEXT_STRING_STREAM_H_

            
            #define SRC_TINT_UTILS_TEXT_STRING_STREAM_H_


            #include <algorithm>

            
            #include <functional>

            
            #include <iomanip>

            
            #include <iterator>

            
            #include <limits>

            
            #include <sstream>

            
            #include <string>

            
            #include <type_traits>

            
            #include <utility>


            #include "src/tint/utils/text/unicode.h"


            namespace tint {


            /// Stringstream wrapper which automatically resets the locale and sets floating point emission

            
            /// settings needed for Tint.

            
            class StringStream {

            
                using SetWRetTy = decltype(std::setw(std::declval<int>()));

            
                using SetPrecisionRetTy = decltype(std::setprecision(std::declval<int>()));

            
                using SetFillRetTy = decltype(std::setfill(std::declval<char>()));


                /// Evaluates to true if `T` is the return type of std::setw, std:setprecision or std::setfill.

            
                template <typename T>

            
                static constexpr bool IsSetType = std::is_same_v<SetWRetTy, std::decay_t<T>> ||

            
                                                  std::is_same_v<SetPrecisionRetTy, std::decay_t<T>> ||

            
                                                  std::is_same_v<SetFillRetTy, std::decay_t<T>>;


              public:

            
                /// Constructor

            
                StringStream();

            
                /// Copy constructor

            
                StringStream(const StringStream&);

            
                /// Destructor

            
                ~StringStream();


                /// Copy assignment operator

            
                StringStream& operator=(const StringStream&);


                /// @returns the format flags for the stream

            
                std::ios_base::fmtflags flags() const { return sstream_.flags(); }


                /// @param flags the flags to set

            
                /// @returns the original format flags

            
                std::ios_base::fmtflags flags(std::ios_base::fmtflags flags) { return sstream_.flags(flags); }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                template <typename T>

            
                    requires(std::is_integral_v<std::decay_t<T>>)

            
                StringStream& operator<<(T&& value) {

            
                    return EmitValue(std::forward<T>(value));

            
                }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                StringStream& operator<<(const char* value) { return EmitValue(value); }

            
                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                StringStream& operator<<(const std::string& value) { return EmitValue(value); }

            
                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                StringStream& operator<<(std::string_view value) { return EmitValue(value); }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                StringStream& operator<<(const void* value) { return EmitValue(value); }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                template <typename T>

            
                    requires(std::is_floating_point_v<std::decay_t<T>>)

            
                StringStream& operator<<(T&& value) {

            
                    return EmitFloat(std::forward<T>(value));

            
                }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                template <typename T>

            
                StringStream& EmitValue(T&& value) {

            
                    sstream_ << std::forward<T>(value);

            
                    return *this;

            
                }


                /// Emit `value` to the stream

            
                /// @param value the value to emit

            
                /// @returns a reference to this

            
                template <typename T>

            
                StringStream& EmitFloat(const T& value) {

            
                    // Try printing the float in fixed point, with a smallish limit on the precision

            
                    std::stringstream fixed;

            
                    fixed.flags(fixed.flags() | std::ios_base::showpoint | std::ios_base::fixed);

            
                    fixed.imbue(std::locale::classic());

            
                    fixed.precision(20);

            
                    fixed << value;


                    std::string str = fixed.str();


                    // If this string can be parsed without loss of information, use it.

            
                    // (Use double here to dodge a bug in older libc++ versions which would incorrectly read

            
                    // back FLT_MAX as INF.)

            
                    double roundtripped;

            
                    fixed >> roundtripped;


                    // Strip trailing zeros from the number.

            
                    auto float_equal_no_warning = std::equal_to<T>();

            
                    if (float_equal_no_warning(value, static_cast<T>(roundtripped))) {

            
                        while (str.length() >= 2 && str[str.size() - 1] == '0' && str[str.size() - 2] != '.') {

            
                            str.pop_back();

            
                        }


                        // Allow numbers up to 45 characters to be printed in fixed-point.

            
                        // This is large enough to allow float::max() (which requires 42 characters: sign, 39

            
                        // digits, '.', and '0') to be printed in fixed-point notation, but prevents excessively

            
                        // long double values (which can be up to 309 characters) from polluting outputs and

            
                        // error messages.

            
                        if (str.size() < 45) {

            
                            sstream_ << str;

            
                            return *this;

            
                        }

            
                    }


                    // Resort to scientific, with the minimum precision needed to preserve the whole float

            
                    std::stringstream sci;

            
                    sci.imbue(std::locale::classic());

            
                    sci.precision(std::numeric_limits<T>::max_digits10);

            
                    sci << value;

            
                    sstream_ << sci.str();


                    return *this;

            
                }


                /// Swaps streams

            
                /// @param other stream to swap to

            
                void swap(StringStream& other) { sstream_.swap(other.sstream_); }


                /// repeat queues the character c to be written to the printer n times.

            
                /// @param c the character to print `n` times

            
                /// @param n the number of times to print character `c`

            
                void repeat(char c, size_t n) { std::fill_n(std::ostream_iterator<char>(sstream_), n, c); }


                /// The callback to emit a `endl` to the stream

            
                using StdEndl = std::ostream& (*)(std::ostream&);


                /// @param manipulator the callback to emit to

            
                /// @returns a reference to this

            
                StringStream& operator<<(StdEndl manipulator) {

            
                    // call the function, and return its value

            
                    manipulator(sstream_);

            
                    return *this;

            
                }


                /// @param manipulator the callback to emit to

            
                /// @returns a reference to this

            
                StringStream& operator<<(decltype(std::hex) manipulator) {

            
                    // call the function, and return its value

            
                    manipulator(sstream_);

            
                    return *this;

            
                }


                /// @param value the value to emit

            
                /// @returns a reference to this

            
                template <typename T>

            
                    requires(IsSetType<T>)

            
                StringStream& operator<<(T&& value) {

            
                    // call the function, and return its value

            
                    sstream_ << std::forward<T>(value);

            
                    return *this;

            
                }


                /// @returns the number of UTF-8 code units (bytes) have been written to the string.

            
                size_t Length() { return static_cast<size_t>(sstream_.tellp()); }


                /// @returns the string contents of the stream

            
                std::string str() const { return sstream_.str(); }


              private:

            
                void Reset();

            
                std::stringstream sstream_;

            
            };


            /// Writes the CodePoint to the stream.

            
            /// @param out the stream to write to

            
            /// @param codepoint the CodePoint to write

            
            /// @returns out so calls can be chained

            
            StringStream& operator<<(StringStream& out, CodePoint codepoint);


            }  // namespace tint


            #endif  // SRC_TINT_UTILS_TEXT_STRING_STREAM_H_
	// Copyright 2023 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#ifndef SRC_TINT_UTILS_TEXT_STRING_STREAM_H_
	#define SRC_TINT_UTILS_TEXT_STRING_STREAM_H_

	#include <algorithm>
	#include <functional>
	#include <iomanip>
	#include <iterator>
	#include <limits>
	#include <sstream>
	#include <string>
	#include <type_traits>
	#include <utility>

	#include "src/tint/utils/text/unicode.h"

	namespace tint {

	/// Stringstream wrapper which automatically resets the locale and sets floating point emission
	/// settings needed for Tint.
	class StringStream {
	using SetWRetTy = decltype(std::setw(std::declval<int>()));
	using SetPrecisionRetTy = decltype(std::setprecision(std::declval<int>()));
	using SetFillRetTy = decltype(std::setfill(std::declval<char>()));

	/// Evaluates to true if `T` is the return type of std::setw, std:setprecision or std::setfill.
	template <typename T>
	static constexpr bool IsSetType = std::is_same_v<SetWRetTy, std::decay_t<T>> \|\|
	std::is_same_v<SetPrecisionRetTy, std::decay_t<T>> \|\|
	std::is_same_v<SetFillRetTy, std::decay_t<T>>;

	public:
	/// Constructor
	StringStream();
	/// Copy constructor
	StringStream(const StringStream&);
	/// Destructor
	~StringStream();

	/// Copy assignment operator
	StringStream& operator=(const StringStream&);

	/// @returns the format flags for the stream
	std::ios_base::fmtflags flags() const { return sstream_.flags(); }

	/// @param flags the flags to set
	/// @returns the original format flags
	std::ios_base::fmtflags flags(std::ios_base::fmtflags flags) { return sstream_.flags(flags); }

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	template <typename T>
	requires(std::is_integral_v<std::decay_t<T>>)
	StringStream& operator<<(T&& value) {
	return EmitValue(std::forward<T>(value));
	}

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	StringStream& operator<<(const char* value) { return EmitValue(value); }
	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	StringStream& operator<<(const std::string& value) { return EmitValue(value); }
	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	StringStream& operator<<(std::string_view value) { return EmitValue(value); }

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	StringStream& operator<<(const void* value) { return EmitValue(value); }

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	template <typename T>
	requires(std::is_floating_point_v<std::decay_t<T>>)
	StringStream& operator<<(T&& value) {
	return EmitFloat(std::forward<T>(value));
	}

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	template <typename T>
	StringStream& EmitValue(T&& value) {
	sstream_ << std::forward<T>(value);
	return *this;
	}

	/// Emit `value` to the stream
	/// @param value the value to emit
	/// @returns a reference to this
	template <typename T>
	StringStream& EmitFloat(const T& value) {
	// Try printing the float in fixed point, with a smallish limit on the precision
	std::stringstream fixed;
	fixed.flags(fixed.flags() \| std::ios_base::showpoint \| std::ios_base::fixed);
	fixed.imbue(std::locale::classic());
	fixed.precision(20);
	fixed << value;

	std::string str = fixed.str();

	// If this string can be parsed without loss of information, use it.
	// (Use double here to dodge a bug in older libc++ versions which would incorrectly read
	// back FLT_MAX as INF.)
	double roundtripped;
	fixed >> roundtripped;

	// Strip trailing zeros from the number.
	auto float_equal_no_warning = std::equal_to<T>();
	if (float_equal_no_warning(value, static_cast<T>(roundtripped))) {
	while (str.length() >= 2 && str[str.size() - 1] == '0' && str[str.size() - 2] != '.') {
	str.pop_back();
	}

	// Allow numbers up to 45 characters to be printed in fixed-point.
	// This is large enough to allow float::max() (which requires 42 characters: sign, 39
	// digits, '.', and '0') to be printed in fixed-point notation, but prevents excessively
	// long double values (which can be up to 309 characters) from polluting outputs and
	// error messages.
	if (str.size() < 45) {
	sstream_ << str;
	return *this;
	}
	}

	// Resort to scientific, with the minimum precision needed to preserve the whole float
	std::stringstream sci;
	sci.imbue(std::locale::classic());
	sci.precision(std::numeric_limits<T>::max_digits10);
	sci << value;
	sstream_ << sci.str();

	return *this;
	}

	/// Swaps streams
	/// @param other stream to swap to
	void swap(StringStream& other) { sstream_.swap(other.sstream_); }

	/// repeat queues the character c to be written to the printer n times.
	/// @param c the character to print `n` times
	/// @param n the number of times to print character `c`
	void repeat(char c, size_t n) { std::fill_n(std::ostream_iterator<char>(sstream_), n, c); }

	/// The callback to emit a `endl` to the stream
	using StdEndl = std::ostream& (*)(std::ostream&);

	/// @param manipulator the callback to emit to
	/// @returns a reference to this
	StringStream& operator<<(StdEndl manipulator) {
	// call the function, and return its value
	manipulator(sstream_);
	return *this;
	}

	/// @param manipulator the callback to emit to
	/// @returns a reference to this
	StringStream& operator<<(decltype(std::hex) manipulator) {
	// call the function, and return its value
	manipulator(sstream_);
	return *this;
	}

	/// @param value the value to emit
	/// @returns a reference to this
	template <typename T>
	requires(IsSetType<T>)
	StringStream& operator<<(T&& value) {
	// call the function, and return its value
	sstream_ << std::forward<T>(value);
	return *this;
	}

	/// @returns the number of UTF-8 code units (bytes) have been written to the string.
	size_t Length() { return static_cast<size_t>(sstream_.tellp()); }

	/// @returns the string contents of the stream
	std::string str() const { return sstream_.str(); }

	private:
	void Reset();
	std::stringstream sstream_;
	};

	/// Writes the CodePoint to the stream.
	/// @param out the stream to write to
	/// @param codepoint the CodePoint to write
	/// @returns out so calls can be chained
	StringStream& operator<<(StringStream& out, CodePoint codepoint);

	} // namespace tint

	#endif // SRC_TINT_UTILS_TEXT_STRING_STREAM_H_