public virtual void reset()
{
isChunked = false;
headers = null;
contentLength = 0;
dataCounter = 0;
endOfResponse = false;
aborted = false;
}
public void onHeadersReceived(capex.http.HTTPClientResponse headers)
{
if (listener != null && listener.onResponseReceived(headers) == false)
{
if (listener != null)
{
listener.onAborted();
}
aborted = true;
}
}
public virtual bool onResponseReceived(capex.http.HTTPClientResponse response)
{
return(true);
}
private capex.http.HTTPClientResponse parseResponse(byte[] buf)
{
var i = 0;
var p = (byte)'0';
capex.http.HTTPClientResponse v = null;
var first = true;
var isChunked = false;
while (true)
{
var sb = new cape.StringBuilder();
while ((p = cape.Buffer.getByte(buf, (long)i)) != 0)
{
if (p == '\r')
{
;
}
else if (p == '\n')
{
i++;
break;
}
else
{
sb.append((char)p);
}
i++;
}
var t = sb.toString();
if (cape.String.isEmpty(t))
{
break;
}
if (first)
{
var comps = cape.String.split(t, ' ', 3);
v = new capex.http.HTTPClientResponse();
v.setHttpVersion(cape.Vector.get(comps, 0));
v.setHttpStatus(cape.Vector.get(comps, 1));
v.setHttpStatusDescription(cape.Vector.get(comps, 2));
}
else
{
var comps1 = cape.String.split(t, ':', 2);
var key = cape.Vector.get(comps1, 0);
if (cape.String.isEmpty(key) == false)
{
var val = cape.String.strip(cape.Vector.get(comps1, 1));
v.addHeader(key, val);
if (isChunked == false && cape.String.equalsIgnoreCase(key, "transfer-encoding"))
{
if (object.Equals(val, "chunked"))
{
isChunked = true;
}
}
else if (contentLength < 1 && cape.String.equalsIgnoreCase(key, "content-length"))
{
contentLength = cape.String.toInteger(val);
}
}
}
first = false;
}
var l = (long)(cape.Buffer.getSize(buf) - i);
if (l > 0)
{
receivedData = cape.Buffer.getSubBuffer(buf, (long)i, l);
}
else
{
receivedData = null;
}
this.isChunked = isChunked;
return(v);
}
public void onDataReceived(byte[] buf, long size)
{
if (size > 0)
{
receivedData = cape.Buffer.append(receivedData, buf, size);
}
if (headers == null)
{
if (hasEndOfHeaders(receivedData, cape.Buffer.getSize(receivedData)))
{
headers = parseResponse(receivedData);
if (headers != null)
{
onHeadersReceived(headers);
}
}
}
if (isChunked)
{
while (true)
{
var r = getChunk();
if (r != null)
{
if (!r.completed)
{
break;
}
if (!(r.data != null))
{
reset();
onEndOfResponse();
break;
}
var sz = cape.Buffer.getSize(r.data);
dataCounter += (int)sz;
onBodyDataReceived(r.data, sz);
}
else
{
reset();
onEndOfResponse();
break;
}
if (receivedData == null)
{
break;
}
}
}
else if (contentLength > 0)
{
var rsz = cape.Buffer.getSize(receivedData);
if (rsz > 0)
{
if (contentLength <= 0 || dataCounter + rsz <= contentLength)
{
var v = receivedData;
receivedData = null;
dataCounter += (int)rsz;
onBodyDataReceived(v, rsz);
}
else
{
var vsz = contentLength - dataCounter;
var v1 = cape.Buffer.getSubBuffer(receivedData, (long)0, (long)vsz);
receivedData = cape.Buffer.getSubBuffer(receivedData, (long)vsz, rsz - vsz);
dataCounter += vsz;
onBodyDataReceived(v1, (long)vsz);
}
}
if (dataCounter >= contentLength)
{
reset();
onEndOfResponse();
}
}
else
{
reset();
onEndOfResponse();
}
}
public capex.http.HTTPClient.MyListener setResponse(capex.http.HTTPClientResponse v)
{
response = v;
return(this);
}
public override bool onResponseReceived(capex.http.HTTPClientResponse response)
{
this.response = response;
return(true);
}
