xml_buffered_writer Class Reference

Public Types
enum	{ bufcapacitybytes , bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4) }

Public Member Functions
	xml_buffered_writer (xml_writer &writer_, xml_encoding user_encoding)
size_t	flush ()
void	flush (const char_t *data, size_t size)
void	write_direct (const char_t *data, size_t length)
void	write_buffer (const char_t *data, size_t length)
void	write_string (const char_t *data)
void	write (char_t d0)
void	write (char_t d0, char_t d1)
void	write (char_t d0, char_t d1, char_t d2)
void	write (char_t d0, char_t d1, char_t d2, char_t d3)
void	write (char_t d0, char_t d1, char_t d2, char_t d3, char_t d4)
void	write (char_t d0, char_t d1, char_t d2, char_t d3, char_t d4, char_t d5)

Public Attributes
char_t	buffer [bufcapacity]
union {
uint8_t   data_u8 [4 *bufcapacity]
uint16_t   data_u16 [2 *bufcapacity]
uint32_t   data_u32 [bufcapacity]
char_t   data_char [bufcapacity]
}	scratch
xml_writer &	writer
size_t	bufsize
xml_encoding	encoding

Detailed Description

Definition at line 3709 of file pugixml.cc.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
bufcapacitybytes
bufcapacity

Definition at line 3896 of file pugixml.cc.

        {
            bufcapacitybytes =
            #ifdef PUGIXML_MEMORY_OUTPUT_STACK
                PUGIXML_MEMORY_OUTPUT_STACK
            #else
                10240
            #endif
            ,
            bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
        };

Constructor & Destructor Documentation

xml_buffered_writer()

xml_buffered_writer::xml_buffered_writer ( xml_writer & writer_, xml_encoding user_encoding )

inline

Definition at line 3715 of file pugixml.cc.

                                                                            : writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
        {
            PUGI__STATIC_ASSERT(bufcapacity >= 8);
        }

Member Function Documentation

flush() [1/2]

size_t xml_buffered_writer::flush ( )

inline

Definition at line 3720 of file pugixml.cc.

        {
            flush(buffer, bufsize);
            bufsize = 0;
            return 0;
        }

Referenced by flush(), write(), write(), write(), write(), write(), write(), and write_direct().

flush() [2/2]

void xml_buffered_writer::flush ( const char_t * data, size_t size )

inline

Definition at line 3727 of file pugixml.cc.

        {
            if (size == 0) return;
 
            // fast path, just write data
            if (encoding == get_write_native_encoding())
                writer.write(data, size * sizeof(char_t));
            else
            {
                // convert chunk
                size_t result = convert_buffer_output(scratch.data_char, scratch.data_u8, scratch.data_u16, scratch.data_u32, data, size, encoding);
                assert(result <= sizeof(scratch));
 
                // write data
                writer.write(scratch.data_u8, result);
            }
        }

write() [1/6]

void xml_buffered_writer::write ( char_t d0 )

inline

Definition at line 3824 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 1) offset = flush();
 
            buffer[offset + 0] = d0;
            bufsize = offset + 1;
        }

write() [2/6]

void xml_buffered_writer::write ( char_t d0, char_t d1 )

inline

Definition at line 3833 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 2) offset = flush();
 
            buffer[offset + 0] = d0;
            buffer[offset + 1] = d1;
            bufsize = offset + 2;
        }

write() [3/6]

void xml_buffered_writer::write ( char_t d0, char_t d1, char_t d2 )

inline

Definition at line 3843 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 3) offset = flush();
 
            buffer[offset + 0] = d0;
            buffer[offset + 1] = d1;
            buffer[offset + 2] = d2;
            bufsize = offset + 3;
        }

write() [4/6]

void xml_buffered_writer::write ( char_t d0, char_t d1, char_t d2, char_t d3 )

inline

Definition at line 3854 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 4) offset = flush();
 
            buffer[offset + 0] = d0;
            buffer[offset + 1] = d1;
            buffer[offset + 2] = d2;
            buffer[offset + 3] = d3;
            bufsize = offset + 4;
        }

write() [5/6]

void xml_buffered_writer::write ( char_t d0, char_t d1, char_t d2, char_t d3, char_t d4 )

inline

Definition at line 3866 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 5) offset = flush();
 
            buffer[offset + 0] = d0;
            buffer[offset + 1] = d1;
            buffer[offset + 2] = d2;
            buffer[offset + 3] = d3;
            buffer[offset + 4] = d4;
            bufsize = offset + 5;
        }

write() [6/6]

void xml_buffered_writer::write ( char_t d0, char_t d1, char_t d2, char_t d3, char_t d4, char_t d5 )

inline

Definition at line 3879 of file pugixml.cc.

        {
            size_t offset = bufsize;
            if (offset > bufcapacity - 6) offset = flush();
 
            buffer[offset + 0] = d0;
            buffer[offset + 1] = d1;
            buffer[offset + 2] = d2;
            buffer[offset + 3] = d3;
            buffer[offset + 4] = d4;
            buffer[offset + 5] = d5;
            bufsize = offset + 6;
        }

write_buffer()

void xml_buffered_writer::write_buffer ( const char_t * data, size_t length )

inline

Definition at line 3784 of file pugixml.cc.

        {
            size_t offset = bufsize;
 
            if (offset + length <= bufcapacity)
            {
                memcpy(buffer + offset, data, length * sizeof(char_t));
                bufsize = offset + length;
            }
            else
            {
                write_direct(data, length);
            }
        }

write_direct()

void xml_buffered_writer::write_direct ( const char_t * data, size_t length )

inline

Definition at line 3745 of file pugixml.cc.

        {
            // flush the remaining buffer contents
            flush();
 
            // handle large chunks
            if (length > bufcapacity)
            {
                if (encoding == get_write_native_encoding())
                {
                    // fast path, can just write data chunk
                    writer.write(data, length * sizeof(char_t));
                    return;
                }
 
                // need to convert in suitable chunks
                while (length > bufcapacity)
                {
                    // get chunk size by selecting such number of characters that are guaranteed to fit into scratch buffer
                    // and form a complete codepoint sequence (i.e. discard start of last codepoint if necessary)
                    size_t chunk_size = get_valid_length(data, bufcapacity);
                    assert(chunk_size);
 
                    // convert chunk and write
                    flush(data, chunk_size);
 
                    // iterate
                    data += chunk_size;
                    length -= chunk_size;
                }
 
                // small tail is copied below
                bufsize = 0;
            }
 
            memcpy(buffer + bufsize, data, length * sizeof(char_t));
            bufsize += length;
        }

Referenced by write_buffer(), and write_string().

write_string()

void xml_buffered_writer::write_string ( const char_t * data )

inline

Definition at line 3799 of file pugixml.cc.

        {
            // write the part of the string that fits in the buffer
            size_t offset = bufsize;
 
            while (*data && offset < bufcapacity)
                buffer[offset++] = *data++;
 
            // write the rest
            if (offset < bufcapacity)
            {
                bufsize = offset;
            }
            else
            {
                // backtrack a bit if we have split the codepoint
                size_t length = offset - bufsize;
                size_t extra = length - get_valid_length(data - length, length);
 
                bufsize = offset - extra;
 
                write_direct(data - extra, strlength(data) + extra);
            }
        }

Member Data Documentation

buffer

char_t xml_buffered_writer::buffer[bufcapacity]

Definition at line 3908 of file pugixml.cc.

Referenced by flush(), write(), write(), write(), write(), write(), write(), write_buffer(), write_direct(), and write_string().

bufsize

size_t xml_buffered_writer::bufsize

Definition at line 3919 of file pugixml.cc.

Referenced by flush(), write(), write(), write(), write(), write(), write(), write_buffer(), write_direct(), write_string(), and xml_buffered_writer().

data_char

char_t xml_buffered_writer::data_char[bufcapacity]

Definition at line 3915 of file pugixml.cc.

data_u16

uint16_t xml_buffered_writer::data_u16[2 *bufcapacity]

Definition at line 3913 of file pugixml.cc.

data_u32

uint32_t xml_buffered_writer::data_u32[bufcapacity]

Definition at line 3914 of file pugixml.cc.

data_u8

uint8_t xml_buffered_writer::data_u8[4 *bufcapacity]

Definition at line 3912 of file pugixml.cc.

encoding

xml_encoding xml_buffered_writer::encoding

Definition at line 3920 of file pugixml.cc.

Referenced by flush(), write_direct(), and xml_buffered_writer().

[union]

union { ... } xml_buffered_writer::scratch

Referenced by flush().

writer

xml_writer& xml_buffered_writer::writer

Definition at line 3918 of file pugixml.cc.

Referenced by flush(), write_direct(), and xml_buffered_writer().

---

The documentation for this class was generated from the following file:

• pugixml.cc