1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/*!********************************************************************
Audacity: A Digital Audio Editor
@file RequestPayload.cpp
@brief Declare a class for constructing HTTP requests.
Dmitry Vedenko
**********************************************************************/
#include "RequestPayload.h"
#include <iterator>
#include <vector>
#include <wx/file.h>
#include "CodeConversions.h"
namespace audacity::network_manager
{
namespace
{
int64_t CalculateOffset(
int64_t currentOffset, int64_t offset, int64_t size, RequestPayloadStream::SeekDirection direction)
{
switch (direction)
{
case RequestPayloadStream::SeekDirection::Start:
return offset;
case RequestPayloadStream::SeekDirection::Current:
return currentOffset + offset;
case RequestPayloadStream::SeekDirection::End:
return size - offset;
default:
return 0;
}
}
class EmptyRequestPayloadStream final : public RequestPayloadStream
{
public:
bool HasData() const override
{
return false;
}
int64_t GetDataSize() const override
{
return 0;
}
bool Seek(int64_t offset, SeekDirection direction) override
{
return false;
}
int64_t Read(void* buffer, int64_t size) override
{
return 0;
}
}; // class EmptyRequestPayloadStream
class MemoryRequestPayloadStream final : public RequestPayloadStream
{
public:
MemoryRequestPayloadStream(const void* data, int64_t size, bool copyData)
: mStreamSize { size }
{
if (copyData && data != nullptr && mStreamSize > 0)
{
mData.reserve(size);
std::copy_n(static_cast<const uint8_t*>(data), size, std::back_inserter(mData));
mDataPointer = mData.data();
}
else
{
mDataPointer = static_cast<const uint8_t*>(data);
}
}
bool HasData() const override
{
return mDataPointer != nullptr && mStreamSize > 0;
}
int64_t GetDataSize() const override
{
return mStreamSize;
}
bool Seek(int64_t offset, SeekDirection direction) override
{
const auto requestedOffset = CalculateOffset(mStreamPosition, offset, mStreamSize, direction);
if (requestedOffset < 0 || requestedOffset > mStreamSize)
return false;
mStreamPosition = requestedOffset;
return true;
}
int64_t Read(void* buffer, int64_t size) override
{
const auto bytesToRead = std::min(size, mStreamSize - mStreamPosition);
if (bytesToRead <= 0)
return 0;
std::copy_n(mDataPointer + mStreamPosition, bytesToRead, static_cast<uint8_t*>(buffer));
mStreamPosition += bytesToRead;
return bytesToRead;
}
private:
std::vector<uint8_t> mData;
const uint8_t* mDataPointer {};
int64_t mStreamSize {};
int64_t mStreamPosition {};
}; // class MemoryRequestPayloadStream
class FileRequestPayloadStream final : public RequestPayloadStream
{
public:
FileRequestPayloadStream(const std::string& filePath)
: mFilePath { audacity::ToWXString(filePath) }
, mFile { mFilePath }
{
wxStat(mFilePath, &mFileStat);
}
bool HasData() const override
{
return mFile.IsOpened();
}
int64_t GetDataSize() const override
{
return mFileStat.st_size;
}
bool Seek(int64_t offset, SeekDirection direction) override
{
const auto platformSeekDirection = [&]
{
switch (direction)
{
case SeekDirection::Start:
return wxFromStart;
case SeekDirection::Current:
return wxFromCurrent;
case SeekDirection::End:
return wxFromEnd;
default:
return wxFromStart;
}
}();
return mFile.Seek(offset, platformSeekDirection) != wxInvalidOffset;
}
int64_t Read(void* buffer, int64_t size) override
{
return mFile.Read(buffer, size);
}
private:
wxString mFilePath;
wxFile mFile;
wxStructStat mFileStat;
}; // class FileRequestPayloadStream
} // namespace
RequestPayloadStream::~RequestPayloadStream()
{
}
RequestPayloadStreamPtr
CreateRequestPayloadStream(const void* data, int64_t size, bool copyData)
{
return std::make_shared<MemoryRequestPayloadStream>(data, size, copyData);
}
RequestPayloadStreamPtr CreateRequestPayloadStream()
{
return std::make_shared<EmptyRequestPayloadStream>();
}
RequestPayloadStreamPtr CreateRequestPayloadStream(const std::string& filePath)
{
return std::make_shared<FileRequestPayloadStream>(filePath);
}
} // namespace audacity::network_manager
|
