public bool Request(string proto, SpObject args, int session, SpStream stream)
{
SpStream encode_stream = EncodeRequest(proto, args, session);
encode_stream.Position = 0;
return(SpPacker.Pack(encode_stream, stream));
}
public SpStream Encode(SpType type, SpObject obj)
{
SpStream stream = new SpStream();
if (Encode(type, obj, stream) == false)
{
if (stream.IsOverflow())
{
if (stream.Position > MAX_SIZE)
{
return(null);
}
int size = stream.Position;
size = ((size + 7) / 8) * 8;
stream = new SpStream(size);
if (Encode(type, obj, stream) == false)
{
return(null);
}
}
else
{
return(null);
}
}
return(stream);
}
public SpObject Decode(SpType type, SpStream stream)
{
if (type == null || stream == null)
{
return(null);
}
mStream = stream;
return(DecodeInternal(type));
}
public static bool Unpack(SpStream input, SpStream output)
{
int src_size = input.Tail;
int src_offset = input.Offset;
byte[] src = input.Buffer;
while (src_offset < src_size)
{
byte header = src[src_offset];
src_offset++;
if (header == 0xff)
{
if (src_offset > src_size)
{
return(false);
}
int n = (src[src_offset] + 1) * 8;
if (src_size - src_offset < n + 1)
{
return(false);
}
src_offset++;
output.Write(src, src_offset, n);
src_offset += n;
}
else
{
for (int i = 0; i < 8; i++)
{
int nz = (header >> i) & 1;
if (nz != 0)
{
if (src_offset > src_size)
{
return(false);
}
output.Write(src[src_offset]);
src_offset++;
}
else
{
output.Write((byte)0);
}
}
}
}
return(output.IsOverflow() == false);
}
public bool Encode(SpType type, SpObject obj, SpStream stream)
{
if (type == null || obj == null || stream == null)
{
return(false);
}
mStream = stream;
bool success = EncodeInternal(type, obj);
return(success && stream.IsOverflow() == false);
}
public static void WriteFF(byte[] src, int src_offset, SpStream output, int n, int correctPos)
{
int align8_n = (n + 7) & (~7);
output.Write((byte)0xff);
output.Write((byte)(align8_n / 8 - 1));
output.Write(src, src_offset, n);
for (int i = 0; i < align8_n - n; i++)
{
output.Write((byte)0);
}
output.CorrectLength(correctPos);
}
public SpRpcResult Dispatch(SpStream stream)
{
SpStream unpack_stream = SpPacker.Unpack(stream);
unpack_stream.Position = 0;
SpObject header = mHostTypeManager.Codec.Decode(mHeaderType, unpack_stream);
int session = 0;
if (header["session"] != null)
{
session = header["session"].AsInt();
}
if (header["type"] != null)
{
// handle request
SpProtocol protocol = mHostTypeManager.GetProtocolByTag(header["type"].AsInt());
SpObject obj = mHostTypeManager.Codec.Decode(protocol.Request, unpack_stream);
if (session != 0)
{
mSessions[session] = protocol;
}
return(new SpRpcResult(session, protocol, SpRpcOp.Request, obj));
}
else
{
// handle response
if (mSessions.ContainsKey(session) == false)
{
return(new SpRpcResult());
}
SpProtocol protocol = mSessions[session];
mSessions.Remove(session);
if (protocol == null)
{
return(new SpRpcResult());
}
if (protocol.Response == null)
{
return(new SpRpcResult(session, protocol, SpRpcOp.Response, null));
}
SpObject obj = mAttachTypeManager.Codec.Decode(protocol.Response, unpack_stream);
return(new SpRpcResult(session, protocol, SpRpcOp.Response, obj));
}
}
private static int PackSeg(byte[] src, int src_offset, SpStream output, int n)
{
byte header = 0;
int notzero = 0;
int dest_begin = output.Position;
output.Position++;
for (int i = 0; i < 8; i++)
{
if (src[src_offset + i] != 0)
{
notzero++;
header |= (byte)(1 << i);
output.Write(src[src_offset + i]);
}
}
if ((notzero == 7 || notzero == 6) && n > 0)
{
notzero = 8;
}
if (notzero == 8)
{
if (n > 0)
{
return(8);
}
else
{
return(10);
}
}
int dest_end = output.Position;
output.Position = dest_begin;
output.Write(header);
output.Position = dest_end;
return(notzero + 1);
}
public static SpStream Unpack(SpStream input)
{
SpStream stream = new SpStream();
int pos = input.Position;
if (Unpack(input, stream) == false)
{
stream = new SpStream(stream.Position);
input.Position = pos;
if (Unpack(input, stream) == false)
{
return(null);
}
}
return(stream);
}
public static SpStream Pack(SpStream input)
{
SpStream stream = new SpStream();
int pos = input.Position;
if (Pack(input, stream) == false)
{
int size = stream.Position;
size = ((size + 7) / 8) * 8;
stream = new SpStream(size);
input.Position = pos;
// do we need this check? it's not possible it will return false this time
if (Pack(input, stream) == false)
{
return(null);
}
}
return(stream);
}
public SpStream Response(int session, SpObject args)
{
SpObject header = new SpObject();
header.Insert("session", session);
SpStream encode_stream = new SpStream();
mHostTypeManager.Codec.Encode(mHeaderType, header, encode_stream);
if (session != 0 && mSessions.ContainsKey(session))
{
mHostTypeManager.Codec.Encode(mSessions[session].Response, args, encode_stream);
}
SpStream pack_stream = new SpStream();
encode_stream.Position = 0;
SpPacker.Pack(encode_stream, pack_stream);
pack_stream.Position = 0;
return(pack_stream);
}
private SpStream EncodeRequest(string proto, SpObject args, int session)
{
if (mAttachTypeManager == null || mHostTypeManager == null || mHeaderType == null)
{
return(null);
}
SpProtocol protocol = mAttachTypeManager.GetProtocolByName(proto);
if (protocol == null)
{
return(null);
}
SpObject header = new SpObject();
header.Insert("type", protocol.Tag);
if (session != 0)
{
header.Insert("session", session);
}
SpStream stream = mHostTypeManager.Codec.Encode(mHeaderType, header);
if (stream == null)
{
return(null);
}
if (args != null)
{
if (mAttachTypeManager.Codec.Encode(protocol.Request, args, stream) == false)
{
if (stream.IsOverflow())
{
if (stream.Position > SpCodec.MAX_SIZE)
{
return(null);
}
int size = stream.Position;
size = ((size + 7) / 8) * 8;
stream = new SpStream(size);
if (mAttachTypeManager.Codec.Encode(protocol.Request, args, stream) == false)
{
return(null);
}
}
else
{
return(null);
}
}
}
if (session != 0)
{
mSessions[session] = protocol;
}
return(stream);
}
public static bool Pack(SpStream input, SpStream output)
{
int src_size = input.Length;
if (src_size % 8 != 0)
{
int new_size = ((src_size + 7) / 8) * 8;
if (input.Capacity < new_size)
{
SpStream new_input = new SpStream(new_size);
Array.Copy(input.Buffer, input.Offset, new_input.Buffer, new_input.Offset, input.Length);
new_input.Position = new_input.Offset;
input = new_input;
src_size = new_size;
}
else
{
int pos = input.Position;
input.Position = input.Tail;
for (int i = src_size; i < new_size; i++)
{
input.Write((byte)0);
}
input.Position = pos;
}
}
int src_start = input.Offset;
int src_offset = input.Offset;
byte[] src = input.Buffer;
int ff_n = 0;
int ff_src_start = 0;
int ff_dest_start = 0;
for (; src_offset < src_size; src_offset += 8)
{
int pos = output.Position;
int n = PackSeg(src, src_offset, output, ff_n);
if (n == 10)
{
ff_src_start = src_offset;
ff_dest_start = pos;
ff_n = 1;
}
else if (n == 8 && ff_n > 0)
{
ff_n++;
if (ff_n == 256)
{
output.Position = ff_dest_start;
WriteFF(src, ff_src_start, output, 256 * 8, n);
ff_n = 0;
}
}
else
{
if (ff_n > 0)
{
output.Position = ff_dest_start;
WriteFF(src, ff_src_start, output, ff_n * 8, n);
ff_n = 0;
}
}
output.Position = pos + n;
}
if (ff_n == 1)
{
output.Position = ff_dest_start;
WriteFF(src, ff_src_start, output, 8, 0);
}
else if (ff_n > 1)
{
output.Position = ff_dest_start;
WriteFF(src, ff_src_start, output, src_size - (ff_src_start - src_start), 0);
}
return(output.IsOverflow() == false);
}
public bool Encode(string proto, SpObject obj, SpStream stream)
{
return(Encode(mTypeManager.GetType(proto), obj, stream));
}
public SpObject Decode(string proto, SpStream stream)
{
return(Decode(mTypeManager.GetType(proto), stream));
}
