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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsUnicharInputStream.h"
#include "nsIInputStream.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsCRT.h"
#include "nsStreamUtils.h"
#include "nsConverterInputStream.h"
#include "mozilla/Attributes.h"
#include <fcntl.h>
#if defined(XP_WIN)
# include <io.h>
#else
# include <unistd.h>
#endif
#define STRING_BUFFER_SIZE 8192
class StringUnicharInputStream final : public nsIUnicharInputStream {
public:
explicit StringUnicharInputStream(const nsAString& aString)
: mString(aString), mPos(0), mLen(aString.Length()) {}
NS_DECL_ISUPPORTS
NS_DECL_NSIUNICHARINPUTSTREAM
nsString mString;
uint32_t mPos;
uint32_t mLen;
private:
~StringUnicharInputStream() = default;
};
NS_IMETHODIMP
StringUnicharInputStream::Read(char16_t* aBuf, uint32_t aCount,
uint32_t* aReadCount) {
if (mPos >= mLen) {
*aReadCount = 0;
return NS_OK;
}
nsAString::const_iterator iter;
mString.BeginReading(iter);
const char16_t* us = iter.get();
uint32_t amount = mLen - mPos;
if (amount > aCount) {
amount = aCount;
}
memcpy(aBuf, us + mPos, sizeof(char16_t) * amount);
mPos += amount;
*aReadCount = amount;
return NS_OK;
}
NS_IMETHODIMP
StringUnicharInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
void* aClosure, uint32_t aCount,
uint32_t* aReadCount) {
uint32_t bytesWritten;
uint32_t totalBytesWritten = 0;
nsresult rv;
aCount = XPCOM_MIN(mString.Length() - mPos, aCount);
nsAString::const_iterator iter;
mString.BeginReading(iter);
while (aCount) {
rv = aWriter(this, aClosure, iter.get() + mPos, totalBytesWritten, aCount,
&bytesWritten);
if (NS_FAILED(rv)) {
// don't propagate errors to the caller
break;
}
aCount -= bytesWritten;
totalBytesWritten += bytesWritten;
mPos += bytesWritten;
}
*aReadCount = totalBytesWritten;
return NS_OK;
}
NS_IMETHODIMP
StringUnicharInputStream::ReadString(uint32_t aCount, nsAString& aString,
uint32_t* aReadCount) {
if (mPos >= mLen) {
*aReadCount = 0;
return NS_OK;
}
uint32_t amount = mLen - mPos;
if (amount > aCount) {
amount = aCount;
}
aString = Substring(mString, mPos, amount);
mPos += amount;
*aReadCount = amount;
return NS_OK;
}
nsresult StringUnicharInputStream::Close() {
mPos = mLen;
return NS_OK;
}
NS_IMPL_ISUPPORTS(StringUnicharInputStream, nsIUnicharInputStream)
//----------------------------------------------------------------------
nsresult NS_NewUnicharInputStream(nsIInputStream* aStreamToWrap,
nsIUnicharInputStream** aResult) {
*aResult = nullptr;
// Create converter input stream
RefPtr<nsConverterInputStream> it = new nsConverterInputStream();
nsresult rv = it->Init(aStreamToWrap, "UTF-8", STRING_BUFFER_SIZE,
nsIConverterInputStream::ERRORS_ARE_FATAL);
if (NS_FAILED(rv)) {
return rv;
}
it.forget(aResult);
return NS_OK;
}
|
