Stroika Library 3.0d16
 
Loading...
Searching...
No Matches
InternallySynchronizedInputStream.inl
1/*
2 * Copyright(c) Sophist Solutions, Inc. 1990-2025. All rights reserved
3 */
4#include "Stroika/Foundation/Memory/BlockAllocated.h"
5
6namespace Stroika::Foundation::Streams::InternallySynchronizedInputStream {
7
8 namespace Private_ {
9 template <typename BASE_REP_TYPE, typename OPTIONS>
10 struct Rep_ final : Memory::InheritAndUseBlockAllocationIfAppropriate<Rep_<BASE_REP_TYPE, OPTIONS>, BASE_REP_TYPE> {
11 using ElementType = typename BASE_REP_TYPE::ElementType;
12 using inherited = Memory::InheritAndUseBlockAllocationIfAppropriate<Rep_<BASE_REP_TYPE, OPTIONS>, BASE_REP_TYPE>;
13 template <typename... ARGS>
14 Rep_ ([[maybe_unused]] const OPTIONS& o, ARGS&&... args)
15 : inherited{forward<ARGS> (args)...}
16 {
17 }
18 Rep_ (const Rep_&) = delete;
19 virtual bool IsSeekable () const override
20 {
21 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
22 return BASE_REP_TYPE::IsSeekable ();
23 }
24 virtual void CloseRead () override
25 {
26 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
27 if (IsOpenRead ()) {
28 BASE_REP_TYPE::CloseRead ();
29 }
30 Ensure (not IsOpenRead ());
31 }
32 virtual bool IsOpenRead () const override
33 {
34 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
35 return BASE_REP_TYPE::IsOpenRead ();
36 }
37 virtual SeekOffsetType GetReadOffset () const override
38 {
39 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
40 Require (IsOpenRead ());
41 return BASE_REP_TYPE::GetReadOffset ();
42 }
43 virtual SeekOffsetType SeekRead (Whence whence, SignedSeekOffsetType offset) override
44 {
45 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
46 Require (IsOpenRead ());
47 return BASE_REP_TYPE::SeekRead (whence, offset);
48 }
49 virtual optional<size_t> AvailableToRead () override
50 {
51 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
52 Require (IsOpenRead ());
53 return BASE_REP_TYPE::AvailableToRead ();
54 }
55 virtual optional<SeekOffsetType> RemainingLength () override
56 {
57 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
58 Require (IsOpenRead ());
59 return BASE_REP_TYPE::RemainingLength ();
60 }
61 virtual optional<span<ElementType>> Read (span<ElementType> intoBuffer, NoDataAvailableHandling blockFlag) override
62 {
63 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
64 Require (IsOpenRead ());
65 return BASE_REP_TYPE::Read (intoBuffer, blockFlag);
66 }
67
68 private:
69 mutable typename OPTIONS::MutexType fCriticalSection_;
70 };
71 template <typename ELEMENT_TYPE, typename OPTIONS>
72 struct Rep2_ : InputStream::IRep<ELEMENT_TYPE> {
73 using ElementType = ELEMENT_TYPE;
74 Rep2_ ([[maybe_unused]] const OPTIONS& o, const InputStream::Ptr<ELEMENT_TYPE>& stream2Wrap)
75 : fStream2Wrap{stream2Wrap}
76 {
77 }
78 virtual bool IsSeekable () const override
79 {
80 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
81 return fStream2Wrap.IsSeekable ();
82 }
83 virtual void CloseRead () override
84 {
85 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
86 if (IsOpenRead ()) {
87 fStream2Wrap.CloseRead ();
88 }
89 Ensure (not IsOpenRead ());
90 }
91 virtual bool IsOpenRead () const override
92 {
93 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
94 return fStream2Wrap.IsOpenRead ();
95 }
96 virtual SeekOffsetType GetReadOffset () const override
97 {
98 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
99 Require (IsOpenRead ());
100 return fStream2Wrap.GetReadOffset ();
101 }
102 virtual SeekOffsetType SeekRead (Whence whence, SignedSeekOffsetType offset) override
103 {
104 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
105 Require (IsOpenRead ());
106 return fStream2Wrap.SeekRead (whence, offset);
107 }
108 virtual optional<SeekOffsetType> RemainingLength () override
109 {
110 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
111 Require (IsOpenRead ());
112 return fStream2Wrap.RemainingLength ();
113 }
114 virtual optional<size_t> AvailableToRead () override
115 {
116 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
117 Require (IsOpenRead ());
118 return fStream2Wrap.AvailableToRead ();
119 }
120 virtual span<ElementType> Read (span<ElementType> intoBuffer, NoDataAvailableHandling blockFlag) override
121 {
122 [[maybe_unused]] lock_guard critSec{fCriticalSection_};
123 Require (IsOpenRead ());
124 return fStream2Wrap.Read (intoBuffer, blockFlag);
125 }
126
127 private:
128 InputStream::Ptr<ELEMENT_TYPE> fStream2Wrap;
129 mutable typename OPTIONS::MutexType fCriticalSection_;
130 };
131 }
132
133 /*
134 ********************************************************************************
135 ************* InternallySynchronizedInputStream<BASE_REP_TYPE>::New ************
136 ********************************************************************************
137 */
138 template <typename BASE_REP_TYPE, typename OPTIONS, typename... ARGS>
139 inline Ptr<typename BASE_REP_TYPE::ElementType> New (const OPTIONS& o, ARGS&&... args)
140 {
141 return Ptr<typename BASE_REP_TYPE::ElementType>{make_shared<Private_::Rep_<BASE_REP_TYPE, OPTIONS>> (o, forward<ARGS> (args)...)};
142 }
143 template <typename ELEMENT_TYPE, typename OPTIONS>
144 inline Ptr<ELEMENT_TYPE> New (const OPTIONS& o, const InputStream::Ptr<ELEMENT_TYPE>& stream2Wrap)
145 {
146 return Ptr<ELEMENT_TYPE>{make_shared<Private_::Rep2_<ELEMENT_TYPE, OPTIONS>> (o, stream2Wrap)};
147 }
148
149}