#include <corecrt_internal_stdio_output.h>

Collaboration diagram for __crt_stdio_output::string_output_adapter< Character >:

Public Types
typedef __acrt_stdio_char_traits< Character >	char_traits

typedef string_output_adapter_context< Character >	context_type

Public Member Functions
	string_output_adapter (context_type *const context) throw ()

bool	validate (__crt_cached_ptd_host &ptd) const throw ()

__forceinline bool	write_character (Character const c, int *const count_written, __crt_cached_ptd_host &) const throw ()

void	write_string (Character const const string, int const length, int const count_written, __crt_cached_ptd_host &ptd) const throw ()

Private Attributes
context_type *	_context

Detailed Description

template<typename Character>
class __crt_stdio_output::string_output_adapter< Character >

Definition at line 227 of file corecrt_internal_stdio_output.h.

Member Typedef Documentation

◆ char_traits

template<typename Character >

typedef __acrt_stdio_char_traits<Character> __crt_stdio_output::string_output_adapter< Character >::char_traits

Definition at line 231 of file corecrt_internal_stdio_output.h.

◆ context_type

template<typename Character >

typedef string_output_adapter_context<Character> __crt_stdio_output::string_output_adapter< Character >::context_type

Definition at line 232 of file corecrt_internal_stdio_output.h.

Constructor & Destructor Documentation

◆ string_output_adapter()

template<typename Character >

__crt_stdio_output::string_output_adapter< Character >::string_output_adapter	(	context_type *const	context	)
throw	(
	)

inline

Definition at line 234 of file corecrt_internal_stdio_output.h.

        : _context(context)
    {
    }

Member Function Documentation

◆ validate()

template<typename Character >

bool __crt_stdio_output::string_output_adapter< Character >::validate	(	__crt_cached_ptd_host &	ptd	)	const
throw	(
	)

inline

Definition at line 239 of file corecrt_internal_stdio_output.h.

    {
        _UCRT_VALIDATE_RETURN(ptd, _context != nullptr, EINVAL, false);
        return true;
    }

◆ write_character()

template<typename Character >

__forceinline bool __crt_stdio_output::string_output_adapter< Character >::write_character	(	Character const	c,
		int *const	count_written,
		__crt_cached_ptd_host &
	)		const
throw	(
	)

inline

Definition at line 245 of file corecrt_internal_stdio_output.h.

    {
        if (_context->_buffer_used == _context->_buffer_count)
        {
            if (_context->_continue_count)
            {
                ++*count_written;
            }
            else
            {
                *count_written = -1;
            }
 
            return _context->_continue_count;
        }
 
        ++*count_written;
        ++_context->_buffer_used;
        *_context->_buffer++ = c;
        return true;
    }

◆ write_string()

template<typename Character >

void __crt_stdio_output::string_output_adapter< Character >::write_string	(	Character const *const	string,
		int const	length,
		int *const	count_written,
		__crt_cached_ptd_host &	ptd
	)		const
throw	(
	)

inline

Definition at line 267 of file corecrt_internal_stdio_output.h.

    {
        // This function does not perform any operations that might reset errno,
        // so we don't need to use __crt_errno_guard as we do in other output
        // adapters.
        UNREFERENCED_PARAMETER(ptd);
 
        if (length == 0)
        {
            return;
        }
 
        if (_context->_buffer_used == _context->_buffer_count)
        {
            if (_context->_continue_count)
            {
                *count_written += length;
            }
            else
            {
                *count_written = -1;
            }
 
            return;
        }
 
        size_t const space_available  = _context->_buffer_count - _context->_buffer_used;
        size_t const elements_to_copy = __min(space_available, static_cast<size_t>(length));
 
        // Performance note:  This is hot code.  Profiling has shown the extra
        // validation done by memcpy_s to be quite expensive.  The validation is
        // unnecessary, so we call memcpy directly here:
        memcpy(
            _context->_buffer,
            string,
            elements_to_copy * sizeof(Character));
 
        _context->_buffer      += elements_to_copy;
        _context->_buffer_used += elements_to_copy;
 
        if (_context->_continue_count)
        {
            *count_written += length;
        }
        else if (elements_to_copy != static_cast<size_t>(length))
        {
            *count_written = -1;
        }
        else
        {
            *count_written += static_cast<int>(elements_to_copy);
        }
    }