/***
* Copyright (C) Microsoft. All rights reserved.
* Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
*
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* Asynchronous I/O: stream buffer implementation details
*
* We're going to some lengths to avoid exporting C++ class member functions and implementation details across
* module boundaries, and the factoring requires that we keep the implementation details away from the main header
* files. The supporting functions, which are in this file, use C-like signatures to avoid as many issues as
* possible.
*
* For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/
#include "stdafx.h"
#include "cpprest/details/fileio.h"
#include "cpprest/interopstream.h"
#include "robuffer.h"
using namespace ::Windows::Foundation;
using namespace ::Windows::Storage;
using namespace ::Windows::Storage::Streams;
using namespace ::Windows::Networking;
using namespace ::Windows::Networking::Sockets;
namespace Concurrency
{
namespace streams
{
namespace details
{
///
/// The public parts of the file information record contain only what is implementation-
/// independent. The actual allocated record is larger and has details that the implementation
/// require in order to function.
///
struct _file_info_impl : _file_info
{
_file_info_impl(Streams::IRandomAccessStream ^ stream, std::ios_base::openmode mode)
: m_stream(stream), m_writer(nullptr), _file_info(mode, 0)
{
m_pendingWrites = pplx::task_from_result();
}
_file_info_impl(Streams::IRandomAccessStream ^ stream, std::ios_base::openmode mode, size_t buffer_size)
: m_stream(stream), m_writer(nullptr), _file_info(mode, buffer_size)
{
m_pendingWrites = pplx::task_from_result();
}
Streams::IRandomAccessStream ^ m_stream;
Streams::IDataWriter ^ m_writer;
pplx::task m_pendingWrites;
};
} // namespace details
} // namespace streams
} // namespace Concurrency
using namespace Concurrency::streams::details;
#pragma warning(push)
#pragma warning(disable : 4100)
///
/// Translate from C++ STL file open modes to Win32 flags.
///
/// The C++ file open mode
/// The C++ file open protection
/// A pointer to a DWORD that will hold the desired access flags
/// A pointer to a DWORD that will hold the creation disposition
/// A pointer to a DWORD that will hold the share mode
void _get_create_flags(std::ios_base::openmode mode,
int prot,
FileAccessMode& acc_mode,
CreationCollisionOption& options)
{
options = CreationCollisionOption::OpenIfExists;
acc_mode = FileAccessMode::ReadWrite;
if ((mode & std::ios_base::in) && !(mode & std::ios_base::out)) acc_mode = FileAccessMode::Read;
if (mode & std::ios_base::trunc) options = CreationCollisionOption::ReplaceExisting;
}
///
/// Perform post-CreateFile processing.
///
/// The Win32 file handle
/// The callback interface pointer
/// The C++ file open mode
/// The error code if there was an error in file creation.
void _finish_create(Streams::IRandomAccessStream ^ stream,
_In_ _filestream_callback* callback,
std::ios_base::openmode mode,
int prot)
{
_file_info_impl* info = nullptr;
info = new _file_info_impl(stream, mode, 512);
// Seek to end if it's in appending write mode
if ((mode & std::ios_base::out) && (mode & std::ios_base::app || mode & std::ios_base::ate))
{
_seekwrpos_fsb(info, static_cast(stream->Size), 1);
}
callback->on_opened(info);
}
///
/// Create a streambuf instance to represent a WinRT file.
///
/// A pointer to the callback interface to invoke when the file has been opened.
/// The file object
/// A creation mode for the stream buffer
/// True if the opening operation could be initiated, false otherwise.
///
/// True does not signal that the file will eventually be successfully opened, just that the process was started.
/// This is only available for WinRT.
///
bool __cdecl _open_fsb_stf_str(_In_ Concurrency::streams::details::_filestream_callback* callback,
::Windows::Storage::StorageFile ^ file,
std::ios_base::openmode mode,
int prot)
{
_ASSERTE(callback != nullptr);
_ASSERTE(file != nullptr);
CreationCollisionOption options;
FileAccessMode acc_mode;
_get_create_flags(mode, prot, acc_mode, options);
pplx::create_task(file->OpenAsync(acc_mode)).then([=](pplx::task sop) {
try
{
_finish_create(sop.get(), callback, mode, prot);
}
catch (Platform::Exception ^ exc)
{
callback->on_error(std::make_exception_ptr(utility::details::create_system_error(exc->HResult)));
}
});
return true;
}
bool __cdecl _sync_fsb_winrt(_In_ Concurrency::streams::details::_file_info* info,
_In_opt_ Concurrency::streams::details::_filestream_callback* callback)
{
_ASSERTE(info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(fInfo->m_lock);
if (fInfo->m_stream == nullptr || fInfo->m_writer == nullptr || !fInfo->m_stream->CanWrite) return false;
// take a snapshot of current writer, since writer can be replaced during flush
auto writer = fInfo->m_writer;
// Flush operation will not begin until all previous writes (StoreAsync) finished, thus it could avoid race.
fInfo->m_pendingWrites = fInfo->m_pendingWrites.then([=] { return writer->StoreAsync(); })
.then([=](unsigned int) {
fInfo->m_buffill = 0;
return writer->FlushAsync();
})
.then([=](pplx::task result) {
// Rethrow exception if no callback attached.
if (callback == nullptr)
result.wait();
else
{
try
{
result.wait();
callback->on_completed(0);
}
catch (Platform::Exception ^ exc)
{
callback->on_error(std::make_exception_ptr(
utility::details::create_system_error(exc->HResult)));
}
}
});
return true;
}
///
/// Close a file stream buffer.
///
/// The file info record of the file
/// A pointer to the callback interface to invoke when the file has been opened.
/// True if the closing operation could be initiated, false otherwise.
///
/// True does not signal that the file will eventually be successfully closed, just that the process was started.
///
bool __cdecl _close_fsb_nolock(_In_ _file_info** info,
_In_ Concurrency::streams::details::_filestream_callback* callback)
{
_ASSERTE(callback != nullptr);
_ASSERTE(info != nullptr);
_ASSERTE(*info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(*info);
*info = nullptr;
auto stream = fInfo->m_stream;
if (fInfo->m_stream->CanWrite)
{
_sync_fsb_winrt(fInfo, nullptr);
fInfo->m_pendingWrites.then([=](pplx::task t) {
try
{
// The lock fInfo->m_lock must not be held at this point
delete fInfo;
t.wait();
callback->on_closed();
}
catch (Platform::Exception ^ exc)
{
callback->on_error(std::make_exception_ptr(utility::details::create_system_error(exc->HResult)));
}
});
}
else
{
// The lock fInfo->m_lock must not be held at this point
delete fInfo;
callback->on_closed();
}
return true;
}
bool __cdecl _close_fsb(_In_ _file_info** info, _In_ Concurrency::streams::details::_filestream_callback* callback)
{
return _close_fsb_nolock(info, callback);
}
///
/// Initiate an asynchronous (overlapped) read from the file stream.
///
/// The file info record of the file
/// A pointer to the callback interface to invoke when the write request is completed.
/// A pointer to a buffer where the data should be placed
/// The size (in bytes) of the buffer
/// The offset in the file to read from
/// 0 if the read request is still outstanding, -1 if the request failed, otherwise the size of the data read
/// into the buffer
size_t __cdecl _read_file_async(_In_ Concurrency::streams::details::_file_info_impl* fInfo,
_In_ Concurrency::streams::details::_filestream_callback* callback,
_Out_writes_(count) void* ptr,
_In_ size_t count,
size_t offset)
{
if (fInfo->m_stream == nullptr)
{
if (callback != nullptr)
{
// I don't know of a better error code, so this will have to do.
callback->on_error(std::make_exception_ptr(utility::details::create_system_error(ERROR_INVALID_ADDRESS)));
}
return 0;
}
auto reader = ref new Streams::DataReader(fInfo->m_stream->GetInputStreamAt(offset));
pplx::create_task(reader->LoadAsync(static_cast(count))).then([=](pplx::task result) {
try
{
auto read = result.get();
if (read > 0)
{
reader->ReadBytes(Platform::ArrayReference(static_cast(ptr), read));
}
callback->on_completed(read);
}
catch (Platform::Exception ^ exc)
{
callback->on_error(std::make_exception_ptr(utility::details::create_system_error(exc->HResult)));
}
});
return 0;
}
template
class _filestream_callback_fill_buffer : public _filestream_callback
{
public:
_filestream_callback_fill_buffer(_In_ _file_info* info, const Func& func) : m_func(func), m_info(info) {}
virtual void on_completed(size_t result)
{
m_func(result);
delete this;
}
private:
_file_info* m_info;
Func m_func;
};
template
_filestream_callback_fill_buffer* create_callback(_In_ _file_info* info, const Func& func)
{
return new _filestream_callback_fill_buffer(info, func);
}
size_t _fill_buffer_fsb(_In_ _file_info_impl* fInfo,
_In_ _filestream_callback* callback,
size_t count,
size_t char_size)
{
msl::safeint3::SafeInt safeCount = count;
if (fInfo->m_buffer == nullptr || safeCount > fInfo->m_bufsize)
{
if (fInfo->m_buffer != nullptr) delete fInfo->m_buffer;
fInfo->m_bufsize = safeCount.Max(fInfo->m_buffer_size);
fInfo->m_buffer = new char[fInfo->m_bufsize * char_size];
fInfo->m_bufoff = fInfo->m_rdpos;
auto cb = create_callback(fInfo, [=](size_t result) {
{
pplx::extensibility::scoped_recursive_lock_t lck(fInfo->m_lock);
fInfo->m_buffill = result / char_size;
}
callback->on_completed(result);
});
auto read = _read_file_async(
fInfo, cb, (uint8_t*)fInfo->m_buffer, fInfo->m_bufsize * char_size, fInfo->m_rdpos * char_size);
switch (read)
{
case 0:
// pending
return read;
case (-1):
// error
delete cb;
return read;
default:
// operation is complete. The pattern of returning synchronously
// has the expectation that we duplicate the callback code here...
// Do the expedient thing for now.
cb->on_completed(read);
// return pending
return 0;
};
}
// First, we need to understand how far into the buffer we have already read
// and how much remains.
size_t bufpos = fInfo->m_rdpos - fInfo->m_bufoff;
size_t bufrem = fInfo->m_buffill - bufpos;
// We have four different scenarios:
// 1. The read position is before the start of the buffer, in which case we will just reuse the buffer.
// 2. The read position is in the middle of the buffer, and we need to read some more.
// 3. The read position is beyond the end of the buffer. Do as in #1.
// 4. We have everything we need.
if ((fInfo->m_rdpos < fInfo->m_bufoff) || (fInfo->m_rdpos >= (fInfo->m_bufoff + fInfo->m_buffill)))
{
// Reuse the existing buffer.
fInfo->m_bufoff = fInfo->m_rdpos;
auto cb = create_callback(fInfo, [=](size_t result) {
{
pplx::extensibility::scoped_recursive_lock_t lck(fInfo->m_lock);
fInfo->m_buffill = result / char_size;
}
callback->on_completed(bufrem * char_size + result);
});
auto read = _read_file_async(
fInfo, cb, (uint8_t*)fInfo->m_buffer, fInfo->m_bufsize * char_size, fInfo->m_rdpos * char_size);
switch (read)
{
case 0:
// pending
return read;
case (-1):
// error
delete cb;
return read;
default:
// operation is complete. The pattern of returning synchronously
// has the expectation that we duplicate the callback code here...
// Do the expedient thing for now.
cb->on_completed(read);
// return pending
return 0;
};
}
else if (bufrem < count)
{
fInfo->m_bufsize = safeCount.Max(fInfo->m_buffer_size);
// Then, we allocate a new buffer.
char* newbuf = new char[fInfo->m_bufsize * char_size];
// Then, we copy the unread part to the new buffer and delete the old buffer
if (bufrem > 0) memcpy(newbuf, fInfo->m_buffer + bufpos * char_size, bufrem * char_size);
delete fInfo->m_buffer;
fInfo->m_buffer = newbuf;
// Then, we read the remainder of the count into the new buffer
fInfo->m_bufoff = fInfo->m_rdpos;
auto cb = create_callback(fInfo, [=](size_t result) {
{
pplx::extensibility::scoped_recursive_lock_t lck(fInfo->m_lock);
fInfo->m_buffill = result / char_size;
}
callback->on_completed(bufrem * char_size + result);
});
auto read = _read_file_async(fInfo,
cb,
(uint8_t*)fInfo->m_buffer + bufrem * char_size,
(fInfo->m_bufsize - bufrem) * char_size,
(fInfo->m_rdpos + bufrem) * char_size);
switch (read)
{
case 0:
// pending
return read;
case (-1):
// error
delete cb;
return read;
default:
// operation is complete. The pattern of returning synchronously
// has the expectation that we duplicate the callback code here...
// Do the expedient thing for now.
cb->on_completed(read);
// return pending
return 0;
};
}
else
{
// If we are here, it means that we didn't need to read, we already have enough data in the buffer
return count * char_size;
}
}
///
/// Read data from a file stream into a buffer
///
/// The file info record of the file
/// A pointer to the callback interface to invoke when the write request is completed.
/// A pointer to a buffer where the data should be placed
/// The size (in characters) of the buffer
/// 0 if the read request is still outstanding, -1 if the request failed, otherwise the size of the data read
/// into the buffer
size_t __cdecl _getn_fsb(_In_ Concurrency::streams::details::_file_info* info,
_In_ Concurrency::streams::details::_filestream_callback* callback,
_Out_writes_(count) void* ptr,
_In_ size_t count,
size_t char_size)
{
_ASSERTE(callback != nullptr);
_ASSERTE(info != nullptr);
_ASSERTE(count > 0);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(info->m_lock);
if (fInfo->m_buffer_size > 0)
{
auto cb = create_callback(fInfo, [=](size_t read) {
auto sz = count * char_size;
auto copy = (read < sz) ? read : sz;
auto bufoff = fInfo->m_rdpos - fInfo->m_bufoff;
memcpy(ptr, fInfo->m_buffer + bufoff * char_size, copy);
fInfo->m_atend = copy < sz;
callback->on_completed(copy);
});
size_t read = _fill_buffer_fsb(fInfo, cb, count, char_size);
if (read > 0)
{
auto sz = count * char_size;
auto copy = (read < sz) ? read : sz;
auto bufoff = fInfo->m_rdpos - fInfo->m_bufoff;
memcpy(ptr, fInfo->m_buffer + bufoff * char_size, copy);
fInfo->m_atend = copy < sz;
return copy;
}
return (size_t)read;
}
else
{
return _read_file_async(fInfo, callback, ptr, count * char_size, fInfo->m_rdpos * char_size);
}
}
///
/// Write data from a buffer into the file stream.
///
/// The file info record of the file
/// A pointer to the callback interface to invoke when the write request is completed.
/// A pointer to a buffer where the data should be placed
/// The size (in characters) of the buffer
/// 0 if the write request is still outstanding, -1 if the request failed, otherwise the size of the data read
/// into the buffer
size_t __cdecl _putn_fsb(_In_ Concurrency::streams::details::_file_info* info,
_In_ Concurrency::streams::details::_filestream_callback* callback,
const void* ptr,
size_t count,
size_t char_size)
{
_ASSERTE(callback != nullptr);
_ASSERTE(info != nullptr);
_ASSERTE(count > 0);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(fInfo->m_lock);
if (fInfo->m_stream == nullptr) return static_cast(-1);
// To preserve the async write order, we have to move the write head before read.
if (fInfo->m_wrpos != static_cast(-1)) fInfo->m_wrpos += count;
msl::safeint3::SafeInt safeWriteSize = count;
safeWriteSize *= char_size;
// In most of the time, we preserve the writer so that it would have better performance.
// However, after user call seek, we will dispose old writer. By doing so, users could
// write to new writer in new position while the old writer is still flushing data into stream.
if (fInfo->m_writer == nullptr)
{
fInfo->m_writer = ref new Streams::DataWriter(fInfo->m_stream);
fInfo->m_buffill = 0;
}
// It keeps tracking the number of bytes written into m_writer buffer.
fInfo->m_buffill += count;
// ArrayReference here is for avoiding data copy.
fInfo->m_writer->WriteBytes(Platform::ArrayReference(
const_cast(static_cast(ptr)), safeWriteSize));
// Flush data from m_writer buffer into stream , if the buffer is full
if (fInfo->m_buffill >= fInfo->m_buffer_size)
{
fInfo->m_buffill = 0;
fInfo->m_pendingWrites = fInfo->m_pendingWrites.then([=] { return fInfo->m_writer->StoreAsync(); })
.then([=](pplx::task result) {
try
{
result.wait();
callback->on_completed(safeWriteSize);
}
catch (Platform::Exception ^ exc)
{
callback->on_error(std::make_exception_ptr(
utility::details::create_system_error(exc->HResult)));
}
});
return 0;
}
else
return safeWriteSize;
}
///
/// Flush all buffered data to the underlying file.
///
/// The file info record of the file
/// A pointer to the callback interface to invoke when the write request is completed.
/// True if the request was initiated
bool __cdecl _sync_fsb(_In_ Concurrency::streams::details::_file_info* info,
_In_ Concurrency::streams::details::_filestream_callback* callback)
{
return _sync_fsb_winrt(info, callback);
}
///
/// Adjust the internal buffers and pointers when the application seeks to a new read location in the stream.
///
/// The file info record of the file
/// The new position (offset from the start) in the file stream
/// New file position or -1 if error
size_t __cdecl _seekrdpos_fsb(_In_ Concurrency::streams::details::_file_info* info, size_t pos, size_t char_size)
{
_ASSERTE(info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(info->m_lock);
if (fInfo->m_stream == nullptr) return static_cast(-1);
;
if (pos < fInfo->m_bufoff || pos > (fInfo->m_bufoff + fInfo->m_buffill))
{
delete fInfo->m_buffer;
fInfo->m_buffer = nullptr;
fInfo->m_bufoff = fInfo->m_buffill = fInfo->m_bufsize = 0;
}
fInfo->m_rdpos = pos;
return fInfo->m_rdpos;
}
///
/// Adjust the internal buffers and pointers when the application seeks to a new read location in the stream.
///
/// The file info record of the file
/// The new position (offset from the end of the stream) in the file stream
/// The size of the character type used for this stream
/// New file position or -1 if error
_ASYNCRTIMP size_t __cdecl _seekrdtoend_fsb(_In_ Concurrency::streams::details::_file_info* info,
int64_t offset,
size_t char_size)
{
_ASSERTE(info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
return _seekrdpos_fsb(info, static_cast(fInfo->m_stream->Size / char_size + offset), char_size);
}
utility::size64_t __cdecl _get_size(_In_ concurrency::streams::details::_file_info* info, size_t char_size)
{
_ASSERTE(info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(info->m_lock);
if (fInfo->m_stream == nullptr) return 0;
return utility::size64_t(fInfo->m_stream->Size / char_size);
}
///
/// Adjust the internal buffers and pointers when the application seeks to a new write location in the stream.
///
/// The file info record of the file
/// The new position (offset from the start) in the file stream
/// New file position or -1 if error
size_t __cdecl _seekwrpos_fsb(_In_ Concurrency::streams::details::_file_info* info, size_t pos, size_t char_size)
{
_ASSERTE(info != nullptr);
_file_info_impl* fInfo = static_cast<_file_info_impl*>(info);
pplx::extensibility::scoped_recursive_lock_t lck(info->m_lock);
if (fInfo->m_stream == nullptr) return static_cast(-1);
fInfo->m_wrpos = pos;
// m_buffill keeps number of chars written into the m_writer buffer.
// We need to flush it into stream before seek the write head of the stream
if (fInfo->m_buffill > 0) _sync_fsb_winrt(fInfo, nullptr);
// Moving write head should follow the flush operation. is_done test is for perf optimization.
if (fInfo->m_pendingWrites.is_done())
fInfo->m_stream->Seek(static_cast(pos) * char_size);
else
{
auto lastWriter = fInfo->m_writer;
fInfo->m_writer = nullptr;
fInfo->m_pendingWrites = fInfo->m_pendingWrites.then([=] {
// Detach stream could avoid stream destruction after writer get destructed.
lastWriter->DetachStream();
fInfo->m_stream->Seek(static_cast(pos) * char_size);
});
}
return fInfo->m_wrpos;
}
namespace Concurrency
{
namespace streams
{
namespace details
{
///
/// This class acts as a bridge between WinRT input streams and Casablanca asynchronous streams.
///
ref class IRandomAccessStream_bridge sealed : public Windows::Storage::Streams::IRandomAccessStream
{
public:
virtual property bool CanRead
{
bool get() { return m_buffer.can_read(); }
}
virtual property bool CanWrite
{
bool get() { return m_buffer.can_write(); }
}
virtual property uint64_t Position
{
uint64_t get() { return m_position; }
}
virtual property uint64_t Size
{
uint64_t get()
{
if (!m_buffer.has_size()) return m_remembered_size;
return m_buffer.size();
}
void set(uint64_t sz)
{
if (!m_buffer.has_size() || !m_buffer.can_write())
m_remembered_size = sz;
else
m_buffer.seekoff(basic_streambuf::pos_type(sz), std::ios_base::beg, std::ios_base::out);
}
}
virtual Windows::Storage::Streams::IRandomAccessStream ^
CloneStream() { return ref new IRandomAccessStream_bridge(m_buffer); }
virtual Windows::Storage::Streams::IInputStream
^
GetInputStreamAt(uint64_t position) {
if (!m_buffer.can_read()) return nullptr;
concurrency::streams::streambuf::pos_type pos = position;
if (m_buffer.can_seek() || pos == m_buffer.getpos(std::ios_base::in))
{
return ref new IRandomAccessStream_bridge(m_buffer, position);
}
return nullptr;
}
virtual Windows::Storage::Streams::IOutputStream
^ GetOutputStreamAt(uint64_t position) {
if (!m_buffer.can_write()) return nullptr;
concurrency::streams::streambuf::pos_type pos = position;
if (m_buffer.can_seek() || pos == m_buffer.getpos(std::ios_base::out))
{
return ref new IRandomAccessStream_bridge(m_buffer, position);
}
return nullptr;
};
virtual void Seek(uint64_t position)
{
if (!m_buffer.can_seek()) throw ref new Platform::InvalidArgumentException(L"underlying buffer cannot seek");
m_position = position;
m_buffer.seekpos(concurrency::streams::streambuf::pos_type(m_position), std::ios_base::in);
m_buffer.seekpos(concurrency::streams::streambuf::pos_type(m_position), std::ios_base::out);
}
virtual Windows::Foundation::IAsyncOperationWithProgress ^
WriteAsync(Windows::Storage::Streams::IBuffer ^ buffer);
virtual Windows::Foundation::IAsyncOperationWithProgress<::Windows::Storage::Streams::IBuffer ^, unsigned int> ^
ReadAsync(::Windows::Storage::Streams::IBuffer ^ buffer,
unsigned int count,
Windows::Storage::Streams::InputStreamOptions options);
virtual Windows::Foundation::IAsyncOperation ^ FlushAsync();
virtual ~IRandomAccessStream_bridge() {}
internal :
IRandomAccessStream_bridge(const concurrency::streams::streambuf& buffer)
: m_buffer(buffer), m_remembered_size(0), m_position(0)
{
}
IRandomAccessStream_bridge(const concurrency::streams::streambuf& buffer,
concurrency::streams::streambuf::pos_type position)
: m_buffer(buffer), m_remembered_size(0), m_position(position)
{
}
private:
uint64_t m_remembered_size;
concurrency::streams::streambuf::pos_type m_position;
concurrency::streams::streambuf m_buffer;
};
struct _alloc_protector
{
_alloc_protector(concurrency::streams::streambuf& buffer) : m_buffer(buffer), m_size(0) {}
~_alloc_protector() { m_buffer.commit(m_size); }
size_t m_size;
private:
_alloc_protector& operator=(const _alloc_protector&);
concurrency::streams::streambuf& m_buffer;
};
struct _acquire_protector
{
_acquire_protector(concurrency::streams::streambuf& buffer, uint8_t* ptr)
: m_buffer(buffer), m_ptr(ptr), m_size(0)
{
}
~_acquire_protector() { m_buffer.release(m_ptr, m_size); }
size_t m_size;
private:
_acquire_protector& operator=(const _acquire_protector&);
uint8_t* m_ptr;
concurrency::streams::streambuf& m_buffer;
};
// Rather than using ComPtr, which is somewhat complex, a simple RAII class
// to make sure that Release() is called is useful here.
struct _IUnknown_protector
{
_IUnknown_protector(IUnknown* unk_ptr) : m_unknown(unk_ptr) {}
~_IUnknown_protector()
{
if (m_unknown != nullptr) m_unknown->Release();
}
private:
IUnknown* m_unknown;
};
Windows::Foundation::IAsyncOperationWithProgress<::Windows::Storage::Streams::IBuffer ^, unsigned int> ^
IRandomAccessStream_bridge::ReadAsync(::Windows::Storage::Streams::IBuffer ^ buffer,
unsigned int count,
Windows::Storage::Streams::InputStreamOptions options)
{
if (!m_buffer.can_read())
{
return pplx::create_async([buffer](pplx::progress_reporter reporter) { return buffer; });
}
if (buffer->Capacity < count)
return pplx::create_async([buffer](pplx::progress_reporter reporter) { return buffer; });
m_buffer.seekpos(concurrency::streams::streambuf::pos_type(m_position), std::ios_base::in);
concurrency::streams::streambuf streambuf = m_buffer;
return pplx::create_async([streambuf, buffer, options, count](pplx::progress_reporter reporter) {
auto sbuf = streambuf;
auto local_buf = ref new ::Platform::Array(count);
uint8_t* ptr = nullptr;
size_t acquired_size = 0;
if (sbuf.acquire(ptr, acquired_size) && acquired_size >= count)
{
_acquire_protector prot(sbuf, ptr);
IUnknown* pUnk = reinterpret_cast(buffer);
::Windows::Storage::Streams::IBufferByteAccess* pBufferByteAccess = nullptr;
HRESULT hr = pUnk->QueryInterface(IID_PPV_ARGS(&pBufferByteAccess));
__abi_ThrowIfFailed(hr);
_IUnknown_protector unkprot(pBufferByteAccess);
byte* buffer_data = nullptr;
hr = pBufferByteAccess->Buffer(&buffer_data);
__abi_ThrowIfFailed(hr);
memcpy(buffer_data, ptr, count);
prot.m_size = count;
buffer->Length = count;
return pplx::task_from_result(buffer);
}
else
{
if (acquired_size > 0)
{
sbuf.release(ptr, 0);
}
IUnknown* pUnk = reinterpret_cast(buffer);
::Windows::Storage::Streams::IBufferByteAccess* pBufferByteAccess = nullptr;
HRESULT hr = pUnk->QueryInterface(IID_PPV_ARGS(&pBufferByteAccess));
__abi_ThrowIfFailed(hr);
_IUnknown_protector unkprot(pBufferByteAccess);
byte* buffer_data = nullptr;
hr = pBufferByteAccess->Buffer(&buffer_data);
__abi_ThrowIfFailed(hr);
pBufferByteAccess->AddRef();
return sbuf.getn(buffer_data, count).then([buffer, pBufferByteAccess, count](pplx::task written) {
_IUnknown_protector unkprot(pBufferByteAccess);
buffer->Length = (unsigned int)written.get();
return pplx::task_from_result(buffer);
});
}
});
}
Windows::Foundation::IAsyncOperationWithProgress ^
IRandomAccessStream_bridge::WriteAsync(Windows::Storage::Streams::IBuffer ^ buffer)
{
if (!m_buffer.can_write())
{
return pplx::create_async([](pplx::progress_reporter reporter) { return 0U; });
}
m_buffer.seekpos(concurrency::streams::streambuf::pos_type(m_position), std::ios_base::out);
concurrency::streams::streambuf streambuf = m_buffer;
return pplx::create_async([buffer, streambuf](pplx::progress_reporter reporter) {
auto size = buffer->Length;
auto sbuf = streambuf;
uint8_t* ptr = sbuf.alloc(size);
if (ptr != nullptr)
{
{
_alloc_protector prot(sbuf);
IUnknown* pUnk = reinterpret_cast(buffer);
::Windows::Storage::Streams::IBufferByteAccess* pBufferByteAccess = nullptr;
HRESULT hr = pUnk->QueryInterface(IID_PPV_ARGS(&pBufferByteAccess));
__abi_ThrowIfFailed(hr);
_IUnknown_protector unkprot(pBufferByteAccess);
byte* buffer_data = nullptr;
hr = pBufferByteAccess->Buffer(&buffer_data);
__abi_ThrowIfFailed(hr);
memcpy(ptr, buffer_data, size);
prot.m_size = size;
}
return pplx::task_from_result((unsigned int)size);
}
else
{
IUnknown* pUnk = reinterpret_cast(buffer);
::Windows::Storage::Streams::IBufferByteAccess* pBufferByteAccess = nullptr;
HRESULT hr = pUnk->QueryInterface(IID_PPV_ARGS(&pBufferByteAccess));
__abi_ThrowIfFailed(hr);
_IUnknown_protector unkprot(pBufferByteAccess);
byte* buffer_data = nullptr;
hr = pBufferByteAccess->Buffer(&buffer_data);
__abi_ThrowIfFailed(hr);
pBufferByteAccess->AddRef();
return sbuf.putn_nocopy(buffer_data, size).then([pBufferByteAccess](pplx::task size) {
pBufferByteAccess->Release();
return (unsigned int)size.get();
});
}
});
}
Windows::Foundation::IAsyncOperation ^ IRandomAccessStream_bridge::FlushAsync()
{
concurrency::streams::streambuf streambuf = m_buffer;
return pplx::create_async([streambuf]() {
if (!streambuf.can_write())
{
return pplx::task_from_result(false);
}
auto sbuf = streambuf;
return sbuf.sync().then([] { return pplx::task_from_result(true); });
});
}
} // namespace details
} // namespace streams
} // namespace Concurrency
Windows::Storage::Streams::IInputStream ^
Concurrency::streams::winrt_stream::create_input_stream(const concurrency::streams::streambuf& buffer)
{
return ref new ::Concurrency::streams::details::IRandomAccessStream_bridge(buffer, 0);
}
Windows::Storage::Streams::IOutputStream ^
Concurrency::streams::winrt_stream::create_output_stream(const concurrency::streams::streambuf& buffer)
{
return ref new Concurrency::streams::details::IRandomAccessStream_bridge(buffer, 0);
}
Windows::Storage::Streams::IRandomAccessStream ^ Concurrency::streams::winrt_stream::create_random_access_stream(
const concurrency::streams::streambuf& buffer)
{
return ref new Concurrency::streams::details::IRandomAccessStream_bridge(buffer);
}
#pragma warning(pop)