worldspawn/libs/stream/textstream.h

476 lines
12 KiB
C
Raw Normal View History

2020-11-17 11:16:16 +00:00
/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.
This file is part of GtkRadiant.
GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#if !defined( INCLUDED_STREAM_TEXTSTREAM_H )
#define INCLUDED_STREAM_TEXTSTREAM_H
#include "globaldefs.h"
/// \file
/// \brief Text-output-formatting.
#include "itextstream.h"
#include "string/string.h"
#include <cctype>
#include <cstddef>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <string>
#include "generic/arrayrange.h"
namespace TextOutputDetail
{
inline char* write_unsigned_nonzero_decimal_backward( char* ptr, unsigned int decimal ){
for (; decimal != 0; decimal /= 10 )
{
*--ptr = char('0' + int(decimal % 10) );
}
return ptr;
}
#if GDEF_ARCH_BITS_64
inline char* write_size_t_nonzero_decimal_backward( char* ptr, size_t decimal ){
for (; decimal != 0; decimal /= 10 )
{
*--ptr = char('0' + (size_t)( decimal % 10 ) );
}
return ptr;
}
#endif
inline char* write_signed_nonzero_decimal_backward( char* ptr, int decimal, bool show_positive ){
const bool negative = decimal < 0 ;
ptr = write_unsigned_nonzero_decimal_backward( ptr, negative ? -decimal : decimal );
if ( negative ) {
*--ptr = '-';
}
else if ( show_positive ) {
*--ptr = '+';
}
return ptr;
}
inline char* write_unsigned_nonzero_decimal_backward( char* ptr, unsigned int decimal, bool show_positive ){
ptr = write_unsigned_nonzero_decimal_backward( ptr, decimal );
if ( show_positive ) {
*--ptr = '+';
}
return ptr;
}
#if GDEF_ARCH_BITS_64
inline char* write_size_t_nonzero_decimal_backward( char* ptr, size_t decimal, bool show_positive ){
ptr = write_size_t_nonzero_decimal_backward( ptr, decimal );
if ( show_positive ) {
*--ptr = '+';
}
return ptr;
}
#endif
inline char* write_signed_decimal_backward( char* ptr, int decimal, bool show_positive ){
if ( decimal == 0 ) {
*--ptr = '0';
}
else
{
ptr = write_signed_nonzero_decimal_backward( ptr, decimal, show_positive );
}
return ptr;
}
inline char* write_unsigned_decimal_backward( char* ptr, unsigned int decimal, bool show_positive ){
if ( decimal == 0 ) {
*--ptr = '0';
}
else
{
ptr = write_unsigned_nonzero_decimal_backward( ptr, decimal, show_positive );
}
return ptr;
}
#if GDEF_ARCH_BITS_64
inline char* write_size_t_decimal_backward( char* ptr, size_t decimal, bool show_positive ){
if ( decimal == 0 ) {
*--ptr = '0';
}
else
{
ptr = write_size_t_nonzero_decimal_backward( ptr, decimal, show_positive );
}
return ptr;
}
#endif
}
#if GDEF_OS_WINDOWS
#define snprintf _snprintf
#endif
/// \brief Writes a single character \p c to \p ostream.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, char c ){
ostream.write( &c, 1 );
return ostream;
}
/// \brief Writes a double-precision floating point value \p d to \p ostream.
/// The value will be formatted either as decimal with trailing zeros removed, or with scientific 'e' notation, whichever is shorter.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const double d ){
const std::size_t bufferSize = 16;
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%g", d ) );
return ostream;
}
/// \brief Writes a single-precision floating point value \p f to \p ostream.
/// The value will be formatted either as decimal with trailing zeros removed, or with scientific 'e' notation, whichever is shorter.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const float f ){
return ostream_write( ostream, static_cast<double>( f ) );
}
/// \brief Writes a signed integer \p i to \p ostream in decimal form.
/// A '-' sign will be added if the value is negative.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const int i ){
const std::size_t bufferSize = 16;
#if 1
char buf[bufferSize];
char* begin = TextOutputDetail::write_signed_decimal_backward( buf + bufferSize, i, false );
ostream.write( begin, ( buf + bufferSize ) - begin );
#else
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%i", i ) );
#endif
return ostream;
}
typedef unsigned int Unsigned;
/// \brief Writes an unsigned integer \p i to \p ostream in decimal form.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const Unsigned i ){
const std::size_t bufferSize = 16;
#if 1
char buf[bufferSize];
char* begin = TextOutputDetail::write_unsigned_decimal_backward( buf + bufferSize, i, false );
ostream.write( begin, ( buf + bufferSize ) - begin );
#else
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%u", i ) );
#endif
return ostream;
}
#if GDEF_ARCH_BITS_64
/// \brief Writes a size_t \p i to \p ostream in decimal form.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const size_t i ){
// max is 18446744073709551615, buffer of 32 chars should always be enough
const std::size_t bufferSize = 32;
#if 1
char buf[bufferSize];
char* begin = TextOutputDetail::write_size_t_decimal_backward( buf + bufferSize, i, false );
ostream.write( begin, ( buf + bufferSize ) - begin );
#else
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%u", i ) );
#endif
return ostream;
}
#endif
/// \brief Writes a null-terminated \p string to \p ostream.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const char* string ){
ostream.write( string, strlen( string ) );
return ostream;
}
class HexChar
{
public:
char m_value;
HexChar( char value ) : m_value( value ){
}
};
/// \brief Writes a single character \p c to \p ostream in hexadecimal form.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const HexChar& c ){
const std::size_t bufferSize = 16;
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%X", c.m_value & 0xFF ) );
return ostream;
}
class FloatFormat
{
public:
double m_f;
int m_width;
int m_precision;
FloatFormat( double f, int width, int precision )
: m_f( f ), m_width( width ), m_precision( precision ){
}
};
/// \brief Writes a floating point value to \p ostream with a specific width and precision.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const FloatFormat& formatted ){
const std::size_t bufferSize = 32;
char buf[bufferSize];
ostream.write( buf, snprintf( buf, bufferSize, "%*.*lf", formatted.m_width, formatted.m_precision, formatted.m_f ) );
return ostream;
}
// never displays exponent, prints up to 10 decimal places
class Decimal
{
public:
double m_f;
Decimal( double f ) : m_f( f ){
}
};
/// \brief Writes a floating point value to \p ostream in decimal form with trailing zeros removed.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const Decimal& decimal ){
const int bufferSize = 22;
char buf[bufferSize];
std::size_t length = snprintf( buf, bufferSize, "%10.10lf", decimal.m_f );
const char* first = buf;
for (; *first == ' '; ++first )
{
}
const char* last = buf + length - 1;
for (; *last == '0'; --last )
{
}
if ( *last == '.' ) {
--last;
}
ostream.write( first, last - first + 1 );
return ostream;
}
/// \brief Writes a \p range of characters to \p ostream.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const StringRange& range ){
ostream.write( range.first, range.last - range.first );
return ostream;
}
template<typename Type>
class Quoted
{
public:
const Type& m_type;
Quoted( const Type& type )
: m_type( type ){
}
};
template<typename Type>
inline Quoted<Type> makeQuoted( const Type& type ){
return Quoted<Type>( type );
}
/// \brief Writes any type to \p ostream with a quotation mark character before and after it.
template<typename TextOutputStreamType, typename Type>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const Quoted<Type>& quoted ){
return ostream << '"' << quoted.m_type << '"';
}
class LowerCase
{
public:
const char* m_string;
LowerCase( const char* string ) : m_string( string ){
}
};
/// \brief Writes a string to \p ostream converted to lower-case.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const LowerCase& lower ){
for ( const char* p = lower.m_string; *p != '\0'; ++p )
{
ostream << static_cast<char>( std::tolower( *p ) );
}
return ostream;
}
/// \brief A wrapper for a TextInputStream optimised for reading a single character at a time.
template<typename TextInputStreamType, int SIZE = 1024>
class SingleCharacterInputStream
{
TextInputStreamType& m_inputStream;
char m_buffer[SIZE];
char* m_cur;
char* m_end;
bool fillBuffer(){
m_end = m_buffer + m_inputStream.read( m_buffer, SIZE );
m_cur = m_buffer;
return m_cur != m_end;
}
public:
SingleCharacterInputStream( TextInputStreamType& inputStream ) : m_inputStream( inputStream ), m_cur( m_buffer ), m_end( m_buffer ){
}
bool readChar( char& c ){
if ( m_cur == m_end && !fillBuffer() ) {
return false;
}
c = *m_cur++;
return true;
}
};
/// \brief A wrapper for a TextOutputStream, optimised for writing a single character at a time.
class SingleCharacterOutputStream : public TextOutputStream
{
enum unnamed0 { m_bufsize = 1024 };
TextOutputStream& m_ostream;
char m_buffer[m_bufsize];
char* m_pos;
const char* m_end;
const char* end() const {
return m_end;
}
void reset(){
m_pos = m_buffer;
}
void flush(){
m_ostream.write( m_buffer, m_pos - m_buffer );
reset();
}
public:
SingleCharacterOutputStream( TextOutputStream& ostream ) : m_ostream( ostream ), m_pos( m_buffer ), m_end( m_buffer + m_bufsize ){
}
~SingleCharacterOutputStream(){
flush();
}
void write( const char c ){
if ( m_pos == end() ) {
flush();
}
*m_pos++ = c;
}
std::size_t write( const char* buffer, std::size_t length ){
const char*const end = buffer + length;
for ( const char* p = buffer; p != end; ++p )
{
write( *p );
}
return length;
}
};
/// \brief A wrapper for a TextInputStream used for reading one text line at a time.
template<typename TextInputStreamType, int SIZE = 1024>
class TextLinesInputStream
{
TextInputStreamType& m_inputStream;
char m_buffer[SIZE + 1];
char* m_cur;
char* m_end;
int fillBuffer(){
m_end = m_buffer + m_inputStream.read( m_buffer, SIZE );
m_cur = m_buffer;
m_buffer[SIZE] = '\0';
*m_end = '\0';
return m_end - m_cur;
}
public:
TextLinesInputStream( TextInputStreamType& inputStream ) : m_inputStream( inputStream ), m_cur( m_buffer ), m_end( m_buffer ){
m_buffer[0] = '\0';
}
CopiedString readLine(){
std::string s;
char* m_fin;
while ( (m_fin = strchr( m_cur, '\n' )) == 0 )
{
s.append( m_cur, m_end - m_cur );
if ( fillBuffer() <= 0 ) break;
}
if ( m_fin != 0 ) {
s.append( m_cur, m_fin - m_cur + 1 );
m_cur = m_fin + 1;
}
return CopiedString( s.c_str() );
}
};
/// \brief A wrapper for a TextOutputStream, optimised for writing a few characters at a time.
template<typename TextOutputStreamType, int SIZE = 1024>
class BufferedTextOutputStream : public TextOutputStream
{
TextOutputStreamType outputStream;
char m_buffer[SIZE];
char* m_cur;
public:
BufferedTextOutputStream( TextOutputStreamType& outputStream ) : outputStream( outputStream ), m_cur( m_buffer ){
}
~BufferedTextOutputStream(){
outputStream.write( m_buffer, m_cur - m_buffer );
}
std::size_t write( const char* buffer, std::size_t length ){
std::size_t remaining = length;
for (;; )
{
std::size_t n = std::min( remaining, std::size_t( ( m_buffer + SIZE ) - m_cur ) );
m_cur = std::copy( buffer, buffer + n, m_cur );
remaining -= n;
if ( remaining == 0 ) {
return 0;
}
outputStream.write( m_buffer, SIZE );
m_cur = m_buffer;
}
}
};
#endif