#pragma once

#ifndef _CASA_STREAMS_H

#define _CASA_STREAMS_H

#include "cpprest/astreambuf.h"

#include <iosfwd>

namespace Concurrency { namespace streams

{

template<typename CharType> class basic_ostream;

template<typename CharType> class basic_istream;

namespace details {

template<typename CharType>

class basic_ostream_helper

};

template<typename CharType>

class basic_istream_helper

};

template <typename CharType>

struct Value2StringFormatter

};

template <>

struct Value2StringFormatter <uint8_t>

{

template <typename T>

static std::basic_string<uint8_t> format(const T &val)

}

static std::basic_string<uint8_t> format(const utf16string &val)

{

return format(utility::conversions::utf16_to_utf8(val));

}

};

static const char *_in_stream_msg = "stream not set up for input of data";

static const char *_in_streambuf_msg = "stream buffer not set up for input of data";

static const char *_out_stream_msg = "stream not set up for output of data";

static const char *_out_streambuf_msg = "stream buffer not set up for output of data";

}

/// <summary>

/// Base interface for all asynchronous output streams.

/// </summary>

template<typename CharType>

class basic_ostream

{

public:

typedef char_traits<CharType> traits;

typedef typename traits::int_type int_type;

typedef typename traits::pos_type pos_type;

typedef typename traits::off_type off_type;

/// <summary>

/// Default constructor

/// </summary>

basic_ostream() {}

/// <summary>

/// Copy constructor

/// </summary>

/// <param name="other">The source object</param>

basic_ostream(const basic_ostream &other) : m_helper(other.m_helper) { }

/// <summary>

/// Assignment operator

/// </summary>

/// <param name="other">The source object</param>

/// <returns>A reference to the stream object that contains the result of the assignment.</returns>

basic_ostream & operator =(const basic_ostream &other) { m_helper = other.m_helper; return *this; }

/// <summary>

/// Constructor

/// </summary>

/// <param name="buffer">A stream buffer.</param>

basic_ostream(streams::streambuf<CharType> buffer) :

}

/// <summary>

/// Close the stream, preventing further write operations.

/// </summary>

pplx::task<void> close() const

}

/// <summary>

/// Close the stream with exception, preventing further write operations.

/// </summary>

/// <param name="eptr">Pointer to the exception.</param>

pplx::task<void> close(std::exception_ptr eptr) const

}

/// <summary>

/// Put a single character into the stream.

/// </summary>

/// <param name="ch">A character</param>

pplx::task<int_type> write(CharType ch) const

}

/// <summary>

/// Write a single value of "blittable" type T into the stream.

/// </summary>

/// <param name="value">A value of type T.</param>

/// <remarks>

/// This is not a replacement for a proper binary serialization solution, but it may

/// form the foundation for one. Writing data bit-wise to a stream is a primitive

/// operation of binary serialization.

/// Currently, no attention is paid to byte order. All data is written in the platform's

/// native byte order, which means little-endian on all platforms that have been tested.

/// This function is only available for streams using a single-byte character size.

/// </remarks>

template<typename T>

CASABLANCA_DEPRECATED("Unsafe API that will be removed in future releases, use one of the other write overloads instead.")

pplx::task<size_t> write(T value) const

}

/// <summary>

/// Write a number of characters from a given stream buffer into the stream.

/// </summary>

/// <param name="source">A source stream buffer.</param>

/// <param name="count">The number of characters to write.</param>

pplx::task<size_t> write(streams::streambuf<CharType> source, size_t count) const

}

/// <summary>

/// Write the specified string to the output stream.

/// </summary>

/// <param name="str">Input string.</param>

pplx::task<size_t> print(const std::basic_string<CharType>& str) const

}

/// <summary>

/// Write a value of type <c>T</c> to the output stream.

/// </summary>

/// <typeparam name="T">

/// The data type of the object to be written to the stream

/// </typeparam>

/// <param name="val">Input object.</param>

template<typename T>

pplx::task<size_t> print(const T& val) const

}

/// <summary>

/// Write a value of type <c>T</c> to the output stream and append a newline character.

/// </summary>

/// <typeparam name="T">

/// The data type of the object to be written to the stream

/// </typeparam>

/// <param name="val">Input object.</param>

template<typename T>

pplx::task<size_t> print_line(const T& val) const

}

/// <summary>

/// Flush any buffered output data.

/// </summary>

pplx::task<void> flush() const

}

/// <summary>

/// Seeks to the specified write position.

/// </summary>

/// <param name="pos">An offset relative to the beginning of the stream.</param>

/// <returns>The new position in the stream.</returns>

pos_type seek(pos_type pos) const

}

/// <summary>

/// Seeks to the specified write position.

/// </summary>

/// <param name="off">An offset relative to the beginning, current write position, or the end of the stream.</param>

/// <param name="way">The starting point (beginning, current, end) for the seek.</param>

/// <returns>The new position in the stream.</returns>

pos_type seek(off_type off, std::ios_base::seekdir way) const

}

/// <summary>

/// Get the current write position, i.e. the offset from the beginning of the stream.

/// </summary>

/// <returns>The current write position.</returns>

pos_type tell() const

}

/// <summary>

/// <c>can_seek<c/> is used to determine whether the stream supports seeking.

/// </summary>

/// <returns><c>true</c> if the stream supports seeking, <c>false</c> otherwise.</returns>

bool can_seek() const { return is_valid() && m_helper->m_buffer.can_seek(); }

/// <summary>

/// Test whether the stream has been initialized with a valid stream buffer.

/// </summary>

/// <returns><c>true</c> if the stream has been initialized with a valid stream buffer, <c>false</c> otherwise.</returns>

bool is_valid() const { return (m_helper != nullptr) && ((bool)m_helper->m_buffer); }

/// <summary>

/// Test whether the stream has been initialized or not.

/// </summary>

operator bool() const { return is_valid(); }

/// <summary>

/// Test whether the stream is open for writing.

/// </summary>

/// <returns><c>true</c> if the stream is open for writing, <c>false</c> otherwise.</returns>

bool is_open() const { return is_valid() && m_helper->m_buffer.can_write(); }

/// <summary>

/// Get the underlying stream buffer.

/// </summary>

/// <returns>The underlying stream buffer.</returns>

concurrency::streams::streambuf<CharType> streambuf() const

{

return helper()->m_buffer;

}

protected:

void set_helper(std::shared_ptr<details::basic_ostream_helper<CharType>> helper)

{

m_helper = helper;

}

private:

template<typename T>

bool _verify_and_return_task(const char *msg, pplx::task<T> &tsk) const

}

void _verify_and_throw(const char *msg) const

}

std::shared_ptr<details::basic_ostream_helper<CharType>> helper() const

}

std::shared_ptr<details::basic_ostream_helper<CharType>> m_helper;

};

template<typename int_type>

struct _type_parser_integral_traits

};

#ifdef _WIN32

#define _INT_TRAIT(_t,_low,_high) template<> struct _type_parser_integral_traits<_t>{typedef std::true_type _is_integral;typedef std::false_type _is_unsigned;static const int64_t _min = _low;static const int64_t _max = _high;};

#define _UINT_TRAIT(_t,_low,_high) template<> struct _type_parser_integral_traits<_t>{typedef std::true_type _is_integral;typedef std::true_type _is_unsigned;static const uint64_t _max = _high;};

_INT_TRAIT(char,INT8_MIN,INT8_MAX)

_INT_TRAIT(signed char,INT8_MIN,INT8_MAX)

_INT_TRAIT(short,INT16_MIN,INT16_MAX)

#if defined(_NATIVE_WCHAR_T_DEFINED)

_INT_TRAIT(wchar_t,WCHAR_MIN, WCHAR_MAX)

#endif

_INT_TRAIT(int,INT32_MIN,INT32_MAX)

_INT_TRAIT(long, LONG_MIN, LONG_MAX)

_INT_TRAIT(long long, LLONG_MIN, LLONG_MAX)

_UINT_TRAIT(unsigned char,UINT8_MIN,UINT8_MAX)

_UINT_TRAIT(unsigned short,UINT16_MIN,UINT16_MAX)

_UINT_TRAIT(unsigned int,UINT32_MIN,UINT32_MAX)

_UINT_TRAIT(unsigned long, ULONG_MIN, ULONG_MAX)

_UINT_TRAIT(unsigned long long, ULLONG_MIN, ULLONG_MAX)

#else

#define _INT_TRAIT(_t) template<> struct _type_parser_integral_traits<_t>{typedef std::true_type _is_integral;typedef std::false_type _is_unsigned;static const int64_t _min = std::numeric_limits<_t>::min();static const int64_t _max = (std::numeric_limits<_t>::max)();};

#define _UINT_TRAIT(_t) template<> struct _type_parser_integral_traits<_t>{typedef std::true_type _is_integral;typedef std::true_type _is_unsigned;static const uint64_t _max = (std::numeric_limits<_t>::max)();};

_INT_TRAIT(char)

_INT_TRAIT(signed char)

_INT_TRAIT(short)

_INT_TRAIT(utf16char)

_INT_TRAIT(int)

_INT_TRAIT(long)

_INT_TRAIT(long long)

_UINT_TRAIT(unsigned char)

_UINT_TRAIT(unsigned short)

_UINT_TRAIT(unsigned int)

_UINT_TRAIT(unsigned long)

_UINT_TRAIT(unsigned long long)

#endif

template<typename CharType>

class _type_parser_base

};

/// <summary>

/// Class used to handle asychronous parsing for basic_istream::extract. To support new

/// types create a new template specialization and implement the parse function.

/// </summary>

template<typename CharType, typename T>

class type_parser

};

/// <summary>

/// Base interface for all asynchronous input streams.

/// </summary>

template<typename CharType>

class basic_istream

{

public:

typedef char_traits<CharType> traits;

typedef typename traits::int_type int_type;

typedef typename traits::pos_type pos_type;

typedef typename traits::off_type off_type;

/// <summary>

/// Default constructor

/// </summary>

basic_istream() {}

/// <summary>

/// Constructor

/// </summary>

/// <typeparam name="CharType">

/// The data type of the basic element of the stream.

/// </typeparam>

/// <param name="buffer">A stream buffer.</param>

basic_istream(streams::streambuf<CharType> buffer) : m_helper(std::make_shared<details::basic_istream_helper<CharType>>(buffer))

{

_verify_and_throw(details::_in_streambuf_msg);

}

/// <summary>

/// Copy constructor

/// </summary>

/// <param name="other">The source object</param>

basic_istream(const basic_istream &other) : m_helper(other.m_helper) { }

/// <summary>

/// Assignment operator

/// </summary>

/// <param name="other">The source object</param>

/// <returns>A reference to the stream object that contains the result of the assignment.</returns>

basic_istream & operator =(const basic_istream &other)

{

m_helper = other.m_helper;

return *this;

}

/// <summary>

/// Close the stream, preventing further read operations.

/// </summary>

pplx::task<void> close() const

}

/// <summary>

/// Close the stream with exception, preventing further read operations.

/// </summary>

/// <param name="eptr">Pointer to the exception.</param>

pplx::task<void> close(std::exception_ptr eptr) const

}

/// <summary>

/// Tests whether last read cause the stream reach EOF.

/// </summary>

/// <returns>True if the read head has reached the end of the stream, false otherwise.</returns>

bool is_eof() const

{

return is_valid() ? m_helper->m_buffer.is_eof() : false;

}

/// <summary>

/// Get the next character and return it as an int_type. Advance the read position.

/// </summary>

/// <returns>A <c>task</c> that holds the next character as an <c>int_type</c> on successful completion.</returns>

pplx::task<int_type> read() const

}

/// <summary>

/// Read a single value of "blittable" type T from the stream.

/// </summary>

/// <returns>A value of type T.</returns>

/// <remarks>

/// This is not a replacement for a proper binary serialization solution, but it may

/// form the foundation for one. Reading data bit-wise to a stream is a primitive

/// operation of binary serialization.

/// Currently, no attention is paid to byte order. All data is read in the platform's

/// native byte order, which means little-endian on all platforms that have been tested.

/// This function is only available for streams using a single-byte character size.

/// </remarks>

template<typename T>

CASABLANCA_DEPRECATED("Unsafe API that will be removed in future releases, use one of the other read overloads instead.")

pplx::task<T> read() const

}

/// <summary>

/// Reads up to <c>count</c> characters and place into the provided buffer.

/// </summary>

/// <param name="target">An async stream buffer supporting write operations.</param>

/// <param name="count">The maximum number of characters to read</param>

/// <returns>A <c>task</c> that holds the number of characters read. This number is 0 if the end of the stream is reached.</returns>

pplx::task<size_t> read(streams::streambuf<CharType> target, size_t count) const

}

/// <summary>

/// Get the next character and return it as an int_type. Do not advance the read position.

/// </summary>

/// <returns>A <c>task</c> that holds the character, widened to an integer. This character is EOF when the peek operation fails.</returns>

pplx::task<int_type> peek() const

}

/// <summary>

/// Read characters until a delimiter or EOF is found, and place them into the target.

/// Proceed past the delimiter, but don't include it in the target buffer.

/// </summary>

/// <param name="target">An async stream buffer supporting write operations.</param>

/// <param name="delim">The delimiting character to stop the read at.</param>

/// <returns>A <c>task</c> that holds the number of characters read.</returns>

pplx::task<size_t> read_to_delim(streams::streambuf<CharType> target, int_type delim) const

}

/// <summary>

/// Read until reaching a newline character. The newline is not included in the target.

/// </summary>

/// <param name="target">An asynchronous stream buffer supporting write operations.</param>

/// <returns>A <c>task</c> that holds the number of characters read. This number is 0 if the end of the stream is reached.</returns>

pplx::task<size_t> read_line(streams::streambuf<CharType> target) const

}

/// <summary>

/// Read until reaching the end of the stream.

/// </summary>

/// <param name="target">An asynchronous stream buffer supporting write operations.</param>

/// <returns>The number of characters read.</returns>

pplx::task<size_t> read_to_end(streams::streambuf<CharType> target) const

}

/// <summary>

/// Seeks to the specified write position.

/// </summary>

/// <param name="pos">An offset relative to the beginning of the stream.</param>

/// <returns>The new position in the stream.</returns>

pos_type seek(pos_type pos) const

}

/// <summary>

/// Seeks to the specified write position.

/// </summary>

/// <param name="off">An offset relative to the beginning, current write position, or the end of the stream.</param>

/// <param name="way">The starting point (beginning, current, end) for the seek.</param>

/// <returns>The new position in the stream.</returns>

pos_type seek(off_type off, std::ios_base::seekdir way) const

}