public Int64 read_integer()
{
if (this.value >= 0)
{
return((Int64)(this.value));
}
else
{
UInt32 sz = this.read_dword();
if (sz == sizeof(UInt32))
{
UInt64 v = this.expand64(this.read_dword());
return((Int64)v);
}
else if (sz == sizeof(UInt64))
{
UInt32 low = this.read_dword();
UInt32 hi = this.read_dword();
UInt64 v = (UInt64)low | (UInt64)hi << 32;
return((Int64)v);
}
else
{
SprotoTypeSize.error("read invalid integer size (" + sz + ")");
}
}
return(0);
}
public void write_integer(Int64 integer, int tag)
{
Int64 vh = integer >> 31;
int sz = (vh == 0 || vh == -1)?(sizeof(UInt32)):(sizeof(UInt64));
int value = 0;
if (sz == sizeof(UInt32))
{
UInt32 v = (UInt32)integer;
if (v < 0x7fff)
{
value = (int)((v + 1) * 2);
sz = 2;
}
else
{
sz = this.encode_integer(v);
}
}
else if (sz == sizeof(UInt64))
{
UInt64 v = (UInt64)integer;
sz = this.encode_uint64(v);
}
else
{
SprotoTypeSize.error("invaild integer size.");
}
this.write_tag(tag, value);
}
public List <byte[]> read_binary_list()
{
UInt32 sz = this.read_array_size();
List <byte[]> bytes_list = new List <byte[]> ();
for (UInt32 i = 0; sz > 0; i++)
{
if (sz < SprotoTypeSize.sizeof_length)
{
SprotoTypeSize.error("error array size.");
}
UInt32 hsz = this.read_dword();
sz -= (UInt32)SprotoTypeSize.sizeof_length;
if (hsz > sz)
{
SprotoTypeSize.error("error array object.");
}
byte[] buffer = new byte[hsz];
this.reader.Read(buffer, 0, buffer.Length);
bytes_list.Add(buffer);
sz -= hsz;
}
return(bytes_list);
}
public List <string> read_string_list()
{
UInt32 sz = this.read_array_size();
List <string> string_list = new List <string> ();
for (UInt32 i = 0; sz > 0; i++)
{
if (sz < SprotoTypeSize.sizeof_length)
{
SprotoTypeSize.error("error array size.");
}
UInt32 hsz = this.read_dword();
sz -= (UInt32)SprotoTypeSize.sizeof_length;
if (hsz > sz)
{
SprotoTypeSize.error("error array object.");
}
byte[] buffer = new byte[hsz];
this.reader.Read(buffer, 0, buffer.Length);
string v = System.Text.Encoding.UTF8.GetString(buffer);
string_list.Add(v);
sz -= hsz;
}
return(string_list);
}
private T read_element <T>(SprotoTypeReader reader, UInt32 sz, out UInt32 read_size) where T : SprotoTypeBase, new()
{
read_size = 0;
if (sz < SprotoTypeSize.sizeof_length)
{
SprotoTypeSize.error("error array size.");
}
UInt32 hsz = this.read_dword();
sz -= (UInt32)SprotoTypeSize.sizeof_length;
read_size += (UInt32)SprotoTypeSize.sizeof_length;
if (hsz > sz)
{
SprotoTypeSize.error("error array object.");
}
reader.Init(this.reader.Buffer, this.reader.Offset, (int)hsz);
this.reader.Seek(this.reader.Position + (int)hsz);
T obj = new T();
obj.init(reader);
read_size += hsz;
return(obj);
}
public List <T> read_obj_list <T>() where T : SprotoTypeBase, new()
{
UInt32 sz = this.read_array_size();
List <T> obj_list = new List <T> ();
for (UInt32 i = 0; sz > 0; i++)
{
if (sz < SprotoTypeSize.sizeof_length)
{
SprotoTypeSize.error("error array size.");
}
UInt32 hsz = this.read_dword();
sz -= (UInt32)SprotoTypeSize.sizeof_length;
if (hsz > sz)
{
SprotoTypeSize.error("error array object.");
}
SprotoTypeReader reader = new SprotoTypeReader(this.reader.Buffer, this.reader.Offset, hsz);
this.reader.Seek(this.reader.Position + hsz);
T obj = new T();
obj.init(reader);
obj_list.Add(obj);
sz -= hsz;
}
return(obj_list);
}
public List <double> read_double_list()
{
List <double> double_list = null;
UInt32 sz = this.read_array_size();
if (sz == 0)
{
return(new List <double>());
}
int len = this.reader.ReadByte();
sz--;
if (len != 8)
{
SprotoTypeSize.error("invalid intlen (" + len + ")");
}
double_list = new List <double>();
UnionValue u = new UnionValue();
for (int i = 0; i < sz / 8; i++)
{
u.integer_v = this.read_uint64();
double_list.Add(u.real_v);
}
return(double_list);
}
private void check()
{
if (this.pos > this.size || this.begin > this.pos)
{
SprotoTypeSize.error("invalid pos.");
}
}
public byte[] unpack(byte[] data, int len = 0)
{
this.clear();
len = (len == 0)?(data.Length):(len);
int srcsz = len;
while (srcsz > 0)
{
byte header = data [len - srcsz];
--srcsz;
if (header == 0xff)
{
if (srcsz < 0)
{
SprotoTypeSize.error("invalid unpack stream.");
}
int n = (data [len - srcsz] + 1) * 8;
if (srcsz < n + 1)
{
SprotoTypeSize.error("invalid unpack stream.");
}
this.buffer.Write(data, len - srcsz + 1, n);
srcsz -= n + 1;
}
else
{
for (int i = 0; i < 8; i++)
{
int nz = (header >> i) & 1;
if (nz == 1)
{
if (srcsz < 0)
{
SprotoTypeSize.error("invalid unpack stream.");
}
this.buffer.WriteByte(data [len - srcsz]);
--srcsz;
}
else
{
this.buffer.WriteByte(0);
}
}
}
}
byte[] unpack_data = new byte[this.buffer.Position];
this.buffer.Seek(0, SeekOrigin.Begin);
this.buffer.Read(unpack_data, 0, unpack_data.Length);
return(unpack_data);;
}
private void fill_size(int sz)
{
if (sz < 0)
{
SprotoTypeSize.error("fill invaild size.");
}
this.write_uint32((UInt32)sz);
}
public bool read_boolean()
{
if (this.value < 0)
{
SprotoTypeSize.error("read invalid boolean.");
return(false);
}
else
{
return((this.value == 0)?(false):(true));
}
}
public List <Int64> read_integer_list()
{
List <Int64> integer_list = null;
UInt32 sz = this.read_array_size();
if (sz == 0)
{
return(new List <Int64> ());
}
int len = this.reader.ReadByte();
sz--;
if (len == sizeof(UInt32))
{
if (sz % sizeof(UInt32) != 0)
{
SprotoTypeSize.error("error array size(" + sz + ")@sizeof(Uint32)");
}
integer_list = new List <Int64> ();
for (int i = 0; i < sz / sizeof(UInt32); i++)
{
UInt64 v = this.expand64(this.read_dword());
integer_list.Add((Int64)v);
}
}
else if (len == sizeof(UInt64))
{
if (sz % sizeof(UInt64) != 0)
{
SprotoTypeSize.error("error array size(" + sz + ")@sizeof(Uint64)");
}
integer_list = new List <Int64> ();
for (int i = 0; i < sz / sizeof(UInt64); i++)
{
UInt32 low = this.read_dword();
UInt32 hi = this.read_dword();
UInt64 v = (UInt64)low | (UInt64)hi << 32;
integer_list.Add((Int64)v);
}
}
else
{
SprotoTypeSize.error("error intlen(" + len + ")");
}
return(integer_list);
}
public double read_double()
{
UInt32 sz = this.read_dword();
if (sz == 8)
{
UnionValue v = new UnionValue();
v.integer_v = this.read_uint64();
return(v.real_v);
}
else
{
SprotoTypeSize.error("read invalid double size (" + sz + ")");
}
return(0.0);
}
private UInt32 read_array_size()
{
if (this.value >= 0)
{
SprotoTypeSize.error("invalid array value.");
}
UInt32 sz = this.read_dword();
if (sz < 0)
{
SprotoTypeSize.error("error array size(" + sz + ")");
}
return(sz);
}
private void init()
{
this.fn = this.read_word();
int header_length = SprotoTypeSize.sizeof_header + this.fn * SprotoTypeSize.sizeof_field;
this.begin_data_pos = header_length;
this.cur_field_pos = this.reader.Position;
if (this.reader.Length < header_length)
{
SprotoTypeSize.error("invalid decode header.");
}
this.reader.Seek(this.begin_data_pos);
}
static private SprotoTypeBase _gen(Dictionary <int, KeyValuePair <Type, typeFunc> > dictionary, int tag, byte[] buffer, int offset = 0)
{
KeyValuePair <Type, typeFunc> v;
if (dictionary.TryGetValue(tag, out v))
{
SprotoTypeBase obj = v.Value(buffer, offset);
if (obj.GetType() != v.Key)
{
SprotoTypeSize.error("sproto type: " + obj.GetType().ToString() + "not is expected. [" + v.Key.ToString() + "]");
}
return(obj);
}
return(null);
}
static private void _set <T>(Dictionary <int, KeyValuePair <Type, typeFunc> > dictionary, int tag)
where T : SprotoTypeBase, new()
{
if (dictionary.ContainsKey(tag))
{
SprotoTypeSize.error("redefine tag: " + tag);
}
typeFunc _func = delegate(byte[] buffer, int offset) {
T obj = new T();
obj.init(buffer, offset);
return(obj);
};
KeyValuePair <Type, typeFunc> kv = new KeyValuePair <Type, typeFunc> (typeof(T), _func);
dictionary.Add(tag, kv);
}
private void write_tag(int tag, int value)
{
int stag = tag - this.lasttag - 1;
if (stag > 0)
{
// skip tag
stag = (stag - 1) * 2 + 1;
if (stag > 0xffff)
{
SprotoTypeSize.error("tag is too big.");
}
this.write_header_record(stag);
}
this.write_header_record(value);
this.lasttag = tag;
}
private void _expand(int sz = 0)
{
if (this.size - this.pos < sz)
{
long bak_sz = this.size;
while (this.size - this.pos < sz)
{
this.size = this.size * 2;
}
if (this.size >= SprotoTypeSize.encode_max_size)
{
SprotoTypeSize.error("object is too large (>" + SprotoTypeSize.encode_max_size + ")");
}
byte[] new_buffer = new byte[this.size];
for (long i = 0; i < bak_sz; i++)
{
new_buffer [i] = this.buffer [i];
}
this.buffer = new_buffer;
}
}
public void write_integer(List <Int64> integer_list, int tag)
{
if (integer_list == null || integer_list.Count <= 0)
{
return;
}
int sz_pos = this.data.Position;
this.data.Seek(sz_pos + SprotoTypeSize.sizeof_length, SeekOrigin.Begin);
int begin_pos = this.data.Position;
int intlen = sizeof(UInt32);
this.data.Seek(begin_pos + 1, SeekOrigin.Begin);
for (int index = 0; index < integer_list.Count; index++)
{
Int64 v = integer_list [index];
Int64 vh = v >> 31;
int sz = (vh == 0 || vh == -1)?(sizeof(UInt32)):(sizeof(UInt64));
if (sz == sizeof(UInt32))
{
this.write_uint32((UInt32)v);
if (intlen == sizeof(UInt64))
{
bool is_negative = ((v & 0x80000000) == 0) ? (false) : (true);
this.write_uint32_to_uint64_sign(is_negative);
}
}
else if (sz == sizeof(UInt64))
{
if (intlen == sizeof(UInt32))
{
this.data.Seek(begin_pos + 1, SeekOrigin.Begin);
for (int i = 0; i < index; i++)
{
UInt64 value = (UInt64)(integer_list[i]);
this.write_uint64(value);
}
intlen = sizeof(UInt64);
}
this.write_uint64((UInt64)v);
}
else
{
SprotoTypeSize.error("invalid integer size(" + sz + ")");
}
}
// fill integer size
int cur_pos = this.data.Position;
this.data.Seek(begin_pos, SeekOrigin.Begin);
this.data.WriteByte((byte)intlen);
// fill array size
int size = (int)(cur_pos - begin_pos);
this.data.Seek(sz_pos, SeekOrigin.Begin);
this.fill_size(size);
this.data.Seek(cur_pos, SeekOrigin.Begin);
this.write_tag(tag, 0);
}
public byte[] pack(byte[] data, int len = 0)
{
this.clear();
len = (len == 0)?(data.Length):(len);
byte[] ff_src = null;
int ff_srcstart = 0;
long ff_desstart = 0;
int ff_n = 0;
byte[] src = data;
int offset = 0;
int srcsz = len;
for (int i = 0; i < srcsz; i += 8)
{
offset = i;
int padding = i + 8 - srcsz;
if (padding > 0)
{
for (int j = 0; j < 8 - padding; j++)
{
this.tmp [j] = src [i + j];
}
for (int j = 0; j < padding; j++)
{
this.tmp [7 - j] = 0;
}
src = this.tmp;
offset = 0;
}
int n = this.pack_seg(src, offset, ff_n);
if (n == 10)
{
// first FF
ff_src = src;
ff_srcstart = offset;
ff_desstart = this.buffer.Position;
ff_n = 1;
}
else if (n == 8 && ff_n > 0)
{
++ff_n;
if (ff_n == 256)
{
this.write_ff(ff_src, ff_srcstart, ff_desstart, 256 * 8);
ff_n = 0;
}
}
else
{
if (ff_n > 0)
{
this.write_ff(ff_src, ff_srcstart, ff_desstart, ff_n * 8);
ff_n = 0;
}
}
this.buffer.Seek(n, SeekOrigin.Current);
}
if (ff_n == 1)
{
this.write_ff(ff_src, ff_srcstart, ff_desstart, 8);
}
else if (ff_n > 1)
{
this.write_ff(ff_src, ff_srcstart, ff_desstart, ff_src.Length - ff_srcstart);
}
long maxsz = (data.LongLength + 2047) / 2048 * 2 + data.LongLength;
if (maxsz < this.buffer.Position)
{
SprotoTypeSize.error("packing error, return size=" + this.buffer.Position);
}
byte[] pack_buffer = new byte[this.buffer.Position];
this.buffer.Seek(0, SeekOrigin.Begin);
this.buffer.Read(pack_buffer, 0, pack_buffer.Length);
return(pack_buffer);
}