C++ Rest SDK
The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to and interact with services.
Public Types | Public Member Functions | Protected Member Functions | Friends | List of all members
Concurrency::streams::details::basic_rawptr_buffer< _CharType > Class Template Reference

The basic_rawptr_buffer class serves as a memory-based steam buffer that supports both writing and reading sequences of characters to and from a fixed-size block. More...

#include <rawptrstream.h>

Inheritance diagram for Concurrency::streams::details::basic_rawptr_buffer< _CharType >:
Concurrency::streams::details::streambuf_state_manager< _CharType > Concurrency::streams::details::basic_streambuf< _CharType >

Public Types

typedef _CharType char_type
 
typedef basic_streambuf< _CharType >::traits traits
 
typedef basic_streambuf< _CharType >::int_type int_type
 
typedef basic_streambuf< _CharType >::pos_type pos_type
 
typedef basic_streambuf< _CharType >::off_type off_type
 
- Public Types inherited from Concurrency::streams::details::streambuf_state_manager< _CharType >
typedef details::basic_streambuf< _CharType >::traits traits
 
typedef details::basic_streambuf< _CharType >::int_type int_type
 
typedef details::basic_streambuf< _CharType >::pos_type pos_type
 
typedef details::basic_streambuf< _CharType >::off_type off_type
 
- Public Types inherited from Concurrency::streams::details::basic_streambuf< _CharType >
typedef _CharType char_type
 
typedef ::concurrency::streams::char_traits< _CharType > traits
 
typedef traits::int_type int_type
 
typedef traits::pos_type pos_type
 
typedef traits::off_type off_type
 

Public Member Functions

 basic_rawptr_buffer ()
 Constructor More...
 
virtual ~basic_rawptr_buffer ()
 Destructor More...
 
- Public Member Functions inherited from Concurrency::streams::details::streambuf_state_manager< _CharType >
virtual bool can_read () const
 can_read is used to determine whether a stream buffer will support read operations (get). More...
 
virtual bool can_write () const
 can_write is used to determine whether a stream buffer will support write operations (put). More...
 
virtual bool is_open () const
 Checks if the stream buffer is open. More...
 
virtual pplx::task< void > close (std::ios_base::openmode mode, std::exception_ptr eptr)
 Closes the stream buffer with an exception. More...
 
virtual bool is_eof () const
 is_eof is used to determine whether a read head has reached the end of the buffer. More...
 
virtual pplx::task< int_type > putc (_CharType ch)
 Writes a single character to the stream. More...
 
virtual pplx::task< size_t > putn (const _CharType *ptr, size_t count)
 Writes a number of characters to the stream. More...
 
virtual pplx::task< size_t > putn_nocopy (const _CharType *ptr, size_t count)
 Writes a number of characters to the stream. Note: callers must make sure the data to be written is valid until the returned task completes. More...
 
virtual pplx::task< int_type > bumpc ()
 Reads a single character from the stream and advances the read position. More...
 
virtual int_type sbumpc ()
 Reads a single character from the stream and advances the read position. More...
 
virtual pplx::task< int_type > getc ()
 Reads a single character from the stream without advancing the read position. More...
 
virtual int_type sgetc ()
 Reads a single character from the stream without advancing the read position. More...
 
virtual pplx::task< int_type > nextc ()
 Advances the read position, then returns the next character without advancing again. More...
 
virtual pplx::task< int_type > ungetc ()
 Retreats the read position, then returns the current character without advancing. More...
 
virtual pplx::task< size_t > getn (_Out_writes_(count) _CharType *ptr, _In_ size_t count)
 Reads up to a given number of characters from the stream. More...
 
virtual size_t scopy (_Out_writes_(count) _CharType *ptr, _In_ size_t count)
 Copies up to a given number of characters from the stream, synchronously. More...
 
virtual pplx::task< void > sync ()
 For output streams, flush any internally buffered data to the underlying medium. More...
 
virtual std::exception_ptr exception () const
 Retrieves the stream buffer exception_ptr if it has been set. More...
 
_CharType * alloc (size_t count)
 Allocates a contiguous memory block and returns it. More...
 
void commit (size_t count)
 Submits a block already allocated by the stream buffer. More...
 
virtual bool acquire (_Out_writes_(count) _CharType *&ptr, _In_ size_t &count)=0
 
virtual void release (_Out_writes_(count) _CharType *ptr, _In_ size_t count)=0
 Releases a block of data acquired using ::acquire method. This frees the stream buffer to de-allocate the memory, if it so desires. Move the read position ahead by the count. More...
 
- Public Member Functions inherited from Concurrency::streams::details::basic_streambuf< _CharType >
virtual ~basic_streambuf ()
 Virtual constructor for stream buffers. More...
 
virtual _CharType * alloc (_In_ size_t count)=0
 Allocates a contiguous memory block and returns it. More...
 
virtual void commit (_In_ size_t count)=0
 Submits a block already allocated by the stream buffer. More...
 

Protected Member Functions

virtual bool can_seek () const
 can_seek is used to determine whether a stream buffer supports seeking. More...
 
virtual bool has_size () const
 has_size is used to determine whether a stream buffer supports size(). More...
 
virtual utility::size64_t size () const
 Gets the size of the stream, if known. Calls to has_size will determine whether the result of size can be relied on. More...
 
virtual size_t buffer_size (std::ios_base::openmode=std::ios_base::in) const
 Get the stream buffer size, if one has been set. More...
 
virtual void set_buffer_size (size_t, std::ios_base::openmode=std::ios_base::in)
 Set the stream buffer implementation to buffer or not buffer. More...
 
virtual size_t in_avail () const
 For any input stream, in_avail returns the number of characters that are immediately available to be consumed without blocking. May be used in conjunction with <cref="::sbumpc method"/> and sgetn() to read data without incurring the overhead of using tasks. More...
 
virtual pplx::task< void > close (std::ios_base::openmode mode)
 Closes the stream buffer, preventing further read or write operations. More...
 
virtual pplx::task< bool > _sync ()
 
virtual pplx::task< int_type > _putc (_CharType ch)
 
virtual pplx::task< size_t > _putn (const _CharType *ptr, size_t count)
 
_CharType * _alloc (size_t count)
 Allocates a contiguous memory block and returns it. More...
 
void _commit (size_t actual)
 Submits a block already allocated by the stream buffer. More...
 
virtual bool acquire (_Out_ _CharType *&ptr, _Out_ size_t &count)
 Gets a pointer to the next already allocated contiguous block of data. More...
 
virtual void release (_Out_writes_opt_(count) _CharType *ptr, _In_ size_t count)
 Releases a block of data acquired using ::acquire method. This frees the stream buffer to de-allocate the memory, if it so desires. Move the read position ahead by the count. More...
 
virtual pplx::task< size_t > _getn (_Out_writes_(count) _CharType *ptr, _In_ size_t count)
 
size_t _sgetn (_Out_writes_(count) _CharType *ptr, _In_ size_t count)
 
virtual size_t _scopy (_Out_writes_(count) _CharType *ptr, _In_ size_t count)
 
virtual pplx::task< int_type > _bumpc ()
 
virtual int_type _sbumpc ()
 
virtual pplx::task< int_type > _getc ()
 
int_type _sgetc ()
 
virtual pplx::task< int_type > _nextc ()
 
virtual pplx::task< int_type > _ungetc ()
 
virtual pos_type getpos (std::ios_base::openmode mode) const
 Gets the current read or write position in the stream. More...
 
virtual pos_type seekpos (pos_type position, std::ios_base::openmode mode)
 Seeks to the given position. More...
 
virtual pos_type seekoff (off_type offset, std::ios_base::seekdir way, std::ios_base::openmode mode)
 Seeks to a position given by a relative offset. More...
 
- Protected Member Functions inherited from Concurrency::streams::details::streambuf_state_manager< _CharType >
virtual pplx::task< size_t > _putn (const _CharType *ptr, size_t count, bool)
 
virtual pplx::task< void > _close_read ()
 The real read head close operation, implementation should override it if there is any resource to be released. More...
 
virtual pplx::task< void > _close_write ()
 The real write head close operation, implementation should override it if there is any resource to be released. More...
 
 streambuf_state_manager (std::ios_base::openmode mode)
 

Friends

template<typename _CharType1 >
class ::concurrency::streams::rawptr_buffer
 

Additional Inherited Members

- Protected Attributes inherited from Concurrency::streams::details::streambuf_state_manager< _CharType >
std::exception_ptr m_currentException
 
bool m_stream_can_read
 
bool m_stream_can_write
 
bool m_stream_read_eof
 
bool m_alloced
 

Detailed Description

template<typename _CharType>
class Concurrency::streams::details::basic_rawptr_buffer< _CharType >

The basic_rawptr_buffer class serves as a memory-based steam buffer that supports both writing and reading sequences of characters to and from a fixed-size block.

Constructor & Destructor Documentation

template<typename _CharType >
Concurrency::streams::details::basic_rawptr_buffer< _CharType >::basic_rawptr_buffer ( )
inline

Constructor

template<typename _CharType >
virtual Concurrency::streams::details::basic_rawptr_buffer< _CharType >::~basic_rawptr_buffer ( )
inlinevirtual

Destructor

Member Function Documentation

template<typename _CharType >
_CharType* Concurrency::streams::details::basic_rawptr_buffer< _CharType >::_alloc ( size_t  count)
inlineprotectedvirtual

Allocates a contiguous memory block and returns it.

Parameters
countThe number of characters to allocate.
Returns
A pointer to a block to write to, null if the stream buffer implementation does not support alloc/commit.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
void Concurrency::streams::details::basic_rawptr_buffer< _CharType >::_commit ( size_t  actual)
inlineprotectedvirtual

Submits a block already allocated by the stream buffer.

Parameters
countThe number of characters to be committed.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual bool Concurrency::streams::details::basic_rawptr_buffer< _CharType >::acquire ( _Out_ _CharType *&  ptr,
_Out_ size_t &  count 
)
inlineprotectedvirtual

Gets a pointer to the next already allocated contiguous block of data.

Parameters
ptrA reference to a pointer variable that will hold the address of the block on success.
countThe number of contiguous characters available at the address in 'ptr.'
Returns
true if the operation succeeded, false otherwise.

A return of false does not necessarily indicate that a subsequent read operation would fail, only that there is no block to return immediately or that the stream buffer does not support the operation. The stream buffer may not de-allocate the block until ::release method is called. If the end of the stream is reached, the function will return true, a null pointer, and a count of zero; a subsequent read will not succeed.

Implements Concurrency::streams::details::basic_streambuf< _CharType >.

template<typename _CharType >
virtual size_t Concurrency::streams::details::basic_rawptr_buffer< _CharType >::buffer_size ( std::ios_base::openmode  = std::ios_base::in) const
inlineprotectedvirtual

Get the stream buffer size, if one has been set.

Parameters
directionThe direction of buffering (in or out)

An implementation that does not support buffering will always return '0'.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual bool Concurrency::streams::details::basic_rawptr_buffer< _CharType >::can_seek ( ) const
inlineprotectedvirtual

can_seek is used to determine whether a stream buffer supports seeking.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual pplx::task<void> Concurrency::streams::details::basic_rawptr_buffer< _CharType >::close ( std::ios_base::openmode  mode)
inlineprotectedvirtual

Closes the stream buffer, preventing further read or write operations.

Parameters
modeThe I/O mode (in or out) to close for.

Reimplemented from Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual pos_type Concurrency::streams::details::basic_rawptr_buffer< _CharType >::getpos ( std::ios_base::openmode  mode) const
inlineprotectedvirtual

Gets the current read or write position in the stream.

Parameters
directionThe I/O direction to seek (see remarks)
Returns
The current position. EOF if the operation fails.

Some streams may have separate write and read cursors. For such streams, the direction parameter defines whether to move the read or the write cursor.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual bool Concurrency::streams::details::basic_rawptr_buffer< _CharType >::has_size ( ) const
inlineprotectedvirtual

has_size is used to determine whether a stream buffer supports size().

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual size_t Concurrency::streams::details::basic_rawptr_buffer< _CharType >::in_avail ( ) const
inlineprotectedvirtual

For any input stream, in_avail returns the number of characters that are immediately available to be consumed without blocking. May be used in conjunction with <cref="::sbumpc method"/> and sgetn() to read data without incurring the overhead of using tasks.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual void Concurrency::streams::details::basic_rawptr_buffer< _CharType >::release ( _Out_writes_opt_(count) _CharType *  ptr,
_In_ size_t  count 
)
inlineprotectedvirtual

Releases a block of data acquired using ::acquire method. This frees the stream buffer to de-allocate the memory, if it so desires. Move the read position ahead by the count.

Parameters
ptrA pointer to the block of data to be released.
countThe number of characters that were read.
template<typename _CharType >
virtual pos_type Concurrency::streams::details::basic_rawptr_buffer< _CharType >::seekoff ( off_type  offset,
std::ios_base::seekdir  way,
std::ios_base::openmode  mode 
)
inlineprotectedvirtual

Seeks to a position given by a relative offset.

Parameters
offsetThe relative position to seek to
wayThe starting point (beginning, end, current) for the seek.
modeThe I/O direction to seek (see remarks)
Returns
The position. EOF if the operation fails.

Some streams may have separate write and read cursors. For such streams, the mode parameter defines whether to move the read or the write cursor.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual pos_type Concurrency::streams::details::basic_rawptr_buffer< _CharType >::seekpos ( pos_type  position,
std::ios_base::openmode  mode 
)
inlineprotectedvirtual

Seeks to the given position.

Parameters
posThe offset from the beginning of the stream.
directionThe I/O direction to seek (see remarks).
Returns
The position. EOF if the operation fails.

Some streams may have separate write and read cursors. For such streams, the direction parameter defines whether to move the read or the write cursor.

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual void Concurrency::streams::details::basic_rawptr_buffer< _CharType >::set_buffer_size ( size_t  ,
std::ios_base::openmode  = std::ios_base::in 
)
inlineprotectedvirtual

Set the stream buffer implementation to buffer or not buffer.

Parameters
sizeThe size to use for internal buffering, 0 if no buffering should be done.
directionThe direction of buffering (in or out)

An implementation that does not support buffering will silently ignore calls to this function and it will not have any effect on what is returned by subsequent calls to buffer_size().

Implements Concurrency::streams::details::streambuf_state_manager< _CharType >.

template<typename _CharType >
virtual utility::size64_t Concurrency::streams::details::basic_rawptr_buffer< _CharType >::size ( ) const
inlineprotectedvirtual

Gets the size of the stream, if known. Calls to has_size will determine whether the result of size can be relied on.

Reimplemented from Concurrency::streams::details::streambuf_state_manager< _CharType >.


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