stdex Additional custom or not Standard C++ covered algorithms

Loading...
Searching...
No Matches
Public Member Functions | Protected Attributes | List of all members
stdex::stream::socket Class Reference

Socket stream. More...

`#include <stdex/stream.hpp>`

Inheritance diagram for stdex::stream::socket:

## Public Member Functions
| socket (socket_t h=stdex::invalid_socket, state_t state=state_t::ok)
| socket (socket &&other) noexcept
socket & | operator= (socket &&other) noexcept
| socket (int af, int type, int protocol)
| Creates a socket.
| operator bool () const noexcept
| Returns true if socket handle is valid.
socket_t | get () const noexcept
| Returns socket handle.
virtual size_t | read (_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
| Reads block of data from the stream.
virtual size_t | write (_In_reads_bytes_opt_(length) const void *data, size_t length)
| Writes block of data to the stream.
virtual void | close ()
| Closes the stream.
Public Member Functions inherited from stdex::stream::basic
| basic (state_t state=state_t::ok)
virtual void | flush ()
| Persists volatile element data.
virtual void | skip (fsize_t amount)
| Skips given amount of bytes of data on the stream.
state_t | state () const
| Returns stream state after last operation.
bool | ok () const
| Returns true if the stream state is clean i.e. previous operation was successful.
virtual std::vector< uint8_t > | read_remainder (size_t max_length=SIZE_MAX)
| Reads and returns remainder of the stream.
uint8_t | read_byte ()
| Reads one byte of data.
void | write_byte (uint8_t byte, fsize_t amount=1)
| Writes a byte of data.
template<class T >
basic & | read_data (T &data)
| Reads one primitive data type.
template<class T >
basic & | write_data (const T data)
| Writes one primitive data type.
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
size_t | readln (std::basic_string< T, TR, AX > &str)
| Reads stream to the end-of-line or end-of-file.
template<class T_from , class T_to , class TR = std::char_traits<T_to>, class AX = std::allocator<T_to>>
size_t | readln (std::basic_string< T_to, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
| Reads stream to the end-of-line or end-of-file.
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
size_t | readln_and_attach (std::basic_string< T, TR, AX > &str)
| Reads stream to the end-of-line or end-of-file and append to str.
template<class T_from , class T_to , class TR = std::char_traits<T_to>, class AX = std::allocator<T_to>>
size_t | readln_and_attach (std::basic_string< T_to, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
| Reads stream to the end-of-line or end-of-file and append to str.
size_t | read_array (_Out_writes_bytes_(size *count) void *array, size_t size, size_t count)
| Reads an array of data from the stream.
size_t | write_array (_In_reads_bytes_opt_(size *count) const void *array, size_t size, size_t count)
| Writes an array of data to the stream.
template<class T_from , class T_to >
size_t | write_array (const T_from *str, charset_encoder< T_from, T_to > &encoder)
| Writes array of characters to the stream.
template<class T_from , class T_to >
size_t | write_array (_In_reads_or_z_opt_(num_chars) const T_from *str, size_t num_chars, charset_encoder< T_from, T_to > &encoder)
| Writes array of characters to the stream.
template<class T_from , class T_to , class TR = std::char_traits<T_from>, class AX = std::allocator<T_from>>
size_t | write_array (const std::basic_string< T_from, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
| Writes array of characters to the stream.
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
basic & | read_str (std::basic_string< T, TR, AX > &data)
| Reads length-prefixed string from the stream.
template<class T >
basic & | write_str (const T *data)
| Writes string to the stream length-prefixed.
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
basic & | write_str (const std::basic_string< T, TR, AX > &data)
| Writes string to the stream length-prefixed.
fsize_t | write_stream (basic &stream, fsize_t amount=fsize_max)
| Writes content of another stream.
void | write_charset (charset_id charset)
| Writes UTF8, UTF-16 or UTF-32 byte-order-mark.
size_t | write_sprintf (_Printf_format_string_params_(2) const char *format, locale_t locale,...)
| Writes formatted string to the stream.
size_t | write_sprintf (_Printf_format_string_params_(2) const wchar_t *format, locale_t locale,...)
| Writes formatted string to the stream.
size_t | write_vsprintf (_Printf_format_string_params_(2) const char *format, locale_t locale, va_list params)
| Writes formatted string to the stream.
size_t | write_vsprintf (_Printf_format_string_params_(2) const wchar_t *format, locale_t locale, va_list params)
| Writes formatted string to the stream.
basic & | operator>> (int8_t &data)
basic & | operator<< (const int8_t data)
basic & | operator>> (int16_t &data)
basic & | operator<< (const int16_t data)
basic & | operator>> (int32_t &data)
basic & | operator<< (const int32_t data)
basic & | operator>> (int64_t &data)
basic & | operator<< (const int64_t data)
basic & | operator>> (uint8_t &data)
basic & | operator<< (const uint8_t data)
basic & | operator>> (uint16_t &data)
basic & | operator<< (const uint16_t data)
basic & | operator>> (uint32_t &data)
basic & | operator<< (const uint32_t data)
basic & | operator>> (uint64_t &data)
basic & | operator<< (const uint64_t data)
basic & | operator>> (float &data)
basic & | operator<< (const float data)
basic & | operator>> (double &data)
basic & | operator<< (const double data)
basic & | operator>> (char &data)
basic & | operator<< (const char data)
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
basic & | operator>> (std::basic_string< T, TR, AX > &data)
template<class T >
basic & | operator<< (const T *data)
template<class T , class TR = std::char_traits<T>, class AX = std::allocator<T>>
basic & | operator<< (const std::basic_string< T, TR, AX > &data)
template<class T , class AX = std::allocator<T>>
basic & | operator<< (const std::vector< T, AX > &data)
template<class T , class AX = std::allocator<T>>
basic & | operator>> (std::vector< T, AX > &data)
template<class KEY , class PR = std::less<KEY>, class AX = std::allocator<KEY>>
basic & | operator<< (const std::set< KEY, PR, AX > &data)
template<class KEY , class PR = std::less<KEY>, class AX = std::allocator<KEY>>
basic & | operator>> (std::set< KEY, PR, AX > &data)
template<class KEY , class PR = std::less<KEY>, class AX = std::allocator<KEY>>
basic & | operator<< (const std::multiset< KEY, PR, AX > &data)
template<class KEY , class PR = std::less<KEY>, class AX = std::allocator<KEY>>
basic & | operator>> (std::multiset< KEY, PR, AX > &data)

## Protected Attributes
socket_t | m_h
Protected Attributes inherited from stdex::stream::basic
state_t | m_state

## Detailed Description

Socket stream.

## Constructor & Destructor Documentation

## ◆ socket()

stdex::stream::socket::socket | ( | int | af,
|  | int | type,
|  | int | protocol )
| inline

Creates a socket.

Parameters

  [in] | af | Address family
  [in] | type | Socket type
  [in] | protocol | Socket protocol

## Member Function Documentation

## ◆ close()

virtual void stdex::stream::socket::close | ( |  | ) |
| inline virtual

Closes the stream.

Reimplemented from stdex::stream::basic.

## ◆ read()

virtual size_t stdex::stream::socket::read | ( | _Out_writes_bytes_to_opt_(length, return) void * | data,
|  | size_t | length )
| inline virtual

Reads block of data from the stream.

Parameters

  [out] | data | Buffer to store read data
  [in] | length | Byte limit of data to read

Returns
  Number of bytes successfully read. On EOF, 0 is returned and stream state is set to state_t::eof. On error, 0 is returned and stream state is set to state_t::fail. On null reads (length == 0), 0 is returned and stream state is set to state_t::ok.

Reimplemented from stdex::stream::basic.

## ◆ write()

virtual size_t stdex::stream::socket::write | ( | _In_reads_bytes_opt_(length) const void * | data,
|  | size_t | length )
| inline virtual

Writes block of data to the stream.

Parameters

  [in] | data | Buffer to write data from
  [in] | length | Number of bytes to write

Returns
  Number of bytes successfully written. On error, stream state is set to state_t::fail.

Reimplemented from stdex::stream::basic.

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

- include/stdex/stream.hpp