public void receiveResponse(std::istream stream, HttpResponse response)
{
string httpVersion;
readWord(stream, httpVersion);
string status;
char c;
stream.get(c);
while (stream.good() && c != '\r')
{ //Till the end
status += c;
stream.get(c);
}
GlobalMembers.throwIfNotGood(stream);
if (c == '\r')
{
stream.get(c);
if (c != '\n')
{
throw new System.Exception("Parser error: '\\n' symbol is expected");
}
}
response.setStatus(parseResponseStatusFromString(status));
string name;
string value;
while (readHeader(stream, name, value))
{
response.addHeader(name, value);
name = "";
value = "";
}
response.addHeader(name, value);
var headers = response.getHeaders();
uint length = 0;
var it = headers.find("content-length");
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
if (it != headers.end())
{
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
length = Convert.ToUInt32(it.second);
}
string body;
if (length != null)
{
readBody(stream, body, new uint(length));
}
response.setBody(body);
}
public override void load(std::istream @is)
{
m_sync.load(@is);
StdInputStream inputStream = new StdInputStream(@is);
CryptoNote.BinaryInputStreamSerializer s = new CryptoNote.BinaryInputStreamSerializer(inputStream);
uint version = 0;
s.functorMethod(version, "version");
if (version > GlobalMembers.TRANSFERS_STORAGE_ARCHIVE_VERSION)
{
throw new System.Exception("TransfersSyncronizer version mismatch");
}
//C++ TO C# CONVERTER TODO TASK: C# does not allow declaring types within methods:
// struct ConsumerState
// {
// PublicKey viewKey;
// string state;
// ClassicVector<System.Tuple<AccountPublicAddress, string>> subscriptionStates;
// };
List <ConsumerState> updatedStates = new List <ConsumerState>();
try
{
ulong subscriptionCount = 0;
s.beginArray(ref subscriptionCount, "consumers");
while (subscriptionCount-- != 0)
{
s.beginObject("");
PublicKey viewKey = new PublicKey();
s.functorMethod(viewKey, "view_key");
string blob;
s.functorMethod(blob, "state");
var subIter = m_consumers.find(viewKey);
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
if (subIter != m_consumers.end())
{
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
var consumerState = m_sync.getConsumerState(subIter.second.get());
Debug.Assert(consumerState);
{
// store previous state
var prevConsumerState = GlobalMembers.getObjectState(*consumerState);
// load consumer state
GlobalMembers.setObjectState(*consumerState, blob);
updatedStates.Add(ConsumerState({ viewKey, std::move(prevConsumerState) }));
}
private void readBody(std::istream stream, string body, uint bodyLen)
{
uint read = 0;
while (stream.good() && read < bodyLen)
{
body += stream.get();
++read;
}
GlobalMembers.throwIfNotGood(stream);
}
private void readHeaders(std::istream stream, SortedDictionary <string, string> headers)
{
string name;
string value;
while (readHeader(stream, name, value))
{
headers[name] = value; //use insert
name = "";
value = "";
}
headers[name] = value; //use insert
}
public void receiveRequest(std::istream stream, HttpRequest request)
{
readWord(stream, request.method);
readWord(stream, request.url);
string httpVersion;
readWord(stream, httpVersion);
readHeaders(stream, request.headers);
string body;
uint bodyLen = getBodyLen(request.headers);
if (bodyLen != null)
{
readBody(stream, request.body, new uint(bodyLen));
}
}
private void readWord(std::istream stream, string word)
{
char c;
stream.get(c);
while (stream.good() && c != ' ' && c != '\r')
{
word += c;
stream.get(c);
}
GlobalMembers.throwIfNotGood(stream);
if (c == '\r')
{
stream.get(c);
if (c != '\n')
{
throw std::system_error(GlobalMembers.make_error_code(CryptoNote.error.HttpParserErrorCodes.UNEXPECTED_SYMBOL));
}
}
}
private bool readHeader(std::istream stream, string name, string value)
{
char c;
bool isName = true;
stream.get(c);
while (stream.good() && c != '\r')
{
if (c == ':')
{
if (stream.peek() == ' ')
{
stream.get(c);
}
if (string.IsNullOrEmpty(name))
{
throw std::system_error(GlobalMembers.make_error_code(CryptoNote.error.HttpParserErrorCodes.EMPTY_HEADER));
}
if (isName)
{
isName = false;
stream.get(c);
continue;
}
}
if (isName)
{
name += c;
stream.get(c);
}
else
{
value += c;
stream.get(c);
}
}
GlobalMembers.throwIfNotGood(stream);
stream.get(c);
if (c != '\n')
{
throw std::system_error(GlobalMembers.make_error_code(CryptoNote.error.HttpParserErrorCodes.UNEXPECTED_SYMBOL));
}
std::transform(name.GetEnumerator(), name.end(), name.GetEnumerator(), global::tolower);
c = stream.peek();
if (c == '\r')
{
stream.get(c).get(c);
if (c != '\n')
{
throw std::system_error(GlobalMembers.make_error_code(CryptoNote.error.HttpParserErrorCodes.UNEXPECTED_SYMBOL));
}
return(false); //no more headers
}
return(true);
}
public JsonInputStreamSerializer(std::istream stream) : base.functorMethod(getJsonValueFromStreamHelper(stream))
