stdex
Additional custom or not Standard C++ covered algorithms
Loading...
Searching...
No Matches
stream.hpp
1/*
2 SPDX-License-Identifier: MIT
3 Copyright © 2023-2024 Amebis
4*/
5
6#pragma once
7
8#include "compat.hpp"
9#include "endian.hpp"
10#include "interval.hpp"
11#include "locale.hpp"
12#include "math.hpp"
13#include "ring.hpp"
14#include "socket.hpp"
15#include "string.hpp"
16#include "unicode.hpp"
17#include <stdint.h>
18#include <stdlib.h>
19#if defined(_WIN32)
20#include "windows.h"
21#include <asptlb.h>
22#include <objidl.h>
23#else
24#include <fcntl.h>
25#include <unistd.h>
26#include <sys/stat.h>
27#endif
28#include <chrono>
29#include <condition_variable>
30#include <list>
31#include <memory>
32#include <set>
33#include <string>
34#include <thread>
35#include <vector>
36
37#if !defined(SET_FILE_OP_TIMES) && defined(RDAT_BELEZI_CAS_DOSTOPA_VER)
38#define SET_FILE_OP_TIMES 1
39#pragma message("RDAT_BELEZI_CAS_DOSTOPA_VER is deprecated. Use SET_FILE_OP_TIMES instead.")
40#elif !defined(SET_FILE_OP_TIMES)
41#define SET_FILE_OP_TIMES 0
42#endif
43#if !defined(CHECK_STREAM_STATE) && defined(RDAT_NE_PREVERJAJ_STANJA_VER)
44#define CHECK_STREAM_STATE 0
45#pragma message("RDAT_NE_PREVERJAJ_EOF_VER is deprecated. Use CHECK_STREAM_STATE=0 instead.")
46#else
47#define CHECK_STREAM_STATE 1
48#endif
49
50namespace stdex
51{
52 namespace stream
53 {
57 enum class state_t {
58 ok = 0,
59 eof,
60 fail,
61 };
62
66 using fsize_t = uint64_t;
67 constexpr fsize_t fsize_max = UINT64_MAX;
68
69 constexpr size_t iterate_count = 0x10;
70 constexpr size_t default_block_size = 0x10000;
71 constexpr char16_t utf16_bom = u'\ufeff';
72 constexpr char32_t utf32_bom = U'\ufeff';
73 constexpr const char utf8_bom[3] = { '\xef', '\xbb', '\xbf' };
74
78 class basic
79 {
80 public:
81 basic(_In_ state_t state = state_t::ok) : m_state(state) {}
82
83 virtual ~basic() noexcept(false) {}
84
96 virtual _Success_(return != 0 || length == 0) size_t read(
97 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
98 {
99 _Unreferenced_(data);
100 _Unreferenced_(length);
101 m_state = state_t::fail;
102 return 0;
103 }
104
114 virtual _Success_(return != 0) size_t write(
115 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
116 {
117 _Unreferenced_(data);
118 _Unreferenced_(length);
119 m_state = state_t::fail;
120 return 0;
121 }
122
126 virtual void flush()
127 {
128 m_state = state_t::ok;
129 }
130
134 virtual void close()
135 {
136 m_state = state_t::ok;
137 }
138
142 virtual void skip(_In_ fsize_t amount)
143 {
144 if (amount == 1)
145 read_byte();
146 else if (amount < iterate_count) {
147 for (size_t i = 0; i < static_cast<size_t>(amount); i++) {
148 read_byte();
149 if (!ok()) _Unlikely_
150 break;
151 }
152 }
153 else {
154 size_t block = static_cast<size_t>(std::min<fsize_t>(amount, default_block_size));
155 try {
156 std::unique_ptr<uint8_t[]> dummy(new uint8_t[block]);
157 while (amount) {
158 amount -= read_array(dummy.get(), sizeof(uint8_t), static_cast<size_t>(std::min<fsize_t>(amount, block)));
159 if (!ok()) _Unlikely_
160 break;
161 }
162 }
163 catch (const std::bad_alloc&) { m_state = state_t::fail; }
164 }
165 }
166
170 state_t state() const { return m_state; };
171
175 bool ok() const { return m_state == state_t::ok; };
176
184 virtual std::vector<uint8_t> read_remainder(_In_ size_t max_length = SIZE_MAX)
185 {
186 std::vector<uint8_t> result;
187 size_t offset, length;
188 offset = 0;
189 length = default_block_size;
190 while (offset < max_length) {
191 length = std::min(length, max_length);
192 try { result.resize(length); }
193 catch (const std::bad_alloc&) {
194 m_state = state_t::fail;
195 return result;
196 }
197 auto num_read = read_array(result.data() + offset, sizeof(uint8_t), length - offset);
198 offset += num_read;
199 if (!ok()) _Unlikely_
200 break;
201 length += default_block_size;
202 }
203 result.resize(offset);
204 return result;
205 }
206
210 uint8_t read_byte()
211 {
212 uint8_t byte;
213 if (read_array(&byte, sizeof(byte), 1) == 1)
214 return byte;
215 throw std::system_error(sys_error(), std::system_category(), "failed to read");
216 }
217
221 void write_byte(_In_ uint8_t byte, _In_ fsize_t amount = 1)
222 {
223 if (amount == 1)
224 write(&byte, sizeof(uint8_t));
225 else if (amount < iterate_count) {
226 for (size_t i = 0; i < static_cast<size_t>(amount); i++) {
227 write(&byte, sizeof(uint8_t));
228 if (!ok()) _Unlikely_
229 break;
230 }
231 }
232 else {
233 size_t block = static_cast<size_t>(std::min<fsize_t>(amount, default_block_size));
234 try {
235 std::unique_ptr<uint8_t[]> dummy(new uint8_t[block]);
236 memset(dummy.get(), byte, block);
237 while (amount) {
238 amount -= write_array(dummy.get(), sizeof(uint8_t), static_cast<size_t>(std::min<fsize_t>(amount, block)));
239 if (!ok()) _Unlikely_
240 break;
241 }
242 }
243 catch (const std::bad_alloc&) { m_state = state_t::fail; }
244 }
245 }
246
258 template <class T>
259 basic& read_data(_Out_ T& data)
260 {
261 if (!ok()) _Unlikely_ {
262 data = 0;
263 return *this;
264 }
265 if (read_array(&data, sizeof(T), 1) == 1)
266 (void)LE2HE(&data);
267 else {
268 data = 0;
269 if (ok())
270 m_state = state_t::eof;
271 }
272 return *this;
273 }
274
286 template <class T>
287 basic& write_data(_In_ const T data)
288 {
289 if (!ok()) _Unlikely_
290 return *this;
291#if BYTE_ORDER == BIG_ENDIAN
292 T data_le = HE2LE(data);
293 write(&data_le, sizeof(T));
294#else
295 write(&data, sizeof(T));
296#endif
297 return *this;
298 }
299
305 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
306 size_t readln(_Inout_ std::basic_string<T, TR, AX>& str)
307 {
308 str.clear();
309 return readln_and_attach(str);
310 }
311
317 template<class T_from, class T_to, class TR = std::char_traits<T_to>, class AX = std::allocator<T_to>>
318 size_t readln(_Inout_ std::basic_string<T_to, TR, AX>& str, _In_ charset_encoder<T_from, T_to>& encoder)
319 {
320 if (encoder.from_encoding() == encoder.to_encoding())
321 return readln(str);
322 std::basic_string<T_from> tmp;
323 readln_and_attach(tmp);
324 encoder.strcpy(str, tmp);
325 return str.size();
326 }
327
333 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
334 size_t readln_and_attach(_Inout_ std::basic_string<T, TR, AX>& str)
335 {
336 bool initial = true;
337 T chr, previous = (T)0;
338 do {
339 read_array(&chr, sizeof(T), 1);
340 if (!initial && !(previous == static_cast<T>('\r') && chr == static_cast<T>('\n')))
341 str += previous;
342 else
343 initial = false;
344 previous = chr;
345 } while (ok() && chr != static_cast<T>('\n'));
346 return str.size();
347 }
348
354 template<class T_from, class T_to, class TR = std::char_traits<T_to>, class AX = std::allocator<T_to>>
355 size_t readln_and_attach(_Inout_ std::basic_string<T_to, TR, AX>& str, _In_ charset_encoder<T_from, T_to>& encoder)
356 {
357 if (encoder.from_encoding() == encoder.to_encoding())
358 return readln_and_attach(str);
359 std::basic_string<T_from> tmp;
360 readln_and_attach(tmp);
361 encoder.strcat(str, tmp);
362 return str.size();
363 }
364
370 size_t read_array(_Out_writes_bytes_(size* count) void* array, _In_ size_t size, _In_ size_t count)
371 {
372 for (size_t to_read = mul(size, count);;) {
373 size_t num_read = read(array, to_read);
374 to_read -= num_read;
375 if (!to_read)
376 return count;
377 if (!ok()) _Unlikely_
378 return count - to_read / size;
379 reinterpret_cast<uint8_t*&>(array) += num_read;
380 }
381 }
382
388 size_t write_array(_In_reads_bytes_opt_(size* count) const void* array, _In_ size_t size, _In_ size_t count)
389 {
390 return write(array, mul(size, count)) / size;
391 }
392
401 template <class T_from, class T_to>
402 size_t write_array(_In_z_ const T_from* str, _In_ charset_encoder<T_from, T_to>& encoder)
403 {
404 if (!ok()) _Unlikely_
405 return 0;
406 size_t num_chars = stdex::strlen(str);
407 if (encoder.from_encoding() == encoder.to_encoding())
408 return write_array(str, sizeof(T_from), num_chars);
409 std::basic_string<T_to> tmp(encoder.convert(str, num_chars));
410 return write_array(tmp.data(), sizeof(T_to), tmp.size());
411 }
412
422 template <class T_from, class T_to>
423 size_t write_array(_In_reads_or_z_opt_(num_chars) const T_from* str, _In_ size_t num_chars, _In_ charset_encoder<T_from, T_to>& encoder)
424 {
425 if (!ok()) _Unlikely_
426 return 0;
427 num_chars = stdex::strnlen(str, num_chars);
428 if (encoder.from_encoding() == encoder.to_encoding())
429 return write_array(str, sizeof(T_from), num_chars);
430 std::basic_string<T_to> tmp(encoder.convert(str, num_chars));
431 return write_array(tmp.data(), sizeof(T_to), tmp.size());
432 }
433
442 template<class T_from, class T_to, class TR = std::char_traits<T_from>, class AX = std::allocator<T_from>>
443 size_t write_array(_In_ const std::basic_string<T_from, TR, AX>& str, _In_ charset_encoder<T_from, T_to>& encoder)
444 {
445 if (!ok()) _Unlikely_
446 return 0;
447 if (encoder.from_encoding() == encoder.to_encoding())
448 return write_array(str.data(), sizeof(T_from), str.size());
449 std::basic_string<T_to> tmp(encoder.convert(str));
450 return write_array(tmp.data(), sizeof(T_to), tmp.size());
451 }
452
464 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
465 basic& read_str(_Out_ std::basic_string<T, TR, AX>& data)
466 {
467 data.clear();
468 if (!ok()) _Unlikely_
469 return *this;
470 uint32_t num_chars;
471 read_data(num_chars);
472 if (!ok()) _Unlikely_
473 return *this;
474 data.reserve(num_chars);
475 for (;;) {
476 T buf[0x400];
477 uint32_t num_read = static_cast<uint32_t>(read_array(buf, sizeof(T), std::min<uint32_t>(num_chars, _countof(buf))));
478 data.append(buf, num_read);
479 num_chars -= num_read;
480 if (!num_chars || !ok())
481 return *this;
482 }
483 }
484
496 template <class T>
497 basic& write_str(_In_z_ const T* data)
498 {
499 // Stream state will be checked in write_data.
500 size_t num_chars = stdex::strlen(data);
501 if (num_chars > UINT32_MAX)
502 throw std::invalid_argument("string too long");
503 write_data(static_cast<uint32_t>(num_chars));
504 if (!ok()) _Unlikely_
505 return *this;
506 write_array(data, sizeof(T), num_chars);
507 return *this;
508 }
509
521 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
522 basic& write_str(_In_ const std::basic_string<T, TR, AX>& data)
523 {
524 // Stream state will be checked in write_data.
525 size_t num_chars = data.size();
526 if (num_chars > UINT32_MAX)
527 throw std::invalid_argument("string too long");
528 write_data(static_cast<uint32_t>(num_chars));
529 if (!ok()) _Unlikely_
530 return *this;
531 write_array(data.data(), sizeof(T), num_chars);
532 return *this;
533 }
534
535#ifdef _WIN32
541 size_t write_sa(_In_ LPSAFEARRAY sa)
542 {
543 safearray_accessor<void> a(sa);
544 long ubound, lbound;
545 if (FAILED(SafeArrayGetUBound(sa, 1, &ubound)) ||
546 FAILED(SafeArrayGetLBound(sa, 1, &lbound)))
547 throw std::invalid_argument("SafeArrayGet[UL]Bound failed");
548 return write(a.data(), static_cast<size_t>(ubound) - lbound + 1);
549 }
550#endif
551
557 fsize_t write_stream(_Inout_ basic& stream, _In_ fsize_t amount = fsize_max)
558 {
559 std::unique_ptr<uint8_t[]> data(new uint8_t[static_cast<size_t>(std::min<fsize_t>(amount, default_block_size))]);
560 fsize_t num_copied = 0, to_write = amount;
561 m_state = state_t::ok;
562 while (to_write) {
563 size_t num_read = stream.read(data.get(), static_cast<size_t>(std::min<fsize_t>(default_block_size, to_write)));
564 size_t num_written = write(data.get(), num_read);
565 num_copied += num_written;
566 to_write -= num_written;
567 if (stream.m_state == state_t::eof) {
568 // EOF is not an error.
569 m_state = state_t::ok;
570 break;
571 }
572 m_state = stream.m_state;
573 if (!ok())
574 break;
575 }
576 return num_copied;
577 }
578
582 void write_charset(_In_ charset_id charset)
583 {
584 if (charset == charset_id::utf32)
585 write_data(utf32_bom);
586 else if (charset == charset_id::utf16)
587 write_data(utf16_bom);
588 else if (charset == charset_id::utf8)
589 write_array(utf8_bom, sizeof(utf8_bom), 1);
590 }
591
597 size_t write_sprintf(_In_z_ _Printf_format_string_params_(2) const char* format, _In_opt_ locale_t locale, ...)
598 {
599 va_list params;
600 va_start(params, locale);
601 size_t num_chars = write_vsprintf(format, locale, params);
602 va_end(params);
603 return num_chars;
604 }
605
611 size_t write_sprintf(_In_z_ _Printf_format_string_params_(2) const wchar_t* format, _In_opt_ locale_t locale, ...)
612 {
613 va_list params;
614 va_start(params, locale);
615 size_t num_chars = write_vsprintf(format, locale, params);
616 va_end(params);
617 return num_chars;
618 }
619
625 size_t write_vsprintf(_In_z_ _Printf_format_string_params_(2) const char* format, _In_opt_ locale_t locale, _In_ va_list params)
626 {
627 std::string tmp;
628 tmp.reserve(default_block_size);
629 vappendf(tmp, format, locale, params);
630 return write_array(tmp.data(), sizeof(char), tmp.size());
631 }
632
638 size_t write_vsprintf(_In_z_ _Printf_format_string_params_(2) const wchar_t* format, _In_opt_ locale_t locale, _In_ va_list params)
639 {
640 std::wstring tmp;
641 tmp.reserve(default_block_size);
642 vappendf(tmp, format, locale, params);
643 return write_array(tmp.data(), sizeof(wchar_t), tmp.size());
644 }
645
646 basic& operator >>(_Out_ int8_t& data) { return read_data(data); }
647 basic& operator <<(_In_ const int8_t data) { return write_data(data); }
648 basic& operator >>(_Out_ int16_t& data) { return read_data(data); }
649 basic& operator <<(_In_ const int16_t data) { return write_data(data); }
650 basic& operator >>(_Out_ int32_t& data) { return read_data(data); }
651 basic& operator <<(_In_ const int32_t data) { return write_data(data); }
652 basic& operator >>(_Out_ int64_t& data) { return read_data(data); }
653 basic& operator <<(_In_ const int64_t data) { return write_data(data); }
654 basic& operator >>(_Out_ uint8_t& data) { return read_data(data); }
655 basic& operator <<(_In_ const uint8_t data) { return write_data(data); }
656 basic& operator >>(_Out_ uint16_t& data) { return read_data(data); }
657 basic& operator <<(_In_ const uint16_t data) { return write_data(data); }
658 basic& operator >>(_Out_ uint32_t& data) { return read_data(data); }
659 basic& operator <<(_In_ const uint32_t data) { return write_data(data); }
660 basic& operator >>(_Out_ uint64_t& data) { return read_data(data); }
661 basic& operator <<(_In_ const uint64_t data) { return write_data(data); }
662 basic& operator >>(_Out_ float& data) { return read_data(data); }
663 basic& operator <<(_In_ const float data) { return write_data(data); }
664 basic& operator >>(_Out_ double& data) { return read_data(data); }
665 basic& operator <<(_In_ const double data) { return write_data(data); }
666 basic& operator >>(_Out_ char& data) { return read_data(data); }
667 basic& operator <<(_In_ const char data) { return write_data(data); }
668#ifdef _NATIVE_WCHAR_T_DEFINED
669 basic& operator >>(_Out_ wchar_t& data) { return read_data(data); }
670 basic& operator <<(_In_ const wchar_t data) { return write_data(data); }
671#endif
672 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
673 basic& operator >>(_Out_ std::basic_string<T, TR, AX>& data) { return read_str(data); }
674 template <class T>
675 basic& operator <<(_In_ const T* data) { return write_str(data); }
676 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
677 basic& operator <<(_In_ const std::basic_string<T, TR, AX>& data) { return write_str(data); }
678
679 template <class T, class AX = std::allocator<T>>
680 basic& operator <<(_In_ const std::vector<T, AX>& data)
681 {
682 size_t num = data.size();
683 if (num > UINT32_MAX) _Unlikely_
684 throw std::invalid_argument("collection too big");
685 *this << static_cast<uint32_t>(num);
686 for (auto& el : data)
687 *this << el;
688 return *this;
689 }
690
691 template <class T, class AX = std::allocator<T>>
692 basic& operator >>(_Out_ std::vector<T, AX>& data)
693 {
694 data.clear();
695 uint32_t num;
696 *this >> num;
697 if (!ok()) _Unlikely_
698 return *this;
699 data.reserve(num);
700 for (uint32_t i = 0; i < num; ++i) {
701 T el;
702 *this >> el;
703 if (!ok()) _Unlikely_
704 return *this;
705 data.push_back(std::move(el));
706 }
707 }
708
709 template <class KEY, class PR = std::less<KEY>, class AX = std::allocator<KEY>>
710 basic& operator <<(_In_ const std::set<KEY, PR, AX>& data)
711 {
712 size_t num = data.size();
713 if (num > UINT32_MAX) _Unlikely_
714 throw std::invalid_argument("collection too big");
715 *this << static_cast<uint32_t>(num);
716 for (auto& el : data)
717 *this << el;
718 return *this;
719 }
720
721 template <class KEY, class PR = std::less<KEY>, class AX = std::allocator<KEY>>
722 basic& operator >>(_Out_ std::set<KEY, PR, AX>& data)
723 {
724 data.clear();
725 uint32_t num;
726 *this >> num;
727 if (!ok()) _Unlikely_
728 return *this;
729 for (uint32_t i = 0; i < num; ++i) {
730 KEY el;
731 *this >> el;
732 if (!ok()) _Unlikely_
733 return *this;
734 data.insert(std::move(el));
735 }
736 }
737
738 template <class KEY, class PR = std::less<KEY>, class AX = std::allocator<KEY>>
739 basic& operator <<(_In_ const std::multiset<KEY, PR, AX>& data)
740 {
741 size_t num = data.size();
742 if (num > UINT32_MAX) _Unlikely_
743 throw std::invalid_argument("collection too big");
744 *this << static_cast<uint32_t>(num);
745 for (auto& el : data)
746 *this << el;
747 return *this;
748 }
749
750 template <class KEY, class PR = std::less<KEY>, class AX = std::allocator<KEY>>
751 basic& operator >>(_Out_ std::multiset<KEY, PR, AX>& data)
752 {
753 data.clear();
754 uint32_t num;
755 *this >> num;
756 if (!ok()) _Unlikely_
757 return *this;
758 for (uint32_t i = 0; i < num; ++i) {
759 KEY el;
760 *this >> el;
761 if (!ok()) _Unlikely_
762 return *this;
763 data.insert(std::move(el));
764 }
765 return *this;
766 }
767
768 protected:
769 state_t m_state;
770 };
771
775 using fpos_t = uint64_t;
776 constexpr fpos_t fpos_max = UINT64_MAX;
777 constexpr fpos_t fpos_min = 0;
778
782 using foff_t = int64_t;
783 constexpr foff_t foff_max = INT64_MAX;
784 constexpr foff_t foff_min = INT64_MIN;
785
789 enum class seek_t {
790#ifdef _WIN32
791 beg = FILE_BEGIN,
792 cur = FILE_CURRENT,
793 end = FILE_END
794#else
795 beg = SEEK_SET,
796 cur = SEEK_CUR,
797 end = SEEK_END
798#endif
799 };
800
801#if _HAS_CXX20
802 using clock = std::chrono::file_clock;
803#else
804 using clock = std::chrono::system_clock;
805#endif
806 using time_point = std::chrono::time_point<clock>;
807
811 class basic_file : virtual public basic
812 {
813 public:
814 virtual std::vector<uint8_t> read_remainder(_In_ size_t max_length = SIZE_MAX)
815 {
816 size_t length = std::min<size_t>(max_length, static_cast<size_t>(size() - tell()));
817 std::vector<uint8_t> result;
818 try { result.resize(length); }
819 catch (const std::bad_alloc&) {
820 m_state = state_t::fail;
821 return result;
822 }
823 result.resize(read_array(result.data(), sizeof(uint8_t), length));
824 return result;
825 }
826
832 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg) = 0;
833
839 fpos_t seekbeg(_In_ fpos_t offset) { return seek(offset, seek_t::beg); }
840
846 fpos_t seekcur(_In_ foff_t offset) { return seek(offset, seek_t::cur); }
847
853 fpos_t seekend(_In_ foff_t offset) { return seek(offset, seek_t::end); }
854
855 virtual void skip(_In_ fsize_t amount)
856 {
857 seek(amount, seek_t::cur);
858 }
859
866 virtual fpos_t tell() const = 0;
867
871 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
872 {
873 _Unreferenced_(offset);
874 _Unreferenced_(length);
875 throw std::domain_error("not implemented");
876 }
877
881 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
882 {
883 _Unreferenced_(offset);
884 _Unreferenced_(length);
885 throw std::domain_error("not implemented");
886 }
887
892 virtual fsize_t size() const = 0;
893
897 virtual void truncate() = 0;
898
902 virtual time_point ctime() const
903 {
904 return time_point::min();
905 }
906
910 virtual time_point atime() const
911 {
912 return time_point::min();
913 }
914
918 virtual time_point mtime() const
919 {
920 return time_point::min();
921 }
922
926 virtual void set_ctime(time_point date)
927 {
928 _Unreferenced_(date);
929 throw std::domain_error("not implemented");
930 }
931
935 virtual void set_atime(time_point date)
936 {
937 _Unreferenced_(date);
938 throw std::domain_error("not implemented");
939 }
940
944 virtual void set_mtime(time_point date)
945 {
946 _Unreferenced_(date);
947 throw std::domain_error("not implemented");
948 }
949
950#ifdef _WIN32
954 LPSAFEARRAY read_sa()
955 {
956 _Assume_(size() <= SIZE_MAX);
957 size_t length = static_cast<size_t>(size());
958 std::unique_ptr<SAFEARRAY, SafeArrayDestroy_delete> sa(SafeArrayCreateVector(VT_UI1, 0, (ULONG)length));
959 if (!sa) _Unlikely_
960 throw std::runtime_error("SafeArrayCreateVector failed");
961 safearray_accessor<void> a(sa.get());
962 if (seek(0) != 0) _Unlikely_
963 throw std::system_error(sys_error(), std::system_category(), "failed to seek");
964 if (read_array(a.data(), 1, length) != length)
965 throw std::system_error(sys_error(), std::system_category(), "failed to read");
966 return sa.release();
967 }
968#endif
969
975 charset_id read_charset(_In_ charset_id default_charset = charset_id::system)
976 {
977 if (seek(0) != 0) _Unlikely_
978 throw std::system_error(sys_error(), std::system_category(), "failed to seek");
979 char32_t id_utf32;
980 read_array(&id_utf32, sizeof(char32_t), 1);
981 if (ok() && id_utf32 == utf32_bom)
982 return charset_id::utf32;
983
984 if (seek(0) != 0) _Unlikely_
985 throw std::system_error(sys_error(), std::system_category(), "failed to seek");
986 char16_t id_utf16;
987 read_array(&id_utf16, sizeof(char16_t), 1);
988 if (ok() && id_utf16 == utf16_bom)
989 return charset_id::utf16;
990
991 if (seek(0) != 0) _Unlikely_
992 throw std::system_error(sys_error(), std::system_category(), "failed to seek");
993 char id_utf8[3] = { 0 };
994 read_array(id_utf8, sizeof(id_utf8), 1);
995 if (ok() && strncmp(id_utf8, _countof(id_utf8), utf8_bom, _countof(utf8_bom)) == 0)
996 return charset_id::utf8;
997
998 if (seek(0) != 0) _Unlikely_
999 throw std::system_error(sys_error(), std::system_category(), "failed to seek");
1000 return default_charset;
1001 }
1002 };
1003
1009 class converter : public basic
1010 {
1011 protected:
1013#pragma warning(suppress: 26495) // The delayed init call will finish initializing the class.
1014 explicit converter() : basic(state_t::fail) {}
1015
1016 void init(_Inout_ basic& source)
1017 {
1018 m_source = &source;
1019 init();
1020 }
1021
1022 void init()
1023 {
1024 m_state = m_source->state();
1025 }
1026
1027 void done()
1028 {
1029 m_source = nullptr;
1030 }
1032
1033 public:
1034 converter(_Inout_ basic& source) :
1035 basic(source.state()),
1036 m_source(&source)
1037 {}
1038
1039 virtual _Success_(return != 0 || length == 0) size_t read(
1040 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1041 {
1042 size_t num_read = m_source->read(data, length);
1043 m_state = m_source->state();
1044 return num_read;
1045 }
1046
1047 virtual _Success_(return != 0) size_t write(
1048 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1049 {
1050 size_t num_written = m_source->write(data, length);
1051 m_state = m_source->state();
1052 return num_written;
1053 }
1054
1055 virtual void close()
1056 {
1057 m_source->close();
1058 m_state = m_source->state();
1059 }
1060
1061 virtual void flush()
1062 {
1063 m_source->flush();
1064 m_state = m_source->state();
1065 }
1066
1067 protected:
1068 basic* m_source;
1069 };
1070
1074 class replicator : public basic
1075 {
1076 public:
1077 virtual ~replicator()
1078 {
1079 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1080 auto _w = w->get();
1081 {
1082 const std::lock_guard<std::mutex> lk(_w->mutex);
1083 _w->op = worker::op_t::quit;
1084 }
1085 _w->cv.notify_one();
1086 }
1087 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w)
1088 w->get()->join();
1089 }
1090
1094 void push_back(_In_ basic* source)
1095 {
1096 m_workers.push_back(std::unique_ptr<worker>(new worker(source)));
1097 }
1098
1102 void remove(basic* source)
1103 {
1104 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1105 auto _w = w->get();
1106 if (_w->source == source) {
1107 {
1108 const std::lock_guard<std::mutex> lk(_w->mutex);
1109 _w->op = worker::op_t::quit;
1110 }
1111 _w->cv.notify_one();
1112 _w->join();
1113 m_workers.erase(w);
1114 return;
1115 }
1116 }
1117 }
1118
1119 virtual _Success_(return != 0) size_t write(
1120 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1121 {
1122 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1123 auto _w = w->get();
1124 {
1125 const std::lock_guard<std::mutex> lk(_w->mutex);
1126 _w->op = worker::op_t::write;
1127 _w->data = data;
1128 _w->length = length;
1129 }
1130 _w->cv.notify_one();
1131 }
1132 size_t num_written = length;
1133 m_state = state_t::ok;
1134 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1135 auto _w = w->get();
1136 std::unique_lock<std::mutex> lk(_w->mutex);
1137 _w->cv.wait(lk, [&] {return _w->op == worker::op_t::noop; });
1138 if (_w->num_written < num_written)
1139 num_written = _w->num_written;
1140 if (ok() && !_w->source->ok())
1141 m_state = _w->source->state();
1142 }
1143 return num_written;
1144 }
1145
1146 virtual void close()
1147 {
1148 foreach_worker(worker::op_t::close);
1149 }
1150
1151 virtual void flush()
1152 {
1153 foreach_worker(worker::op_t::flush);
1154 }
1155
1156 protected:
1157 class worker : public std::thread
1158 {
1159 public:
1160 worker(_In_ basic* _source) :
1161 source(_source),
1162 op(op_t::noop),
1163 data(nullptr),
1164 length(0),
1165 num_written(0)
1166 {
1167 *static_cast<std::thread*>(this) = std::thread([](_Inout_ worker& w) { w.process_op(); }, std::ref(*this));
1168 }
1169
1170 protected:
1171 void process_op()
1172 {
1173 for (;;) {
1174 std::unique_lock<std::mutex> lk(mutex);
1175 cv.wait(lk, [&] {return op != op_t::noop; });
1176 switch (op) {
1177 case op_t::quit:
1178 return;
1179 case op_t::write:
1180 num_written = source->write(data, length);
1181 break;
1182 case op_t::close:
1183 source->close();
1184 break;
1185 case op_t::flush:
1186 source->flush();
1187 break;
1188 case op_t::noop:;
1189 }
1190 op = op_t::noop;
1191 lk.unlock();
1192 cv.notify_one();
1193 }
1194 }
1195
1196 public:
1197 basic* source;
1198 enum class op_t {
1199 noop = 0,
1200 quit,
1201 write,
1202 close,
1203 flush,
1204 } op;
1205 const void* data;
1206 size_t length;
1207 size_t num_written;
1208 std::mutex mutex;
1209 std::condition_variable cv;
1210 };
1211
1212 void foreach_worker(_In_ worker::op_t op)
1213 {
1214 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1215 auto _w = w->get();
1216 {
1217 const std::lock_guard<std::mutex> lk(_w->mutex);
1218 _w->op = op;
1219 }
1220 _w->cv.notify_one();
1221 }
1222 m_state = state_t::ok;
1223 for (auto w = m_workers.begin(), w_end = m_workers.end(); w != w_end; ++w) {
1224 auto _w = w->get();
1225 std::unique_lock<std::mutex> lk(_w->mutex);
1226 _w->cv.wait(lk, [&] {return _w->op == worker::op_t::noop; });
1227 if (ok())
1228 m_state = _w->source->state();
1229 }
1230 }
1231
1232 std::list<std::unique_ptr<worker>> m_workers;
1233 };
1234
1235 constexpr size_t default_async_limit = 0x100000;
1236
1242 template <size_t N_cap = default_async_limit>
1243 class async_reader : public converter
1244 {
1245 public:
1246 async_reader(_Inout_ basic& source) :
1247 converter(source),
1248 m_worker([](_Inout_ async_reader& w) { w.process(); }, std::ref(*this))
1249 {}
1250
1251 virtual ~async_reader()
1252 {
1253 m_ring.quit();
1254 m_worker.join();
1255 }
1256
1257#pragma warning(suppress: 6101) // See [1] below
1258 virtual _Success_(return != 0 || length == 0) size_t read(
1259 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1260 {
1261 _Assume_(data || !length);
1262 for (size_t to_read = length;;) {
1263 uint8_t* ptr; size_t num_read;
1264 std::tie(ptr, num_read) = m_ring.front();
1265 if (!ptr) _Unlikely_ {
1266 m_state = to_read < length || !length ? state_t::ok : m_source->state();
1267 return length - to_read; // [1] Code analysis misses `length - to_read` bytes were written to data in previous loop iterations.
1268 }
1269 if (to_read < num_read)
1270 num_read = to_read;
1271 memcpy(data, ptr, num_read);
1272 m_ring.pop(num_read);
1273 to_read -= num_read;
1274 if (!to_read) {
1275 m_state = state_t::ok;
1276 return length;
1277 }
1278 reinterpret_cast<uint8_t*&>(data) += num_read;
1279 }
1280 }
1281
1282 protected:
1283 void process()
1284 {
1285 for (;;) {
1286 uint8_t* ptr; size_t num_write;
1287 std::tie(ptr, num_write) = m_ring.back();
1288 if (!ptr) _Unlikely_
1289 break;
1290 num_write = m_source->read(ptr, num_write);
1291 m_ring.push(num_write);
1292 if (!m_source->ok()) {
1293 m_ring.quit();
1294 break;
1295 }
1296 }
1297 }
1298
1299 protected:
1300 ring<uint8_t, N_cap> m_ring;
1301 std::thread m_worker;
1302 };
1303
1309 template <size_t N_cap = default_async_limit>
1310 class async_writer : public converter
1311 {
1312 public:
1313 async_writer(_Inout_ basic& source) :
1314 converter(source),
1315 m_worker([](_Inout_ async_writer& w) { w.process(); }, std::ref(*this))
1316 {}
1317
1318 virtual ~async_writer()
1319 {
1320 m_ring.quit();
1321 m_worker.join();
1322 }
1323
1324 virtual _Success_(return != 0) size_t write(
1325 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1326 {
1327 _Assume_(data || !length);
1328 for (size_t to_write = length;;) {
1329 uint8_t* ptr; size_t num_write;
1330 std::tie(ptr, num_write) = m_ring.back();
1331 if (!ptr) _Unlikely_ {
1332 m_state = state_t::fail;
1333 return length - to_write;
1334 }
1335 if (to_write < num_write)
1336 num_write = to_write;
1337 memcpy(ptr, data, num_write);
1338 m_ring.push(num_write);
1339 to_write -= num_write;
1340 if (!to_write) {
1341 m_state = state_t::ok;
1342 return length;
1343 }
1344 reinterpret_cast<const uint8_t*&>(data) += num_write;
1345 }
1346 }
1347
1348 virtual void flush()
1349 {
1350 m_ring.sync();
1351 converter::flush();
1352 }
1353
1354 protected:
1355 void process()
1356 {
1357 for (;;) {
1358 uint8_t* ptr; size_t num_read;
1359 std::tie(ptr, num_read) = m_ring.front();
1360 if (!ptr)
1361 break;
1362 num_read = m_source->write(ptr, num_read);
1363 m_ring.pop(num_read);
1364 if (!m_source->ok()) {
1365 m_ring.quit();
1366 break;
1367 }
1368 }
1369 }
1370
1371 protected:
1372 ring<uint8_t, N_cap> m_ring;
1373 std::thread m_worker;
1374 };
1375
1376 constexpr size_t default_buffer_size = 0x400;
1377
1381 class buffer : public converter
1382 {
1383 protected:
1385 explicit buffer(_In_ size_t read_buffer_size = default_buffer_size, _In_ size_t write_buffer_size = default_buffer_size) :
1386 converter(),
1387 m_read_buffer(read_buffer_size),
1388 m_write_buffer(write_buffer_size)
1389 {}
1390
1391 void done()
1392 {
1393 if (m_source)
1394 flush_write();
1395 converter::done();
1396 }
1398
1399 public:
1400 buffer(_Inout_ basic& source, _In_ size_t read_buffer_size = default_buffer_size, _In_ size_t write_buffer_size = default_buffer_size) :
1401 converter(source),
1402 m_read_buffer(read_buffer_size),
1403 m_write_buffer(write_buffer_size)
1404 {}
1405
1406 virtual ~buffer()
1407 {
1408 if (m_source)
1409 flush_write();
1410 }
1411
1412 virtual _Success_(return != 0 || length == 0) size_t read(
1413 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1414 {
1415 _Assume_(data || !length);
1416 for (size_t to_read = length;;) {
1417 size_t buffer_size = m_read_buffer.tail - m_read_buffer.head;
1418 if (to_read <= buffer_size) {
1419 memcpy(data, m_read_buffer.data + m_read_buffer.head, to_read);
1420 m_read_buffer.head += to_read;
1421 m_state = state_t::ok;
1422 return length;
1423 }
1424 if (buffer_size) {
1425 memcpy(data, m_read_buffer.data + m_read_buffer.head, buffer_size);
1426 reinterpret_cast<uint8_t*&>(data) += buffer_size;
1427 to_read -= buffer_size;
1428 }
1429 m_read_buffer.head = 0;
1430 if (to_read > m_read_buffer.capacity) {
1431 // When needing to read more data than buffer capacity, bypass the buffer.
1432 m_read_buffer.tail = 0;
1433 to_read -= m_source->read(data, to_read);
1434 m_state = to_read < length ? state_t::ok : m_source->state();
1435 return length - to_read;
1436 }
1437 m_read_buffer.tail = m_source->read(m_read_buffer.data, m_read_buffer.capacity);
1438 if (m_read_buffer.tail < m_read_buffer.capacity && m_read_buffer.tail < to_read) _Unlikely_ {
1439 memcpy(data, m_read_buffer.data, m_read_buffer.tail);
1440 m_read_buffer.head = m_read_buffer.tail;
1441 to_read -= m_read_buffer.tail;
1442 m_state = to_read < length ? state_t::ok : m_source->state();
1443 return length - to_read;
1444 }
1445 }
1446 }
1447
1448 virtual _Success_(return != 0) size_t write(
1449 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1450 {
1451 _Assume_(data || !length);
1452 if (!length) _Unlikely_ {
1453 // Pass null writes (zero-byte length). Null write operations have special meaning with with Windows pipes.
1454 flush_write();
1455 if (!ok()) _Unlikely_
1456 return 0;
1457 converter::write(nullptr, 0);
1458 return 0;
1459 }
1460
1461 for (size_t to_write = length;;) {
1462 size_t available_buffer = m_write_buffer.capacity - m_write_buffer.tail;
1463 if (to_write <= available_buffer) {
1464 memcpy(m_write_buffer.data + m_write_buffer.tail, data, to_write);
1465 m_write_buffer.tail += to_write;
1466 m_state = state_t::ok;
1467 return length;
1468 }
1469 if (available_buffer) {
1470 memcpy(m_write_buffer.data + m_write_buffer.tail, data, available_buffer);
1471 reinterpret_cast<const uint8_t*&>(data) += available_buffer;
1472 to_write -= available_buffer;
1473 m_write_buffer.tail += available_buffer;
1474 }
1475 size_t buffer_size = m_write_buffer.tail - m_write_buffer.head;
1476 if (buffer_size) {
1477 m_write_buffer.head += converter::write(m_write_buffer.data + m_write_buffer.head, buffer_size);
1478 if (m_write_buffer.head == m_write_buffer.tail)
1479 m_write_buffer.head = m_write_buffer.tail = 0;
1480 else
1481 return length - to_write;
1482 }
1483 if (to_write > m_write_buffer.capacity) {
1484 // When needing to write more data than buffer capacity, bypass the buffer.
1485 to_write -= converter::write(data, to_write);
1486 return length - to_write;
1487 }
1488 }
1489 }
1490
1491 virtual void flush()
1492 {
1493 flush_write();
1494 if (ok())
1495 converter::flush();
1496 }
1497
1498 protected:
1499 void flush_write()
1500 {
1501 size_t buffer_size = m_write_buffer.tail - m_write_buffer.head;
1502 if (buffer_size) {
1503 m_write_buffer.head += m_source->write(m_write_buffer.data + m_write_buffer.head, buffer_size);
1504 if (m_write_buffer.head == m_write_buffer.tail) {
1505 m_write_buffer.head = 0;
1506 m_write_buffer.tail = 0;
1507 }
1508 else {
1509 m_state = m_source->state();
1510 return;
1511 }
1512 }
1513 m_state = state_t::ok;
1514 }
1515
1516 struct buffer_t {
1517 uint8_t* data;
1518 size_t head, tail, capacity;
1519
1520 buffer_t(_In_ size_t buffer_size) :
1521 head(0),
1522 tail(0),
1523 capacity(buffer_size),
1524 data(buffer_size ? new uint8_t[buffer_size] : nullptr)
1525 {}
1526
1527 ~buffer_t()
1528 {
1529 if (data)
1530 delete[] data;
1531 }
1532 } m_read_buffer, m_write_buffer;
1533 };
1534
1538 class limiter : public converter
1539 {
1540 public:
1541 limiter(_Inout_ basic& source, _In_ fsize_t _read_limit = 0, _In_ fsize_t _write_limit = 0) :
1542 converter(source),
1543 read_limit(_read_limit),
1544 write_limit(_write_limit)
1545 {}
1546
1547 virtual _Success_(return != 0 || length == 0) size_t read(
1548 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1549 {
1550 size_t num_read;
1551 if (read_limit == fsize_max)
1552 num_read = converter::read(data, length);
1553 else if (length <= read_limit) {
1554 num_read = converter::read(data, length);
1555 read_limit -= num_read;
1556 }
1557 else if (length && !read_limit) {
1558 num_read = 0;
1559 m_state = state_t::eof;
1560 }
1561 else {
1562 num_read = converter::read(data, static_cast<size_t>(read_limit));
1563 read_limit -= num_read;
1564 }
1565 return num_read;
1566 }
1567
1568 virtual _Success_(return != 0) size_t write(
1569 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1570 {
1571 size_t num_written;
1572 if (write_limit == fsize_max)
1573 num_written = converter::write(data, length);
1574 else if (length <= write_limit) {
1575 num_written = converter::write(data, length);
1576 write_limit -= num_written;
1577 }
1578 else if (length && !write_limit) {
1579 num_written = 0;
1580 m_state = state_t::fail;
1581 }
1582 else {
1583 num_written = converter::write(data, static_cast<size_t>(write_limit));
1584 write_limit -= num_written;
1585 }
1586 return num_written;
1587 }
1588
1589 public:
1590 fsize_t
1591 read_limit,
1592 write_limit;
1593 };
1594
1598 class window : public limiter
1599 {
1600 public:
1601 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) :
1602 limiter(source, read_limit, write_limit),
1603 read_offset(_read_offset),
1604 write_offset(_write_offset)
1605 {}
1606
1607 virtual _Success_(return != 0 || length == 0) size_t read(
1608 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1609 {
1610 if (read_offset) {
1611 m_source->skip(read_offset);
1612 m_state = m_source->state();
1613 if (!ok()) _Unlikely_
1614 return 0;
1615 read_offset = 0;
1616 }
1617 size_t num_read;
1618 if (read_limit == fsize_max)
1619 num_read = converter::read(data, length);
1620 else if (length <= read_limit) {
1621 num_read = converter::read(data, length);
1622 read_limit -= num_read;
1623 }
1624 else if (length && !read_limit) {
1625 num_read = 0;
1626 m_source->skip(length);
1627 m_state = state_t::eof;
1628 }
1629 else {
1630 num_read = converter::read(data, static_cast<size_t>(read_limit));
1631 read_limit -= num_read;
1632 }
1633 return num_read;
1634 }
1635
1636 virtual _Success_(return != 0) size_t write(
1637 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1638 {
1639 size_t num_skipped, num_written;
1640 if (length <= write_offset) {
1641 write_offset -= length;
1642 m_state = state_t::ok;
1643 return length;
1644 }
1645 if (write_offset) {
1646 reinterpret_cast<const uint8_t*&>(data) += static_cast<size_t>(write_offset);
1647 length -= static_cast<size_t>(write_offset);
1648 num_skipped = static_cast<size_t>(write_offset);
1649 write_offset = 0;
1650 }
1651 else
1652 num_skipped = 0;
1653 if (write_limit == fsize_max)
1654 num_written = converter::write(data, length);
1655 else if (length <= write_limit) {
1656 num_written = converter::write(data, length);
1657 write_limit -= num_written;
1658 }
1659 else if (length && !write_limit) {
1660 num_skipped += length;
1661 num_written = 0;
1662 m_state = state_t::ok;
1663 }
1664 else {
1665 num_skipped += length - static_cast<size_t>(write_limit);
1666 num_written = converter::write(data, static_cast<size_t>(write_limit));
1667 write_limit -= num_written;
1668 }
1669 return num_skipped + num_written;
1670 }
1671
1672 public:
1673 fpos_t
1674 read_offset,
1675 write_offset;
1676 };
1677
1681 class file_window : public basic_file
1682 {
1683 public:
1684 file_window(_Inout_ basic_file& source, fpos_t offset = 0, fsize_t length = 0) :
1685 basic(source.state()),
1686 m_source(source),
1687 m_offset(source.tell()),
1688 m_region(offset, offset + length)
1689 {}
1690
1691 virtual _Success_(return != 0 || length == 0) size_t read(
1692 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1693 {
1694 _Assume_(data || !length);
1695 if (m_region.contains(m_offset)) {
1696 size_t num_read = m_source.read(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
1697 m_state = m_source.state();
1698 m_offset += num_read;
1699 return num_read;
1700 }
1701 m_state = length ? state_t::eof : state_t::ok;
1702 return 0;
1703 }
1704
1705 virtual _Success_(return != 0) size_t write(
1706 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1707 {
1708 _Assume_(data || !length);
1709 if (m_region.contains(m_offset)) {
1710 size_t num_written = m_source.write(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
1711 m_state = m_source.state();
1712 m_offset += num_written;
1713 return num_written;
1714 }
1715 m_state = state_t::fail;
1716 return 0;
1717 }
1718
1719 virtual void close()
1720 {
1721 m_source.close();
1722 m_state = m_source.state();
1723 }
1724
1725 virtual void flush()
1726 {
1727 m_source.flush();
1728 m_state = m_source.state();
1729 }
1730
1731 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
1732 {
1733 m_offset = m_source.seek(offset, how);
1734 m_state = m_source.state();
1735 return ok() ? m_offset - m_region.start : fpos_max;
1736 }
1737
1738 virtual void skip(_In_ fsize_t amount)
1739 {
1740 m_source.skip(amount);
1741 m_state = m_source.state();
1742 }
1743
1744 virtual fpos_t tell() const
1745 {
1746 fpos_t offset = m_source.tell();
1747 return m_region.contains(offset) ? offset - m_region.start : fpos_max;
1748 }
1749
1750 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
1751 {
1752 if (m_region.contains(offset)) {
1753 m_source.lock(m_region.start + offset, std::min<fsize_t>(length, m_region.end - offset));
1754 m_state = m_source.state();
1755 }
1756 else
1757 m_state = state_t::fail;
1758 }
1759
1760 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
1761 {
1762 if (m_region.contains(offset)) {
1763 m_source.unlock(m_region.start + offset, std::min<fsize_t>(length, m_region.end - offset));
1764 m_state = m_source.state();
1765 }
1766 else
1767 m_state = state_t::fail;
1768 }
1769
1770 virtual fsize_t size() const
1771 {
1772 return m_region.size();
1773 }
1774
1775 virtual void truncate()
1776 {
1777 m_state = state_t::fail;
1778 }
1779
1780 protected:
1781 basic_file& m_source;
1782 fpos_t m_offset;
1783 interval<fpos_t> m_region;
1784 };
1785
1786 constexpr size_t default_cache_size = 0x1000;
1787
1791 class cache : public basic_file
1792 {
1793 protected:
1795#pragma warning(suppress: 26495) // The delayed init call will finish initializing the class.
1796 explicit cache(_In_ size_t cache_size = default_cache_size) :
1797 basic(state_t::fail),
1798 m_cache(cache_size)
1799 {}
1800
1801 void init(_Inout_ basic_file& source)
1802 {
1803 m_source = &source;
1804 init();
1805 }
1806
1807 void init()
1808 {
1809 m_state = m_source->state();
1810 m_offset = m_source->tell();
1811#if SET_FILE_OP_TIMES
1812 m_atime = m_source->atime();
1813 m_mtime = m_source->mtime();
1814#endif
1815 }
1816
1817 void done()
1818 {
1819 if (m_source) {
1820 flush_cache();
1821 if (!ok()) _Unlikely_
1822 throw std::system_error(sys_error(), std::system_category(), "failed to flush cache"); // Data loss occured
1823 m_source->seek(m_offset);
1824#if SET_FILE_OP_TIMES
1825 m_source->set_atime(m_atime);
1826 m_source->set_mtime(m_mtime);
1827#endif
1828 m_source = nullptr;
1829 }
1830 }
1832
1833 public:
1834 cache(_Inout_ basic_file& source, _In_ size_t cache_size = default_cache_size) :
1835 basic(source.state()),
1836 m_source(&source),
1837 m_cache(cache_size),
1838 m_offset(source.tell())
1839#if SET_FILE_OP_TIMES
1840 , m_atime(source.atime())
1841 , m_mtime(source.mtime())
1842#endif
1843 {}
1844
1845 virtual ~cache() noexcept(false)
1846 {
1847 if (m_source) {
1848 flush_cache();
1849 if (!ok()) _Unlikely_
1850 throw std::system_error(sys_error(), std::system_category(), "failed to flush cache"); // Data loss occured
1851 m_source->seek(m_offset);
1852#if SET_FILE_OP_TIMES
1853 m_source->set_atime(m_atime);
1854 m_source->set_mtime(m_mtime);
1855#endif
1856 }
1857 }
1858
1859 virtual _Success_(return != 0 || length == 0) size_t read(
1860 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
1861 {
1862 _Assume_(data || !length);
1863#if SET_FILE_OP_TIMES
1864 m_atime = time_point::now();
1865#endif
1866 for (size_t to_read = length;;) {
1867 if (m_cache.status != cache_t::cache_t::status_t::empty) {
1868 if (m_cache.region.contains(m_offset)) {
1869 size_t remaining_cache = static_cast<size_t>(m_cache.region.end - m_offset);
1870 if (to_read <= remaining_cache) {
1871 memcpy(data, m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), to_read);
1872 m_offset += to_read;
1873 m_state = state_t::ok;
1874 return length;
1875 }
1876 memcpy(data, m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), remaining_cache);
1877 reinterpret_cast<uint8_t*&>(data) += remaining_cache;
1878 to_read -= remaining_cache;
1879 m_offset += remaining_cache;
1880 }
1881 flush_cache();
1882 if (!ok()) _Unlikely_ {
1883 if (to_read < length)
1884 m_state = state_t::ok;
1885 return length - to_read;
1886 }
1887 }
1888 {
1889 fpos_t end_max = m_offset + to_read;
1890 if (m_offset / m_cache.capacity < end_max / m_cache.capacity) {
1891 // Read spans multiple cache blocks. Bypass cache to the last block.
1892 m_source->seek(m_offset);
1893 if (!m_source->ok()) _Unlikely_ {
1894 m_state = to_read < length ? state_t::ok : state_t::fail;
1895 return length - to_read;
1896 }
1897 size_t num_read = m_source->read(data, to_read - static_cast<size_t>(end_max % m_cache.capacity));
1898 m_offset += num_read;
1899 to_read -= num_read;
1900 if (!to_read) {
1901 m_state = state_t::ok;
1902 return length;
1903 }
1904 reinterpret_cast<uint8_t*&>(data) += num_read;
1905 m_state = m_source->state();
1906 if (!ok()) {
1907 if (to_read < length)
1908 m_state = state_t::ok;
1909 return length - to_read;
1910 }
1911 }
1912 }
1913 load_cache(m_offset);
1914 if (!ok()) _Unlikely_ {
1915 m_state = to_read < length ? state_t::ok : state_t::fail;
1916 return length - to_read;
1917 }
1918 if (m_cache.region.end <= m_offset) _Unlikely_ {
1919 m_state = to_read < length ? state_t::ok : state_t::eof;
1920 return length - to_read;
1921 }
1922 }
1923 }
1924
1925 virtual _Success_(return != 0) size_t write(
1926 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
1927 {
1928 _Assume_(data || !length);
1929#if SET_FILE_OP_TIMES
1930 m_atime = m_mtime = time_point::now();
1931#endif
1932 for (size_t to_write = length;;) {
1933 if (m_cache.status != cache_t::cache_t::status_t::empty) {
1934 fpos_t end_max = m_cache.region.start + m_cache.capacity;
1935 if (m_cache.region.start <= m_offset && m_offset < end_max) {
1936 size_t remaining_cache = static_cast<size_t>(end_max - m_offset);
1937 if (to_write <= remaining_cache) {
1938 memcpy(m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), data, to_write);
1939 m_offset += to_write;
1940 m_cache.status = cache_t::cache_t::status_t::dirty;
1941 m_cache.region.end = std::max(m_cache.region.end, m_offset);
1942 m_state = state_t::ok;
1943 return length;
1944 }
1945 memcpy(m_cache.data + static_cast<size_t>(m_offset - m_cache.region.start), data, remaining_cache);
1946 reinterpret_cast<const uint8_t*&>(data) += remaining_cache;
1947 to_write -= remaining_cache;
1948 m_offset += remaining_cache;
1949 m_cache.status = cache_t::cache_t::status_t::dirty;
1950 m_cache.region.end = end_max;
1951 }
1952 flush_cache();
1953 if (!ok()) _Unlikely_
1954 return length - to_write;
1955 }
1956 {
1957 fpos_t end_max = m_offset + to_write;
1958 if (m_offset / m_cache.capacity < end_max / m_cache.capacity) {
1959 // Write spans multiple cache blocks. Bypass cache to the last block.
1960 m_source->seek(m_offset);
1961 if (!ok()) _Unlikely_
1962 return length - to_write;
1963 size_t num_written = m_source->write(data, to_write - static_cast<size_t>(end_max % m_cache.capacity));
1964 m_offset += num_written;
1965 m_state = m_source->state();
1966 to_write -= num_written;
1967 if (!to_write || !ok())
1968 return length - to_write;
1969 reinterpret_cast<const uint8_t*&>(data) += num_written;
1970 }
1971 }
1972 load_cache(m_offset);
1973 if (!ok()) _Unlikely_
1974 return length - to_write;
1975 }
1976 }
1977
1978 virtual void close()
1979 {
1980 invalidate_cache();
1981 if (!ok()) _Unlikely_
1982 throw std::system_error(sys_error(), std::system_category(), "failed to flush cache"); // Data loss occured
1983 m_source->close();
1984 m_state = m_source->state();
1985 }
1986
1987 virtual void flush()
1988 {
1989#if SET_FILE_OP_TIMES
1990 m_atime = m_mtime = time_point::min();
1991#endif
1992 flush_cache();
1993 if (!ok()) _Unlikely_
1994 return;
1995 m_source->flush();
1996 }
1997
1998 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
1999 {
2000 m_state = state_t::ok;
2001 switch (how) {
2002 case seek_t::beg:
2003 return m_offset = offset;
2004 case seek_t::cur:
2005 return m_offset += offset;
2006 case seek_t::end: {
2007 auto n = size();
2008 if (n == fsize_max) _Unlikely_{
2009 m_state = state_t::fail;
2010 return fpos_max;
2011 }
2012 return m_offset = n + offset;
2013 }
2014 default:
2015 throw std::invalid_argument("unknown seek origin");
2016 }
2017 }
2018
2019 virtual fpos_t tell() const
2020 {
2021 return m_offset;
2022 }
2023
2024 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
2025 {
2026 m_source->lock(offset, length);
2027 m_state = m_source->state();
2028 }
2029
2030 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
2031 {
2032 m_source->unlock(offset, length);
2033 m_state = m_source->state();
2034 }
2035
2036 virtual fsize_t size() const
2037 {
2038 return m_cache.status != cache_t::cache_t::status_t::empty ?
2039 std::max(m_source->size(), m_cache.region.end) :
2040 m_source->size();
2041 }
2042
2043 virtual void truncate()
2044 {
2045#if SET_FILE_OP_TIMES
2046 m_atime = m_mtime = time_point::now();
2047#endif
2048 m_source->seek(m_offset);
2049 if (m_cache.region.end <= m_offset) {
2050 // Truncation does not affect cache.
2051 }
2052 else if (m_cache.region.start <= m_offset) {
2053 // Truncation truncates cache.
2054 m_cache.region.end = m_offset;
2055 }
2056 else {
2057 // Truncation invalidates cache.
2058 m_cache.status = cache_t::cache_t::status_t::empty;
2059 }
2060 m_source->truncate();
2061 m_state = m_source->state();
2062 }
2063
2064 virtual time_point ctime() const
2065 {
2066 return m_source->ctime();
2067 }
2068
2069 virtual time_point atime() const
2070 {
2071#if SET_FILE_OP_TIMES
2072 return std::max(m_atime, m_source->atime());
2073#else
2074 return m_source->atime();
2075#endif
2076 }
2077
2078 virtual time_point mtime() const
2079 {
2080#if SET_FILE_OP_TIMES
2081 return std::max(m_mtime, m_source->mtime());
2082#else
2083 return m_source->mtime();
2084#endif
2085 }
2086
2087 virtual void set_ctime(time_point date)
2088 {
2089 m_source->set_ctime(date);
2090 }
2091
2092 virtual void set_atime(time_point date)
2093 {
2094#if SET_FILE_OP_TIMES
2095 m_atime = date;
2096#endif
2097 m_source->set_atime(date);
2098 }
2099
2100 virtual void set_mtime(time_point date)
2101 {
2102#if SET_FILE_OP_TIMES
2103 m_mtime = date;
2104#endif
2105 m_source->set_mtime(date);
2106 }
2107
2108 protected:
2110 void flush_cache()
2111 {
2112 if (m_cache.status != cache_t::cache_t::status_t::dirty)
2113 m_state = state_t::ok;
2114 else if (!m_cache.region.empty()) {
2115 write_cache();
2116 if (ok())
2117 m_cache.status = cache_t::cache_t::status_t::loaded;
2118 }
2119 else {
2120 m_state = state_t::ok;
2121 m_cache.status = cache_t::cache_t::status_t::loaded;
2122 }
2123 }
2124
2125 void invalidate_cache()
2126 {
2127 if (m_cache.status == cache_t::cache_t::status_t::dirty && !m_cache.region.empty()) {
2128 write_cache();
2129 if (!ok()) _Unlikely_
2130 return;
2131 } else
2132 m_state = state_t::ok;
2133 m_cache.status = cache_t::cache_t::status_t::empty;
2134 }
2135
2136 void load_cache(_In_ fpos_t start)
2137 {
2138 _Assume_(m_cache.status != cache_t::cache_t::status_t::dirty);
2139 start -= start % m_cache.capacity; // Align to cache block size.
2140 m_source->seek(m_cache.region.start = start);
2141 if (m_source->ok()) {
2142 m_cache.region.end = start + m_source->read(m_cache.data, m_cache.capacity);
2143 m_cache.status = cache_t::cache_t::status_t::loaded;
2144 m_state = state_t::ok; // Regardless the read failure, we still might have cached some data.
2145 }
2146 else
2147 m_state = state_t::fail;
2148 }
2149
2150 void write_cache()
2151 {
2152 _Assume_(m_cache.status == cache_t::cache_t::status_t::dirty);
2153 m_source->seek(m_cache.region.start);
2154 m_source->write(m_cache.data, static_cast<size_t>(m_cache.region.size()));
2155 m_state = m_source->state();
2156 }
2157
2158 basic_file* m_source;
2159 struct cache_t {
2160 uint8_t* data;
2161 size_t capacity;
2162 enum class status_t {
2163 empty = 0,
2164 loaded,
2165 dirty,
2166 } status;
2167 interval<fpos_t> region;
2168
2169 cache_t(_In_ size_t _capacity) :
2170 data(new uint8_t[_capacity]),
2171 capacity(_capacity),
2172 status(status_t::empty),
2173 region(0)
2174 {}
2175
2176 ~cache_t()
2177 {
2178 delete[] data;
2179 }
2180 } m_cache;
2181 fpos_t m_offset;
2182#if SET_FILE_OP_TIMES
2183 time_point
2184 m_atime,
2185 m_mtime;
2186#endif
2188 };
2189
2193 class basic_sys : virtual public basic, public sys_object
2194 {
2195 public:
2196 basic_sys(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok) :
2197 basic(state),
2198 sys_object(h)
2199 {}
2200
2201 virtual _Success_(return != 0 || length == 0) size_t read(
2202 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2203 {
2204 _Assume_(data || !length);
2205 // Windows Server 2003 and Windows XP: Pipe write operations across a network are limited in size per write.
2206 // The amount varies per platform. For x86 platforms it's 63.97 MB. For x64 platforms it's 31.97 MB. For Itanium
2207 // it's 63.95 MB. For more information regarding pipes, see the Remarks section.
2208 size_t
2209#if defined(_WIN64)
2210 block_size = 0x1F80000;
2211#elif defined(_WIN32)
2212 block_size = 0x3f00000;
2213#else
2214 block_size = SSIZE_MAX;
2215#endif
2216 for (size_t to_read = length;;) {
2217#ifdef _WIN32
2218 // ReadFile() might raise exception (e.g. STATUS_FILE_BAD_FORMAT/0xE0000002).
2219 BOOL succeeded;
2220 DWORD num_read;
2221 __try { succeeded = ReadFile(m_h, data, static_cast<DWORD>(std::min<size_t>(to_read, block_size)), &num_read, nullptr); }
2222 __except (EXCEPTION_EXECUTE_HANDLER) { succeeded = FALSE; SetLastError(ERROR_UNHANDLED_EXCEPTION); num_read = 0; }
2223 if (!succeeded && GetLastError() == ERROR_NO_SYSTEM_RESOURCES && block_size > default_block_size) _Unlikely_ {
2224 // Error "Insufficient system resources exist to complete the requested service." occurs
2225 // ocasionally, when attempting to read too much data at once (e.g. over \\TSClient).
2226 block_size = default_block_size;
2227 continue;
2228 }
2229 if (!succeeded) _Unlikely_
2230#else
2231 ssize_t num_read = ::read(m_h, data, static_cast<ssize_t>(std::min<size_t>(to_read, block_size)));
2232 if (num_read < 0) _Unlikely_
2233#endif
2234 {
2235 m_state = to_read < length ? state_t::ok : state_t::fail;
2236 return length - to_read;
2237 }
2238 if (!num_read) _Unlikely_ {
2239 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2240 return length - to_read;
2241 }
2242 to_read -= num_read;
2243 if (!to_read) {
2244 m_state = state_t::ok;
2245 return length;
2246 }
2247 reinterpret_cast<uint8_t*&>(data) += num_read;
2248 }
2249 }
2250
2251 virtual _Success_(return != 0) size_t write(
2252 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2253 {
2254 // Windows Server 2003 and Windows XP: Pipe write operations across a network are limited in size per write.
2255 // The amount varies per platform. For x86 platforms it's 63.97 MB. For x64 platforms it's 31.97 MB. For Itanium
2256 // it's 63.95 MB. For more information regarding pipes, see the Remarks section.
2257 constexpr size_t
2258#if defined(_WIN64)
2259 block_size = 0x1F80000;
2260#elif defined(_WIN32)
2261 block_size = 0x3f00000;
2262#else
2263 block_size = SSIZE_MAX;
2264#endif
2265 for (size_t to_write = length;;) {
2266#ifdef _WIN32
2267 // ReadFile() might raise an exception. Be cautious with WriteFile() too.
2268 BOOL succeeded;
2269 DWORD num_written;
2270 __try { succeeded = WriteFile(m_h, data, static_cast<DWORD>(std::min<size_t>(to_write, block_size)), &num_written, nullptr); }
2271 __except (EXCEPTION_EXECUTE_HANDLER) { succeeded = FALSE; SetLastError(ERROR_UNHANDLED_EXCEPTION); num_written = 0; }
2272 to_write -= num_written;
2273 if (!to_write) {
2274 m_state = state_t::ok;
2275 return length;
2276 }
2277 reinterpret_cast<const uint8_t*&>(data) += num_written;
2278 if (!succeeded) _Unlikely_ {
2279 m_state = state_t::fail;
2280 return length - to_write;
2281 }
2282#else
2283 ssize_t num_written = ::write(m_h, data, static_cast<ssize_t>(std::min<size_t>(to_write, block_size)));
2284 if (num_written < 0) _Unlikely_ {
2285 m_state = state_t::fail;
2286 return length - to_write;
2287 }
2288 to_write -= num_written;
2289 if (!to_write) {
2290 m_state = state_t::ok;
2291 return length;
2292 }
2293 reinterpret_cast<const uint8_t*&>(data) += num_written;
2294#endif
2295 }
2296 }
2297
2298 virtual void close()
2299 {
2300 try {
2301 sys_object::close();
2302 m_state = state_t::ok;
2303 }
2304 catch (...) {
2305 m_state = state_t::fail;
2306 }
2307 }
2308
2309 virtual void flush()
2310 {
2311#ifdef _WIN32
2312 m_state = FlushFileBuffers(m_h) ? state_t::ok : state_t::fail;
2313#else
2314 m_state = fsync(m_h) >= 0 ? state_t::ok : state_t::fail;
2315#endif
2316 }
2317 };
2318
2322 class buffered_sys : public buffer
2323 {
2324 public:
2325 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) :
2326 buffer(read_buffer_size, write_buffer_size),
2327 m_source(h)
2328 {
2329 init(m_source);
2330 }
2331
2332 virtual ~buffered_sys()
2333 {
2334 done();
2335 }
2336
2337 protected:
2338 basic_sys m_source;
2339 };
2340
2344 class socket : public basic
2345 {
2346 public:
2347 socket(_In_opt_ socket_t h = invalid_socket, _In_ state_t state = state_t::ok) :
2348 basic(state),
2349 m_h(h)
2350 {}
2351
2352 private:
2353 socket(_In_ const socket& other);
2354 socket& operator =(_In_ const socket& other);
2355
2356 public:
2357 socket(_Inout_ socket&& other) noexcept : m_h(other.m_h)
2358 {
2359 other.m_h = invalid_socket;
2360 }
2361
2362 socket& operator =(_Inout_ socket&& other) noexcept
2363 {
2364 if (this != std::addressof(other)) {
2365 if (m_h != invalid_socket)
2366 closesocket(m_h);
2367 m_h = other.m_h;
2368 other.m_h = invalid_socket;
2369 }
2370 return *this;
2371 }
2372
2380 socket(_In_ int af, _In_ int type, _In_ int protocol)
2381 {
2382 m_h = ::socket(af, type, protocol);
2383 if (m_h == invalid_socket) _Unlikely_
2384 m_state = state_t::fail;
2385 }
2386
2387 virtual ~socket()
2388 {
2389 if (m_h != invalid_socket)
2390 closesocket(m_h);
2391 }
2392
2396 operator bool() const noexcept { return m_h != invalid_socket; }
2397
2401 socket_t get() const noexcept { return m_h; }
2402
2403 virtual _Success_(return != 0 || length == 0) size_t read(
2404 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2405 {
2406 _Assume_(data || !length);
2407 constexpr int block_size = 0x10000000;
2408 for (size_t to_read = length;;) {
2409 int num_read = recv(m_h, reinterpret_cast<char*>(data), static_cast<int>(std::min<size_t>(to_read, block_size)), 0);
2410 if (num_read == SOCKET_ERROR) _Unlikely_ {
2411 m_state = to_read < length ? state_t::ok : state_t::fail;
2412 return length - to_read;
2413 }
2414 if (!num_read) {
2415 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2416 return length - to_read;
2417 }
2418 to_read -= num_read;
2419 if (!to_read) {
2420 m_state = state_t::ok;
2421 return length;
2422 }
2423 reinterpret_cast<uint8_t*&>(data) += num_read;
2424 }
2425 }
2426
2427 virtual _Success_(return != 0) size_t write(
2428 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2429 {
2430 _Assume_(data || !length);
2431 constexpr int block_size = 0x10000000;
2432 for (size_t to_write = length;;) {
2433 int num_written = send(m_h, reinterpret_cast<const char*>(data), static_cast<int>(std::min<size_t>(to_write, block_size)), 0);
2434 if (num_written == SOCKET_ERROR) _Unlikely_ {
2435 m_state = state_t::fail;
2436 return length - to_write;
2437 }
2438 to_write -= num_written;
2439 if (!to_write) {
2440 m_state = state_t::ok;
2441 return length;
2442 }
2443 reinterpret_cast<const uint8_t*&>(data) += num_written;
2444 }
2445 }
2446
2447 virtual void close()
2448 {
2449 if (m_h != invalid_socket) {
2450 closesocket(m_h);
2451 m_h = invalid_socket;
2452 }
2453 m_state = state_t::ok;
2454 }
2455
2456 protected:
2457 socket_t m_h;
2458 };
2459
2460#ifdef _WIN32
2464 class sequential_stream : public basic
2465 {
2466 public:
2467 sequential_stream(_In_ ISequentialStream* source) : m_source(source)
2468 {
2469 m_source->AddRef();
2470 }
2471
2472 virtual ~sequential_stream()
2473 {
2474 m_source->Release();
2475 }
2476
2477 virtual _Success_(return != 0 || length == 0) size_t read(
2478 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2479 {
2480 _Assume_(data || !length);
2481 for (size_t to_read = length;;) {
2482 HRESULT hr;
2483 ULONG num_read = 0;
2484 __try { hr = m_source->Read(data, (ULONG)std::min<size_t>(to_read, ULONG_MAX), &num_read); }
2485 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2486 if (FAILED(hr)) _Unlikely_ {
2487 m_state = to_read < length ? state_t::ok : state_t::fail;
2488 return length - to_read;
2489 }
2490 to_read -= num_read;
2491 if (hr == S_FALSE) _Unlikely_ {
2492 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2493 return length - to_read;
2494 }
2495 if (!to_read) {
2496 m_state = state_t::ok;
2497 return length;
2498 }
2499 reinterpret_cast<uint8_t*&>(data) += num_read;
2500 }
2501 }
2502
2503 virtual _Success_(return != 0) size_t write(
2504 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2505 {
2506 _Assume_(data || !length);
2507 for (size_t to_write = length;;) {
2508 HRESULT hr;
2509 ULONG num_written = 0;
2510 __try { hr = m_source->Write(data, static_cast<ULONG>(std::min<size_t>(to_write, ULONG_MAX)), &num_written); }
2511 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2512 // In abscence of documentation whether num_written gets set when FAILED(hr) (i.e. partially succesful writes),
2513 // assume write failed completely.
2514 if (FAILED(hr)) _Unlikely_ {
2515 m_state = state_t::fail;
2516 return length - to_write;
2517 }
2518 to_write -= num_written;
2519 if (!to_write) {
2520 m_state = state_t::ok;
2521 return length;
2522 }
2523 reinterpret_cast<const uint8_t*&>(data) += num_written;
2524 }
2525 }
2526
2527 protected:
2528 ISequentialStream* m_source;
2529 };
2530
2534 class asp : public basic
2535 {
2536 public:
2537 asp(_In_opt_ IRequest* request, _In_opt_ IResponse* response) :
2538 m_request(request),
2539 m_response(response)
2540 {
2541 if (m_request)
2542 m_request->AddRef();
2543 if (m_response)
2544 m_response->AddRef();
2545 }
2546
2547 virtual ~asp()
2548 {
2549 if (m_request)
2550 m_request->Release();
2551 if (m_response)
2552 m_response->Release();
2553 }
2554
2555 virtual _Success_(return != 0 || length == 0) size_t read(
2556 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
2557 {
2558 _Assume_(data || !length);
2559 if (!m_request) _Unlikely_ {
2560 m_state = state_t::fail;
2561 return 0;
2562 }
2563 for (size_t to_read = length;;) {
2564 VARIANT var_amount, var_data;
2565 V_VT(&var_amount) = VT_I4;
2566 V_I4(&var_amount) = (LONG)std::min<size_t>(to_read, LONG_MAX);
2567 V_VT(&var_data) = VT_EMPTY;
2568 HRESULT hr = [&]() {
2569 __try { return m_request->BinaryRead(&var_amount, &var_data); }
2570 __except (EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
2571 }();
2572 if (FAILED(hr)) _Unlikely_ {
2573 m_state = to_read < length ? state_t::ok : state_t::fail;
2574 return length - to_read;
2575 }
2576 _Assume_(V_VT(&var_amount) == VT_I4);
2577 _Assume_(V_VT(&var_data) == (VT_ARRAY | VT_UI1));
2578 std::unique_ptr<SAFEARRAY, SafeArrayDestroy_delete> sa(V_ARRAY(&var_data));
2579 if (!V_I4(&var_amount)) _Unlikely_ {
2580 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
2581 return length - to_read;
2582 }
2583 safearray_accessor<uint8_t> a(sa.get());
2584 memcpy(data, a.data(), V_I4(&var_amount));
2585 to_read -= V_I4(&var_amount);
2586 if (!to_read) {
2587 m_state = state_t::ok;
2588 return length;
2589 }
2590 reinterpret_cast<uint8_t*&>(data) += V_I4(&var_amount);
2591 }
2592 }
2593
2594 virtual _Success_(return != 0) size_t write(
2595 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
2596 {
2597 if (!m_response) {
2598 m_state = state_t::fail;
2599 return 0;
2600 }
2601 for (size_t to_write = length;;) {
2602 UINT num_written = static_cast<UINT>(std::min<size_t>(to_write, UINT_MAX));
2603 std::unique_ptr<OLECHAR, SysFreeString_delete> bstr_data(SysAllocStringByteLen(reinterpret_cast<LPCSTR>(data), num_written));
2604 VARIANT var_data;
2605 V_VT(&var_data) = VT_BSTR;
2606 V_BSTR(&var_data) = bstr_data.get();
2607 HRESULT hr = [&]() {
2608 __try { return m_response->BinaryWrite(var_data); }
2609 __except (EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
2610 }();
2611 if (FAILED(hr)) _Unlikely_ {
2612 m_state = state_t::fail;
2613 return length - to_write;
2614 }
2615 to_write -= num_written;
2616 if (!to_write) {
2617 m_state = state_t::ok;
2618 return length;
2619 }
2620 reinterpret_cast<const uint8_t*&>(data) += num_written;
2621 }
2622 }
2623
2624 virtual void close()
2625 {
2626 if (m_response) {
2627 __try { m_response->End(); }
2628 __except (EXCEPTION_EXECUTE_HANDLER) {}
2629 }
2630 m_state = state_t::ok;
2631 }
2632
2633 virtual void flush()
2634 {
2635 if (m_response) {
2636 HRESULT hr;
2637 __try { hr = m_response->Flush(); }
2638 __except (EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }
2639 m_state = SUCCEEDED(hr) ? state_t::ok : state_t::fail;
2640 }
2641 }
2642
2643 protected:
2644 IRequest* m_request;
2645 IResponse* m_response;
2646 };
2647#endif
2648
2652 enum mode_t
2653 {
2654 mode_for_reading = 1 << 0,
2655 mode_for_writing = 1 << 1,
2656 mode_for_chmod = 1 << 2,
2657
2658 mode_open_existing = 0 << 3,
2659 mode_truncate_existing = 1 << 3,
2660 mode_preserve_existing = 2 << 3,
2661 mode_create_new = 3 << 3,
2662 mode_create = 4 << 3,
2663 mode_disposition_mask = 7 << 3,
2664
2665 mode_append = 1 << 6,
2666 mode_text = 0,
2667 mode_binary = 1 << 7,
2668
2669 share_none = 0,
2670 share_reading = 1 << 8,
2671 share_writing = 1 << 9,
2672 share_deleting = 1 << 10,
2673 share_all = share_reading | share_writing | share_deleting, // Allow others all operations on our file
2674
2675 inherit_handle = 1 << 11,
2676
2677 hint_write_thru = 1 << 12,
2678 hint_no_buffering = 1 << 13,
2679 hint_random_access = 1 << 14,
2680 hint_sequential_access = 1 << 15,
2681 };
2682
2683#pragma warning(push)
2684#pragma warning(disable: 4250)
2688 class file : virtual public basic_file, virtual public basic_sys
2689 {
2690 public:
2691 file(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok) : basic_sys(h, state) {}
2692
2699 file(_In_z_ const schar_t* filename, _In_ int mode)
2700 {
2701 open(filename, mode);
2702 }
2703
2710 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
2711 file(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode) : file(filename.c_str(), mode) {}
2712
2719 void open(_In_z_ const schar_t* filename, _In_ int mode)
2720 {
2721 if (m_h != invalid_handle)
2722 close();
2723
2724#ifdef _WIN32
2725 DWORD dwDesiredAccess = 0;
2726 if (mode & mode_for_reading) dwDesiredAccess |= GENERIC_READ;
2727 if (mode & mode_for_writing) dwDesiredAccess |= GENERIC_WRITE;
2728 if (mode & mode_for_chmod) dwDesiredAccess |= FILE_WRITE_ATTRIBUTES;
2729
2730 DWORD dwShareMode = 0;
2731 if (mode & share_reading) dwShareMode |= FILE_SHARE_READ;
2732 if (mode & share_writing) dwShareMode |= FILE_SHARE_WRITE;
2733 if (mode & share_deleting) dwShareMode |= FILE_SHARE_DELETE;
2734
2735 SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES) };
2736 sa.bInheritHandle = mode & inherit_handle ? true : false;
2737
2738 DWORD dwCreationDisposition;
2739 switch (mode & mode_disposition_mask) {
2740 case mode_open_existing: dwCreationDisposition = OPEN_EXISTING; break;
2741 case mode_truncate_existing: dwCreationDisposition = TRUNCATE_EXISTING; break;
2742 case mode_preserve_existing: dwCreationDisposition = OPEN_ALWAYS; break;
2743 case mode_create_new: dwCreationDisposition = CREATE_NEW; break;
2744 case mode_create: dwCreationDisposition = CREATE_ALWAYS; break;
2745 default: throw std::invalid_argument("invalid mode");
2746 }
2747
2748 DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
2749 if (mode & hint_write_thru) dwFlagsAndAttributes |= FILE_FLAG_WRITE_THROUGH;
2750 if (mode & hint_no_buffering) dwFlagsAndAttributes |= FILE_FLAG_NO_BUFFERING;
2751 if (mode & hint_random_access) dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
2752 if (mode & hint_sequential_access) dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
2753
2754 m_h = CreateFile(filename, dwDesiredAccess, dwShareMode, &sa, dwCreationDisposition, dwFlagsAndAttributes, NULL);
2755#else
2756 int flags = 0;
2757 switch (mode & (mode_for_reading | mode_for_writing)) {
2758 case mode_for_reading: flags |= O_RDONLY; break;
2759 case mode_for_writing: flags |= O_WRONLY; break;
2760 case mode_for_reading | mode_for_writing: flags |= O_RDWR; break;
2761 }
2762 switch (mode & mode_disposition_mask) {
2763 case mode_open_existing: break;
2764 case mode_truncate_existing: flags |= O_TRUNC; break;
2765 case mode_preserve_existing: flags |= O_CREAT; break;
2766 case mode_create_new: flags |= O_CREAT | O_EXCL; break;
2767 case mode_create: flags |= O_CREAT | O_TRUNC; break;
2768 default: throw std::invalid_argument("invalid mode");
2769 }
2770 if (mode & hint_write_thru) flags |= O_DSYNC;
2771#ifndef __APPLE__
2772 if (mode & hint_no_buffering) flags |= O_RSYNC;
2773#endif
2774
2775 m_h = ::open(filename, flags, DEFFILEMODE);
2776#endif
2777 if (m_h != invalid_handle) {
2778 m_state = state_t::ok;
2779 if (mode & mode_append)
2780 seek(0, seek_t::end);
2781 }
2782 else
2783 m_state = state_t::fail;
2784 }
2785
2792 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
2793 void open(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode)
2794 {
2795 open(filename.c_str(), mode);
2796 }
2797
2798 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
2799 {
2800#ifdef _WIN32
2801 LARGE_INTEGER li;
2802 li.QuadPart = offset;
2803 li.LowPart = SetFilePointer(m_h, li.LowPart, &li.HighPart, static_cast<DWORD>(how));
2804 if (li.LowPart != 0xFFFFFFFF || GetLastError() == NO_ERROR) {
2805 m_state = state_t::ok;
2806 return li.QuadPart;
2807 }
2808#else
2809 off64_t result = lseek64(m_h, offset, static_cast<int>(how));
2810 if (result >= 0) {
2811 m_state = state_t::ok;
2812 return result;
2813 }
2814#endif
2815 m_state = state_t::fail;
2816 return fpos_max;
2817 }
2818
2819 virtual fpos_t tell() const
2820 {
2821 if (m_h != invalid_handle) {
2822#ifdef _WIN32
2823 LARGE_INTEGER li;
2824 li.QuadPart = 0;
2825 li.LowPart = SetFilePointer(m_h, 0, &li.HighPart, FILE_CURRENT);
2826 if (li.LowPart != 0xFFFFFFFF || GetLastError() == NO_ERROR)
2827 return li.QuadPart;
2828#else
2829 off64_t result = lseek64(m_h, 0, SEEK_CUR);
2830 if (result >= 0)
2831 return result;
2832#endif
2833 }
2834 return fpos_max;
2835 }
2836
2837 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
2838 {
2839#ifdef _WIN32
2840 LARGE_INTEGER liOffset;
2841 LARGE_INTEGER liSize;
2842 liOffset.QuadPart = offset;
2843 liSize.QuadPart = length;
2844 if (LockFile(m_h, liOffset.LowPart, liOffset.HighPart, liSize.LowPart, liSize.HighPart)) {
2845 m_state = state_t::ok;
2846 return;
2847 }
2848#else
2849 off64_t orig = lseek64(m_h, 0, SEEK_CUR);
2850 if (orig >= 0) {
2851 m_state = lseek64(m_h, offset, SEEK_SET) >= 0 && lockf64(m_h, F_LOCK, length) >= 0 ? state_t::ok : state_t::fail;
2852 lseek64(m_h, orig, SEEK_SET);
2853 m_state = state_t::ok;
2854 return;
2855 }
2856#endif
2857 m_state = state_t::fail;
2858 }
2859
2860 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
2861 {
2862#ifdef _WIN32
2863 LARGE_INTEGER liOffset;
2864 LARGE_INTEGER liSize;
2865 liOffset.QuadPart = offset;
2866 liSize.QuadPart = length;
2867 if (UnlockFile(m_h, liOffset.LowPart, liOffset.HighPart, liSize.LowPart, liSize.HighPart)) {
2868 m_state = state_t::ok;
2869 return;
2870 }
2871#else
2872 off64_t orig = lseek64(m_h, 0, SEEK_CUR);
2873 if (orig >= 0) {
2874 if (lseek64(m_h, offset, SEEK_SET) >= 0 && lockf64(m_h, F_ULOCK, length) >= 0) {
2875 lseek64(m_h, orig, SEEK_SET);
2876 m_state = state_t::ok;
2877 return;
2878 }
2879 lseek64(m_h, orig, SEEK_SET);
2880 }
2881#endif
2882 m_state = state_t::fail;
2883 }
2884
2885 virtual fsize_t size() const
2886 {
2887#ifdef _WIN32
2888 LARGE_INTEGER li;
2889 li.LowPart = GetFileSize(m_h, (LPDWORD)&li.HighPart);
2890 if (li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR)
2891 li.QuadPart = -1;
2892 return li.QuadPart;
2893#else
2894 off64_t length = -1, orig = lseek64(m_h, 0, SEEK_CUR);
2895 if (orig >= 0) {
2896 length = lseek64(m_h, 0, SEEK_END);
2897 lseek64(m_h, orig, SEEK_SET);
2898 }
2899 return length;
2900#endif
2901 }
2902
2903 virtual void truncate()
2904 {
2905#ifdef _WIN32
2906 if (SetEndOfFile(m_h)) {
2907 m_state = state_t::ok;
2908 return;
2909 }
2910#else
2911 off64_t length = lseek64(m_h, 0, SEEK_CUR);
2912 if (length >= 0 && ftruncate64(m_h, length) >= 0) {
2913 m_state = state_t::ok;
2914 return;
2915 }
2916#endif
2917 m_state = state_t::fail;
2918 }
2919
2920#ifdef _WIN32
2921 static time_point ft2tp(_In_ const FILETIME& ft)
2922 {
2923#if _HAS_CXX20
2924 uint64_t t = (static_cast<int64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
2925#else
2926 uint64_t t = ((static_cast<int64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime) - 116444736000000000ll;
2927#endif
2928 return time_point(time_point::duration(t));
2929 }
2930
2931 static void tp2ft(_In_ time_point tp, _Out_ FILETIME& ft)
2932 {
2933#if _HAS_CXX20
2934 uint64_t t = tp.time_since_epoch().count();
2935#else
2936 uint64_t t = tp.time_since_epoch().count() + 116444736000000000ll;
2937#endif
2938 ft.dwHighDateTime = static_cast<DWORD>((t >> 32) & 0xffffffff);
2939 ft.dwLowDateTime = static_cast<DWORD>(t & 0xffffffff);
2940 }
2941#endif
2942
2943 virtual time_point ctime() const
2944 {
2945#ifdef _WIN32
2946 FILETIME ft;
2947 if (GetFileTime(m_h, &ft, nullptr, nullptr))
2948 return ft2tp(ft);
2949#endif
2950 return time_point::min();
2951 }
2952
2953 virtual time_point atime() const
2954 {
2955#ifdef _WIN32
2956 FILETIME ft;
2957 if (GetFileTime(m_h, nullptr, &ft, nullptr))
2958 return ft2tp(ft);
2959#else
2960 struct stat buf;
2961 if (fstat(m_h, &buf) >= 0)
2962 return clock::from_time_t(buf.st_atime);
2963#endif
2964 return time_point::min();
2965 }
2966
2967 virtual time_point mtime() const
2968 {
2969#ifdef _WIN32
2970 FILETIME ft;
2971 if (GetFileTime(m_h, nullptr, nullptr, &ft))
2972 return ft2tp(ft);
2973#else
2974 struct stat buf;
2975 if (fstat(m_h, &buf) >= 0)
2976 return clock::from_time_t(buf.st_mtime);
2977#endif
2978 return time_point::min();
2979 }
2980
2981 virtual void set_ctime(time_point date)
2982 {
2983 _Assume_(m_h != invalid_handle);
2984#ifdef _WIN32
2985 FILETIME ft;
2986 tp2ft(date, ft);
2987 if (SetFileTime(m_h, &ft, nullptr, nullptr))
2988 return;
2989 throw std::system_error(GetLastError(), std::system_category(), "SetFileTime failed");
2990#else
2991 throw std::runtime_error("not supported");
2992#endif
2993 }
2994
2995 virtual void set_atime(time_point date)
2996 {
2997 _Assume_(m_h != invalid_handle);
2998#ifdef _WIN32
2999 FILETIME ft;
3000 tp2ft(date, ft);
3001 if (SetFileTime(m_h, nullptr, &ft, nullptr))
3002 return;
3003 throw std::system_error(GetLastError(), std::system_category(), "SetFileTime failed");
3004#else
3005 struct timespec ts[2] = {
3006 { date.time_since_epoch().count(), 0 },
3007 { 0, UTIME_OMIT },
3008 };
3009 if (futimens(m_h, ts) >= 0)
3010 return;
3011 throw std::system_error(errno, std::system_category(), "futimens failed");
3012#endif
3013 }
3014
3015 virtual void set_mtime(time_point date)
3016 {
3017#ifdef _WIN32
3018 FILETIME ft;
3019 tp2ft(date, ft);
3020 if (SetFileTime(m_h, nullptr, nullptr, &ft))
3021 return;
3022 throw std::system_error(GetLastError(), std::system_category(), "SetFileTime failed");
3023#else
3024 struct timespec ts[2] = {
3025 { 0, UTIME_OMIT },
3026 { date.time_since_epoch().count(), 0 },
3027 };
3028 if (futimens(m_h, ts) >= 0)
3029 return;
3030 throw std::system_error(errno, std::system_category(), "futimens failed");
3031#endif
3032 }
3033
3039 static bool exists(_In_z_ const stdex::schar_t* filename)
3040 {
3041#ifdef _WIN32
3042 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
3043#else
3044 struct stat s;
3045 return stat(filename, &s) == 0;
3046#endif
3047 }
3048
3054 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3055 static bool exists(_In_ const std::basic_string<TR, AX>& filename)
3056 {
3057 return exists(filename.c_str());
3058 }
3059
3067 static bool readonly(_In_z_ const stdex::schar_t* filename)
3068 {
3069#ifdef _WIN32
3070 DWORD dwAttr = GetFileAttributes(filename);
3071 return dwAttr != INVALID_FILE_ATTRIBUTES && (dwAttr & FILE_ATTRIBUTE_READONLY) != 0;
3072#else
3073 struct stat s;
3074 return stat(filename, &s) == 0 && (s.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0;
3075#endif
3076 }
3077
3085 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3086 static bool readonly(_In_ const std::basic_string<TR, AX>& filename)
3087 {
3088 return readonly(filename.c_str());
3089 }
3090 };
3091#pragma warning(pop)
3092
3096 class cached_file : public cache
3097 {
3098 public:
3099 cached_file(_In_opt_ sys_handle h = invalid_handle, _In_ state_t state = state_t::ok, _In_ size_t cache_size = default_cache_size) :
3100 cache(cache_size),
3101 m_source(h, state)
3102 {
3103 init(m_source);
3104 }
3105
3113 cached_file(_In_z_ const schar_t* filename, _In_ int mode, _In_ size_t cache_size = default_cache_size) :
3114 cache(cache_size),
3115 m_source(filename, mode & mode_for_writing ? mode | mode_for_reading : mode)
3116 {
3117 init(m_source);
3118 }
3119
3127 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3128 cached_file(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode, _In_ size_t cache_size = default_cache_size) : cached_file(filename.c_str(), mode, cache_size) {}
3129
3130 virtual ~cached_file()
3131 {
3132 done();
3133 }
3134
3141 void open(_In_z_ const schar_t* filename, _In_ int mode)
3142 {
3143 invalidate_cache();
3144 if (!ok()) _Unlikely_{
3145 m_state = state_t::fail;
3146 return;
3147 }
3148 m_source.open(filename, mode & mode_for_writing ? mode | mode_for_reading : mode);
3149 if (m_source.ok()) {
3150 init();
3151 return;
3152 }
3153 m_state = state_t::fail;
3154 }
3155
3162 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3163 void open(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode)
3164 {
3165 open(filename.c_str(), mode);
3166 }
3167
3171 operator bool() const noexcept { return m_source; }
3172
3173 protected:
3174 file m_source;
3175 };
3176
3180 class memory_file : public basic_file
3181 {
3182 public:
3183 memory_file(_In_ state_t state = state_t::ok) :
3184 basic(state),
3185 m_data(nullptr),
3186 m_offset(0),
3187 m_size(0),
3188 m_reserved(0),
3189 m_manage(true)
3190 {
3191#if SET_FILE_OP_TIMES
3192 m_ctime = m_atime = m_mtime = time_point::now();
3193#endif
3194 }
3195
3202 memory_file(_In_ size_t size, _In_ state_t state = state_t::ok) :
3203 basic(state),
3204 m_data(reinterpret_cast<uint8_t*>(malloc(size))),
3205 m_offset(0),
3206 m_size(0),
3207 m_reserved(size),
3208 m_manage(true)
3209 {
3210 if (!m_data) {
3211 m_state = state_t::fail;
3212 throw std::bad_alloc();
3213 }
3214#if SET_FILE_OP_TIMES
3215 m_ctime = m_atime = m_mtime = time_point::now();
3216#endif
3217 }
3218
3228 memory_file(_Inout_ void* data, _In_ size_t size, _In_ size_t reserved, _In_ bool manage = false, _In_ state_t state = state_t::ok) :
3229 basic(state),
3230 m_data(reinterpret_cast<uint8_t*>(data)),
3231 m_offset(0),
3232 m_size(size),
3233 m_reserved(reserved),
3234 m_manage(manage)
3235 {
3236 _Assume_(data || !size);
3237 _Assume_(reserved >= size);
3238#if SET_FILE_OP_TIMES
3239 m_ctime = m_atime = m_mtime = time_point::now();
3240#endif
3241 }
3242
3251 memory_file(_Inout_ void* data, _In_ size_t size, _In_ bool manage = false, _In_ state_t state = state_t::ok) :
3252 memory_file(data, size, size, manage, state)
3253 {}
3254
3261 memory_file(_In_z_ const schar_t* filename, _In_ int mode) : memory_file()
3262 {
3263 load(filename, mode);
3264 }
3265
3272 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3273 memory_file(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode) : memory_file(filename.c_str(), mode) {}
3274
3280 memory_file(_In_ const memory_file& other) :
3281 basic_file(other),
3282 m_data(reinterpret_cast<uint8_t*>(malloc(other.m_size))),
3283 m_offset(other.m_offset),
3284 m_size(other.m_size),
3285 m_reserved(other.m_size),
3286 m_manage(true)
3287#if SET_FILE_OP_TIMES
3288 , m_ctime(other.m_ctime)
3289 , m_atime(other.m_atime)
3290 , m_mtime(other.m_mtime)
3291#endif
3292 {
3293 if (!m_data) {
3294 m_state = state_t::fail;
3295 throw std::bad_alloc();
3296 }
3297 memcpy(m_data, other.m_data, other.m_size);
3298 }
3299
3305 memory_file& operator=(_In_ const memory_file& other)
3306 {
3307 if (this != std::addressof(other)) {
3308 *static_cast<basic_file*>(this) = other;
3309 if (m_manage && m_data)
3310 free(m_data);
3311 m_data = reinterpret_cast<uint8_t*>(malloc(other.m_size));
3312 if (!m_data) {
3313 m_state = state_t::fail;
3314 throw std::bad_alloc();
3315 }
3316 memcpy(m_data, other.m_data, other.m_size);
3317 m_offset = other.m_offset;
3318 m_size = other.m_size;
3319 m_reserved = other.m_size;
3320 m_manage = true;
3321#if SET_FILE_OP_TIMES
3322 m_ctime = other.m_ctime;
3323 m_atime = other.m_atime;
3324 m_mtime = other.m_mtime;
3325#endif
3326 }
3327 return *this;
3328 }
3329
3335 memory_file(_Inout_ memory_file&& other) noexcept :
3336 basic_file(std::move(other)),
3337 m_data(other.m_data),
3338 m_offset(other.m_offset),
3339 m_size(other.m_size),
3340 m_reserved(other.m_reserved),
3341 m_manage(other.m_manage)
3342#if SET_FILE_OP_TIMES
3343 , m_ctime(other.m_ctime)
3344 , m_atime(other.m_atime)
3345 , m_mtime(other.m_mtime)
3346#endif
3347 {
3348 other.m_state = state_t::ok;
3349 other.m_data = nullptr;
3350 other.m_offset = 0;
3351 other.m_size = 0;
3352 other.m_reserved = 0;
3353 other.m_manage = true;
3354#if SET_FILE_OP_TIMES
3355 other.m_ctime = other.m_atime = other.m_mtime = time_point::now();
3356#endif
3357 }
3358
3364 memory_file& operator=(_Inout_ memory_file&& other) noexcept
3365 {
3366 if (this != std::addressof(other)) {
3367 *static_cast<basic_file*>(this) = std::move(other);
3368 if (m_manage && m_data)
3369 free(m_data);
3370 m_data = other.m_data;
3371 other.m_data = nullptr;
3372 m_offset = other.m_offset;
3373 other.m_offset = 0;
3374 m_size = other.m_size;
3375 other.m_size = 0;
3376 m_reserved = other.m_reserved;
3377 other.m_reserved = 0;
3378 m_manage = other.m_manage;
3379 other.m_manage = true;
3380#if SET_FILE_OP_TIMES
3381 m_ctime = other.m_ctime;
3382 m_atime = other.m_atime;
3383 m_mtime = other.m_mtime;
3384 other.m_ctime = other.m_atime = other.m_mtime = time_point::now();
3385#endif
3386 }
3387 return *this;
3388 }
3389
3390 virtual ~memory_file()
3391 {
3392 if (m_manage && m_data)
3393 free(m_data);
3394 }
3395
3402 void reserve(_In_ size_t required, _In_ bool tight = false) noexcept
3403 {
3404 if (required <= m_reserved && (!tight || required >= m_reserved)) {
3405 m_state = state_t::ok;
3406 return;
3407 }
3408 if (!m_manage) {
3409 m_state = state_t::fail;
3410 return;
3411 }
3412 size_t reserved = tight ? required : ((required + required / 4 + (default_block_size - 1)) / default_block_size) * default_block_size;
3413 auto data = reinterpret_cast<uint8_t*>(realloc(m_data, reserved));
3414 if (!data && reserved) _Unlikely_ {
3415 m_state = state_t::fail;
3416 return;
3417 }
3418 m_data = data;
3419 if (reserved < m_size)
3420 m_size = reserved;
3421 m_reserved = reserved;
3422 m_state = state_t::ok;
3423 }
3424
3431 void load(_In_z_ const schar_t* filename, _In_ int mode)
3432 {
3433 file f(filename, (mode & ~hint_random_access) | mode_for_reading | hint_sequential_access);
3434 if (!f.ok()) {
3435 m_state = state_t::fail;
3436 return;
3437 }
3438 fsize_t size = f.size();
3439 if (size > SIZE_MAX) {
3440 m_state = state_t::fail;
3441 return;
3442 }
3443 reserve(static_cast<size_t>(size), true);
3444 if (!ok()) _Unlikely_ {
3445 return;
3446 }
3447 m_offset = m_size = 0;
3448 write_stream(f);
3449 if (ok())
3450 m_offset = 0;
3451#if SET_FILE_OP_TIMES
3452 m_ctime = f.ctime();
3453 m_atime = f.atime();
3454 m_mtime = f.mtime();
3455#endif
3456 }
3457
3464 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3465 void load(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode)
3466 {
3467 load(filename.c_str(), mode);
3468 }
3469
3476 void save(_In_z_ const schar_t* filename, _In_ int mode)
3477 {
3478 file f(filename, (mode & ~hint_random_access) | mode_for_writing | hint_sequential_access);
3479 if (!f.ok()) {
3480 m_state = state_t::fail;
3481 return;
3482 }
3483 f.write(m_data, m_size);
3484 if (!f.ok()) {
3485 m_state = state_t::fail;
3486 return;
3487 }
3488 f.truncate();
3489#if SET_FILE_OP_TIMES
3490 f.set_ctime(m_ctime);
3491 f.set_atime(m_atime);
3492 f.set_mtime(m_mtime);
3493#endif
3494 }
3495
3502 template <class TR = std::char_traits<schar_t>, class AX = std::allocator<schar_t>>
3503 void save(_In_ const std::basic_string<TR, AX>& filename, _In_ int mode)
3504 {
3505 save(filename.c_str(), mode);
3506 }
3507
3511 const void* data() const { return m_data; }
3512
3513 virtual _Success_(return != 0 || length == 0) size_t read(
3514 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
3515 {
3516 _Assume_(data || !length);
3517#if SET_FILE_OP_TIMES
3518 m_atime = time_point::now();
3519#endif
3520 size_t available = m_size - m_offset;
3521 if (length <= available) {
3522 memcpy(data, m_data + m_offset, length);
3523 m_offset += length;
3524 m_state = state_t::ok;
3525 return length;
3526 }
3527 if (length && !available) {
3528 m_state = state_t::eof;
3529 return 0;
3530 }
3531 memcpy(data, m_data + m_offset, available);
3532 m_offset += available;
3533 m_state = state_t::ok;
3534 return available;
3535 }
3536
3551 template <class T>
3552 memory_file& read_data(_Out_ T& data)
3553 {
3554#if SET_FILE_OP_TIMES
3555 m_atime = time_point::now();
3556#endif
3557 if (CHECK_STREAM_STATE && !ok()) _Unlikely_ {
3558 data = 0;
3559 return *this;
3560 }
3561 size_t end_offset = m_offset + sizeof(T);
3562 if (end_offset <= m_size) {
3563 data = LE2HE(*reinterpret_cast<T*>(m_data + m_offset));
3564 m_offset = end_offset;
3565#if !CHECK_STREAM_STATE
3566 m_state = state_t::ok;
3567#endif
3568 }
3569 else {
3570 data = 0;
3571 m_offset = m_size;
3572 m_state = state_t::eof;
3573 }
3574 return *this;
3575 }
3576
3591 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
3592 memory_file& read_str(_Inout_ std::basic_string<T, TR, AX>&data)
3593 {
3594#if SET_FILE_OP_TIMES
3595 m_atime = time_point::now();
3596#endif
3597 if (CHECK_STREAM_STATE && !ok()) _Unlikely_ {
3598 data.clear();
3599 return *this;
3600 }
3601 size_t end_offset = m_offset + sizeof(uint32_t);
3602 if (end_offset <= m_size) {
3603 uint32_t num_chars = LE2HE(*reinterpret_cast<uint32_t*>(m_data + m_offset));
3604 m_offset = end_offset;
3605 end_offset = stdex::add(m_offset, stdex::mul(num_chars, sizeof(T)));
3606 T* start = reinterpret_cast<T*>(m_data + m_offset);
3607 if (end_offset <= m_size) {
3608 data.assign(start, start + num_chars);
3609 m_offset = end_offset;
3610#if !CHECK_STREAM_STATE
3611 m_state = state_t::ok;
3612#endif
3613 return *this;
3614 }
3615 if (end_offset <= m_size)
3616 data.assign(start, reinterpret_cast<T*>(m_data + m_size));
3617 }
3618 m_offset = m_size;
3619 m_state = state_t::eof;
3620 return *this;
3621 }
3622
3623 virtual _Success_(return != 0) size_t write(
3624 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
3625 {
3626 _Assume_(data || !length);
3627#if SET_FILE_OP_TIMES
3628 m_atime = m_mtime = time_point::now();
3629#endif
3630 size_t end_offset = m_offset + length;
3631 if (end_offset > m_reserved) {
3632 reserve(end_offset);
3633 if (!ok()) _Unlikely_
3634 return 0;
3635 }
3636 memcpy(m_data + m_offset, data, length);
3637 m_offset = end_offset;
3638 if (m_offset > m_size)
3639 m_size = m_offset;
3640 m_state = state_t::ok;
3641 return length;
3642 }
3643
3647 void write_byte(_In_ uint8_t byte, _In_ size_t amount = 1)
3648 {
3649#if SET_FILE_OP_TIMES
3650 m_atime = m_mtime = time_point::now();
3651#endif
3652 size_t end_offset = m_offset + amount;
3653 if (end_offset > m_reserved) {
3654 reserve(end_offset);
3655 if (!ok()) _Unlikely_
3656 return;
3657 }
3658 memset(m_data + m_offset, byte, amount);
3659 m_offset = end_offset;
3660 if (m_offset > m_size)
3661 m_size = m_offset;
3662 m_state = state_t::ok;
3663 }
3664
3679 template <class T>
3680 memory_file& write_data(const T data)
3681 {
3682#if SET_FILE_OP_TIMES
3683 m_atime = m_mtime = time_point::now();
3684#endif
3685 if (CHECK_STREAM_STATE && !ok()) _Unlikely_
3686 return *this;
3687 size_t end_offset = m_offset + sizeof(T);
3688 if (end_offset > m_reserved) {
3689 reserve(end_offset);
3690 if (!ok()) _Unlikely_
3691 return *this;
3692 }
3693 (*reinterpret_cast<T*>(m_data + m_offset)) = HE2LE(data);
3694 m_offset = end_offset;
3695 if (m_offset > m_size)
3696 m_size = m_offset;
3697#if !CHECK_STREAM_STATE
3698 m_state = state_t::ok;
3699#endif
3700 return *this;
3701 }
3702
3717 template <class T>
3718 memory_file& write_str(_In_z_ const T * data)
3719 {
3720#if SET_FILE_OP_TIMES
3721 m_atime = m_mtime = time_point::now();
3722#endif
3723 if (CHECK_STREAM_STATE && !ok()) _Unlikely_
3724 return *this;
3725 size_t num_chars = stdex::strlen(data);
3726 if (num_chars > UINT32_MAX)
3727 throw std::invalid_argument("string too long");
3728 size_t size_chars = num_chars * sizeof(T);
3729 size_t size = sizeof(uint32_t) + size_chars;
3730 size_t end_offset = m_offset + size;
3731 if (end_offset > m_reserved) {
3732 reserve(end_offset);
3733 if (!ok()) _Unlikely_
3734 return *this;
3735 }
3736 auto p = m_data + m_offset;
3737 *reinterpret_cast<uint32_t*>(p) = HE2LE((uint32_t)num_chars);
3738 memcpy(p + sizeof(uint32_t), data, size_chars);
3739 m_offset = end_offset;
3740 if (m_offset > m_size)
3741 m_size = m_offset;
3742#if !CHECK_STREAM_STATE
3743 m_state = state_t::ok;
3744#endif
3745 return *this;
3746 }
3747
3762 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
3763 memory_file& write_str(_In_ const std::basic_string<T, TR, AX>& data)
3764 {
3765#if SET_FILE_OP_TIMES
3766 m_atime = m_mtime = time_point::now();
3767#endif
3768 if (CHECK_STREAM_STATE && !ok()) _Unlikely_
3769 return *this;
3770 size_t num_chars = data.size();
3771 if (num_chars > UINT32_MAX)
3772 throw std::invalid_argument("string too long");
3773 size_t size_chars = num_chars * sizeof(T);
3774 size_t size = sizeof(uint32_t) + size_chars;
3775 size_t end_offset = m_offset + size;
3776 if (end_offset > m_reserved) {
3777 reserve(end_offset);
3778 if (!ok()) _Unlikely_
3779 return *this;
3780 }
3781 auto p = m_data + m_offset;
3782 *reinterpret_cast<uint32_t*>(p) = HE2LE((uint32_t)num_chars);
3783 memcpy(p + sizeof(uint32_t), data.data(), size_chars);
3784 m_offset = end_offset;
3785 if (m_offset > m_size)
3786 m_size = m_offset;
3787#if !CHECK_STREAM_STATE
3788 m_state = state_t::ok;
3789#endif
3790 return *this;
3791 }
3792
3798 size_t write_stream(_Inout_ basic & stream, _In_ size_t amount = SIZE_MAX)
3799 {
3800#if SET_FILE_OP_TIMES
3801 m_atime = m_mtime = time_point::now();
3802#endif
3803 size_t num_read, dst_offset = m_offset, dst_size = m_offset;
3804 size_t num_copied = 0, to_write = amount;
3805 m_state = state_t::ok;
3806 if (amount != SIZE_MAX) {
3807 dst_size = stdex::add(dst_size, amount);
3808 reserve(dst_size);
3809 if (!ok()) _Unlikely_
3810 return 0;
3811 while (to_write) {
3812 num_read = stream.read(m_data + dst_offset, to_write);
3813 dst_size = dst_offset += num_read;
3814 num_copied += num_read;
3815 to_write -= num_read;
3816 if (!stream.ok()) {
3817 if (stream.state() != state_t::eof)
3818 m_state = state_t::fail;
3819 break;
3820 }
3821 };
3822 }
3823 else {
3824 size_t block_size;
3825 while (to_write) {
3826 block_size = std::min(to_write, default_block_size);
3827 dst_size = stdex::add(dst_size, block_size);
3828 reserve(dst_size);
3829 if (!ok()) _Unlikely_
3830 break;
3831 num_read = stream.read(m_data + dst_offset, block_size);
3832 dst_size = dst_offset += num_read;
3833 num_copied += num_read;
3834 to_write -= num_read;
3835 if (!stream.ok()) {
3836 if (stream.state() != state_t::eof)
3837 m_state = state_t::fail;
3838 break;
3839 }
3840 };
3841 }
3842 m_offset = dst_offset;
3843 if (m_offset > m_size)
3844 m_size = m_offset;
3845 return num_copied;
3846 }
3847
3848 virtual void close()
3849 {
3850 if (m_manage && m_data)
3851 free(m_data);
3852 m_data = nullptr;
3853 m_manage = true;
3854 m_offset = 0;
3855 m_size = m_reserved = 0;
3856#if SET_FILE_OP_TIMES
3857 m_ctime = m_atime = m_mtime = time_point::min();
3858#endif
3859 m_state = state_t::ok;
3860 }
3861
3862 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
3863 {
3864 fpos_t target;
3865 switch (how) {
3866 case seek_t::beg: target = offset; break;
3867 case seek_t::cur: target = static_cast<fpos_t>(m_offset) + offset; break;
3868 case seek_t::end: target = static_cast<fpos_t>(m_size) + offset; break;
3869 default: throw std::invalid_argument("unknown seek origin");
3870 }
3871 if (target <= SIZE_MAX) {
3872 m_state = state_t::ok;
3873 return m_offset = static_cast<size_t>(target);
3874 }
3875 m_state = state_t::fail;
3876 return fpos_max;
3877 }
3878
3879 virtual fpos_t tell() const
3880 {
3881 return m_offset;
3882 }
3883
3884 virtual fsize_t size() const
3885 {
3886 return m_size;
3887 }
3888
3889 virtual void truncate()
3890 {
3891#if SET_FILE_OP_TIMES
3892 m_atime = m_mtime = time_point::now();
3893#endif
3894 m_size = m_offset;
3895 reserve(m_offset);
3896 }
3897
3898#if SET_FILE_OP_TIMES
3899 virtual time_point ctime() const
3900 {
3901 return m_ctime;
3902 }
3903
3904 virtual time_point atime() const
3905 {
3906 return m_atime;
3907 }
3908
3909 virtual time_point mtime() const
3910 {
3911 return m_mtime;
3912 }
3913
3914 virtual void set_ctime(time_point date)
3915 {
3916 m_ctime = date;
3917 }
3918
3919 virtual void set_atime(time_point date)
3920 {
3921 m_atime = date;
3922 }
3923
3924 virtual void set_mtime(time_point date)
3925 {
3926 m_mtime = date;
3927 }
3928#endif
3929
3930 protected:
3938 template <class T>
3939 void set(_In_ fpos_t offset, _In_ const T data)
3940 {
3941#if SET_FILE_OP_TIMES
3942 m_atime = m_mtime = time_point::now();
3943#endif
3944 _Assume_(offset + sizeof(T) < m_size);
3945 (*reinterpret_cast<T*>(m_data + offset)) = HE2LE(data);
3946 }
3947
3948 public:
3949 void set(_In_ fpos_t offset, _In_ const int8_t data) { set<int8_t>(offset, data); }
3950 void set(_In_ fpos_t offset, _In_ const int16_t data) { set<int16_t>(offset, data); }
3951 void set(_In_ fpos_t offset, _In_ const int32_t data) { set<int32_t>(offset, data); }
3952 void set(_In_ fpos_t offset, _In_ const int64_t data) { set<int64_t>(offset, data); }
3953 void set(_In_ fpos_t offset, _In_ const uint8_t data) { set<uint8_t>(offset, data); }
3954 void set(_In_ fpos_t offset, _In_ const uint16_t data) { set<uint16_t>(offset, data); }
3955 void set(_In_ fpos_t offset, _In_ const uint32_t data) { set<uint32_t>(offset, data); }
3956 void set(_In_ fpos_t offset, _In_ const uint64_t data) { set<uint64_t>(offset, data); }
3957 void set(_In_ fpos_t offset, _In_ const float data) { set<float>(offset, data); }
3958 void set(_In_ fpos_t offset, _In_ const double data) { set<double>(offset, data); }
3959 void set(_In_ fpos_t offset, _In_ const char data) { set<char>(offset, data); }
3960#ifdef _NATIVE_WCHAR_T_DEFINED
3961 void set(_In_ fpos_t offset, _In_ const wchar_t data) { set<wchar_t>(offset, data); }
3962#endif
3963
3971 protected:
3972 template <class T>
3973 void get(_In_ fpos_t offset, _Out_ T & data)
3974 {
3975 _Assume_(offset + sizeof(T) < m_size);
3976 data = LE2HE(*(T*)(m_data + offset));
3977#if SET_FILE_OP_TIMES
3978 m_atime = time_point::now();
3979#endif
3980 }
3981
3982 public:
3983 void get(_In_ fpos_t offset, _Out_ int8_t & data) { get<int8_t>(offset, data); }
3984 void get(_In_ fpos_t offset, _Out_ int16_t & data) { get<int16_t>(offset, data); }
3985 void get(_In_ fpos_t offset, _Out_ int32_t & data) { get<int32_t>(offset, data); }
3986 void get(_In_ fpos_t offset, _Out_ int64_t & data) { get<int64_t>(offset, data); }
3987 void get(_In_ fpos_t offset, _Out_ uint8_t & data) { get<uint8_t>(offset, data); }
3988 void get(_In_ fpos_t offset, _Out_ uint16_t & data) { get<uint16_t>(offset, data); }
3989 void get(_In_ fpos_t offset, _Out_ uint32_t & data) { get<uint32_t>(offset, data); }
3990 void get(_In_ fpos_t offset, _Out_ uint64_t & data) { get<uint64_t>(offset, data); }
3991 void get(_In_ fpos_t offset, _Out_ float& data) { get<float>(offset, data); }
3992 void get(_In_ fpos_t offset, _Out_ double& data) { get<double>(offset, data); }
3993 void get(_In_ fpos_t offset, _Out_ char& data) { get<char>(offset, data); }
3994#ifdef _NATIVE_WCHAR_T_DEFINED
3995 void get(_In_ fpos_t offset, _Out_ wchar_t& data) { get<wchar_t>(offset, data); }
3996#endif
3997
3998 memory_file& operator <<(_In_ const int8_t data) { return write_data(data); }
3999 memory_file& operator >>(_Out_ int8_t & data) { return read_data(data); }
4000 memory_file& operator <<(_In_ const int16_t data) { return write_data(data); }
4001 memory_file& operator >>(_Out_ int16_t & data) { return read_data(data); }
4002 memory_file& operator <<(_In_ const int32_t data) { return write_data(data); }
4003 memory_file& operator >>(_Out_ int32_t & data) { return read_data(data); }
4004 memory_file& operator <<(_In_ const int64_t data) { return write_data(data); }
4005 memory_file& operator >>(_Out_ int64_t & data) { return read_data(data); }
4006 memory_file& operator <<(_In_ const uint8_t data) { return write_data(data); }
4007 memory_file& operator >>(_Out_ uint8_t & data) { return read_data(data); }
4008 memory_file& operator <<(_In_ const uint16_t data) { return write_data(data); }
4009 memory_file& operator >>(_Out_ uint16_t & data) { return read_data(data); }
4010 memory_file& operator <<(_In_ const uint32_t data) { return write_data(data); }
4011 memory_file& operator >>(_Out_ uint32_t & data) { return read_data(data); }
4012 memory_file& operator <<(_In_ const uint64_t data) { return write_data(data); }
4013 memory_file& operator >>(_Out_ uint64_t & data) { return read_data(data); }
4014 memory_file& operator <<(_In_ const float data) { return write_data(data); }
4015 memory_file& operator >>(_Out_ float& data) { return read_data(data); }
4016 memory_file& operator <<(_In_ const double data) { return write_data(data); }
4017 memory_file& operator >>(_Out_ double& data) { return read_data(data); }
4018 memory_file& operator <<(_In_ const char data) { return write_data(data); }
4019 memory_file& operator >>(_Out_ char& data) { return read_data(data); }
4020#ifdef _NATIVE_WCHAR_T_DEFINED
4021 memory_file& operator <<(_In_ const wchar_t data) { return write_data(data); }
4022 memory_file& operator >>(_Out_ wchar_t& data) { return read_data(data); }
4023#endif
4024 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
4025 memory_file& operator >>(_Out_ std::basic_string<T, TR, AX>&data) { return read_str(data); }
4026 template <class T>
4027 memory_file& operator <<(_In_ const T * data) { return write_str(data); }
4028 template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
4029 memory_file& operator <<(_In_ const std::basic_string<T, TR, AX>& data) { return write_str(data); }
4030
4031 protected:
4032 uint8_t* m_data;
4033 bool m_manage;
4034 size_t m_offset;
4035 size_t m_size;
4036 size_t m_reserved;
4037#if SET_FILE_OP_TIMES
4038 time_point
4039 m_ctime,
4040 m_atime,
4041 m_mtime;
4042#endif
4043 };
4044
4048 class fifo : public basic {
4049 public:
4050 fifo() :
4051 m_offset(0),
4052 m_size(0),
4053 m_head(nullptr),
4054 m_tail(nullptr)
4055 {}
4056
4057 virtual ~fifo()
4058 {
4059 while (m_head) {
4060 auto p = m_head;
4061 m_head = p->next;
4062 delete p;
4063 }
4064 }
4065
4066#pragma warning(suppress: 6101) // See [2] below
4067 virtual _Success_(return != 0 || length == 0) size_t read(
4068 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
4069 {
4070 _Assume_(data || !length);
4071 for (size_t to_read = length;;) {
4072 if (!m_head) _Unlikely_ {
4073 m_state = to_read < length || !length ? state_t::ok : state_t::eof;
4074 return length - to_read; // [2] Code analysis misses `length - to_read` bytes were written to data in previous loop iterations.
4075 }
4076 size_t remaining = m_head->size - m_offset;
4077 if (remaining > to_read) {
4078 memcpy(data, m_head->data + m_offset, to_read);
4079 m_offset += to_read;
4080 m_size -= to_read;
4081 m_state = state_t::ok;
4082 return length;
4083 }
4084 memcpy(data, m_head->data + m_offset, remaining);
4085 m_offset = 0;
4086 m_size -= remaining;
4087 reinterpret_cast<uint8_t*&>(data) += remaining;
4088 to_read -= remaining;
4089 auto p = m_head;
4090 m_head = p->next;
4091 delete p;
4092 }
4093 }
4094
4095 virtual _Success_(return != 0) size_t write(
4096 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
4097 {
4098 _Assume_(data || !length);
4099 try {
4100 std::unique_ptr<node_t> n(reinterpret_cast<node_t*>(new uint8_t[sizeof(node_t) + length]));
4101 n->next = nullptr;
4102 n->size = length;
4103 memcpy(n->data, data, length);
4104 m_size += length;
4105 if (m_head)
4106 m_tail = m_tail->next = n.release();
4107 else
4108 m_head = m_tail = n.release();
4109 m_state = state_t::ok;
4110 return length;
4111 }
4112 catch (const std::bad_alloc&) {
4113 m_state = state_t::fail;
4114 return 0;
4115 }
4116 }
4117
4118 virtual void close()
4119 {
4120 m_size = m_offset = 0;
4121 while (m_head) {
4122 auto p = m_head;
4123 m_head = p->next;
4124 delete p;
4125 }
4126 m_state = state_t::ok;
4127 }
4128
4132 size_t size() const { return m_size; };
4133
4134 protected:
4135 size_t m_offset, m_size;
4136 struct node_t {
4137 node_t* next;
4138 size_t size;
4139#pragma warning(suppress:4200)
4140 uint8_t data[0];
4141 } *m_head, * m_tail;
4142 };
4143
4147 class diag_file : public basic_file {
4148 public:
4149 diag_file(_In_count_(num_files) basic_file* const* files, _In_ size_t num_files) :
4150 basic(num_files ? files[0]->state() : state_t::fail),
4151 m_files(files, files + num_files)
4152 {}
4153
4154 virtual _Success_(return != 0 || length == 0) size_t read(
4155 _Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
4156 {
4157 _Assume_(data || !length);
4158 if (m_files.empty()) {
4159 m_state = state_t::fail;
4160 return 0;
4161 }
4162 size_t result = m_files[0]->read(data, length);
4163 _Assume_(result <= length);
4164 m_state = m_files[0]->state();
4165 if (length > m_tmp.size())
4166 m_tmp.resize(length);
4167 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4168 if (m_files[i]->read(m_tmp.data(), length) != result ||
4169 memcmp(m_tmp.data(), data, result))
4170 throw std::runtime_error("read mismatch");
4171 if (m_files[i]->state() != m_state)
4172 throw std::runtime_error("state mismatch");
4173 }
4174 return result;
4175 }
4176
4177 virtual _Success_(return != 0) size_t write(
4178 _In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
4179 {
4180 if (m_files.empty()) {
4181 m_state = state_t::fail;
4182 return 0;
4183 }
4184 size_t result = m_files[0]->write(data, length);
4185 m_state = m_files[0]->state();
4186 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4187 if (m_files[i]->write(data, length) != result)
4188 throw std::runtime_error("write mismatch");
4189 if (m_files[i]->state() != m_state)
4190 throw std::runtime_error("state mismatch");
4191 }
4192 return result;
4193 }
4194
4195 virtual void flush()
4196 {
4197 if (m_files.empty()) {
4198 m_state = state_t::ok;
4199 return;
4200 }
4201 m_files[0]->flush();
4202 m_state = m_files[0]->state();
4203 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4204 m_files[i]->flush();
4205 if (m_files[i]->state() != m_state)
4206 throw std::runtime_error("state mismatch");
4207 }
4208 }
4209
4210 virtual void close()
4211 {
4212 if (m_files.empty()) {
4213 m_state = state_t::ok;
4214 return;
4215 }
4216 m_files[0]->close();
4217 m_state = m_files[0]->state();
4218 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4219 m_files[i]->close();
4220 if (m_files[i]->state() != m_state)
4221 throw std::runtime_error("state mismatch");
4222 }
4223 m_tmp.clear();
4224 m_tmp.shrink_to_fit();
4225 }
4226
4227 virtual fpos_t seek(_In_ foff_t offset, _In_ seek_t how = seek_t::beg)
4228 {
4229 if (m_files.empty()) {
4230 m_state = state_t::fail;
4231 return fpos_max;
4232 }
4233 fpos_t result = m_files[0]->seek(offset, how);
4234 m_state = m_files[0]->state();
4235 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4236 if (m_files[i]->seek(offset, how) != result)
4237 throw std::runtime_error("seek mismatch");
4238 if (m_files[i]->state() != m_state)
4239 throw std::runtime_error("state mismatch");
4240 }
4241 return result;
4242 }
4243
4244 virtual fpos_t tell() const
4245 {
4246 if (m_files.empty())
4247 return fpos_max;
4248 fpos_t result = m_files[0]->tell();
4249 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4250 if (m_files[i]->tell() != result)
4251 throw std::runtime_error("tell mismatch");
4252 }
4253 return result;
4254 }
4255
4256 virtual void lock(_In_ fpos_t offset, _In_ fsize_t length)
4257 {
4258 if (m_files.empty())
4259 m_state = state_t::fail;
4260 m_files[0]->lock(offset, length);
4261 m_state = m_files[0]->state();
4262 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4263 m_files[i]->lock(offset, length);
4264 if (m_files[i]->state() != m_state)
4265 throw std::runtime_error("state mismatch");
4266 }
4267 }
4268
4269 virtual void unlock(_In_ fpos_t offset, _In_ fsize_t length)
4270 {
4271 if (m_files.empty())
4272 m_state = state_t::fail;
4273 m_files[0]->unlock(offset, length);
4274 m_state = m_files[0]->state();
4275 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4276 m_files[i]->unlock(offset, length);
4277 if (m_files[i]->state() != m_state)
4278 throw std::runtime_error("state mismatch");
4279 }
4280 }
4281
4282 virtual fsize_t size() const
4283 {
4284 if (m_files.empty())
4285 return fsize_max;
4286 fsize_t result = m_files[0]->size();
4287 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4288 if (m_files[i]->size() != result)
4289 throw std::runtime_error("size mismatch");
4290 }
4291 return result;
4292 }
4293
4294 virtual void truncate()
4295 {
4296 if (m_files.empty())
4297 m_state = state_t::fail;
4298 m_files[0]->truncate();
4299 m_state = m_files[0]->state();
4300 for (size_t i = 1, n = m_files.size(); i < n; ++i) {
4301 m_files[i]->truncate();
4302 if (m_files[i]->state() != m_state)
4303 throw std::runtime_error("state mismatch");
4304 }
4305 }
4306
4307 protected:
4308 std::vector<basic_file*> m_files;
4309 std::vector<uint8_t> m_tmp;
4310 };
4311 }
4312}
stdex::charset_encoder
Encoding converter context.
Definition unicode.hpp:137
stdex::locale
locale_t helper class to free_locale when going out of scope.
Definition locale.hpp:69
stdex::stream::async_reader
Provides read-ahead stream capability.
Definition stream.hpp:1244
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:1258
stdex::stream::async_writer
Provides write-back stream capability.
Definition stream.hpp:1311
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:1324
stdex::stream::async_writer::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1348
stdex::stream::basic_file
Basic seekable stream operations.
Definition stream.hpp:812
stdex::stream::basic_file::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:855
stdex::stream::basic_file::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:902
stdex::stream::basic_file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:871
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::size
virtual fsize_t size() const =0
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
stdex::stream::basic_file::read_charset
charset_id read_charset(charset_id default_charset=charset_id::system)
Attempts to detect textfile charset based on UTF-32, UTF-16 or UTF-8 BOM.
Definition stream.hpp:975
stdex::stream::basic_file::seekbeg
fpos_t seekbeg(fpos_t offset)
Seeks to absolute file position.
Definition stream.hpp:839
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:814
stdex::stream::basic_file::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:944
stdex::stream::basic_file::seekcur
fpos_t seekcur(foff_t offset)
Seeks to relative from current file position.
Definition stream.hpp:846
stdex::stream::basic_file::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:910
stdex::stream::basic_file::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:926
stdex::stream::basic_file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:881
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:918
stdex::stream::basic_file::seekend
fpos_t seekend(foff_t offset)
Seeks to relative from end file position.
Definition stream.hpp:853
stdex::stream::basic_file::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:935
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:2194
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:2251
stdex::stream::basic_sys::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:2309
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:2201
stdex::stream::basic_sys::close
virtual void close()
Closes the stream.
Definition stream.hpp:2298
stdex::stream::basic
‍UTF-8 byte-order-mark
Definition stream.hpp:79
stdex::stream::basic::write_array
size_t write_array(const T_from *str, charset_encoder< T_from, T_to > &encoder)
Writes array of characters to the stream.
Definition stream.hpp:402
stdex::stream::basic::ok
bool ok() const
Returns true if the stream state is clean i.e. previous operation was succesful.
Definition stream.hpp:175
stdex::stream::basic::readln_and_attach
size_t readln_and_attach(std::basic_string< T, TR, AX > &str)
Reads stream to the end-of-line or end-of-file and append to str.
Definition stream.hpp:334
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:625
stdex::stream::basic::state
state_t state() const
Returns stream state after last operation.
Definition stream.hpp:170
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:611
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:638
stdex::stream::basic::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:126
stdex::stream::basic::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:142
stdex::stream::basic::close
virtual void close()
Closes the stream.
Definition stream.hpp:134
stdex::stream::basic::read_byte
uint8_t read_byte()
Reads one byte of data.
Definition stream.hpp:210
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:184
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:597
stdex::stream::basic::readln
size_t readln(std::basic_string< T_to, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
Reads stream to the end-of-line or end-of-file.
Definition stream.hpp:318
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:370
stdex::stream::basic::readln
size_t readln(std::basic_string< T, TR, AX > &str)
Reads stream to the end-of-line or end-of-file.
Definition stream.hpp:306
stdex::stream::basic::read_str
basic & read_str(std::basic_string< T, TR, AX > &data)
Reads length-prefixed string from the stream.
Definition stream.hpp:465
stdex::stream::basic::write_str
basic & write_str(const T *data)
Writes string to the stream length-prefixed.
Definition stream.hpp:497
stdex::stream::basic::readln_and_attach
size_t readln_and_attach(std::basic_string< T_to, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
Reads stream to the end-of-line or end-of-file and append to str.
Definition stream.hpp:355
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:96
stdex::stream::basic::write_charset
void write_charset(charset_id charset)
Writes UTF8, UTF-16 or UTF-32 byte-order-mark.
Definition stream.hpp:582
stdex::stream::basic::write_data
basic & write_data(const T data)
Writes one primitive data type.
Definition stream.hpp:287
stdex::stream::basic::write_stream
fsize_t write_stream(basic &stream, fsize_t amount=fsize_max)
Writes content of another stream.
Definition stream.hpp:557
stdex::stream::basic::write_array
size_t write_array(const std::basic_string< T_from, TR, AX > &str, charset_encoder< T_from, T_to > &encoder)
Writes array of characters to the stream.
Definition stream.hpp:443
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:114
stdex::stream::basic::write_str
basic & write_str(const std::basic_string< T, TR, AX > &data)
Writes string to the stream length-prefixed.
Definition stream.hpp:522
stdex::stream::basic::write_array
size_t write_array(_In_reads_or_z_opt_(num_chars) const T_from *str, size_t num_chars, charset_encoder< T_from, T_to > &encoder)
Writes array of characters to the stream.
Definition stream.hpp:423
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:388
stdex::stream::basic::write_byte
void write_byte(uint8_t byte, fsize_t amount=1)
Writes a byte of data.
Definition stream.hpp:221
stdex::stream::basic::read_data
basic & read_data(T &data)
Reads one primitive data type.
Definition stream.hpp:259
stdex::stream::buffer
Buffered read/write stream.
Definition stream.hpp:1382
stdex::stream::buffer::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1491
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:1412
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:1448
stdex::stream::buffered_sys
Buffered OS data stream (file, pipe, socket...)
Definition stream.hpp:2323
stdex::stream::cache
Cached file.
Definition stream.hpp:1792
stdex::stream::cache::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:2064
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:2043
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:1859
stdex::stream::cache::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:2069
stdex::stream::cache::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:2030
stdex::stream::cache::mtime
virtual time_point mtime() const
Returns file modification time.
Definition stream.hpp:2078
stdex::stream::cache::close
virtual void close()
Closes the stream.
Definition stream.hpp:1978
stdex::stream::cache::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:2100
stdex::stream::cache::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:2024
stdex::stream::cache::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1987
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:1925
stdex::stream::cache::size
virtual fsize_t size() const
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:2036
stdex::stream::cache::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:2087
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:2019
stdex::stream::cache::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:2092
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:1998
stdex::stream::cached_file
Cached file-system file.
Definition stream.hpp:3097
stdex::stream::cached_file::open
void open(const std::basic_string< TR, AX > &filename, int mode)
Opens file.
Definition stream.hpp:3163
stdex::stream::cached_file::open
void open(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:3141
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:3113
stdex::stream::cached_file::cached_file
cached_file(const std::basic_string< TR, AX > &filename, int mode, size_t cache_size=default_cache_size)
Opens file.
Definition stream.hpp:3128
stdex::stream::converter
Modifies data on the fly when reading from/writing to a source stream. Could also be used to modify r...
Definition stream.hpp:1010
stdex::stream::converter::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1061
stdex::stream::converter::close
virtual void close()
Closes the stream.
Definition stream.hpp:1055
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:1039
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:1047
stdex::stream::diag_file
Compares multiple files to perform the same.
Definition stream.hpp:4147
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:4294
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:4177
stdex::stream::diag_file::close
virtual void close()
Closes the stream.
Definition stream.hpp:4210
stdex::stream::diag_file::size
virtual fsize_t size() const
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:4282
stdex::stream::diag_file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:4256
stdex::stream::diag_file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:4269
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:4227
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:4244
stdex::stream::diag_file::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:4195
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:4154
stdex::stream::fifo
In-memory FIFO queue.
Definition stream.hpp:4048
stdex::stream::fifo::close
virtual void close()
Closes the stream.
Definition stream.hpp:4118
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:4095
stdex::stream::fifo::size
size_t size() const
Returns total size of pending data in the queue.
Definition stream.hpp:4132
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:4067
stdex::stream::file_window
Limits file reading/writing to a predefined window.
Definition stream.hpp:1682
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:1775
stdex::stream::file_window::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1725
stdex::stream::file_window::skip
virtual void skip(fsize_t amount)
Skips given amount of bytes of data on the stream.
Definition stream.hpp:1738
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:1731
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:1705
stdex::stream::file_window::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:1750
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:1691
stdex::stream::file_window::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:1760
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:1744
stdex::stream::file_window::close
virtual void close()
Closes the stream.
Definition stream.hpp:1719
stdex::stream::file_window::size
virtual fsize_t size() const
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:1770
stdex::stream::file
File-system file.
Definition stream.hpp:2689
stdex::stream::file::size
virtual fsize_t size() const
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:2885
stdex::stream::file::readonly
static bool readonly(const std::basic_string< TR, AX > &filename)
Checks if file/folder/symlink is read-only.
Definition stream.hpp:3086
stdex::stream::file::mtime
virtual time_point mtime() const
Returns file modification time.
Definition stream.hpp:2967
stdex::stream::file::unlock
virtual void unlock(fpos_t offset, fsize_t length)
Unlocks file section for exclusive access.
Definition stream.hpp:2860
stdex::stream::file::file
file(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:2699
stdex::stream::file::set_ctime
virtual void set_ctime(time_point date)
Sets file create time.
Definition stream.hpp:2981
stdex::stream::file::readonly
static bool readonly(const stdex::schar_t *filename)
Checks if file/folder/symlink is read-only.
Definition stream.hpp:3067
stdex::stream::file::atime
virtual time_point atime() const
Returns file access time.
Definition stream.hpp:2953
stdex::stream::file::exists
static bool exists(const std::basic_string< TR, AX > &filename)
Checks if file/folder/symlink likely exists.
Definition stream.hpp:3055
stdex::stream::file::open
void open(const schar_t *filename, int mode)
Opens file.
Definition stream.hpp:2719
stdex::stream::file::set_mtime
virtual void set_mtime(time_point date)
Sets file modification time.
Definition stream.hpp:3015
stdex::stream::file::set_atime
virtual void set_atime(time_point date)
Sets file access time.
Definition stream.hpp:2995
stdex::stream::file::lock
virtual void lock(fpos_t offset, fsize_t length)
Locks file section for exclusive access.
Definition stream.hpp:2837
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:2903
stdex::stream::file::open
void open(const std::basic_string< TR, AX > &filename, int mode)
Opens file.
Definition stream.hpp:2793
stdex::stream::file::ctime
virtual time_point ctime() const
Returns file creation time.
Definition stream.hpp:2943
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:2798
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:2819
stdex::stream::file::file
file(const std::basic_string< TR, AX > &filename, int mode)
Opens file.
Definition stream.hpp:2711
stdex::stream::file::exists
static bool exists(const stdex::schar_t *filename)
Checks if file/folder/symlink likely exists.
Definition stream.hpp:3039
stdex::stream::limiter
Limits reading from/writing to stream to a predefined number of bytes.
Definition stream.hpp:1539
stdex::stream::limiter::read_limit
fsize_t read_limit
Number of bytes left that may be read from the stream.
Definition stream.hpp:1591
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:1547
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:1568
stdex::stream::limiter::write_limit
fsize_t write_limit
Number of bytes left, that can be written to the stream.
Definition stream.hpp:1592
stdex::stream::memory_file
In-memory file.
Definition stream.hpp:3181
stdex::stream::memory_file::save
void save(const std::basic_string< TR, AX > &filename, int mode)
Saves content to a file-system file.
Definition stream.hpp:3503
stdex::stream::memory_file::operator=
memory_file & operator=(memory_file &&other) noexcept
Moves content from another file.
Definition stream.hpp:3364
stdex::stream::memory_file::size
virtual fsize_t size() const
Returns file size Should the file size cannot be determined, the method returns fsize_max and it does...
Definition stream.hpp:3884
stdex::stream::memory_file::memory_file
memory_file(const schar_t *filename, int mode)
Loads content from file-system file.
Definition stream.hpp:3261
stdex::stream::memory_file::read_str
memory_file & read_str(std::basic_string< T, TR, AX > &data)
Reads length-prefixed string from the stream.
Definition stream.hpp:3592
stdex::stream::memory_file::memory_file
memory_file(const memory_file &other)
Copies content from another file.
Definition stream.hpp:3280
stdex::stream::memory_file::write_str
memory_file & write_str(const std::basic_string< T, TR, AX > &data)
Writes string to the stream length-prefixed.
Definition stream.hpp:3763
stdex::stream::memory_file::load
void load(const std::basic_string< TR, AX > &filename, int mode)
Loads content from a file-system file.
Definition stream.hpp:3465
stdex::stream::memory_file::m_size
size_t m_size
file size
Definition stream.hpp:4035
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 Assu...
Definition stream.hpp:3973
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:3798
stdex::stream::memory_file::m_data
uint8_t * m_data
file data
Definition stream.hpp:4032
stdex::stream::memory_file::read_data
memory_file & read_data(T &data)
Reads one primitive data type.
Definition stream.hpp:3552
stdex::stream::memory_file::close
virtual void close()
Closes the stream.
Definition stream.hpp:3848
stdex::stream::memory_file::memory_file
memory_file(const std::basic_string< TR, AX > &filename, int mode)
Loads content from file-system file.
Definition stream.hpp:3273
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:3513
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:3879
stdex::stream::memory_file::m_reserved
size_t m_reserved
reserved file size
Definition stream.hpp:4036
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:3202
stdex::stream::memory_file::reserve
void reserve(size_t required, bool tight=false) noexcept
Reallocates memory.
Definition stream.hpp:3402
stdex::stream::memory_file::memory_file
memory_file(memory_file &&other) noexcept
Moves content from another file.
Definition stream.hpp:3335
stdex::stream::memory_file::write_byte
void write_byte(uint8_t byte, size_t amount=1)
Writes a byte of data.
Definition stream.hpp:3647
stdex::stream::memory_file::operator=
memory_file & operator=(const memory_file &other)
Copies content from another file.
Definition stream.hpp:3305
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:3939
stdex::stream::memory_file::m_offset
size_t m_offset
file pointer
Definition stream.hpp:4034
stdex::stream::memory_file::save
void save(const schar_t *filename, int mode)
Saves content to a file-system file.
Definition stream.hpp:3476
stdex::stream::memory_file::load
void load(const schar_t *filename, int mode)
Loads content from a file-system file.
Definition stream.hpp:3431
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:3862
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:3889
stdex::stream::memory_file::write_data
memory_file & write_data(const T data)
Writes one primitive data type.
Definition stream.hpp:3680
stdex::stream::memory_file::write_str
memory_file & write_str(const T *data)
Writes string to the stream length-prefixed.
Definition stream.hpp:3718
stdex::stream::memory_file::m_manage
bool m_manage
may reallocate m_data?
Definition stream.hpp:4033
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:3251
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:3623
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:3228
stdex::stream::memory_file::data
const void * data() const
Returns pointer to data.
Definition stream.hpp:3511
stdex::stream::replicator::worker
Definition stream.hpp:1158
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:1207
stdex::stream::replicator::worker::length
size_t length
Byte limit of data to write.
Definition stream.hpp:1206
stdex::stream::replicator::worker::data
const void * data
Data to write.
Definition stream.hpp:1205
stdex::stream::replicator
Replicates writing of the same data to multiple streams.
Definition stream.hpp:1075
stdex::stream::replicator::push_back
void push_back(basic *source)
Adds stream on the list.
Definition stream.hpp:1094
stdex::stream::replicator::flush
virtual void flush()
Persists volatile element data.
Definition stream.hpp:1151
stdex::stream::replicator::remove
void remove(basic *source)
Removes stream from the list.
Definition stream.hpp:1102
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:1119
stdex::stream::replicator::close
virtual void close()
Closes the stream.
Definition stream.hpp:1146
stdex::stream::socket
Socket stream.
Definition stream.hpp:2345
stdex::stream::socket::get
socket_t get() const noexcept
Returns socket handle.
Definition stream.hpp:2401
stdex::stream::socket::close
virtual void close()
Closes the stream.
Definition stream.hpp:2447
stdex::stream::socket::socket
socket(int af, int type, int protocol)
Creates a socket.
Definition stream.hpp:2380
stdex::stream::socket::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:2403
stdex::stream::socket::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:2427
stdex::stream::window
Limits reading from/writing to stream to a predefined window.
Definition stream.hpp:1599
stdex::stream::window::write_offset
fpos_t write_offset
Number of bytes to discard on write.
Definition stream.hpp:1675
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:1636
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:1607
stdex::stream::window::read_offset
fpos_t read_offset
Number of bytes to skip on read.
Definition stream.hpp:1674
stdex::sys_object
Operating system object (file, pipe, anything with an OS handle etc.)
Definition system.hpp:99
stdex::sys_object::close
virtual void close()
Closes object.
Definition system.hpp:140
stdex::interval
Numerical interval.
Definition interval.hpp:18
stdex::interval::contains
bool contains(T x) const
Is value in interval?
Definition interval.hpp:79
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:1516
stdex::stream::fifo::node_t
Definition stream.hpp:4136
Generated on Tue Jan 9 2024 21:02:08 for stdex by doxygen 1.10.0