stdex
Additional custom or not Standard C++ covered algorithms
Loading...
Searching...
No Matches
stream.hpp
1/*
2 SPDX-License-Identifier: MIT
3 Copyright © 2023 Amebis
4*/
5
6#pragma once
7
8#include "compat.hpp"
9#include "endian.hpp"
10#include "interval.hpp"
11#include "math.hpp"
12#include "ring.hpp"
13#include "string.hpp"
14#include "system.hpp"
15#include "unicode.hpp"
16#include <assert.h>
17#include <stdint.h>
18#include <stdlib.h>
19#if defined(_WIN32)
20#include <asptlb.h>
21#include <objidl.h>
22#else
23#include <fcntl.h>
24#include <unistd.h>
25#include <sys/stat.h>
26#endif
27#include <chrono>
28#include <condition_variable>
29#include <list>
30#include <memory>
31#include <string>
32#include <thread>
33#include <vector>
34
35#if !defined(SET_FILE_OP_TIMES) && defined(RDAT_BELEZI_CAS_DOSTOPA_VER)
36#define SET_FILE_OP_TIMES 1
37#pragma message("RDAT_BELEZI_CAS_DOSTOPA_VER is deprecated. Use SET_FILE_OP_TIMES instead.")
38#elif !defined(SET_FILE_OP_TIMES)
39#define SET_FILE_OP_TIMES 0
40#endif
41#if !defined(CHECK_STREAM_STATE) && defined(RDAT_NE_PREVERJAJ_STANJA_VER)
42#define CHECK_STREAM_STATE 0
43#pragma message("RDAT_NE_PREVERJAJ_EOF_VER is deprecated. Use CHECK_STREAM_STATE=0 instead.")
44#else
45#define CHECK_STREAM_STATE 1
46#endif
47
48namespace stdex
49{
50 namespace stream
51 {
55 enum class state_t {
56 ok = 0,
57 eof,
58 fail,
59 };
60
64 using fsize_t = uint64_t;
65 constexpr fsize_t fsize_max = UINT64_MAX;
66
67 constexpr size_t iterate_count = 0x10;
68 constexpr size_t default_block_size = 0x10000;
69 constexpr wchar_t utf16_bom = L'\ufeff';
70 constexpr const char utf8_bom[3] = { '\xef', '\xbb', '\xbf' };
71
75 class basic
76 {
77 public:
78 basic(_In_ state_t state = state_t::ok) : m_state(state) {}
79
80 virtual ~basic() noexcept(false) {}
81
93 virtual _Success_(return != 0 || length == 0) size_t read(
94 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
95 {
96 _Unreferenced_(data);
97 _Unreferenced_(length);
98 m_state = state_t::fail;
99 return 0;
100 }
101
111 virtual _Success_(return != 0) size_t write(
112 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
113 {
114 _Unreferenced_(data);
115 _Unreferenced_(length);
116 m_state = state_t::fail;
117 return 0;
118 }
119
123 virtual void flush()
124 {
125 m_state = state_t::ok;
126 }
127
131 virtual void close()
132 {
133 m_state = state_t::ok;
134 }
135
139 virtual void skip(_In_ fsize_t amount)
140 {
141 if (amount == 1)
142 read_byte();
143 else if (amount < iterate_count) {
144 for (size_t i = 0; i < static_cast<size_t>(amount); i++) {
145 read_byte();
146 if (!ok()) _Unlikely_
147 break;
148 }
149 }
150 else {
151 size_t block = static_cast<size_t>(std::min<fsize_t>(amount, default_block_size));
152 try {
153 std::unique_ptr<uint8_t[]> dummy(new uint8_t[block]);
154 while (amount) {
155 amount -= read_array(dummy.get(), sizeof(uint8_t), static_cast<size_t>(std::min<fsize_t>(amount, block)));
156 if (!ok()) _Unlikely_
157 break;
158 }
159 }
160 catch (const std::bad_alloc&) { m_state = state_t::fail; }
161 }
162 }
163
167 inline state_t state() const { return m_state; };
168
172 inline bool ok() const { return m_state == state_t::ok; };
173
181 virtual std::vector<uint8_t> read_remainder(_In_ size_t max_length = SIZE_MAX)
182 {
183 std::vector<uint8_t> result;
184 size_t offset, length;
185 offset = 0;
186 length = default_block_size;
187 while (offset < max_length) {
188 length = std::min(length, max_length);
189 try { result.resize(length); }
190 catch (const std::bad_alloc&) {
191 m_state = state_t::fail;
192 return result;
193 }
194 auto num_read = read_array(result.data() + offset, sizeof(uint8_t), length - offset);
195 offset += num_read;
196 if (!ok()) _Unlikely_
197 break;
198 length += default_block_size;
199 }
200 result.resize(offset);
201 return result;
202 }
203
207 inline uint8_t read_byte()
208 {
209 uint8_t byte;
210 if (read_array(&byte, sizeof(byte), 1) == 1)
211 return byte;
212 throw std::runtime_error("failed to read");
213 }
214
218 void write_byte(_In_ uint8_t byte, _In_ fsize_t amount = 1)
219 {
220 if (amount == 1)
221 write(&byte, sizeof(uint8_t));
222 else if (amount < iterate_count) {
223 for (size_t i = 0; i < static_cast<size_t>(amount); i++) {
224 write(&byte, sizeof(uint8_t));
225 if (!ok()) _Unlikely_
226 break;
227 }
228 }
229 else {
230 size_t block = static_cast<size_t>(std::min<fsize_t>(amount, default_block_size));
231 try {
232 std::unique_ptr<uint8_t[]> dummy(new uint8_t[block]);
233 memset(dummy.get(), byte, block);
234 while (amount) {
235 amount -= write_array(dummy.get(), sizeof(uint8_t), static_cast<size_t>(std::min<fsize_t>(amount, block)));
236 if (!ok()) _Unlikely_
237 break;
238 }
239 }
240 catch (const std::bad_alloc&) { m_state = state_t::fail; }
241 }
242 }
243
255 template <class T>
256 inline basic& read_data(_Out_ T& data)
257 {
258 if (!ok()) _Unlikely_ {
259 data = 0;
260 return *this;
261 }
262 if (read_array(&data, sizeof(T), 1) == 1)
263 (void)LE2HE(&data);
264 else {
265 data = 0;
266 if (ok())
267 m_state = state_t::eof;
268 }
269 return *this;
270 }
271
283 template <class T>
284 inline basic& write_data(_In_ const T data)
285 {
286 if (!ok()) _Unlikely_
287 return *this;
288#if BYTE_ORDER == BIG_ENDIAN
289 T data_le = HE2LE(data);
290 write(&data_le, sizeof(T));
291#else
292 write(&data, sizeof(T));
293#endif
294 return *this;
295 }
296
302 template<class _Traits = std::char_traits<char>, class _Ax = std::allocator<char>>
303 inline size_t readln(_Inout_ std::basic_string<char, _Traits, _Ax>& str)
304 {
305 str.clear();
306 return readln_and_attach(str);
307 }
308
314 template<class _Traits = std::char_traits<wchar_t>, class _Ax = std::allocator<wchar_t>>
315 inline size_t readln(_Inout_ std::basic_string<wchar_t, _Traits, _Ax>& wstr)
316 {
317 wstr.clear();
318 return readln_and_attach(wstr);
319 }
320
326 template<class _Traits = std::char_traits<wchar_t>, class _Ax = std::allocator<wchar_t>>
327 size_t readln(_Inout_ std::basic_string<wchar_t, _Traits, _Ax>& wstr, _In_ charset_id charset)
328 {
329 if (charset == charset_id::utf16)
330 return readln(wstr);
331 std::string str;
332 readln_and_attach(str);
333 wstr.clear();
334 str2wstr(wstr, str, charset);
335 return wstr.size();
336 }
337
343 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
344 size_t readln_and_attach(_Inout_ std::basic_string<_Elem, _Traits, _Ax>& str)
345 {
346 bool initial = true;
347 _Elem chr, previous = (_Elem)0;
348 do {
349 read_array(&chr, sizeof(_Elem), 1);
350 if (!initial && !(previous == static_cast<_Elem>('\r') && chr == static_cast<_Elem>('\n')))
351 str += previous;
352 else
353 initial = false;
354 previous = chr;
355 } while (ok() && chr != static_cast<_Elem>('\n'));
356 return str.size();
357 }
358
364 template<class _Traits = std::char_traits<wchar_t>, class _Ax = std::allocator<wchar_t>>
365 size_t readln_and_attach(_Inout_ std::basic_string<wchar_t, _Traits, _Ax>& wstr, _In_ charset_id charset)
366 {
367 if (charset == charset_id::utf16)
368 return readln_and_attach(wstr);
369 std::string str;
370 readln_and_attach(str);
371 str2wstr(wstr, str, charset);
372 return wstr.size();
373 }
374
380 size_t read_array(_Out_writes_bytes_(size* count) void* array, _In_ size_t size, _In_ size_t count)
381 {
382 for (size_t to_read = mul(size, count);;) {
383 size_t num_read = read(array, to_read);
384 to_read -= num_read;
385 if (!to_read)
386 return count;
387 if (!ok()) _Unlikely_
388 return count - to_read / size;
389 reinterpret_cast<uint8_t*&>(array) += num_read;
390 }
391 }
392
398 inline size_t write_array(_In_reads_bytes_opt_(size* count) const void* array, _In_ size_t size, _In_ size_t count)
399 {
400 return write(array, mul(size, count)) / size;
401 }
402
411 size_t write_array(_In_z_ const wchar_t* wstr, _In_ charset_id charset)
412 {
413 if (!ok()) _Unlikely_
414 return 0;
415 size_t num_chars = stdex::strlen(wstr);
416 if (charset != charset_id::utf16) {
417 std::string str(wstr2str(wstr, num_chars, charset));
418 return write_array(str.data(), sizeof(char), str.size());
419 }
420 return write_array(wstr, sizeof(wchar_t), num_chars);
421 }
422
432 size_t write_array(_In_reads_or_z_opt_(num_chars) const wchar_t* wstr, _In_ size_t num_chars, _In_ charset_id charset)
433 {
434 if (!ok()) _Unlikely_
435 return 0;
436 num_chars = stdex::strnlen(wstr, num_chars);
437 if (charset != charset_id::utf16) {
438 std::string str(wstr2str(wstr, num_chars, charset));
439 return write_array(str.data(), sizeof(char), str.size());
440 }
441 return write_array(wstr, sizeof(wchar_t), num_chars);
442 }
443
452 template<class _Traits = std::char_traits<wchar_t>, class _Ax = std::allocator<wchar_t>>
453 size_t write_array(_In_ const std::basic_string<wchar_t, _Traits, _Ax>& wstr, _In_ charset_id charset)
454 {
455 if (!ok()) _Unlikely_
456 return 0;
457 if (charset != charset_id::utf16) {
458 std::string str(wstr2str(wstr, charset));
459 return write_array(str.data(), sizeof(char), str.size());
460 }
461 return write_array(wstr.data(), sizeof(wchar_t), wstr.size());
462 }
463
475 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
476 inline basic& read_str(_Inout_ std::basic_string<_Elem, _Traits, _Ax>& data)
477 {
478 uint32_t num_chars;
479 read_data(num_chars);
480 if (!ok()) _Unlikely_ {
481 data.clear();
482 return *this;
483 }
484 data.resize(num_chars);
485 data.resize(read_array(data.data(), sizeof(_Elem), num_chars));
486 return *this;
487 }
488
500 template <class T>
501 inline basic& write_str(_In_z_ const T* data)
502 {
503 // Stream state will be checked in write_data.
504 size_t num_chars = stdex::strlen(data);
505 if (num_chars > UINT32_MAX)
506 throw std::invalid_argument("string too long");
507 write_data((uint32_t)num_chars);
508 if (!ok()) _Unlikely_
509 return *this;
510 write_array(data, sizeof(T), num_chars);
511 return *this;
512 }
513
514#ifdef _WIN32
520 size_t write_sa(_In_ LPSAFEARRAY sa)
521 {
522 safearray_accessor<void> a(sa);
523 long ubound, lbound;
524 if (FAILED(SafeArrayGetUBound(sa, 1, &ubound)) ||
525 FAILED(SafeArrayGetLBound(sa, 1, &lbound)))
526 throw std::invalid_argument("SafeArrayGet[UL]Bound failed");
527 return write(a.data(), static_cast<size_t>(ubound) - lbound + 1);
528 }
529#endif
530
536 fsize_t write_stream(_Inout_ basic& stream, _In_ fsize_t amount = fsize_max)
537 {
538 std::unique_ptr<uint8_t[]> data(new uint8_t[static_cast<size_t>(std::min<fsize_t>(amount, default_block_size))]);
539 fsize_t num_copied = 0, to_write = amount;
540 m_state = state_t::ok;
541 while (to_write) {
542 size_t num_read = stream.read(data.get(), static_cast<size_t>(std::min<fsize_t>(default_block_size, to_write)));
543 size_t num_written = write(data.get(), num_read);
544 num_copied += num_written;
545 to_write -= num_written;
546 if (stream.m_state == state_t::eof) {
547 // EOF is not an error.
548 m_state = state_t::ok;
549 break;
550 }
551 m_state = stream.m_state;
552 if (!ok())
553 break;
554 }
555 return num_copied;
556 }
557
561 void write_charset(_In_ charset_id charset)
562 {
563 if (charset == charset_id::utf16)
564 write_data(utf16_bom);
565 else if (charset == charset_id::utf8)
566 write_array(utf8_bom, sizeof(utf8_bom), 1);
567 }
568
574 size_t write_sprintf(_In_z_ _Printf_format_string_params_(2) const char* format, _In_opt_ locale_t locale, ...)
575 {
576 va_list params;
577 va_start(params, locale);
578 size_t num_chars = write_vsprintf(format, locale, params);
579 va_end(params);
580 return num_chars;
581 }
582
588 size_t write_sprintf(_In_z_ _Printf_format_string_params_(2) const wchar_t* format, _In_opt_ locale_t locale, ...)
589 {
590 va_list params;
591 va_start(params, locale);
592 size_t num_chars = write_vsprintf(format, locale, params);
593 va_end(params);
594 return num_chars;
595 }
596
602 size_t write_vsprintf(_In_z_ _Printf_format_string_params_(2) const char* format, _In_opt_ locale_t locale, _In_ va_list params)
603 {
604 std::string str;
605 str.reserve(default_block_size);
606 vappendf(str, format, locale, params);
607 return write_array(str.data(), sizeof(char), str.size());
608 }
609
615 size_t write_vsprintf(_In_z_ _Printf_format_string_params_(2) const wchar_t* format, _In_opt_ locale_t locale, _In_ va_list params)
616 {
617 std::wstring str;
618 str.reserve(default_block_size);
619 vappendf(str, format, locale, params);
620 return write_array(str.data(), sizeof(wchar_t), str.size());
621 }
622
623 inline basic& operator >>(_Out_ int8_t& data) { return read_data(data); }
624 inline basic& operator <<(_In_ const int8_t data) { return write_data(data); }
625 inline basic& operator >>(_Out_ int16_t& data) { return read_data(data); }
626 inline basic& operator <<(_In_ const int16_t data) { return write_data(data); }
627 inline basic& operator >>(_Out_ int32_t& data) { return read_data(data); }
628 inline basic& operator <<(_In_ const int32_t data) { return write_data(data); }
629 inline basic& operator >>(_Out_ int64_t& data) { return read_data(data); }
630 inline basic& operator <<(_In_ const int64_t data) { return write_data(data); }
631 inline basic& operator >>(_Out_ uint8_t& data) { return read_data(data); }
632 inline basic& operator <<(_In_ const uint8_t data) { return write_data(data); }
633 inline basic& operator >>(_Out_ uint16_t& data) { return read_data(data); }
634 inline basic& operator <<(_In_ const uint16_t data) { return write_data(data); }
635 inline basic& operator >>(_Out_ uint32_t& data) { return read_data(data); }
636 inline basic& operator <<(_In_ const uint32_t data) { return write_data(data); }
637 inline basic& operator >>(_Out_ uint64_t& data) { return read_data(data); }
638 inline basic& operator <<(_In_ const uint64_t data) { return write_data(data); }
639 inline basic& operator >>(_Out_ float& data) { return read_data(data); }
640 inline basic& operator <<(_In_ const float data) { return write_data(data); }
641 inline basic& operator >>(_Out_ double& data) { return read_data(data); }
642 inline basic& operator <<(_In_ const double data) { return write_data(data); }
643 inline basic& operator >>(_Out_ char& data) { return read_data(data); }
644 inline basic& operator <<(_In_ const char data) { return write_data(data); }
645#ifdef _NATIVE_WCHAR_T_DEFINED
646 inline basic& operator >>(_Out_ wchar_t& data) { return read_data(data); }
647 inline basic& operator <<(_In_ const wchar_t data) { return write_data(data); }
648#endif
649 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
650 inline basic& operator >>(_Inout_ std::basic_string<_Elem, _Traits, _Ax>& data) { return read_str(data); }
651 template <class T>
652 inline basic& operator <<(_In_ const T* data) { return write_str(data); }
653
654 protected:
655 state_t m_state;
656 };
657
661 using fpos_t = uint64_t;
662 constexpr fpos_t fpos_max = UINT64_MAX;
663 constexpr fpos_t fpos_min = 0;
664
668 using foff_t = int64_t;
669 constexpr foff_t foff_max = INT64_MAX;
670 constexpr foff_t foff_min = INT64_MIN;
671
675 enum class seek_t {
676#ifdef _WIN32
677 beg = FILE_BEGIN,
678 cur = FILE_CURRENT,
679 end = FILE_END
680#else
681 beg = SEEK_SET,
682 cur = SEEK_CUR,
683 end = SEEK_END
684#endif
685 };
686
687#if _HAS_CXX20
688 using clock = std::chrono::file_clock;
689#else
690 using clock = std::chrono::system_clock;
691#endif
692 using time_point = std::chrono::time_point<clock>;
693
697 class basic_file : virtual public basic
698 {
699 public:
700 virtual std::vector<uint8_t> read_remainder(_In_ size_t max_length = SIZE_MAX)
701 {
702 size_t length = std::min<size_t>(max_length, static_cast<size_t>(size() - tell()));
703 std::vector<uint8_t> result;
704 try { result.resize(length); }
705 catch (const std::bad_alloc&) {
706 m_state = state_t::fail;
707 return result;
708 }
709 result.resize(read_array(result.data(), sizeof(uint8_t), length));
710 return result;
711 }
712
718 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg) = 0;
719
725 inline fpos_t seekbeg(_In_ fpos_t offset) { return seek(offset, seek_t::beg); }
726
732 inline fpos_t seekcur(_In_ foff_t offset) { return seek(offset, seek_t::cur); }
733
739 inline fpos_t seekend(_In_ foff_t offset) { return seek(offset, seek_t::end); }
740
741 virtual void skip(_In_ fsize_t amount)
742 {
743 seek(amount, seek_t::cur);
744 }
745
752 virtual fpos_t tell() const = 0;
753
757 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
758 {
759 _Unreferenced_(offset);
760 _Unreferenced_(length);
761 throw std::domain_error("not implemented");
762 }
763
767 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
768 {
769 _Unreferenced_(offset);
770 _Unreferenced_(length);
771 throw std::domain_error("not implemented");
772 }
773
778 virtual fsize_t size() = 0;
779
783 virtual void truncate() = 0;
784
788 virtual time_point ctime() const
789 {
790 return time_point::min();
791 }
792
796 virtual time_point atime() const
797 {
798 return time_point::min();
799 }
800
804 virtual time_point mtime() const
805 {
806 return time_point::min();
807 }
808
812 virtual void set_ctime(time_point date)
813 {
814 _Unreferenced_(date);
815 throw std::domain_error("not implemented");
816 }
817
821 virtual void set_atime(time_point date)
822 {
823 _Unreferenced_(date);
824 throw std::domain_error("not implemented");
825 }
826
830 virtual void set_mtime(time_point date)
831 {
832 _Unreferenced_(date);
833 throw std::domain_error("not implemented");
834 }
835
836#ifdef _WIN32
840 LPSAFEARRAY read_sa()
841 {
842 assert(size() <= SIZE_MAX);
843 size_t length = static_cast<size_t>(size());
844 std::unique_ptr<SAFEARRAY, SafeArrayDestroy_delete> sa(SafeArrayCreateVector(VT_UI1, 0, (ULONG)length));
845 if (!sa)
846 throw std::runtime_error("SafeArrayCreateVector failed");
847 safearray_accessor<void> a(sa.get());
848 if (seek(0) != 0)
849 throw std::runtime_error("failed to seek");
850 if (read_array(a.data(), 1, length) != length)
851 throw std::runtime_error("failed to read");
852 return sa.release();
853 }
854#endif
855
861 charset_id read_charset(_In_ charset_id default_charset = charset_id::system)
862 {
863 if (seek(0) != 0)
864 throw std::runtime_error("failed to seek");
865 wchar_t id_utf16;
866 read_array(&id_utf16, sizeof(wchar_t), 1);
867 if (!ok()) _Unlikely_
868 return default_charset;
869 if (id_utf16 == utf16_bom)
870 return charset_id::utf16;
871
872 if (seek(0) != 0)
873 throw std::runtime_error("failed to seek");
874 char id_utf8[3] = { 0 };
875 read_array(id_utf8, sizeof(id_utf8), 1);
876 if (!ok()) _Unlikely_
877 return default_charset;
878 if (strncmp(id_utf8, _countof(id_utf8), utf8_bom, _countof(utf8_bom)) == 0)
879 return charset_id::utf8;
880
881 if (seek(0) != 0)
882 throw std::runtime_error("failed to seek");
883 return default_charset;
884 }
885 };
886
890 class converter : public basic
891 {
892 protected:
893 explicit converter() :
894 basic(state_t::fail),
895 m_source(nullptr)
896 {}
897
898 void init(_Inout_ basic& source)
899 {
900 m_state = source.state();
901 m_source = &source;
902 }
903
904 void done()
905 {
906 m_source = nullptr;
907 }
908
909 public:
910 converter(_Inout_ basic& source) :
911 basic(source.state()),
912 m_source(&source)
913 {}
914
915 virtual _Success_(return != 0 || length == 0) size_t read(
916 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
917 {
918 size_t num_read = m_source->read(data, length);
919 m_state = m_source->state();
920 return num_read;
921 }
922
923 virtual _Success_(return != 0) size_t write(
924 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
925 {
926 size_t num_written = m_source->write(data, length);
927 m_state = m_source->state();
928 return num_written;
929 }
930
931 virtual void close()
932 {
933 m_source->close();
934 m_state = m_source->state();
935 }
936
937 virtual void flush()
938 {
939 m_source->flush();
940 m_state = m_source->state();
941 }
942
943 protected:
944 basic* m_source;
945 };
946
950 class replicator : public basic
951 {
952 public:
953 virtual ~replicator()
954 {
955 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
956 auto _w = w->get();
957 {
958 const std::lock_guard<std::mutex> lk(_w->mutex);
959 _w->op = worker::op_t::quit;
960 }
961 _w->cv.notify_one();
962 }
963 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w)
964 w->get()->thread.join();
965 }
966
970 void push_back(_In_ basic* source)
971 {
972 m_workers.push_back(std::unique_ptr<worker>(new worker(source)));
973 }
974
978 void remove(basic* source)
979 {
980 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
981 auto _w = w->get();
982 if (_w->source == source) {
983 {
984 const std::lock_guard<std::mutex> lk(_w->mutex);
985 _w->op = worker::op_t::quit;
986 }
987 _w->cv.notify_one();
988 _w->thread.join();
989 m_workers.erase(w);
990 return;
991 }
992 }
993 }
994
995 virtual _Success_(return != 0) size_t write(
996 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
997 {
998 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
999 auto _w = w->get();
1000 {
1001 const std::lock_guard<std::mutex> lk(_w->mutex);
1002 _w->op = worker::op_t::write;
1003 _w->data = data;
1004 _w->length = length;
1005 }
1006 _w->cv.notify_one();
1007 }
1008 size_t num_written = length;
1009 m_state = state_t::ok;
1010 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1011 auto _w = w->get();
1012 std::unique_lock<std::mutex> lk(_w->mutex);
1013 _w->cv.wait(lk, [&] {return _w->op == worker::op_t::noop; });
1014 if (_w->num_written < num_written)
1015 num_written = _w->num_written;
1016 if (ok() && !_w->source->ok())
1017 m_state = _w->source->state();
1018 }
1019 return num_written;
1020 }
1021
1022 virtual void close()
1023 {
1024 foreach_worker(worker::op_t::close);
1025 }
1026
1027 virtual void flush()
1028 {
1029 foreach_worker(worker::op_t::flush);
1030 }
1031
1032 protected:
1033 class worker
1034 {
1035 public:
1036 worker(_In_ basic* _source) :
1037 source(_source),
1038 op(op_t::noop),
1039 data(nullptr),
1040 length(0),
1041 num_written(0),
1042 thread(process_op, std::ref(*this))
1043 {}
1044
1045 protected:
1046 static void process_op(_Inout_ worker& w)
1047 {
1048 for (;;) {
1049 std::unique_lock<std::mutex> lk(w.mutex);
1050 w.cv.wait(lk, [&] {return w.op != op_t::noop; });
1051 switch (w.op) {
1052 case op_t::quit:
1053 return;
1054 case op_t::write:
1055 w.num_written = w.source->write(w.data, w.length);
1056 break;
1057 case op_t::close:
1058 w.source->close();
1059 break;
1060 case op_t::flush:
1061 w.source->flush();
1062 break;
1063 case op_t::noop:;
1064 }
1065 w.op = op_t::noop;
1066 lk.unlock();
1067 w.cv.notify_one();
1068 }
1069 }
1070
1071 public:
1072 basic* source;
1073 enum class op_t {
1074 noop = 0,
1075 quit,
1076 write,
1077 close,
1078 flush,
1079 } op;
1080 const void* data;
1081 size_t length;
1082 size_t num_written;
1083 std::mutex mutex;
1084 std::condition_variable cv;
1085 std::thread thread;
1086 };
1087
1088 void foreach_worker(_In_ worker::op_t op)
1089 {
1090 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1091 auto _w = w->get();
1092 {
1093 const std::lock_guard<std::mutex> lk(_w->mutex);
1094 _w->op = op;
1095 }
1096 _w->cv.notify_one();
1097 }
1098 m_state = state_t::ok;
1099 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1100 auto _w = w->get();
1101 std::unique_lock<std::mutex> lk(_w->mutex);
1102 _w->cv.wait(lk, [&] {return _w->op == worker::op_t::noop; });
1103 if (ok())
1104 m_state = _w->source->state();
1105 }
1106 }
1107
1108 std::list<std::unique_ptr<worker>> m_workers;
1109 };
1110
1111 constexpr size_t default_async_limit = 0x100000;
1112
1118 template <size_t CAPACITY = default_async_limit>
1119 class async_reader : public converter
1120 {
1121 public:
1122 async_reader(_Inout_ basic& source) :
1123 converter(source),
1124 m_worker(process, std::ref(*this))
1125 {}
1126
1127 virtual ~async_reader()
1128 {
1129 m_ring.quit();
1130 m_worker.join();
1131 }
1132
1133#pragma warning(suppress: 6101) // See [1] below
1134 virtual _Success_(return != 0 || length == 0) size_t read(
1135 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1136 {
1137 assert(data || !length);
1138 for (size_t to_read = length;;) {
1139 uint8_t* ptr; size_t num_read;
1140 std::tie(ptr, num_read) = m_ring.front();
1141 if (!ptr) _Unlikely_ {
1142 // [1] Code analysis misses length - to_read bytes were written to data in previous loop iterations.
1143 m_state = to_read < length || !length ? state_t::ok : m_source->state();
1144 return length - to_read;
1145 }
1146 if (to_read < num_read)
1147 num_read = to_read;
1148 memcpy(data, ptr, num_read);
1149 m_ring.pop(num_read);
1150 to_read -= num_read;
1151 if (!to_read) {
1152 m_state = state_t::ok;
1153 return length;
1154 }
1155 reinterpret_cast<uint8_t*&>(data) += num_read;
1156 }
1157 }
1158
1159 protected:
1160 static void process(_Inout_ async_reader& w)
1161 {
1162 for (;;) {
1163 uint8_t* ptr; size_t num_write;
1164 std::tie(ptr, num_write) = w.m_ring.back();
1165 if (!ptr) _Unlikely_
1166 break;
1167 num_write = w.m_source->read(ptr, num_write);
1168 w.m_ring.push(num_write);
1169 if (!w.m_source->ok()) {
1170 w.m_ring.quit();
1171 break;
1172 }
1173 }
1174 }
1175
1176 protected:
1177 ring<uint8_t, CAPACITY> m_ring;
1178 std::thread m_worker;
1179 };
1180
1186 template <size_t CAPACITY = default_async_limit>
1187 class async_writer : public converter
1188 {
1189 public:
1190 async_writer(_Inout_ basic& source) :
1191 converter(source),
1192 m_worker(process, std::ref(*this))
1193 {}
1194
1195 virtual ~async_writer()
1196 {
1197 m_ring.quit();
1198 m_worker.join();
1199 }
1200
1201 virtual _Success_(return != 0) size_t write(
1202 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1203 {
1204 assert(data || !length);
1205 for (size_t to_write = length;;) {
1206 uint8_t* ptr; size_t num_write;
1207 std::tie(ptr, num_write) = m_ring.back();
1208 if (!ptr) _Unlikely_ {
1209 m_state = state_t::fail;
1210 return length - to_write;
1211 }
1212 if (to_write < num_write)
1213 num_write = to_write;
1214 memcpy(ptr, data, num_write);
1215 m_ring.push(num_write);
1216 to_write -= num_write;
1217 if (!to_write) {
1218 m_state = state_t::ok;
1219 return length;
1220 }
1221 reinterpret_cast<const uint8_t*&>(data) += num_write;
1222 }
1223 }
1224
1225 virtual void flush()
1226 {
1227 m_ring.sync();
1228 converter::flush();
1229 }
1230
1231 protected:
1232 static void process(_Inout_ async_writer& w)
1233 {
1234 for (;;) {
1235 uint8_t* ptr; size_t num_read;
1236 std::tie(ptr, num_read) = w.m_ring.front();
1237 if (!ptr)
1238 break;
1239 num_read = w.m_source->write(ptr, num_read);
1240 w.m_ring.pop(num_read);
1241 if (!w.m_source->ok()) {
1242 w.m_ring.quit();
1243 break;
1244 }
1245 }
1246 }
1247
1248 protected:
1249 ring<uint8_t, CAPACITY> m_ring;
1250 std::thread m_worker;
1251 };
1252
1253 constexpr size_t default_buffer_size = 0x400;
1254
1258 class buffer : public converter
1259 {
1260 protected:
1261 explicit buffer(_In_ size_t read_buffer_size = default_buffer_size, _In_ size_t write_buffer_size = default_buffer_size) :
1262 converter(),
1263 m_read_buffer(read_buffer_size),
1264 m_write_buffer(write_buffer_size)
1265 {}
1266
1267 void done()
1268 {
1269 if (m_source)
1270 flush_write();
1271 converter::done();
1272 }
1273
1274 public:
1275 buffer(_Inout_ basic& source, _In_ size_t read_buffer_size = default_buffer_size, _In_ size_t write_buffer_size = default_buffer_size) :
1276 converter(source),
1277 m_read_buffer(read_buffer_size),
1278 m_write_buffer(write_buffer_size)
1279 {}
1280
1281 virtual ~buffer()
1282 {
1283 if (m_source)
1284 flush_write();
1285 }
1286
1287 virtual _Success_(return != 0 || length == 0) size_t read(
1288 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1289 {
1290 assert(data || !length);
1291 for (size_t to_read = length;;) {
1292 size_t buffer_size = m_read_buffer.tail - m_read_buffer.head;
1293 if (to_read <= buffer_size) {
1294 memcpy(data, m_read_buffer.data + m_read_buffer.head, to_read);
1295 m_read_buffer.head += to_read;
1296 m_state = state_t::ok;
1297 return length;
1298 }
1299 if (buffer_size) {
1300 memcpy(data, m_read_buffer.data + m_read_buffer.head, buffer_size);
1301 reinterpret_cast<uint8_t*&>(data) += buffer_size;
1302 to_read -= buffer_size;
1303 }
1304 m_read_buffer.head = 0;
1305 if (to_read > m_read_buffer.capacity) {
1306 // When needing to read more data than buffer capacity, bypass the buffer.
1307 m_read_buffer.tail = 0;
1308 to_read -= m_source->read(data, to_read);
1309 m_state = to_read < length ? state_t::ok : m_source->state();
1310 return length - to_read;
1311 }
1312 m_read_buffer.tail = m_source->read(m_read_buffer.data, m_read_buffer.capacity);
1313 if (m_read_buffer.tail < m_read_buffer.capacity && m_read_buffer.tail < to_read) _Unlikely_ {
1314 memcpy(data, m_read_buffer.data, m_read_buffer.tail);
1315 m_read_buffer.head = m_read_buffer.tail;
1316 to_read -= m_read_buffer.tail;
1317 m_state = to_read < length ? state_t::ok : m_source->state();
1318 return length - to_read;
1319 }
1320 }
1321 }
1322
1323 virtual _Success_(return != 0) size_t write(
1324 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1325 {
1326 assert(data || !length);
1327 if (!length) _Unlikely_ {
1328 // Pass null writes (zero-byte length). Null write operations have special meaning with with Windows pipes.
1329 flush_write();
1330 if (!ok()) _Unlikely_
1331 return 0;
1332 m_source->write(nullptr, 0);
1333 m_state = m_source->state();
1334 return 0;
1335 }
1336
1337 for (size_t to_write = length;;) {
1338 size_t available_buffer = m_write_buffer.capacity - m_write_buffer.tail;
1339 if (to_write <= available_buffer) {
1340 memcpy(m_write_buffer.data + m_write_buffer.tail, data, to_write);
1341 m_write_buffer.tail += to_write;
1342 m_state = state_t::ok;
1343 return length;
1344 }
1345 if (available_buffer) {
1346 memcpy(m_write_buffer.data + m_write_buffer.tail, data, available_buffer);
1347 reinterpret_cast<const uint8_t*&>(data) += available_buffer;
1348 to_write -= available_buffer;
1349 m_write_buffer.tail += available_buffer;
1350 }
1351 size_t buffer_size = m_write_buffer.tail - m_write_buffer.head;
1352 if (buffer_size) {
1353 m_write_buffer.head += m_source->write(m_write_buffer.data + m_write_buffer.head, buffer_size);
1354 m_state = m_source->state();
1355 if (m_write_buffer.head == m_write_buffer.tail)
1356 m_write_buffer.head = m_write_buffer.tail = 0;
1357 else
1358 return length - to_write;
1359 }
1360 if (to_write > m_write_buffer.capacity) {
1361 // When needing to write more data than buffer capacity, bypass the buffer.
1362 to_write -= m_source->write(data, to_write);
1363 m_state = m_source->state();
1364 return length - to_write;
1365 }
1366 }
1367 }
1368
1369 virtual void flush()
1370 {
1371 flush_write();
1372 if (ok())
1373 converter::flush();
1374 }
1375
1376 protected:
1377 void flush_write()
1378 {
1379 size_t buffer_size = m_write_buffer.tail - m_write_buffer.head;
1380 if (buffer_size) {
1381 m_write_buffer.head += m_source->write(m_write_buffer.data + m_write_buffer.head, buffer_size);
1382 if (m_write_buffer.head == m_write_buffer.tail) {
1383 m_write_buffer.head = 0;
1384 m_write_buffer.tail = 0;
1385 }
1386 else {
1387 m_state = m_source->state();
1388 return;
1389 }
1390 }
1391 m_state = state_t::ok;
1392 }
1393
1394 struct buffer_t {
1395 uint8_t* data;
1396 size_t head, tail, capacity;
1397
1398 buffer_t(_In_ size_t buffer_size) :
1399 head(0),
1400 tail(0),
1401 capacity(buffer_size),
1402 data(buffer_size ? new uint8_t[buffer_size] : nullptr)
1403 {}
1404
1405 ~buffer_t()
1406 {
1407 if (data)
1408 delete[] data;
1409 }
1410 } m_read_buffer, m_write_buffer;
1411 };
1412
1416 class limiter : public converter
1417 {
1418 public:
1419 limiter(_Inout_ basic& source, _In_ fsize_t _read_limit = 0, _In_ fsize_t _write_limit = 0) :
1420 converter(source),
1421 read_limit(_read_limit),
1422 write_limit(_write_limit)
1423 {}
1424
1425 virtual _Success_(return != 0 || length == 0) size_t read(
1426 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1427 {
1428 size_t num_read;
1429 if (read_limit == fsize_max) {
1430 num_read = m_source->read(data, length);
1431 m_state = m_source->state();
1432 }
1433 else if (length <= read_limit) {
1434 num_read = m_source->read(data, length);
1435 m_state = m_source->state();
1436 read_limit -= num_read;
1437 }
1438 else if (length && !read_limit) {
1439 num_read = 0;
1440 m_state = state_t::eof;
1441 }
1442 else {
1443 num_read = m_source->read(data, static_cast<size_t>(read_limit));
1444 m_state = m_source->state();
1445 read_limit -= num_read;
1446 }
1447 return num_read;
1448 }
1449
1450 virtual _Success_(return != 0) size_t write(
1451 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1452 {
1453 size_t num_written;
1454 if (write_limit == fsize_max) {
1455 num_written = m_source->write(data, length);
1456 m_state = m_source->state();
1457 }
1458 else if (length <= write_limit) {
1459 num_written = m_source->write(data, length);
1460 m_state = m_source->state();
1461 write_limit -= num_written;
1462 }
1463 else if (length && !write_limit) {
1464 num_written = 0;
1465 m_state = state_t::fail;
1466 }
1467 else {
1468 num_written = m_source->write(data, static_cast<size_t>(write_limit));
1469 m_state = m_source->state();
1470 write_limit -= num_written;
1471 }
1472 return num_written;
1473 }
1474
1475 public:
1476 fsize_t
1477 read_limit,
1478 write_limit;
1479 };
1480
1484 class window : public limiter
1485 {
1486 public:
1487 window(_Inout_ basic& source, _In_ fpos_t _read_offset = 0, _In_ fsize_t read_limit = fsize_max, _In_ fpos_t _write_offset = 0, _In_ fsize_t write_limit = fsize_max) :
1488 limiter(source, read_limit, write_limit),
1489 read_offset(_read_offset),
1490 write_offset(_write_offset)
1491 {}
1492
1493 virtual _Success_(return != 0 || length == 0) size_t read(
1494 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1495 {
1496 if (read_offset) {
1497 m_source->skip(read_offset);
1498 m_state = m_source->state();
1499 if (!ok()) _Unlikely_
1500 return 0;
1501 read_offset = 0;
1502 }
1503 size_t num_read;
1504 if (read_limit == fsize_max) {
1505 num_read = m_source->read(data, length);
1506 m_state = m_source->state();
1507 }
1508 else if (length <= read_limit) {
1509 num_read = m_source->read(data, length);
1510 m_state = m_source->state();
1511 read_limit -= num_read;
1512 }
1513 else if (length && !read_limit) {
1514 num_read = 0;
1515 m_source->skip(length);
1516 m_state = state_t::eof;
1517 }
1518 else {
1519 num_read = m_source->read(data, static_cast<size_t>(read_limit));
1520 m_state = m_source->state();
1521 read_limit -= num_read;
1522 }
1523 return num_read;
1524 }
1525
1526 virtual _Success_(return != 0) size_t write(
1527 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1528 {
1529 size_t num_skipped, num_written;
1530 if (length <= write_offset) {
1531 write_offset -= length;
1532 m_state = state_t::ok;
1533 return length;
1534 }
1535 if (write_offset) {
1536 reinterpret_cast<const uint8_t*&>(data) += static_cast<size_t>(write_offset);
1537 length -= static_cast<size_t>(write_offset);
1538 num_skipped = static_cast<size_t>(write_offset);
1539 write_offset = 0;
1540 }
1541 else
1542 num_skipped = 0;
1543 if (write_limit == fsize_max) {
1544 num_written = m_source->write(data, length);
1545 m_state = m_source->state();
1546 }
1547 else if (length <= write_limit) {
1548 num_written = m_source->write(data, length);
1549 m_state = m_source->state();
1550 write_limit -= num_written;
1551 }
1552 else if (length && !write_limit) {
1553 num_skipped += length;
1554 num_written = 0;
1555 m_state = state_t::ok;
1556 }
1557 else {
1558 num_skipped += length - static_cast<size_t>(write_limit);
1559 num_written = m_source->write(data, static_cast<size_t>(write_limit));
1560 m_state = m_source->state();
1561 write_limit -= num_written;
1562 }
1563 return num_skipped + num_written;
1564 }
1565
1566 public:
1567 fpos_t
1568 read_offset,
1569 write_offset;
1570 };
1571
1575 class file_window : public basic_file
1576 {
1577 public:
1578 file_window(_Inout_ basic_file& source, fpos_t offset = 0, fsize_t length = 0) :
1579 basic(source.state()),
1580 m_source(source),
1581 m_offset(source.tell()),
1582 m_region(offset, offset + length)
1583 {}
1584
1585 virtual _Success_(return != 0 || length == 0) size_t read(
1586 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1587 {
1588 assert(data || !length);
1589 if (m_region.contains(m_offset)) {
1590 size_t num_read = m_source.read(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
1591 m_state = m_source.state();
1592 m_offset += num_read;
1593 return num_read;
1594 }
1595 m_state = length ? state_t::eof : state_t::ok;
1596 return 0;
1597 }
1598
1599 virtual _Success_(return != 0) size_t write(
1600 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1601 {
1602 assert(data || !length);
1603 if (m_region.contains(m_offset)) {
1604 size_t num_written = m_source.write(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
1605 m_state = m_source.state();
1606 m_offset += num_written;
1607 return num_written;
1608 }
1609 m_state = state_t::fail;
1610 return 0;
1611 }
1612
1613 virtual void close()
1614 {
1615 m_source.close();
1616 m_state = m_source.state();
1617 }
1618
1619 virtual void flush()
1620 {
1621 m_source.flush();
1622 m_state = m_source.state();
1623 }
1624
1625 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
1626 {
1627 m_offset = m_source.seek(offset, how);
1628 m_state = m_source.state();
1629 return ok() ? m_offset - m_region.start : fpos_max;
1630 }
1631
1632 virtual void skip(_In_ fsize_t amount)
1633 {
1634 m_source.skip(amount);
1635 m_state = m_source.state();
1636 }
1637
1638 virtual fpos_t tell() const
1639 {
1640 fpos_t offset = m_source.tell();
1641 return m_region.contains(offset) ? offset - m_region.start : fpos_max;
1642 }
1643
1644 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
1645 {
1646 if (m_region.contains(offset)) {
1647 m_source.lock(m_region.start + offset, std::min<fsize_t>(length, m_region.end - offset));
1648 m_state = m_source.state();
1649 }
1650 else
1651 m_state = state_t::fail;
1652 }
1653
1654 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
1655 {
1656 if (m_region.contains(offset)) {
1657 m_source.unlock(m_region.start + offset, std::min<fsize_t>(length, m_region.end - offset));
1658 m_state = m_source.state();
1659 }
1660 else
1661 m_state = state_t::fail;
1662 }
1663
1664 virtual fsize_t size()
1665 {
1666 return m_region.size();
1667 }
1668
1669 virtual void truncate()
1670 {
1671 m_state = state_t::fail;
1672 }
1673
1674 protected:
1675 basic_file& m_source;
1676 fpos_t m_offset;
1677 interval<fpos_t> m_region;
1678 };
1679
1680 constexpr size_t default_cache_size = 0x1000;
1681
1685 class cache : public basic_file
1686 {
1687 protected:
1688 explicit cache(_In_ size_t cache_size = default_cache_size) :
1689 basic(state_t::fail),
1690 m_source(nullptr),
1691 m_cache(cache_size),
1692 m_offset(0)
1693#if SET_FILE_OP_TIMES
1694 , m_atime(time_point::min()),
1695 m_mtime(time_point::min())
1696#endif
1697 {}
1698
1699 void init(_Inout_ basic_file& source)
1700 {
1701 m_state = source.state();
1702 m_source = &source;
1703 m_offset = source.tell();
1704#if SET_FILE_OP_TIMES
1705 m_atime = source.atime();
1706 m_mtime = source.mtime();
1707#endif
1708 }
1709
1710 void done()
1711 {
1712 if (m_source) {
1713 flush_cache();
1714 if (!ok()) _Unlikely_
1715 throw std::runtime_error("cache flush failed"); // Data loss occured
1716 m_source->seek(m_offset);
1717 m_source = nullptr;
1718 }
1719 }
1720
1721 public:
1722 cache(_Inout_ basic_file& source, _In_ size_t cache_size = default_cache_size) :
1723 basic(source.state()),
1724 m_source(&source),
1725 m_cache(cache_size),
1726 m_offset(source.tell())
1727#if SET_FILE_OP_TIMES
1728 , m_atime(source.atime()),
1729 m_mtime(source.mtime())
1730#endif
1731 {}
1732
1733 virtual ~cache() noexcept(false)
1734 {
1735 if (m_source) {
1736 flush_cache();
1737 if (!ok()) _Unlikely_
1738 throw std::runtime_error("cache flush failed"); // Data loss occured
1739 m_source->seek(m_offset);
1740 }
1741 }
1742
1743 virtual _Success_(return != 0 || length == 0) size_t read(
1744 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1745 {
1746 assert(data || !length);
1747#if SET_FILE_OP_TIMES
1748 m_atime = time_point::now();
1749#endif
1750 for (size_t to_read = length;;) {
1751 if (m_cache.status != cache_t::cache_t::status_t::empty) {
1752 if (m_cache.region.contains(m_offset)) {
1753 size_t remaining_cache = static_cast<size_t>(m_cache.region.end - m_offset);
1754 if (to_read <= remaining_cache) {
1755 memcpy(data, m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), to_read);
1756 m_offset += to_read;
1757 m_state = state_t::ok;
1758 return length;
1759 }
1760 memcpy(data, m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), remaining_cache);
1761 reinterpret_cast<uint8_t*&>(data) += remaining_cache;
1762 to_read -= remaining_cache;
1763 m_offset += remaining_cache;
1764 }
1765 flush_cache();
1766 if (!ok()) _Unlikely_ {
1767 if (to_read < length)
1768 m_state = state_t::ok;
1769 return length - to_read;
1770 }
1771 }
1772 {
1773 fpos_t end_max = m_offset + to_read;
1774 if (m_offset / m_cache.capacity < end_max / m_cache.capacity) {
1775 // Read spans multiple cache blocks. Bypass cache to the last block.
1776 m_source->seek(m_offset);
1777 if (!m_source->ok()) _Unlikely_ {
1778 m_state = to_read < length ? state_t::ok : state_t::fail;
1779 return length - to_read;
1780 }
1781 size_t num_read = m_source->read(data, to_read - static_cast<size_t>(end_max % m_cache.capacity));
1782 m_offset += num_read;
1783 to_read -= num_read;
1784 if (!to_read) {
1785 m_state = state_t::ok;
1786 return length;
1787 }
1788 reinterpret_cast<uint8_t*&>(data) += num_read;
1789 m_state = m_source->state();
1790 if (!ok()) {
1791 if (to_read < length)
1792 m_state = state_t::ok;
1793 return length - to_read;
1794 }
1795 }
1796 }
1797 load_cache(m_offset);
1798 if (!ok() || m_cache.region.end <= m_offset) _Unlikely_ {
1799 m_state = to_read < length ? state_t::ok : state_t::fail;
1800 return length - to_read;
1801 }
1802 }
1803 }
1804
1805 virtual _Success_(return != 0) size_t write(
1806 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1807 {
1808 assert(data || !length);
1809#if SET_FILE_OP_TIMES
1810 m_atime = m_mtime = time_point::now();
1811#endif
1812 for (size_t to_write = length;;) {
1813 if (m_cache.status != cache_t::cache_t::status_t::empty) {
1814 fpos_t end_max = m_cache.region.start + m_cache.capacity;
1815 if (m_cache.region.start <= m_offset && m_offset < end_max) {
1816 size_t remaining_cache = static_cast<size_t>(end_max - m_offset);
1817 if (to_write <= remaining_cache) {
1818 memcpy(m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), data, to_write);
1819 m_offset += to_write;
1820 m_cache.status = cache_t::cache_t::status_t::dirty;
1821 m_cache.region.end = std::max(m_cache.region.end, m_offset);
1822 m_state = state_t::ok;
1823 return length;
1824 }
1825 memcpy(m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), data, remaining_cache);
1826 reinterpret_cast<const uint8_t*&>(data) += remaining_cache;
1827 to_write -= remaining_cache;
1828 m_offset += remaining_cache;
1829 m_cache.status = cache_t::cache_t::status_t::dirty;
1830 m_cache.region.end = end_max;
1831 }
1832 flush_cache();
1833 if (!ok()) _Unlikely_
1834 return length - to_write;
1835 }
1836 {
1837 fpos_t end_max = m_offset + to_write;
1838 if (m_offset / m_cache.capacity < end_max / m_cache.capacity) {
1839 // Write spans multiple cache blocks. Bypass cache to the last block.
1840 m_source->seek(m_offset);
1841 if (!ok()) _Unlikely_
1842 return length - to_write;
1843 size_t num_written = m_source->write(data, to_write - static_cast<size_t>(end_max % m_cache.capacity));
1844 m_offset += num_written;
1845 m_state = m_source->state();
1846 to_write -= num_written;
1847 if (!to_write || !ok())
1848 return length - to_write;
1849 reinterpret_cast<const uint8_t*&>(data) += num_written;
1850 }
1851 }
1852 load_cache(m_offset);
1853 if (!ok()) _Unlikely_
1854 return length - to_write;
1855 }
1856 }
1857
1858 virtual void close()
1859 {
1860 invalidate_cache();
1861 if (!ok()) _Unlikely_
1862 throw std::runtime_error("cache flush failed"); // Data loss occured
1863 m_source->close();
1864 m_state = m_source->state();
1865 }
1866
1867 virtual void flush()
1868 {
1869#if SET_FILE_OP_TIMES
1870 m_atime = m_mtime = time_point::min();
1871#endif
1872 flush_cache();
1873 if (!ok()) _Unlikely_
1874 return;
1875 m_source->flush();
1876 }
1877
1878 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
1879 {
1880 m_state = state_t::ok;
1881 switch (how) {
1882 case seek_t::beg:
1883 return m_offset = offset;
1884 case seek_t::cur:
1885 return m_offset += offset;
1886 case seek_t::end:
1887 return m_offset = size() + offset;
1888 default:
1889 throw std::invalid_argument("unknown seek origin");
1890 }
1891 }
1892
1893 virtual fpos_t tell() const
1894 {
1895 return m_offset;
1896 }
1897
1898 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
1899 {
1900 m_source->lock(offset, length);
1901 m_state = m_source->state();
1902 }
1903
1904 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
1905 {
1906 m_source->unlock(offset, length);
1907 m_state = m_source->state();
1908 }
1909
1910 virtual fsize_t size()
1911 {
1912 return m_cache.status != cache_t::cache_t::status_t::empty ?
1913 std::max(m_source->size(), m_cache.region.end) :
1914 m_source->size();
1915 }
1916
1917 virtual void truncate()
1918 {
1919#if SET_FILE_OP_TIMES
1920 m_atime = m_mtime = time_point::now();
1921#endif
1922 m_source->seek(m_offset);
1923 if (m_cache.region.end <= m_offset) {
1924 // Truncation does not affect cache.
1925 }
1926 else if (m_cache.region.start <= m_offset) {
1927 // Truncation truncates cache.
1928 m_cache.region.end = m_offset;
1929 }
1930 else {
1931 // Truncation invalidates cache.
1932 m_cache.status = cache_t::cache_t::status_t::empty;
1933 }
1934 m_source->truncate();
1935 m_state = m_source->state();
1936 }
1937
1938 virtual time_point ctime() const
1939 {
1940 return m_source->ctime();
1941 }
1942
1943 virtual time_point atime() const
1944 {
1945#if SET_FILE_OP_TIMES
1946 return std::max(m_atime, m_source->atime());
1947#else
1948 return m_source->atime();
1949#endif
1950 }
1951
1952 virtual time_point mtime() const
1953 {
1954#if SET_FILE_OP_TIMES
1955 return std::max(m_mtime, m_source->mtime());
1956#else
1957 return m_source->mtime();
1958#endif
1959 }
1960
1961 virtual void set_ctime(time_point date)
1962 {
1963 m_source->set_ctime(date);
1964 }
1965
1966 virtual void set_atime(time_point date)
1967 {
1968#if SET_FILE_OP_TIMES
1969 m_atime = date;
1970#endif
1971 m_source->set_atime(date);
1972 }
1973
1974 virtual void set_mtime(time_point date)
1975 {
1976#if SET_FILE_OP_TIMES
1977 m_mtime = date;
1978#endif
1979 m_source->set_mtime(date);
1980 }
1981
1982 protected:
1983 void flush_cache()
1984 {
1985 if (m_cache.status != cache_t::cache_t::status_t::dirty)
1986 m_state = state_t::ok;
1987 else if (!m_cache.region.empty()) {
1988 write_cache();
1989 if (ok())
1990 m_cache.status = cache_t::cache_t::status_t::loaded;
1991 }
1992 else {
1993 m_state = state_t::ok;
1994 m_cache.status = cache_t::cache_t::status_t::loaded;
1995 }
1996 }
1997
1998 void invalidate_cache()
1999 {
2000 if (m_cache.status == cache_t::cache_t::status_t::dirty && !m_cache.region.empty()) {
2001 write_cache();
2002 if (!ok()) _Unlikely_
2003 return;
2004 } else
2005 m_state = state_t::ok;
2006 m_cache.status = cache_t::cache_t::status_t::empty;
2007 }
2008
2009 void load_cache(_In_ fpos_t start)
2010 {
2011 assert(m_cache.status != cache_t::cache_t::status_t::dirty);
2012 start -= start % m_cache.capacity; // Align to cache block size.
2013 m_source->seek(m_cache.region.start = start);
2014 if (m_source->ok()) {
2015 m_cache.region.end = start + m_source->read(m_cache.data, m_cache.capacity);
2016 m_cache.status = cache_t::cache_t::status_t::loaded;
2017 m_state = state_t::ok; // Regardless the read failure, we still might have cached some data.
2018 }
2019 else
2020 m_state = state_t::fail;
2021 }
2022
2023 void write_cache()
2024 {
2025 assert(m_cache.status == cache_t::cache_t::status_t::dirty);
2026 m_source->seek(m_cache.region.start);
2027 m_source->write(m_cache.data, static_cast<size_t>(m_cache.region.size()));
2028 m_state = m_source->state();
2029 }
2030
2031 basic_file* m_source;
2032 struct cache_t {
2033 uint8_t* data;
2034 size_t capacity;
2035 enum class status_t {
2036 empty = 0,
2037 loaded,
2038 dirty,
2039 } status;
2040 interval<fpos_t> region;
2041
2042 cache_t(_In_ size_t _capacity) :
2043 data(new uint8_t[_capacity]),
2044 capacity(_capacity),
2045 status(status_t::empty),
2046 region(0)
2047 {}
2048
2049 ~cache_t()
2050 {
2051 delete[] data;
2052 }
2053 } m_cache;
2054 fpos_t m_offset;
2055#if SET_FILE_OP_TIMES
2056 time_point
2057 m_atime,
2058 m_mtime;
2059#endif
2060 };
2061
2065 class basic_sys : virtual public basic, public sys_object
2066 {
2067 public:
2068 basic_sys(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok) :
2069 basic(state),
2070 sys_object(h)
2071 {}
2072
2073 virtual _Success_(return != 0 || length == 0) size_t read(
2074 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2075 {
2076 assert(data || !length);
2077 // Windows Server 2003 and Windows XP: Pipe write operations across a network are limited in size per write.
2078 // The amount varies per platform. For x86 platforms it's 63.97 MB. For x64 platforms it's 31.97 MB. For Itanium
2079 // it's 63.95 MB. For more information regarding pipes, see the Remarks section.
2080 size_t
2081#if defined(_WIN64)
2082 block_size = 0x1F80000;
2083#elif defined(_WIN32)
2084 block_size = 0x3f00000;
2085#else
2086 block_size = SSIZE_MAX;
2087#endif
2088 for (size_t to_read = length;;) {
2089#ifdef _WIN32
2090 // ReadFile() might raise exception (e.g. STATUS_FILE_BAD_FORMAT/0xE0000002).
2091 BOOL succeeded;
2092 DWORD num_read;
2093 __try { succeeded = ReadFile(m_h, data, static_cast<DWORD>(std::min<size_t>(to_read, block_size)), &num_read, nullptr); }
2094 __except (EXCEPTION_EXECUTE_HANDLER) { succeeded = FALSE; SetLastError(ERROR_UNHANDLED_EXCEPTION); num_read = 0; }
2095 if (!succeeded && GetLastError() == ERROR_NO_SYSTEM_RESOURCES && block_size > default_block_size) _Unlikely_ {
2096 // Error "Insufficient system resources exist to complete the requested service." occurs
2097 // ocasionally, when attempting to read too much data at once (e.g. over \\TSClient).
2098 block_size = default_block_size;
2099 continue;
2100 }
2101 if (!succeeded) _Unlikely_
2102#else
2103 ssize_t num_read = ::read(m_h, data, static_cast<ssize_t>(std::min<size_t>(to_read, block_size)));
2104 if (num_read < 0) _Unlikely_
2105#endif
2106 {
2107 m_state = to_read < length ? state_t::ok : state_t::fail;
2108 return length - to_read;
2109 }
2110 if (!num_read) _Unlikely_ {
2111 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2112 return length - to_read;
2113 }
2114 to_read -= num_read;
2115 if (!to_read) {
2116 m_state = state_t::ok;
2117 return length;
2118 }
2119 reinterpret_cast<uint8_t*&>(data) += num_read;
2120 }
2121 }
2122
2123 virtual _Success_(return != 0) size_t write(
2124 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2125 {
2126 // Windows Server 2003 and Windows XP: Pipe write operations across a network are limited in size per write.
2127 // The amount varies per platform. For x86 platforms it's 63.97 MB. For x64 platforms it's 31.97 MB. For Itanium
2128 // it's 63.95 MB. For more information regarding pipes, see the Remarks section.
2129 constexpr size_t
2130#if defined(_WIN64)
2131 block_size = 0x1F80000;
2132#elif defined(_WIN32)
2133 block_size = 0x3f00000;
2134#else
2135 block_size = SSIZE_MAX;
2136#endif
2137 for (size_t to_write = length;;) {
2138#ifdef _WIN32
2139 // ReadFile() might raise an exception. Be cautious with WriteFile() too.
2140 BOOL succeeded;
2141 DWORD num_written;
2142 __try { succeeded = WriteFile(m_h, data, static_cast<DWORD>(std::min<size_t>(to_write, block_size)), &num_written, nullptr); }
2143 __except (EXCEPTION_EXECUTE_HANDLER) { succeeded = FALSE; SetLastError(ERROR_UNHANDLED_EXCEPTION); num_written = 0; }
2144 to_write -= num_written;
2145 if (!to_write) {
2146 m_state = state_t::ok;
2147 return length;
2148 }
2149 reinterpret_cast<const uint8_t*&>(data) += num_written;
2150 if (!succeeded) _Unlikely_ {
2151 m_state = state_t::fail;
2152 return length - to_write;
2153 }
2154#else
2155 ssize_t num_written = ::write(m_h, data, static_cast<ssize_t>(std::min<size_t>(to_write, block_size)));
2156 if (num_written < 0) _Unlikely_ {
2157 m_state = state_t::fail;
2158 return length - to_write;
2159 }
2160 to_write -= num_written;
2161 if (!to_write) {
2162 m_state = state_t::ok;
2163 return length;
2164 }
2165 reinterpret_cast<const uint8_t*&>(data) += num_written;
2166#endif
2167 }
2168 }
2169
2170 virtual void close()
2171 {
2172 try {
2173 sys_object::close();
2174 m_state = state_t::ok;
2175 }
2176 catch (...) {
2177 m_state = state_t::fail;
2178 }
2179 }
2180
2181 virtual void flush()
2182 {
2183#ifdef _WIN32
2184 m_state = FlushFileBuffers(m_h) ? state_t::ok : state_t::fail;
2185#else
2186 m_state = fsync(m_h) >= 0 ? state_t::ok : state_t::fail;
2187#endif
2188 }
2189 };
2190
2194 class buffered_sys : public buffer
2195 {
2196 public:
2197 buffered_sys(_In_opt_ sys_handle h = invalid_handle, size_t read_buffer_size = default_buffer_size, size_t write_buffer_size = default_buffer_size) :
2198 buffer(read_buffer_size, write_buffer_size),
2199 m_source(h)
2200 {
2201 init(m_source);
2202 }
2203
2204 virtual ~buffered_sys()
2205 {
2206 done();
2207 }
2208
2209 protected:
2210 basic_sys m_source;
2211 };
2212
2213#ifdef _WIN32
2217 class sequential_stream : public basic
2218 {
2219 public:
2220 sequential_stream(_In_ ISequentialStream* source) : m_source(source)
2221 {
2222 m_source->AddRef();
2223 }
2224
2225 virtual ~sequential_stream()
2226 {
2227 m_source->Release();
2228 }
2229
2230 virtual _Success_(return != 0 || length == 0) size_t read(
2231 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2232 {
2233 assert(data || !length);
2234 for (size_t to_read = length;;) {
2235 HRESULT hr;
2236 ULONG num_read = 0;
2237 __try { hr = m_source->Read(data, (ULONG)std::min<size_t>(to_read, ULONG_MAX), &num_read); }
2238 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2239 if (FAILED(hr)) _Unlikely_ {
2240 m_state = to_read < length ? state_t::ok : state_t::fail;
2241 return length - to_read;
2242 }
2243 to_read -= num_read;
2244 if (hr == S_FALSE) _Unlikely_ {
2245 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2246 return length - to_read;
2247 }
2248 if (!to_read) {
2249 m_state = state_t::ok;
2250 return length;
2251 }
2252 reinterpret_cast<uint8_t*&>(data) += num_read;
2253 }
2254 }
2255
2256 virtual _Success_(return != 0) size_t write(
2257 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2258 {
2259 assert(data || !length);
2260 for (size_t to_write = length;;) {
2261 HRESULT hr;
2262 ULONG num_written = 0;
2263 __try { hr = m_source->Write(data, static_cast<ULONG>(std::min<size_t>(to_write, ULONG_MAX)), &num_written); }
2264 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2265 // In abscence of documentation whether num_written gets set when FAILED(hr) (i.e. partially succesful writes),
2266 // assume write failed completely.
2267 if (FAILED(hr)) _Unlikely_ {
2268 m_state = state_t::fail;
2269 return length - to_write;
2270 }
2271 to_write -= num_written;
2272 if (!to_write) {
2273 m_state = state_t::ok;
2274 return length;
2275 }
2276 reinterpret_cast<const uint8_t*&>(data) += num_written;
2277 }
2278 }
2279
2280 protected:
2281 ISequentialStream* m_source;
2282 };
2283
2287 class asp : public basic
2288 {
2289 public:
2290 asp(_In_opt_ IRequest* request, _In_opt_ IResponse* response) :
2291 m_request(request),
2292 m_response(response)
2293 {
2294 if (m_request)
2295 m_request->AddRef();
2296 if (m_response)
2297 m_response->AddRef();
2298 }
2299
2300 virtual ~asp()
2301 {
2302 if (m_request)
2303 m_request->Release();
2304 if (m_response)
2305 m_response->Release();
2306 }
2307
2308 virtual _Success_(return != 0 || length == 0) size_t read(
2309 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2310 {
2311 assert(data || !length);
2312 if (!m_request) _Unlikely_ {
2313 m_state = state_t::fail;
2314 return 0;
2315 }
2316 for (size_t to_read = length;;) {
2317 VARIANT var_amount, var_data;
2318 V_VT(&var_amount) = VT_I4;
2319 V_I4(&var_amount) = (LONG)std::min<size_t>(to_read, LONG_MAX);
2320 V_VT(&var_data) = VT_EMPTY;
2321 HRESULT hr = [&]() {
2322 __try { return m_request->BinaryRead(&var_amount, &var_data); }
2323 __except (EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
2324 }();
2325 if (FAILED(hr)) _Unlikely_ {
2326 m_state = to_read < length ? state_t::ok : state_t::fail;
2327 return length - to_read;
2328 }
2329 assert(V_VT(&var_amount) == VT_I4);
2330 assert(V_VT(&var_data) == (VT_ARRAY | VT_UI1));
2331 std::unique_ptr<SAFEARRAY, SafeArrayDestroy_delete> sa(V_ARRAY(&var_data));
2332 if (!V_I4(&var_amount)) _Unlikely_ {
2333 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2334 return length - to_read;
2335 }
2336 safearray_accessor<uint8_t> a(sa.get());
2337 memcpy(data, a.data(), V_I4(&var_amount));
2338 to_read -= V_I4(&var_amount);
2339 if (!to_read) {
2340 m_state = state_t::ok;
2341 return length;
2342 }
2343 reinterpret_cast<uint8_t*&>(data) += V_I4(&var_amount);
2344 }
2345 }
2346
2347 virtual _Success_(return != 0) size_t write(
2348 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2349 {
2350 if (!m_response) {
2351 m_state = state_t::fail;
2352 return 0;
2353 }
2354 for (size_t to_write = length;;) {
2355 UINT num_written = static_cast<UINT>(std::min<size_t>(to_write, UINT_MAX));
2356 std::unique_ptr<OLECHAR, SysFreeString_delete> bstr_data(SysAllocStringByteLen(reinterpret_cast<LPCSTR>(data), num_written));
2357 VARIANT var_data;
2358 V_VT(&var_data) = VT_BSTR;
2359 V_BSTR(&var_data) = bstr_data.get();
2360 HRESULT hr = [&]() {
2361 __try { return m_response->BinaryWrite(var_data); }
2362 __except (EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
2363 }();
2364 if (FAILED(hr)) _Unlikely_ {
2365 m_state = state_t::fail;
2366 return length - to_write;
2367 }
2368 to_write -= num_written;
2369 if (!to_write) {
2370 m_state = state_t::ok;
2371 return length;
2372 }
2373 reinterpret_cast<const uint8_t*&>(data) += num_written;
2374 }
2375 }
2376
2377 virtual void close()
2378 {
2379 if (m_response) {
2380 __try { m_response->End(); }
2381 __except (EXCEPTION_EXECUTE_HANDLER) {}
2382 }
2383 m_state = state_t::ok;
2384 }
2385
2386 virtual void flush()
2387 {
2388 if (m_response) {
2389 HRESULT hr;
2390 __try { hr = m_response->Flush(); }
2391 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2392 m_state = SUCCEEDED(hr) ? state_t::ok : state_t::fail;
2393 }
2394 }
2395
2396 protected:
2397 IRequest* m_request;
2398 IResponse* m_response;
2399 };
2400#endif
2401
2405 enum mode_t
2406 {
2407 mode_for_reading = 1 << 0,
2408 mode_for_writing = 1 << 1,
2409 mode_for_chmod = 1 << 2,
2410 mode_create = 1 << 3,
2411 mode_preserve_existing = mode_create | (1 << 4),
2412 mode_append = 1 << 5,
2413 mode_text = 0,
2414 mode_binary = 1 << 6,
2415
2416 share_none = 0,
2417 share_reading = 1 << 7,
2418 share_writing = 1 << 8,
2419 share_deleting = 1 << 9,
2420 share_all = share_reading | share_writing | share_deleting, // Allow others all operations on our file
2421
2422 inherit_handle = 1 << 10,
2423
2424 hint_write_thru = 1 << 11,
2425 hint_no_buffering = 1 << 12,
2426 hint_random_access = 1 << 13,
2427 hint_sequential_access = 1 << 14,
2428 };
2429
2430#pragma warning(push)
2431#pragma warning(disable: 4250)
2435 class file : virtual public basic_file, virtual public basic_sys
2436 {
2437 public:
2438 file(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok) : basic_sys(h, state) {}
2439
2446 file(_In_z_ const schar_t* filename, _In_ int mode)
2447 {
2448 open(filename, mode);
2449 }
2450
2457 void open(_In_z_ const schar_t* filename, _In_ int mode)
2458 {
2459 if (m_h != invalid_handle)
2460 close();
2461
2462#ifdef _WIN32
2463 DWORD dwDesiredAccess = 0;
2464 if (mode & mode_for_reading) dwDesiredAccess |= GENERIC_READ;
2465 if (mode & mode_for_writing) dwDesiredAccess |= GENERIC_WRITE;
2466 if (mode & mode_for_chmod) dwDesiredAccess |= FILE_WRITE_ATTRIBUTES;
2467
2468 DWORD dwShareMode = 0;
2469 if (mode & share_reading) dwShareMode |= FILE_SHARE_READ;
2470 if (mode & share_writing) dwShareMode |= FILE_SHARE_WRITE;
2471 if (mode & share_deleting) dwShareMode |= FILE_SHARE_DELETE;
2472
2473 SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES) };
2474 sa.bInheritHandle = mode & inherit_handle ? true : false;
2475
2476 DWORD dwCreationDisposition;
2477 switch (mode & mode_preserve_existing) {
2478 case mode_create: dwCreationDisposition = CREATE_ALWAYS; break;
2479 case mode_preserve_existing: dwCreationDisposition = OPEN_ALWAYS; break;
2480 case 0: dwCreationDisposition = OPEN_EXISTING; break;
2481 default: throw std::invalid_argument("invalid mode");
2482 }
2483
2484 DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
2485 if (mode & hint_write_thru) dwFlagsAndAttributes |= FILE_FLAG_WRITE_THROUGH;
2486 if (mode & hint_no_buffering) dwFlagsAndAttributes |= FILE_FLAG_NO_BUFFERING;
2487 if (mode & hint_random_access) dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
2488 if (mode & hint_sequential_access) dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
2489
2490 m_h = CreateFile(filename, dwDesiredAccess, dwShareMode, &sa, dwCreationDisposition, dwFlagsAndAttributes, nullptr);
2491#else
2492 int flags = 0;
2493 switch (mode & (mode_for_reading | mode_for_writing)) {
2494 case mode_for_reading: flags |= O_RDONLY; break;
2495 case mode_for_writing: flags |= O_WRONLY; break;
2496 case mode_for_reading | mode_for_writing: flags |= O_RDWR; break;
2497 }
2498 if (mode & mode_create) flags |= mode & mode_preserve_existing ? O_CREAT : (O_CREAT | O_EXCL);
2499 if (mode & hint_write_thru) flags |= O_DSYNC;
2500#ifndef __APPLE__
2501 if (mode & hint_no_buffering) flags |= O_RSYNC;
2502#endif
2503
2504 m_h = ::open(filename, flags, DEFFILEMODE);
2505#endif
2506 if (m_h != invalid_handle) {
2507 m_state = state_t::ok;
2508 if (mode & mode_append)
2509 seek(0, seek_t::end);
2510 }
2511 else
2512 m_state = state_t::fail;
2513 }
2514
2515 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
2516 {
2517#ifdef _WIN32
2518 LARGE_INTEGER li;
2519 li.QuadPart = offset;
2520 li.LowPart = SetFilePointer(m_h, li.LowPart, &li.HighPart, static_cast<DWORD>(how));
2521 if (li.LowPart != 0xFFFFFFFF || GetLastError() == NO_ERROR) {
2522 m_state = state_t::ok;
2523 return li.QuadPart;
2524 }
2525#else
2526 off64_t result = lseek64(m_h, offset, static_cast<int>(how));
2527 if (result >= 0) {
2528 m_state = state_t::ok;
2529 return result;
2530 }
2531#endif
2532 m_state = state_t::fail;
2533 return fpos_max;
2534 }
2535
2536 virtual fpos_t tell() const
2537 {
2538 if (m_h != invalid_handle) {
2539#ifdef _WIN32
2540 LARGE_INTEGER li;
2541 li.QuadPart = 0;
2542 li.LowPart = SetFilePointer(m_h, 0, &li.HighPart, FILE_CURRENT);
2543 if (li.LowPart != 0xFFFFFFFF || GetLastError() == NO_ERROR)
2544 return li.QuadPart;
2545#else
2546 off64_t result = lseek64(m_h, 0, SEEK_CUR);
2547 if (result >= 0)
2548 return result;
2549#endif
2550 }
2551 return fpos_max;
2552 }
2553
2554 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
2555 {
2556#ifdef _WIN32
2557 LARGE_INTEGER liOffset;
2558 LARGE_INTEGER liSize;
2559 liOffset.QuadPart = offset;
2560 liSize.QuadPart = length;
2561 if (LockFile(m_h, liOffset.LowPart, liOffset.HighPart, liSize.LowPart, liSize.HighPart)) {
2562 m_state = state_t::ok;
2563 return;
2564 }
2565#else
2566 off64_t orig = lseek64(m_h, 0, SEEK_CUR);
2567 if (orig >= 0) {
2568 m_state = lseek64(m_h, offset, SEEK_SET) >= 0 && lockf64(m_h, F_LOCK, length) >= 0 ? state_t::ok : state_t::fail;
2569 lseek64(m_h, orig, SEEK_SET);
2570 m_state = state_t::ok;
2571 return;
2572 }
2573#endif
2574 m_state = state_t::fail;
2575 }
2576
2577 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
2578 {
2579#ifdef _WIN32
2580 LARGE_INTEGER liOffset;
2581 LARGE_INTEGER liSize;
2582 liOffset.QuadPart = offset;
2583 liSize.QuadPart = length;
2584 if (UnlockFile(m_h, liOffset.LowPart, liOffset.HighPart, liSize.LowPart, liSize.HighPart)) {
2585 m_state = state_t::ok;
2586 return;
2587 }
2588#else
2589 off64_t orig = lseek64(m_h, 0, SEEK_CUR);
2590 if (orig >= 0) {
2591 if (lseek64(m_h, offset, SEEK_SET) >= 0 && lockf64(m_h, F_ULOCK, length) >= 0) {
2592 lseek64(m_h, orig, SEEK_SET);
2593 m_state = state_t::ok;
2594 return;
2595 }
2596 lseek64(m_h, orig, SEEK_SET);
2597 }
2598#endif
2599 m_state = state_t::fail;
2600 }
2601
2602 virtual fsize_t size()
2603 {
2604#ifdef _WIN32
2605 LARGE_INTEGER li;
2606 li.LowPart = GetFileSize(m_h, (LPDWORD)&li.HighPart);
2607 if (li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR)
2608 li.QuadPart = -1;
2609 return li.QuadPart;
2610#else
2611 off64_t length = -1, orig = lseek64(m_h, 0, SEEK_CUR);
2612 if (orig >= 0) {
2613 length = lseek64(m_h, 0, SEEK_END);
2614 lseek64(m_h, orig, SEEK_SET);
2615 }
2616 return length;
2617#endif
2618 }
2619
2620 virtual void truncate()
2621 {
2622#ifdef _WIN32
2623 if (SetEndOfFile(m_h)) {
2624 m_state = state_t::ok;
2625 return;
2626 }
2627#else
2628 off64_t length = lseek64(m_h, 0, SEEK_CUR);
2629 if (length >= 0 && ftruncate64(m_h, length) >= 0) {
2630 m_state = state_t::ok;
2631 return;
2632 }
2633#endif
2634 m_state = state_t::fail;
2635 }
2636
2637#ifdef _WIN32
2638 static inline time_point ft2tp(_In_ const FILETIME& ft)
2639 {
2640#if _HAS_CXX20
2641 uint64_t t = (static_cast<int64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
2642#else
2643 uint64_t t = ((static_cast<int64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime) - 116444736000000000ll;
2644#endif
2645 return time_point(time_point::duration(t));
2646 }
2647
2648 static inline void tp2ft(_In_ time_point tp, _Out_ FILETIME& ft)
2649 {
2650#if _HAS_CXX20
2651 uint64_t t = tp.time_since_epoch().count();
2652#else
2653 uint64_t t = tp.time_since_epoch().count() + 116444736000000000ll;
2654#endif
2655 ft.dwHighDateTime = static_cast<DWORD>((t >> 32) & 0xffffffff);
2656 ft.dwLowDateTime = static_cast<DWORD>(t & 0xffffffff);
2657 }
2658#endif
2659
2660 virtual time_point ctime() const
2661 {
2662#ifdef _WIN32
2663 FILETIME ft;
2664 if (GetFileTime(m_h, &ft, nullptr, nullptr))
2665 return ft2tp(ft);
2666#endif
2667 return time_point::min();
2668 }
2669
2670 virtual time_point atime() const
2671 {
2672#ifdef _WIN32
2673 FILETIME ft;
2674 if (GetFileTime(m_h, nullptr, &ft, nullptr))
2675 return ft2tp(ft);
2676#else
2677 struct stat buf;
2678 if (fstat(m_h, &buf) >= 0)
2679 return clock::from_time_t(buf.st_atime);
2680#endif
2681 return time_point::min();
2682 }
2683
2684 virtual time_point mtime() const
2685 {
2686#ifdef _WIN32
2687 FILETIME ft;
2688 if (GetFileTime(m_h, nullptr, nullptr, &ft))
2689 return ft2tp(ft);
2690#else
2691 struct stat buf;
2692 if (fstat(m_h, &buf) >= 0)
2693 return clock::from_time_t(buf.st_mtime);
2694#endif
2695 return time_point::min();
2696 }
2697
2698 virtual void set_ctime(time_point date)
2699 {
2700 assert(m_h != invalid_handle);
2701#ifdef _WIN32
2702 FILETIME ft;
2703 tp2ft(date, ft);
2704 if (SetFileTime(m_h, &ft, nullptr, nullptr))
2705 return;
2706#endif
2707 throw std::runtime_error("failed to set file ctime");
2708 }
2709
2710 virtual void set_atime(time_point date)
2711 {
2712 assert(m_h != invalid_handle);
2713#ifdef _WIN32
2714 FILETIME ft;
2715 tp2ft(date, ft);
2716 if (SetFileTime(m_h, nullptr, &ft, nullptr))
2717 return;
2718#else
2719 struct timespec ts[2] = {
2720 { date.time_since_epoch().count(), 0 },
2721 { 0, UTIME_OMIT },
2722 };
2723 if (futimens(m_h, ts) >= 0)
2724 return;
2725#endif
2726 throw std::runtime_error("failed to set file atime");
2727 }
2728
2729 virtual void set_mtime(time_point date)
2730 {
2731#ifdef _WIN32
2732 FILETIME ft;
2733 tp2ft(date, ft);
2734 if (SetFileTime(m_h, nullptr, nullptr, &ft))
2735 return;
2736#else
2737 struct timespec ts[2] = {
2738 { 0, UTIME_OMIT },
2739 { date.time_since_epoch().count(), 0 },
2740 };
2741 if (futimens(m_h, ts) >= 0)
2742 return;
2743#endif
2744 throw std::runtime_error("failed to set file mtime");
2745 }
2746 };
2747#pragma warning(pop)
2748
2752 class cached_file : public cache
2753 {
2754 public:
2755 cached_file(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok, _In_ size_t cache_size = default_cache_size) :
2756 cache(cache_size),
2757 m_source(h, state)
2758 {
2759 init(m_source);
2760 }
2761
2769 cached_file(_In_z_ const schar_t* filename, _In_ int mode, _In_ size_t cache_size = default_cache_size) :
2770 cache(cache_size),
2771 m_source(filename, mode & mode_for_writing ? mode | mode_for_reading : mode)
2772 {
2773 init(m_source);
2774 }
2775
2776 virtual ~cached_file()
2777 {
2778 done();
2779 }
2780
2787 void open(_In_z_ const schar_t* filename, _In_ int mode)
2788 {
2789 invalidate_cache();
2790 if (!ok()) _Unlikely_{
2791 m_state = state_t::fail;
2792 return;
2793 }
2794 m_source.open(filename, mode & mode_for_writing ? mode | mode_for_reading : mode);
2795 if (m_source.ok()) {
2796#if SET_FILE_OP_TIMES
2797 m_atime = m_source.atime();
2798 m_mtime = m_source.mtime();
2799#endif
2800 m_offset = m_source.tell();
2801 m_state = state_t::ok;
2802 return;
2803 }
2804 m_state = state_t::fail;
2805 }
2806
2807 protected:
2808 file m_source;
2809 };
2810
2814 class memory_file : public basic_file
2815 {
2816 public:
2817 memory_file(_In_ state_t state = state_t::ok) :
2818 basic(state),
2819 m_data(nullptr),
2820 m_offset(0),
2821 m_size(0),
2822 m_reserved(0),
2823 m_manage(true)
2824 {
2825#if SET_FILE_OP_TIMES
2826 m_ctime = m_atime = m_mtime = time_point::now();
2827#endif
2828 }
2829
2836 memory_file(_In_ size_t size, _In_ state_t state = state_t::ok) :
2837 basic(state),
2838 m_data(reinterpret_cast<uint8_t*>(malloc(size))),
2839 m_offset(0),
2840 m_size(0),
2841 m_reserved(size),
2842 m_manage(true)
2843 {
2844 if (!m_data)
2845 throw std::bad_alloc();
2846#if SET_FILE_OP_TIMES
2847 m_ctime = m_atime = m_mtime = time_point::now();
2848#endif
2849 }
2850
2860 memory_file(_Inout_ void* data, _In_ size_t size, _In_ size_t reserved, _In_ bool manage = false, _In_ state_t state = state_t::ok) :
2861 basic(state),
2862 m_data(reinterpret_cast<uint8_t*>(data)),
2863 m_offset(0),
2864 m_size(size),
2865 m_reserved(reserved),
2866 m_manage(manage)
2867 {
2868 assert(data || !size);
2869 assert(reserved >= size);
2870#if SET_FILE_OP_TIMES
2871 m_ctime = m_atime = m_mtime = time_point::now();
2872#endif
2873 }
2874
2883 memory_file(_Inout_ void* data, _In_ size_t size, _In_ bool manage = false, _In_ state_t state = state_t::ok) :
2884 memory_file(data, size, size, manage, state)
2885 {}
2886
2893 memory_file(_In_z_ const schar_t* filename, _In_ int mode) : memory_file()
2894 {
2895 load(filename, mode);
2896 }
2897
2898 virtual ~memory_file()
2899 {
2900 if (m_manage && m_data)
2901 free(m_data);
2902 }
2903
2910 void reserve(_In_ size_t required, _In_ bool tight = false) noexcept
2911 {
2912 if (required <= m_reserved && (!tight || required >= m_reserved)) {
2913 m_state = state_t::ok;
2914 return;
2915 }
2916 if (!m_manage) {
2917 m_state = state_t::fail;
2918 return;
2919 }
2920 size_t reserved = tight ? required : ((required + required / 4 + (default_block_size - 1)) / default_block_size) * default_block_size;
2921 auto data = reinterpret_cast<uint8_t*>(realloc(m_data, reserved));
2922 if (!data && reserved) _Unlikely_ {
2923 m_state = state_t::fail;
2924 return;
2925 }
2926 m_data = data;
2927 if (reserved < m_size)
2928 m_size = reserved;
2929 m_reserved = reserved;
2930 m_state = state_t::ok;
2931 }
2932
2939 void load(_In_z_ const schar_t* filename, _In_ int mode)
2940 {
2941 file f(filename, (mode & ~hint_random_access) | mode_for_reading | hint_sequential_access);
2942 if (!f.ok()) {
2943 m_state = state_t::fail;
2944 return;
2945 }
2946 fsize_t size = f.size();
2947 if (size > SIZE_MAX) {
2948 m_state = state_t::fail;
2949 return;
2950 }
2951 reserve(static_cast<size_t>(size), true);
2952 if (!ok()) _Unlikely_ {
2953 return;
2954 }
2955 m_offset = m_size = 0;
2956 write_stream(f);
2957 if (ok())
2958 m_offset = 0;
2959#if SET_FILE_OP_TIMES
2960 m_ctime = f.ctime();
2961 m_atime = f.atime();
2962 m_mtime = f.mtime();
2963#endif
2964 }
2965
2972 void save(_In_z_ const schar_t* filename, _In_ int mode)
2973 {
2974 file f(filename, (mode & ~hint_random_access) | mode_for_writing | hint_sequential_access);
2975 if (!f.ok()) {
2976 m_state = state_t::fail;
2977 return;
2978 }
2979 f.write(m_data, m_size);
2980 if (!f.ok()) {
2981 m_state = state_t::fail;
2982 return;
2983 }
2984 f.truncate();
2985#if SET_FILE_OP_TIMES
2986 f.set_ctime(m_ctime);
2987 f.set_atime(m_atime);
2988 f.set_mtime(m_mtime);
2989#endif
2990 }
2991
2995 inline const void* data() const { return m_data; }
2996
2997 virtual _Success_(return != 0 || length == 0) size_t read(
2998 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2999 {
3000 assert(data || !length);
3001#if SET_FILE_OP_TIMES
3002 m_atime = time_point::now();
3003#endif
3004 size_t available = m_size - m_offset;
3005 if (length <= available) {
3006 memcpy(data, m_data + m_offset, length);
3007 m_offset += length;
3008 m_state = state_t::ok;
3009 return length;
3010 }
3011 if (length && !available) {
3012 m_state = state_t::eof;
3013 return 0;
3014 }
3015 memcpy(data, m_data + m_offset, available);
3016 m_offset += available;
3017 m_state = state_t::ok;
3018 return available;
3019 }
3020
3035 template <class T>
3036 inline memory_file& read_data(T & data)
3037 {
3038#if SET_FILE_OP_TIMES
3039 m_atime = time_point::now();
3040#endif
3041 if (CHECK_STREAM_STATE && !ok()) _Unlikely_ {
3042 data = 0;
3043 return *this;
3044 }
3045 size_t end_offset = m_offset + sizeof(T);
3046 if (end_offset <= m_size) {
3047 data = LE2HE(*reinterpret_cast<T*>(m_data + m_offset));
3048 m_offset = end_offset;
3049#if !CHECK_STREAM_STATE
3050 m_state = state_t::ok;
3051#endif
3052 }
3053 else {
3054 data = 0;
3055 m_offset = m_size;
3056 m_state = state_t::eof;
3057 }
3058 return *this;
3059 }
3060
3075 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
3076 memory_file& read_str(_Inout_ std::basic_string<_Elem, _Traits, _Ax>&data)
3077 {
3078#if SET_FILE_OP_TIMES
3079 m_atime = time_point::now();
3080#endif
3081 if (CHECK_STREAM_STATE && !ok()) _Unlikely_ {
3082 data.clear();
3083 return *this;
3084 }
3085 size_t end_offset = m_offset + sizeof(uint32_t);
3086 if (end_offset <= m_size) {
3087 uint32_t num_chars = LE2HE(*reinterpret_cast<uint32_t*>(m_data + m_offset));
3088 m_offset = end_offset;
3089 end_offset = stdex::add(m_offset, stdex::mul(num_chars, sizeof(_Elem)));
3090 _Elem* start = reinterpret_cast<_Elem*>(m_data + m_offset);
3091 if (end_offset <= m_size) {
3092 data.assign(start, start + num_chars);
3093 m_offset = end_offset;
3094#if !CHECK_STREAM_STATE
3095 m_state = state_t::ok;
3096#endif
3097 return *this;
3098 }
3099 if (end_offset <= m_size)
3100 data.assign(start, reinterpret_cast<_Elem*>(m_data + m_size));
3101 }
3102 m_offset = m_size;
3103 m_state = state_t::eof;
3104 return *this;
3105 }
3106
3107 virtual _Success_(return != 0) size_t write(
3108 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
3109 {
3110 assert(data || !length);
3111#if SET_FILE_OP_TIMES
3112 m_atime = m_mtime = time_point::now();
3113#endif
3114 size_t end_offset = m_offset + length;
3115 if (end_offset > m_reserved) {
3116 reserve(end_offset);
3117 if (!ok()) _Unlikely_
3118 return 0;
3119 }
3120 memcpy(m_data + m_offset, data, length);
3121 m_offset = end_offset;
3122 if (m_offset > m_size)
3123 m_size = m_offset;
3124 m_state = state_t::ok;
3125 return length;
3126 }
3127
3131 void write_byte(_In_ uint8_t byte, _In_ size_t amount = 1)
3132 {
3133#if SET_FILE_OP_TIMES
3134 m_atime = m_mtime = time_point::now();
3135#endif
3136 size_t end_offset = m_offset + amount;
3137 if (end_offset > m_reserved) {
3138 reserve(end_offset);
3139 if (!ok()) _Unlikely_
3140 return;
3141 }
3142 memset(m_data + m_offset, byte, amount);
3143 m_offset = end_offset;
3144 if (m_offset > m_size)
3145 m_size = m_offset;
3146 m_state = state_t::ok;
3147 }
3148
3163 template <class T>
3164 inline memory_file& write_data(const T data)
3165 {
3166#if SET_FILE_OP_TIMES
3167 m_atime = m_mtime = time_point::now();
3168#endif
3169 if (CHECK_STREAM_STATE && !ok()) _Unlikely_
3170 return *this;
3171 size_t end_offset = m_offset + sizeof(T);
3172 if (end_offset > m_reserved) {
3173 reserve(end_offset);
3174 if (!ok()) _Unlikely_
3175 return *this;
3176 }
3177 (*reinterpret_cast<T*>(m_data + m_offset)) = HE2LE(data);
3178 m_offset = end_offset;
3179 if (m_offset > m_size)
3180 m_size = m_offset;
3181#if !CHECK_STREAM_STATE
3182 m_state = state_t::ok;
3183#endif
3184 return *this;
3185 }
3186
3201 template <class T>
3202 inline memory_file& write_str(_In_z_ const T * data)
3203 {
3204#if SET_FILE_OP_TIMES
3205 m_atime = m_mtime = time_point::now();
3206#endif
3207 if (CHECK_STREAM_STATE && !ok()) _Unlikely_
3208 return *this;
3209 size_t num_chars = stdex::strlen(data);
3210 if (num_chars > UINT32_MAX)
3211 throw std::invalid_argument("string too long");
3212 size_t size_chars = num_chars * sizeof(T);
3213 size_t size = sizeof(uint32_t) + size_chars;
3214 size_t end_offset = m_offset + size;
3215 if (end_offset > m_reserved) {
3216 reserve(end_offset);
3217 if (!ok()) _Unlikely_
3218 return *this;
3219 }
3220 auto p = m_data + m_offset;
3221 *reinterpret_cast<uint32_t*>(p) = HE2LE((uint32_t)num_chars);
3222 memcpy(p + sizeof(uint32_t), data, size_chars);
3223 m_offset = end_offset;
3224 if (m_offset > m_size)
3225 m_size = m_offset;
3226#if !CHECK_STREAM_STATE
3227 m_state = state_t::ok;
3228#endif
3229 return *this;
3230 }
3231
3237 size_t write_stream(_Inout_ basic & stream, _In_ size_t amount = SIZE_MAX)
3238 {
3239#if SET_FILE_OP_TIMES
3240 m_atime = m_mtime = time_point::now();
3241#endif
3242 size_t num_read, dst_offset = m_offset, dst_size = m_offset;
3243 size_t num_copied = 0, to_write = amount;
3244 m_state = state_t::ok;
3245 if (amount != SIZE_MAX) {
3246 dst_size = stdex::add(dst_size, amount);
3247 reserve(dst_size);
3248 if (!ok()) _Unlikely_
3249 return 0;
3250 while (to_write) {
3251 num_read = stream.read(m_data + dst_offset, to_write);
3252 dst_size = dst_offset += num_read;
3253 num_copied += num_read;
3254 to_write -= num_read;
3255 if (!stream.ok()) {
3256 if (stream.state() != state_t::eof)
3257 m_state = state_t::fail;
3258 break;
3259 }
3260 };
3261 }
3262 else {
3263 size_t block_size;
3264 while (to_write) {
3265 block_size = std::min(to_write, default_block_size);
3266 dst_size = stdex::add(dst_size, block_size);
3267 reserve(dst_size);
3268 if (!ok()) _Unlikely_
3269 break;
3270 num_read = stream.read(m_data + dst_offset, block_size);
3271 dst_size = dst_offset += num_read;
3272 num_copied += num_read;
3273 to_write -= num_read;
3274 if (!stream.ok()) {
3275 if (stream.state() != state_t::eof)
3276 m_state = state_t::fail;
3277 break;
3278 }
3279 };
3280 }
3281 m_offset = dst_offset;
3282 if (m_offset > m_size)
3283 m_size = m_offset;
3284 return num_copied;
3285 }
3286
3287 virtual void close()
3288 {
3289 if (m_manage && m_data)
3290 free(m_data);
3291 m_data = nullptr;
3292 m_manage = true;
3293 m_offset = 0;
3294 m_size = m_reserved = 0;
3295#if SET_FILE_OP_TIMES
3296 m_ctime = m_atime = m_mtime = time_point::min();
3297#endif
3298 m_state = state_t::ok;
3299 }
3300
3301 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
3302 {
3303 fpos_t target;
3304 switch (how) {
3305 case seek_t::beg: target = offset; break;
3306 case seek_t::cur: target = static_cast<fpos_t>(m_offset) + offset; break;
3307 case seek_t::end: target = static_cast<fpos_t>(m_size) + offset; break;
3308 default: throw std::invalid_argument("unknown seek origin");
3309 }
3310 if (target <= SIZE_MAX) {
3311 m_state = state_t::ok;
3312 return m_offset = static_cast<size_t>(target);
3313 }
3314 m_state = state_t::fail;
3315 return fpos_max;
3316 }
3317
3318 virtual fpos_t tell() const
3319 {
3320 return m_offset;
3321 }
3322
3323 virtual fsize_t size()
3324 {
3325 return m_size;
3326 }
3327
3328 virtual void truncate()
3329 {
3330#if SET_FILE_OP_TIMES
3331 m_atime = m_mtime = time_point::now();
3332#endif
3333 m_size = m_offset;
3334 reserve(m_offset);
3335 }
3336
3337#if SET_FILE_OP_TIMES
3338 virtual time_point ctime() const
3339 {
3340 return m_ctime;
3341 }
3342
3343 virtual time_point atime() const
3344 {
3345 return m_atime;
3346 }
3347
3348 virtual time_point mtime() const
3349 {
3350 return m_mtime;
3351 }
3352
3353 virtual void set_ctime(time_point date)
3354 {
3355 m_ctime = date;
3356 }
3357
3358 virtual void set_atime(time_point date)
3359 {
3360 m_atime = date;
3361 }
3362
3363 virtual void set_mtime(time_point date)
3364 {
3365 m_mtime = date;
3366 }
3367#endif
3368
3369 protected:
3377 template <class T>
3378 inline void set(_In_ fpos_t offset, _In_ const T data)
3379 {
3380#if SET_FILE_OP_TIMES
3381 m_atime = m_mtime = time_point::now();
3382#endif
3383 assert(offset + sizeof(T) < m_size);
3384 (*reinterpret_cast<T*>(m_data + offset)) = HE2LE(data);
3385 }
3386
3387 public:
3388 inline void set(_In_ fpos_t offset, _In_ const int8_t data) { set<int8_t>(offset, data); }
3389 inline void set(_In_ fpos_t offset, _In_ const int16_t data) { set<int16_t>(offset, data); }
3390 inline void set(_In_ fpos_t offset, _In_ const int32_t data) { set<int32_t>(offset, data); }
3391 inline void set(_In_ fpos_t offset, _In_ const int64_t data) { set<int64_t>(offset, data); }
3392 inline void set(_In_ fpos_t offset, _In_ const uint8_t data) { set<uint8_t>(offset, data); }
3393 inline void set(_In_ fpos_t offset, _In_ const uint16_t data) { set<uint16_t>(offset, data); }
3394 inline void set(_In_ fpos_t offset, _In_ const uint32_t data) { set<uint32_t>(offset, data); }
3395 inline void set(_In_ fpos_t offset, _In_ const uint64_t data) { set<uint64_t>(offset, data); }
3396 inline void set(_In_ fpos_t offset, _In_ const float data) { set<float>(offset, data); }
3397 inline void set(_In_ fpos_t offset, _In_ const double data) { set<double>(offset, data); }
3398 inline void set(_In_ fpos_t offset, _In_ const char data) { set<char>(offset, data); }
3399#ifdef _NATIVE_WCHAR_T_DEFINED
3400 inline void set(_In_ fpos_t offset, _In_ const wchar_t data) { set<wchar_t>(offset, data); }
3401#endif
3402
3410 protected:
3411 template <class T>
3412 inline void get(_In_ fpos_t offset, _Out_ T & data)
3413 {
3414 assert(offset + sizeof(T) < m_size);
3415 data = LE2HE(*(T*)(m_data + offset));
3416#if SET_FILE_OP_TIMES
3417 m_atime = time_point::now();
3418#endif
3419 }
3420
3421 public:
3422 inline void get(_In_ fpos_t offset, _Out_ int8_t & data) { get<int8_t>(offset, data); }
3423 inline void get(_In_ fpos_t offset, _Out_ int16_t & data) { get<int16_t>(offset, data); }
3424 inline void get(_In_ fpos_t offset, _Out_ int32_t & data) { get<int32_t>(offset, data); }
3425 inline void get(_In_ fpos_t offset, _Out_ int64_t & data) { get<int64_t>(offset, data); }
3426 inline void get(_In_ fpos_t offset, _Out_ uint8_t & data) { get<uint8_t>(offset, data); }
3427 inline void get(_In_ fpos_t offset, _Out_ uint16_t & data) { get<uint16_t>(offset, data); }
3428 inline void get(_In_ fpos_t offset, _Out_ uint32_t & data) { get<uint32_t>(offset, data); }
3429 inline void get(_In_ fpos_t offset, _Out_ uint64_t & data) { get<uint64_t>(offset, data); }
3430 inline void get(_In_ fpos_t offset, _Out_ float& data) { get<float>(offset, data); }
3431 inline void get(_In_ fpos_t offset, _Out_ double& data) { get<double>(offset, data); }
3432 inline void get(_In_ fpos_t offset, _Out_ char& data) { get<char>(offset, data); }
3433#ifdef _NATIVE_WCHAR_T_DEFINED
3434 inline void get(_In_ fpos_t offset, _Out_ wchar_t& data) { get<wchar_t>(offset, data); }
3435#endif
3436
3437 inline memory_file& operator <<(_In_ const int8_t data) { return write_data(data); }
3438 inline memory_file& operator >>(_Out_ int8_t & data) { return read_data(data); }
3439 inline memory_file& operator <<(_In_ const int16_t data) { return write_data(data); }
3440 inline memory_file& operator >>(_Out_ int16_t & data) { return read_data(data); }
3441 inline memory_file& operator <<(_In_ const int32_t data) { return write_data(data); }
3442 inline memory_file& operator >>(_Out_ int32_t & data) { return read_data(data); }
3443 inline memory_file& operator <<(_In_ const int64_t data) { return write_data(data); }
3444 inline memory_file& operator >>(_Out_ int64_t & data) { return read_data(data); }
3445 inline memory_file& operator <<(_In_ const uint8_t data) { return write_data(data); }
3446 inline memory_file& operator >>(_Out_ uint8_t & data) { return read_data(data); }
3447 inline memory_file& operator <<(_In_ const uint16_t data) { return write_data(data); }
3448 inline memory_file& operator >>(_Out_ uint16_t & data) { return read_data(data); }
3449 inline memory_file& operator <<(_In_ const uint32_t data) { return write_data(data); }
3450 inline memory_file& operator >>(_Out_ uint32_t & data) { return read_data(data); }
3451 inline memory_file& operator <<(_In_ const uint64_t data) { return write_data(data); }
3452 inline memory_file& operator >>(_Out_ uint64_t & data) { return read_data(data); }
3453 inline memory_file& operator <<(_In_ const float data) { return write_data(data); }
3454 inline memory_file& operator >>(_Out_ float& data) { return read_data(data); }
3455 inline memory_file& operator <<(_In_ const double data) { return write_data(data); }
3456 inline memory_file& operator >>(_Out_ double& data) { return read_data(data); }
3457 inline memory_file& operator <<(_In_ const char data) { return write_data(data); }
3458 inline memory_file& operator >>(_Out_ char& data) { return read_data(data); }
3459#ifdef _NATIVE_WCHAR_T_DEFINED
3460 inline memory_file& operator <<(_In_ const wchar_t data) { return write_data(data); }
3461 inline memory_file& operator >>(_Out_ wchar_t& data) { return read_data(data); }
3462#endif
3463 template <class T>
3464 inline memory_file& operator <<(_In_ const T * data) { return write_str(data); }
3465 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
3466 inline memory_file& operator >>(_Inout_ std::basic_string<_Elem, _Traits, _Ax>&data) { return read_str(data); }
3467
3468 protected:
3469 uint8_t* m_data;
3470 bool m_manage;
3471 size_t m_offset;
3472 size_t m_size;
3473 size_t m_reserved;
3474#if SET_FILE_OP_TIMES
3475 time_point
3476 m_ctime,
3477 m_atime,
3478 m_mtime;
3479#endif
3480 };
3481
3485 class fifo : public basic {
3486 public:
3487 fifo() :
3488 m_offset(0),
3489 m_size(0),
3490 m_head(nullptr),
3491 m_tail(nullptr)
3492 {}
3493
3494 virtual ~fifo()
3495 {
3496 while (m_head) {
3497 auto p = m_head;
3498 m_head = p->next;
3499 delete p;
3500 }
3501 }
3502
3503#pragma warning(suppress: 6101) // See [2] below
3504 virtual _Success_(return != 0 || length == 0) size_t read(
3505 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
3506 {
3507 assert(data || !length);
3508 for (size_t to_read = length;;) {
3509 if (!m_head) _Unlikely_ {
3510 // [1] Code analysis misses length - to_read bytes were written to data in previous loop iterations.
3511 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
3512 return length - to_read;
3513 }
3514 size_t remaining = m_head->size - m_offset;
3515 if (remaining > to_read) {
3516 memcpy(data, m_head->data + m_offset, to_read);
3517 m_offset += to_read;
3518 m_size -= to_read;
3519 m_state = state_t::ok;
3520 return length;
3521 }
3522 memcpy(data, m_head->data + m_offset, remaining);
3523 m_offset = 0;
3524 m_size -= remaining;
3525 reinterpret_cast<uint8_t*&>(data) += remaining;
3526 to_read -= remaining;
3527 auto p = m_head;
3528 m_head = p->next;
3529 delete p;
3530 }
3531 }
3532
3533 virtual _Success_(return != 0) size_t write(
3534 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
3535 {
3536 assert(data || !length);
3537 try {
3538 std::unique_ptr<node_t> n(reinterpret_cast<node_t*>(new uint8_t[sizeof(node_t) + length]));
3539 n->next = nullptr;
3540 n->size = length;
3541 memcpy(n->data, data, length);
3542 m_size += length;
3543 if (m_head)
3544 m_tail = m_tail->next = n.release();
3545 else
3546 m_head = m_tail = n.release();
3547 m_state = state_t::ok;
3548 return length;
3549 }
3550 catch (const std::bad_alloc&) {
3551 m_state = state_t::fail;
3552 return 0;
3553 }
3554 }
3555
3556 virtual void close()
3557 {
3558 m_size = m_offset = 0;
3559 while (m_head) {
3560 auto p = m_head;
3561 m_head = p->next;
3562 delete p;
3563 }
3564 m_state = state_t::ok;
3565 }
3566
3570 inline size_t size() const { return m_size; };
3571
3572 protected:
3573 size_t m_offset, m_size;
3574 struct node_t {
3575 node_t* next;
3576 size_t size;
3577#pragma warning(suppress:4200)
3578 uint8_t data[0];
3579 } *m_head, * m_tail;
3580 };
3581
3585 class diag_file : public basic_file {
3586 public:
3587 diag_file(_In_count_(num_files) basic_file* const* files, _In_ size_t num_files) :
3588 basic(num_files ? files[0]->state() : state_t::fail),
3589 m_files(files, files + num_files)
3590 {
3591 }
3592
3593 virtual _Success_(return != 0 || length == 0) size_t read(
3594 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
3595 {
3596 assert(data || !length);
3597 if (m_files.empty()) {
3598 m_state = state_t::fail;
3599 return 0;
3600 }
3601 size_t result = m_files[0]->read(data, length);
3602 _Analysis_assume_(result <= length);
3603 m_state = m_files[0]->state();
3604 if (length > m_tmp.size())
3605 m_tmp.resize(length);
3606 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3607 if (m_files[i]->read(m_tmp.data(), length) != result ||
3608 memcmp(m_tmp.data(), data, result))
3609 throw std::runtime_error("read mismatch");
3610 if (m_files[i]->state() != m_state)
3611 throw std::runtime_error("state mismatch");
3612 }
3613 return result;
3614 }
3615
3616 virtual _Success_(return != 0) size_t write(
3617 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
3618 {
3619 if (m_files.empty()) {
3620 m_state = state_t::fail;
3621 return 0;
3622 }
3623 size_t result = m_files[0]->write(data, length);
3624 m_state = m_files[0]->state();
3625 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3626 if (m_files[i]->write(data, length) != result)
3627 throw std::runtime_error("write mismatch");
3628 if (m_files[i]->state() != m_state)
3629 throw std::runtime_error("state mismatch");
3630 }
3631 return result;
3632 }
3633
3634 virtual void flush()
3635 {
3636 if (m_files.empty()) {
3637 m_state = state_t::ok;
3638 return;
3639 }
3640 m_files[0]->flush();
3641 m_state = m_files[0]->state();
3642 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3643 m_files[i]->flush();
3644 if (m_files[i]->state() != m_state)
3645 throw std::runtime_error("state mismatch");
3646 }
3647 }
3648
3649 virtual void close()
3650 {
3651 if (m_files.empty()) {
3652 m_state = state_t::ok;
3653 return;
3654 }
3655 m_files[0]->close();
3656 m_state = m_files[0]->state();
3657 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3658 m_files[i]->close();
3659 if (m_files[i]->state() != m_state)
3660 throw std::runtime_error("state mismatch");
3661 }
3662 m_tmp.clear();
3663 m_tmp.shrink_to_fit();
3664 }
3665
3666 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
3667 {
3668 if (m_files.empty()) {
3669 m_state = state_t::fail;
3670 return fpos_max;
3671 }
3672 fpos_t result = m_files[0]->seek(offset, how);
3673 m_state = m_files[0]->state();
3674 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3675 if (m_files[i]->seek(offset, how) != result)
3676 throw std::runtime_error("seek mismatch");
3677 if (m_files[i]->state() != m_state)
3678 throw std::runtime_error("state mismatch");
3679 }
3680 return result;
3681 }
3682
3683 virtual fpos_t tell() const
3684 {
3685 if (m_files.empty())
3686 return fpos_max;
3687 fpos_t result = m_files[0]->tell();
3688 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3689 if (m_files[i]->tell() != result)
3690 throw std::runtime_error("tell mismatch");
3691 }
3692 return result;
3693 }
3694
3695 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
3696 {
3697 if (m_files.empty())
3698 m_state = state_t::fail;
3699 m_files[0]->lock(offset, length);
3700 m_state = m_files[0]->state();
3701 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3702 m_files[i]->lock(offset, length);
3703 if (m_files[i]->state() != m_state)
3704 throw std::runtime_error("state mismatch");
3705 }
3706 }
3707
3708 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
3709 {
3710 if (m_files.empty())
3711 m_state = state_t::fail;
3712 m_files[0]->unlock(offset, length);
3713 m_state = m_files[0]->state();
3714 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3715 m_files[i]->unlock(offset, length);
3716 if (m_files[i]->state() != m_state)
3717 throw std::runtime_error("state mismatch");
3718 }
3719 }
3720
3721 virtual fsize_t size()
3722 {
3723 if (m_files.empty()) {
3724 m_state = state_t::fail;
3725 return 0;
3726 }
3727 fsize_t result = m_files[0]->size();
3728 m_state = m_files[0]->state();
3729 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3730 if (m_files[i]->size() != result)
3731 throw std::runtime_error("size mismatch");
3732 if (m_files[i]->state() != m_state)
3733 throw std::runtime_error("state mismatch");
3734 }
3735 return result;
3736 }
3737
3738 virtual void truncate()
3739 {
3740 if (m_files.empty())
3741 m_state = state_t::fail;
3742 m_files[0]->truncate();
3743 m_state = m_files[0]->state();
3744 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
3745 m_files[i]->truncate();
3746 if (m_files[i]->state() != m_state)
3747 throw std::runtime_error("state mismatch");
3748 }
3749 }
3750
3751 protected:
3752 std::vector<basic_file*> m_files;
3753 std::vector<uint8_t> m_tmp;
3754 };
3755 }
3756}
stdex::stream::async_reader
Provides read-ahead stream capability.
Definition stream.hpp:1120
stdex::stream::async_reader::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1134
stdex::stream::async_writer
Provides write-back stream capability.
Definition stream.hpp:1188
stdex::stream::async_writer::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1225
stdex::stream::async_writer::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1201
stdex::stream::basic_file
Basic seekable stream operations.
Definition stream.hpp:698
stdex::stream::basic_file::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:741
stdex::stream::basic_file::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:788
stdex::stream::basic_file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:757
stdex::stream::basic_file::truncate
virtual void truncate()=0
Sets file size - truncates the remainder of file content from the current file position to the end of...
stdex::stream::basic_file::read_charset
charset_id read_charset(charset_id default_charset=charset_id::system)
Attempts to detect textfile charset based on UTF16 or UTF8 BOM.
Definition stream.hpp:861
stdex::stream::basic_file::seekbeg
fpos_t seekbeg(fpos_t offset)
Seeks to absolute file position.
Definition stream.hpp:725
stdex::stream::basic_file::read_remainder
virtual std::vector< uint8_t > read_remainder(size_t max_length=SIZE_MAX)
Reads and returns remainder of the stream.
Definition stream.hpp:700
stdex::stream::basic_file::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:830
stdex::stream::basic_file::seekcur
fpos_t seekcur(foff_t offset)
Seeks to relative from current file position.
Definition stream.hpp:732
stdex::stream::basic_file::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:796
stdex::stream::basic_file::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:812
stdex::stream::basic_file::size
virtual fsize_t size()=0
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
stdex::stream::basic_file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:767
stdex::stream::basic_file::tell
virtual fpos_t tell() const =0
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
stdex::stream::basic_file::mtime
virtual time_point mtime() const
Returns file modification time.
Definition stream.hpp:804
stdex::stream::basic_file::seekend
fpos_t seekend(foff_t offset)
Seeks to relative from end file position.
Definition stream.hpp:739
stdex::stream::basic_file::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:821
stdex::stream::basic_file::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)=0
Seeks to specified relative file position.
stdex::stream::basic_sys
OS data stream (file, pipe, socket...)
Definition stream.hpp:2066
stdex::stream::basic_sys::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:2123
stdex::stream::basic_sys::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:2181
stdex::stream::basic_sys::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:2073
stdex::stream::basic_sys::close
virtual void close()
Closes the stream.
Definition stream.hpp:2170
stdex::stream::basic
‍UTF-8 byte-order-mark
Definition stream.hpp:76
stdex::stream::basic::ok
bool ok() const
Returns true if the stream state is clean i.e. previous operation was succesful.
Definition stream.hpp:172
stdex::stream::basic::write_vsprintf
size_t write_vsprintf(_Printf_format_string_params_(2) const char *format, locale_t locale, va_list params)
Writes formatted string to the stream.
Definition stream.hpp:602
stdex::stream::basic::write_array
size_t write_array(_In_reads_or_z_opt_(num_chars) const wchar_t *wstr, size_t num_chars, charset_id charset)
Writes array of characters to the stream.
Definition stream.hpp:432
stdex::stream::basic::state
state_t state() const
Returns stream state after last operation.
Definition stream.hpp:167
stdex::stream::basic::read_str
basic & read_str(std::basic_string< _Elem, _Traits, _Ax > &data)
Reads length-prefixed string from the stream.
Definition stream.hpp:476
stdex::stream::basic::write_sprintf
size_t write_sprintf(_Printf_format_string_params_(2) const wchar_t *format, locale_t locale,...)
Writes formatted string to the stream.
Definition stream.hpp:588
stdex::stream::basic::write_vsprintf
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.
Definition stream.hpp:615
stdex::stream::basic::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:123
stdex::stream::basic::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:139
stdex::stream::basic::close
virtual void close()
Closes the stream.
Definition stream.hpp:131
stdex::stream::basic::read_byte
uint8_t read_byte()
Reads one byte of data.
Definition stream.hpp:207
stdex::stream::basic::read_remainder
virtual std::vector< uint8_t > read_remainder(size_t max_length=SIZE_MAX)
Reads and returns remainder of the stream.
Definition stream.hpp:181
stdex::stream::basic::write_sprintf
size_t write_sprintf(_Printf_format_string_params_(2) const char *format, locale_t locale,...)
Writes formatted string to the stream.
Definition stream.hpp:574
stdex::stream::basic::readln_and_attach
size_t readln_and_attach(std::basic_string< wchar_t, _Traits, _Ax > &wstr, charset_id charset)
Reads stream to the end-of-line or end-of-file and append to str.
Definition stream.hpp:365
stdex::stream::basic::readln
size_t readln(std::basic_string< char, _Traits, _Ax > &str)
Reads stream to the end-of-line or end-of-file.
Definition stream.hpp:303
stdex::stream::basic::readln_and_attach
size_t readln_and_attach(std::basic_string< _Elem, _Traits, _Ax > &str)
Reads stream to the end-of-line or end-of-file and append to str.
Definition stream.hpp:344
stdex::stream::basic::read_array
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.
Definition stream.hpp:380
stdex::stream::basic::write_str
basic & write_str(const T *data)
Writes string to the stream length-prefixed.
Definition stream.hpp:501
stdex::stream::basic::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:93
stdex::stream::basic::readln
size_t readln(std::basic_string< wchar_t, _Traits, _Ax > &wstr)
Reads stream to the end-of-line or end-of-file.
Definition stream.hpp:315
stdex::stream::basic::write_charset
void write_charset(charset_id charset)
Writes UTF8 or UTF-16 byte-order-mark.
Definition stream.hpp:561
stdex::stream::basic::readln
size_t readln(std::basic_string< wchar_t, _Traits, _Ax > &wstr, charset_id charset)
Reads stream to the end-of-line or end-of-file.
Definition stream.hpp:327
stdex::stream::basic::write_array
size_t write_array(const wchar_t *wstr, charset_id charset)
Writes array of characters to the stream.
Definition stream.hpp:411
stdex::stream::basic::write_data
basic & write_data(const T data)
Writes one primitive data type.
Definition stream.hpp:284
stdex::stream::basic::write_stream
fsize_t write_stream(basic &stream, fsize_t amount=fsize_max)
Writes content of another stream.
Definition stream.hpp:536
stdex::stream::basic::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:111
stdex::stream::basic::write_array
size_t write_array(const std::basic_string< wchar_t, _Traits, _Ax > &wstr, charset_id charset)
Writes array of characters to the stream.
Definition stream.hpp:453
stdex::stream::basic::write_array
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.
Definition stream.hpp:398
stdex::stream::basic::write_byte
void write_byte(uint8_t byte, fsize_t amount=1)
Writes a byte of data.
Definition stream.hpp:218
stdex::stream::basic::read_data
basic & read_data(T &data)
Reads one primitive data type.
Definition stream.hpp:256
stdex::stream::buffer
Buffered read/write stream.
Definition stream.hpp:1259
stdex::stream::buffer::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1369
stdex::stream::buffer::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1287
stdex::stream::buffer::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1323
stdex::stream::buffered_sys
Buffered OS data stream (file, pipe, socket...)
Definition stream.hpp:2195
stdex::stream::cache
Cached file.
Definition stream.hpp:1686
stdex::stream::cache::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:1938
stdex::stream::cache::m_offset
fpos_t m_offset
Logical absolute file position.
Definition stream.hpp:2054
stdex::stream::cache::truncate
virtual void truncate()
Sets file size - truncates the remainder of file content from the current file position to the end of...
Definition stream.hpp:1917
stdex::stream::cache::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1743
stdex::stream::cache::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:1943
stdex::stream::cache::size
virtual fsize_t size()
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:1910
stdex::stream::cache::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:1904
stdex::stream::cache::mtime
virtual time_point mtime() const
Returns file modification time.
Definition stream.hpp:1952
stdex::stream::cache::close
virtual void close()
Closes the stream.
Definition stream.hpp:1858
stdex::stream::cache::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:1974
stdex::stream::cache::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:1898
stdex::stream::cache::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1867
stdex::stream::cache::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1805
stdex::stream::cache::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:1961
stdex::stream::cache::tell
virtual fpos_t tell() const
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
Definition stream.hpp:1893
stdex::stream::cache::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:1966
stdex::stream::cache::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)
Seeks to specified relative file position.
Definition stream.hpp:1878
stdex::stream::cached_file
Cached file-system file.
Definition stream.hpp:2753
stdex::stream::cached_file::open
void open(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:2787
stdex::stream::cached_file::cached_file
cached_file(const schar_t *filename, int mode, size_t cache_size=default_cache_size)
Opens file.
Definition stream.hpp:2769
stdex::stream::converter
Modifies data on the fly when reading from/writing to a source stream.
Definition stream.hpp:891
stdex::stream::converter::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:937
stdex::stream::converter::close
virtual void close()
Closes the stream.
Definition stream.hpp:931
stdex::stream::converter::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:915
stdex::stream::converter::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:923
stdex::stream::diag_file
Compares multiple files to perform the same.
Definition stream.hpp:3585
stdex::stream::diag_file::size
virtual fsize_t size()
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:3721
stdex::stream::diag_file::truncate
virtual void truncate()
Sets file size - truncates the remainder of file content from the current file position to the end of...
Definition stream.hpp:3738
stdex::stream::diag_file::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:3616
stdex::stream::diag_file::close
virtual void close()
Closes the stream.
Definition stream.hpp:3649
stdex::stream::diag_file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:3695
stdex::stream::diag_file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:3708
stdex::stream::diag_file::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)
Seeks to specified relative file position.
Definition stream.hpp:3666
stdex::stream::diag_file::tell
virtual fpos_t tell() const
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
Definition stream.hpp:3683
stdex::stream::diag_file::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:3634
stdex::stream::diag_file::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:3593
stdex::stream::fifo
In-memory FIFO queue.
Definition stream.hpp:3485
stdex::stream::fifo::close
virtual void close()
Closes the stream.
Definition stream.hpp:3556
stdex::stream::fifo::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:3533
stdex::stream::fifo::size
size_t size() const
Returns total size of pending data in the queue.
Definition stream.hpp:3570
stdex::stream::fifo::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:3504
stdex::stream::file_window
Limits file reading/writing to a predefined window.
Definition stream.hpp:1576
stdex::stream::file_window::truncate
virtual void truncate()
Sets file size - truncates the remainder of file content from the current file position to the end of...
Definition stream.hpp:1669
stdex::stream::file_window::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1619
stdex::stream::file_window::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:1632
stdex::stream::file_window::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)
Seeks to specified relative file position.
Definition stream.hpp:1625
stdex::stream::file_window::size
virtual fsize_t size()
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:1664
stdex::stream::file_window::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1599
stdex::stream::file_window::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:1644
stdex::stream::file_window::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1585
stdex::stream::file_window::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:1654
stdex::stream::file_window::tell
virtual fpos_t tell() const
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
Definition stream.hpp:1638
stdex::stream::file_window::close
virtual void close()
Closes the stream.
Definition stream.hpp:1613
stdex::stream::file
File-system file.
Definition stream.hpp:2436
stdex::stream::file::mtime
virtual time_point mtime() const
Returns file modification time.
Definition stream.hpp:2684
stdex::stream::file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:2577
stdex::stream::file::file
file(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:2446
stdex::stream::file::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:2698
stdex::stream::file::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:2670
stdex::stream::file::open
void open(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:2457
stdex::stream::file::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:2729
stdex::stream::file::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:2710
stdex::stream::file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:2554
stdex::stream::file::truncate
virtual void truncate()
Sets file size - truncates the remainder of file content from the current file position to the end of...
Definition stream.hpp:2620
stdex::stream::file::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:2660
stdex::stream::file::size
virtual fsize_t size()
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:2602
stdex::stream::file::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)
Seeks to specified relative file position.
Definition stream.hpp:2515
stdex::stream::file::tell
virtual fpos_t tell() const
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
Definition stream.hpp:2536
stdex::stream::limiter
Limits reading from/writing to stream to a predefined number of bytes.
Definition stream.hpp:1417
stdex::stream::limiter::read_limit
fsize_t read_limit
Number of bytes left that may be read from the stream.
Definition stream.hpp:1477
stdex::stream::limiter::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1425
stdex::stream::limiter::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1450
stdex::stream::limiter::write_limit
fsize_t write_limit
Number of bytes left, that can be written to the stream.
Definition stream.hpp:1478
stdex::stream::memory_file
In-memory file.
Definition stream.hpp:2815
stdex::stream::memory_file::memory_file
memory_file(const schar_t *filename, int mode)
Loads content from file-system file.
Definition stream.hpp:2893
stdex::stream::memory_file::m_size
size_t m_size
file size
Definition stream.hpp:3472
stdex::stream::memory_file::get
void get(fpos_t offset, T &data)
Reads data from specified file location This does not move file pointer. It checks for data size asse...
Definition stream.hpp:3412
stdex::stream::memory_file::write_stream
size_t write_stream(basic &stream, size_t amount=SIZE_MAX)
Writes content of another stream.
Definition stream.hpp:3237
stdex::stream::memory_file::m_data
uint8_t * m_data
file data
Definition stream.hpp:3469
stdex::stream::memory_file::read_data
memory_file & read_data(T &data)
Reads one primitive data type.
Definition stream.hpp:3036
stdex::stream::memory_file::close
virtual void close()
Closes the stream.
Definition stream.hpp:3287
stdex::stream::memory_file::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:2997
stdex::stream::memory_file::tell
virtual fpos_t tell() const
Returns absolute file position in file or fpos_max if fails. This method does not update stream state...
Definition stream.hpp:3318
stdex::stream::memory_file::m_reserved
size_t m_reserved
reserved file size
Definition stream.hpp:3473
stdex::stream::memory_file::memory_file
memory_file(size_t size, state_t state=state_t::ok)
Creates an empty file of reserved size.
Definition stream.hpp:2836
stdex::stream::memory_file::reserve
void reserve(size_t required, bool tight=false) noexcept
Reallocates memory.
Definition stream.hpp:2910
stdex::stream::memory_file::read_str
memory_file & read_str(std::basic_string< _Elem, _Traits, _Ax > &data)
Reads length-prefixed string from the stream.
Definition stream.hpp:3076
stdex::stream::memory_file::write_byte
void write_byte(uint8_t byte, size_t amount=1)
Writes a byte of data.
Definition stream.hpp:3131
stdex::stream::memory_file::set
void set(fpos_t offset, const T data)
Writes data to specified file location This does not move file pointer nor update file size....
Definition stream.hpp:3378
stdex::stream::memory_file::m_offset
size_t m_offset
file pointer
Definition stream.hpp:3471
stdex::stream::memory_file::save
void save(const schar_t *filename, int mode)
Saves content to a file-system file.
Definition stream.hpp:2972
stdex::stream::memory_file::load
void load(const schar_t *filename, int mode)
Loads content from a file-system file.
Definition stream.hpp:2939
stdex::stream::memory_file::size
virtual fsize_t size()
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:3323
stdex::stream::memory_file::seek
virtual fpos_t seek(foff_t offset, seek_t how=seek_t::beg)
Seeks to specified relative file position.
Definition stream.hpp:3301
stdex::stream::memory_file::truncate
virtual void truncate()
Sets file size - truncates the remainder of file content from the current file position to the end of...
Definition stream.hpp:3328
stdex::stream::memory_file::write_data
memory_file & write_data(const T data)
Writes one primitive data type.
Definition stream.hpp:3164
stdex::stream::memory_file::write_str
memory_file & write_str(const T *data)
Writes string to the stream length-prefixed.
Definition stream.hpp:3202
stdex::stream::memory_file::m_manage
bool m_manage
may reallocate m_data?
Definition stream.hpp:3470
stdex::stream::memory_file::memory_file
memory_file(void *data, size_t size, bool manage=false, state_t state=state_t::ok)
Creates a file based on available data.
Definition stream.hpp:2883
stdex::stream::memory_file::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:3107
stdex::stream::memory_file::memory_file
memory_file(void *data, size_t size, size_t reserved, bool manage=false, state_t state=state_t::ok)
Creates a file based on available data.
Definition stream.hpp:2860
stdex::stream::memory_file::data
const void * data() const
Returns pointer to data.
Definition stream.hpp:2995
stdex::stream::replicator::worker
Definition stream.hpp:1034
stdex::stream::replicator::worker::op
enum stdex::stream::replicator::worker::op_t op
Operation to perform.
stdex::stream::replicator::worker::num_written
size_t num_written
Number of bytes written.
Definition stream.hpp:1082
stdex::stream::replicator::worker::length
size_t length
Byte limit of data to write.
Definition stream.hpp:1081
stdex::stream::replicator::worker::data
const void * data
Data to write.
Definition stream.hpp:1080
stdex::stream::replicator
Replicates writing of the same data to multiple streams.
Definition stream.hpp:951
stdex::stream::replicator::push_back
void push_back(basic *source)
Adds stream on the list.
Definition stream.hpp:970
stdex::stream::replicator::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1027
stdex::stream::replicator::remove
void remove(basic *source)
Removes stream from the list.
Definition stream.hpp:978
stdex::stream::replicator::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:995
stdex::stream::replicator::close
virtual void close()
Closes the stream.
Definition stream.hpp:1022
stdex::stream::window
Limits reading from/writing to stream to a predefined window.
Definition stream.hpp:1485
stdex::stream::window::write_offset
fpos_t write_offset
Number of bytes to discard on write.
Definition stream.hpp:1569
stdex::stream::window::write
virtual size_t write(_In_reads_bytes_opt_(length) const void *data, size_t length)
Writes block of data to the stream.
Definition stream.hpp:1526
stdex::stream::window::read
virtual size_t read(_Out_writes_bytes_to_opt_(length, return) void *data, size_t length)
Reads block of data from the stream.
Definition stream.hpp:1493
stdex::stream::window::read_offset
fpos_t read_offset
Number of bytes to skip on read.
Definition stream.hpp:1568
stdex::sys_object
Operating system object (file, pipe, anything with an OS handle etc.)
Definition system.hpp:88
stdex::sys_object::close
virtual void close()
Closes object.
Definition system.hpp:129
stdex::interval
Numerical interval.
Definition interval.hpp:18
stdex::interval::contains
bool contains(T x) const
Is value in interval?
Definition interval.hpp:70
stdex::interval::empty
bool empty() const
Is interval empty?
Definition interval.hpp:54
stdex::interval::size
T size() const
Returns interval size.
Definition interval.hpp:47
stdex::interval::end
T end
interval end
Definition interval.hpp:20
stdex::interval::start
T start
interval start
Definition interval.hpp:19
stdex::stream::buffer::buffer_t
Definition stream.hpp:1394
stdex::stream::cache::cache_t
Definition stream.hpp:2032
stdex::stream::cache::cache_t::region
interval< fpos_t > region
valid data region
Definition stream.hpp:2040
stdex::stream::fifo::node_t
Definition stream.hpp:3574
Generated on Wed Sep 20 2023 06:08:16 for stdex by doxygen 1.9.8