Esempio n. 1
0
		public override int encode (SprotoStream stream) {
			base.serialize.open (stream);

			if (base.has_field.has_field (0)) {
				base.serialize.write_obj (this.person, 0);
			}

			return base.serialize.close ();
		}
        private void test_array()
        {
            /*
             * .Test {
             * 	var1 0: *boolean
             *  var2 4: *integer
             *  var3 5: *string
             * }
             * */

            SprotoTypeSerialize serialize = new SprotoTypeSerialize (20);

            List<Int64> data = new List<Int64> ();
            data.Add (4);
            data.Add (0x1123);
            data.Add (0x1122334455);
            data.Add (-0x778899aabb);
            data.Add (-6);

            List<bool> b_data = new List<bool> ();
            b_data.Add (true);
            b_data.Add (false);
            b_data.Add (true);

            List<string> str_data = new List<string> ();
            str_data.Add ("abc");
            str_data.Add ("1234");
            str_data.Add ("fgcbvb");

            byte[] test_result_data = {
                0X04, 0X00, 0X00, 0X00, 0X05, 0X00, 0X00, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00,
                0X00, 0X01, 0X00, 0X01, 0X29, 0X00, 0X00, 0X00, 0X08, 0X04, 0X00, 0X00, 0X00,
                0X00, 0X00, 0X00, 0X00, 0X23, 0X11, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X55,
                0X44, 0X33, 0X22, 0X11, 0X00, 0X00, 0X00, 0X45, 0X55, 0X66, 0X77, 0X88, 0Xff,
                0Xff, 0Xff, 0Xfa, 0Xff, 0Xff, 0Xff, 0Xff, 0Xff, 0Xff, 0Xff, 0X19, 0X00, 0X00,
                0X00, 0X03, 0X00, 0X00, 0X00, 0X61, 0X62, 0X63, 0X04, 0X00, 0X00, 0X00, 0X31,
                0X32, 0X33, 0X34, 0X06, 0X00, 0X00, 0X00, 0X66, 0X67, 0X63, 0X62, 0X76, 0X62,
            };

            SprotoStream stream = new SprotoStream ();
            serialize.open (stream);

            serialize.write_boolean (b_data, 0);
            serialize.write_integer (data, 4);
            serialize.write_string (str_data, 5);

            int len = serialize.close ();
            byte[] buffer = new byte[len];
            stream.Seek (0, System.IO.SeekOrigin.Begin);
            stream.Read (buffer, 0, len);

            Console.Write ("====== array dump ========");
            dump_bytes (buffer);

            assert(buffer, test_result_data);
        }
Esempio n. 3
0
		public  byte[] encode () {
			SprotoStream stream = new SprotoStream ();
			this.encode (stream);
			int len = stream.Position;

			byte[] buffer = new byte[len];
			stream.Seek (0, SeekOrigin.Begin);
			stream.Read (buffer, 0, len);

			return buffer;
		}
Esempio n. 4
0
		public BenchMark ()
		{

			AddressBook address = new AddressBook ();
			address.person = new System.Collections.Generic.List<Person> ();

			Person person = new Person ();
			person.name = "Alice";
			person.id = 10000;

			person.phone = new System.Collections.Generic.List<Person.PhoneNumber> ();
			Person.PhoneNumber num1 = new Person.PhoneNumber ();
			num1.number = "123456789";
			num1.type = 1;
			person.phone.Add (num1);

			Person.PhoneNumber num2 = new Person.PhoneNumber ();
			num2.number = "87654321";
			num2.type = 2;
			person.phone.Add (num2);

			address.person.Add (person);

			Person person1 = new Person ();
			person1.name = "Bob";
			person1.id = 20000;
			person1.phone = new System.Collections.Generic.List<Person.PhoneNumber> ();
			Person.PhoneNumber num3 = new Person.PhoneNumber ();
			num3.number = "01234567890";
			num3.type = 3;
			person1.phone.Add (num3);

			address.person.Add (person1);

			byte[] data = address.encode ();

			Sproto.SprotoPack spack = new Sproto.SprotoPack ();

//			byte[] pack_data = spack.pack (data);

			Sproto.SprotoStream stream = new SprotoStream ();
			double b = this.cur_mseconds ();
			for (int i = 0; i < 1000000; i++) {
				address.init (data);
//				int len = address.encode (stream);
//				stream.Seek (0, System.IO.SeekOrigin.Begin);
//				spack.pack (stream.Buffer, len);

//				byte[] unpack_data = spack.unpack (pack_data);
//				address.init (unpack_data);
			}
			double e = this.cur_mseconds ();
			Console.WriteLine ("total: " + (e - b)/1000  +"s");
		}
Esempio n. 5
0
 private void WriteUInt64(SprotoStream writer, UInt64 v)
 {
     //Console.WriteLine("WriteUInt64: {0}",v);
     writer.WriteByte((byte)(v & 0xff));
     writer.WriteByte((byte)((v >> 8) & 0xff));
     writer.WriteByte((byte)((v >> 16) & 0xff));
     writer.WriteByte((byte)((v >> 24) & 0xff));
     writer.WriteByte((byte)((v >> 32) & 0xff));
     writer.WriteByte((byte)((v >> 40) & 0xff));
     writer.WriteByte((byte)((v >> 48) & 0xff));
     writer.WriteByte((byte)((v >> 56) & 0xff));
 }
Esempio n. 6
0
        private List <string> DecodeStringList(SprotoStream reader)
        {
            List <string> list       = new List <string>();
            List <byte[]> bytes_list = this.DecodeBinaryList(reader);

            for (int i = 0; i < bytes_list.Count; i++)
            {
                byte[] bytes = bytes_list[i];
                list.Add(Encoding.UTF8.GetString(bytes));
            }
            return(list);
        }
        public byte[] encode()
        {
            SprotoStream stream = new SprotoStream();

            this.encode(stream);
            int len = stream.Position;

            byte[] buffer = new byte[len];
            stream.Seek(0, SeekOrigin.Begin);
            stream.Read(buffer, 0, len);

            return(buffer);
        }
Esempio n. 8
0
		public override int encode (SprotoStream stream) {
			base.serialize.open (stream);

			if (base.has_field.has_field (0)) {
				base.serialize.write_integer (this.type, 0);
			}

			if (base.has_field.has_field (1)) {
				base.serialize.write_integer (this.session, 1);
			}

			return base.serialize.close ();
		}
Esempio n. 9
0
        private UInt64 ReadUInt64(SprotoStream reader)
        {
            UInt64 number;
            int    len = 8;

            byte[] bytes = new byte[len];
            for (int i = 0; i < len; i++)
            {
                bytes[i] = reader.ReadByte();
            }
            number = BitConverter.ToUInt64(bytes, 0);
            //Console.WriteLine("ReadUInt64: {0}",number);
            return(number);
        }
Esempio n. 10
0
        private UInt32 PeekUInt32(SprotoStream reader)
        {
            UInt32 number;
            int    len = 4;

            byte[] bytes = new byte[len];
            for (int i = 0; i < len; i++)
            {
                bytes[i] = reader.Buffer[reader.Position + i];
            }
            number = BitConverter.ToUInt32(bytes, 0);
            //Console.WriteLine("PeekUInt32: {0}",number);
            return(number);
        }
Esempio n. 11
0
        private UInt16 ReadUInt16(SprotoStream reader)
        {
            // little-endian
            UInt16 number;
            int    len = 2;

            byte[] bytes = new byte[len];
            for (int i = 0; i < len; i++)
            {
                bytes[i] = reader.ReadByte();
            }
            number = BitConverter.ToUInt16(bytes, 0);
            //Console.WriteLine("ReadUInt16: {0}",number);
            return(number);
        }
Esempio n. 12
0
        private UInt32 EncodeBinaryList(List <byte[]> binary_list, SprotoStream writer)
        {
            UInt32 size = 0;

            for (int i = 0; i < binary_list.Count; i++)
            {
                byte[] binary     = binary_list[i];
                int    length_pos = writer.Position;
                writer.Seek(SprotoCodec.SIZEOF_LENGTH, SprotoStream.SEEK_CUR);
                UInt32 length = this.EncodeBinary(binary, writer);
                this.FillSize(writer, length_pos, length);
                size += (SprotoCodec.SIZEOF_LENGTH + length);
            }
            return(size);
        }
Esempio n. 13
0
        private UInt32 EncodeStringList(List <string> string_list, SprotoStream writer)
        {
            UInt32 size = 0;

            for (int i = 0; i < string_list.Count; i++)
            {
                string str        = string_list[i];
                int    length_pos = writer.Position;
                writer.Seek(SprotoCodec.SIZEOF_LENGTH, SprotoStream.SEEK_CUR);
                UInt32 length = this.EncodeString(str, writer);
                this.FillSize(writer, length_pos, length);
                size += (SprotoCodec.SIZEOF_LENGTH + length);
            }
            return(size);
        }
Esempio n. 14
0
        private List <bool> DecodeBooleanList(SprotoStream reader)
        {
            List <bool> list = new List <bool>();
            UInt32      size = this.ReadUInt32(reader);

            for (; size > 0; size--)
            {
                bool ok = this.DecodeBoolean(reader);
                list.Add(ok);
            }
            if (size != 0)
            {
                SprotoHelper.Error("[SprotoCodec.DecodeBooleanList] fail");
            }
            return(list);
        }
Esempio n. 15
0
        public SprotoObject Decode(SprotoMgr sprotomgr, string typename, SprotoStream reader)
        {
            if (SprotoHelper.IsBuildInType(typename))
            {
                SprotoHelper.Error("[SprotoCodec.Decode] expect a 'non-buildin-type' got '{0}'", typename);
            }
            SprotoType type = sprotomgr.GetType(typename);

            if (null == type)
            {
                SprotoHelper.Error("[SprotoCodec.Decode] occur a unknow-type '{0}'", typename);
            }
            SprotoObject obj = this.DecodeSprotoObject(sprotomgr, type, reader);

            return(obj);
        }
Esempio n. 16
0
			public override int encode (SprotoStream stream) {
				base.serialize.open (stream);

				if (base.has_field.has_field (0)) {
					base.serialize.write_string (this.a, 1);
				}

				if (base.has_field.has_field (1)) {
					base.serialize.write_boolean (this.b, 3);
				}

				if (base.has_field.has_field (2)) {
					base.serialize.write_integer (this.c, 5);
				}

				return base.serialize.close ();
			}
Esempio n. 17
0
        private UInt32 EncodeInteger(Int64 integer, SprotoStream writer)
        {
            UInt32 sizeof_uint32  = sizeof(UInt32);
            UInt32 sizeof_integer = this.RealSizeOfInteger(integer);

            if (sizeof_integer == sizeof_uint32)
            {
                UInt32 number = (UInt32)integer;
                this.WriteUInt32(writer, number);
            }
            else
            {
                UInt64 number = (UInt64)integer;
                this.WriteUInt64(writer, number);
            }
            return(sizeof_integer);
        }
Esempio n. 18
0
        public static SprotoMgr ParseFromBinaryFile(string filename)
        {
            FileStream   stream = new FileStream(filename, FileMode.Open, FileAccess.Read);
            SprotoStream ms     = new SprotoStream();

            byte[] buf = new byte[1024];
            int    len = stream.Read(buf, 0, buf.Length);

            while (len > 0)
            {
                ms.Write(buf, 0, buf.Length);
                len = stream.Read(buf, 0, buf.Length);
            }
            stream.Close();
            byte[] bytes  = ms.Buffer;
            int    length = (int)ms.Position;

            return(SprotoParser.ParseFromBinary(bytes, length));
        }
		private void test_field() {
			SprotoTypeSerialize serialize = new SprotoTypeSerialize (20);

			/*
			 * .Test {
			 *   var1 0: integer
			 * 	 var2 1: string
			 *   var3 5: intger
			 *   var4 7: boolean
			 * 	 var5 9: integer
			 * 	 var6 10: boolean
			 *   var7 12: intger
			 * }
			 * */

			byte[] test_result_data = {
				0X0b, 0X00, 0X00, 0X00, 0X00, 0X00, 0X05, 0X00, 0Xac, 0X88, 0X01, 0X00, 0X04, 
				0X00, 0X01, 0X00, 0X00, 0X00, 0X02, 0X00, 0X01, 0X00, 0X46, 0X22, 0X04, 0X00, 
				0X00, 0X00, 0Xde, 0Xff, 0Xff, 0Xff, 0X0b, 0X00, 0X00, 0X00, 0X74, 0X65, 0X73, 
				0X74, 0X5f, 0X73, 0X74, 0X72, 0X69, 0X6e, 0X67, 0X08, 0X00, 0X00, 0X00, 0X66, 
				0X55, 0X44, 0X33, 0X22, 0X11, 0X00, 0X00
			};

			SprotoStream stream = new SprotoStream ();
			serialize.open (stream);

			serialize.write_integer (-34, 0);
			serialize.write_string ("test_string", 1);
			serialize.write_integer (0x4455, 5);
			serialize.write_boolean (true, 7);
			serialize.write_integer (0x112233445566, 9);
			serialize.write_boolean (false, 10);
			serialize.write_integer (0x1122, 12);

			int len = serialize.close ();
			byte[] buffer = new byte[len];
			stream.Seek (0, System.IO.SeekOrigin.Begin);
			stream.Read (buffer, 0, len);

			Console.WriteLine ("======== encode buffer ===========");
			dump_bytes (buffer);
			assert(buffer, test_result_data);
		}
Esempio n. 20
0
        private Int64 DecodeInteger(SprotoStream reader)
        {
            UInt32 sizeof_integer = this.ReadUInt32(reader);
            Int64  integer;

            if (sizeof_integer == 4)
            {
                Int32 number = (Int32)this.ReadUInt32(reader);
                integer = (Int64)number;
            }
            else
            {
                if (sizeof_integer != 8)
                {
                    SprotoHelper.Error("[SprotoCodec.DecodeInteger] invalid integer size '{0}'", sizeof_integer);
                }
                integer = (Int64)this.ReadUInt64(reader);
            }
            return(integer);
        }
Esempio n. 21
0
        public SprotoStream Encode(SprotoMgr sprotomgr, SprotoObject obj, SprotoStream writer = null)
        {
            if (null == writer)
            {
                writer = new SprotoStream();
            }
            string typename = obj.type;

            if (SprotoHelper.IsBuildInType(typename))
            {
                SprotoHelper.Error("[SprotoCodec.Encode] expect a 'non-buildin-type sprotoobj' got '{0}'", typename);
            }
            SprotoType type = sprotomgr.GetType(typename);

            if (null == type)
            {
                SprotoHelper.Error("[SprotoCodec.Encode] occur a unknow-type '{0}'", typename);
            }

            this.EncodeSprotoObject(sprotomgr, type, obj, writer);
            return(writer);
        }
Esempio n. 22
0
        private List <byte[]> DecodeBinaryList(SprotoStream reader)
        {
            List <byte[]> list = new List <byte[]>();
            UInt32        size = this.ReadUInt32(reader);

            while (size > 0)
            {
                byte[] bytes     = this.DecodeBinary(reader);
                UInt32 elem_size = (UInt32)(bytes.Length + SprotoCodec.SIZEOF_LENGTH);
                size = size - elem_size;
                if (size < 0)
                {
                    SprotoHelper.Error("[SprotoCodec.DecodeBinaryList] fail");
                }
                list.Add(bytes);
            }
            if (size != 0)
            {
                SprotoHelper.Error("[SprotoCodec.DecodeBinaryList] fail");
            }
            return(list);
        }
Esempio n. 23
0
        public RpcPackage PackResponse(string proto, SprotoObject response = null, Int64 session = 0, SprotoObject ud = null)
        {
            //Console.WriteLine("PackResponse {0} {1} {2}",proto,response,session);
            SprotoProtocol protocol = this.S2C.GetProtocol(proto);
            SprotoObject   header   = this.NewPackageHeader(this.S2C, 0, session, ud);

            this.writer.Seek(0, SprotoStream.SEEK_BEGIN);            // clear stream
            SprotoStream writer = this.S2C.Encode(header, this.writer);

            if (response != null)
            {
                string expect = protocol.response;
                if (response.type != expect)
                {
                    SprotoHelper.Error("[SprotoRpc.Response] expect '{0}' got '{1}'", expect, response.type);
                }
                writer = this.S2C.Encode(response, writer);
            }
            RpcPackage package = new RpcPackage();

            package.data = this.S2C.Pack(writer.Buffer, 0, writer.Position, out package.size);
            return(package);
        }
 public abstract int encode(SprotoStream stream);
Esempio n. 25
0
        private UInt32 EncodeSprotoObjectList(SprotoMgr sprotomgr, List <SprotoObject> list, SprotoStream writer)
        {
            UInt32 size = 0;

            for (int i = 0; i < list.Count; i++)
            {
                SprotoObject elemobj      = list[i];
                SprotoType   elemtype     = sprotomgr.GetType(elemobj.type);
                int          elemsize_pos = writer.Position;
                writer.Seek(SprotoCodec.SIZEOF_LENGTH, SprotoStream.SEEK_CUR);
                UInt32 elemsize = this.EncodeSprotoObject(sprotomgr, elemtype, elemobj, writer);
                this.FillSize(writer, elemsize_pos, elemsize);
                size += (SprotoCodec.SIZEOF_LENGTH + elemsize);
            }
            return(size);
        }
Esempio n. 26
0
        public byte[] PackEncode(SprotoObject obj, out int size, SprotoStream writer = null)
        {
            SprotoStream stream = this.Encode(obj, writer);

            return(this.Pack(stream.Buffer, 0, stream.Position, out size));
        }
Esempio n. 27
0
 public SprotoObject Decode(string typename, SprotoStream reader)
 {
     return(this.Codec.Decode(this, typename, reader));
 }
Esempio n. 28
0
 public SprotoStream Encode(SprotoObject obj, SprotoStream writer = null)
 {
     return(this.Codec.Encode(this, obj, writer));
 }
Esempio n. 29
0
        private List <SprotoObject> DecodeSprotoObjectList(SprotoMgr sprotomgr, SprotoType type, SprotoStream reader)
        {
            List <SprotoObject> list = new List <SprotoObject>();
            UInt32 size = this.ReadUInt32(reader);

            while (size > 0)
            {
                UInt32 elem_size = this.ReadUInt32(reader);
                UInt32 need_size = elem_size + SprotoCodec.SIZEOF_LENGTH;
                size = size - need_size;
                if (size < 0)
                {
                    SprotoHelper.Error("[SprotoCodec.DecodeSprotoObjectList] fail");
                }
                SprotoObject elemobj = this.DecodeSprotoObject(sprotomgr, type, reader);
                list.Add(elemobj);
            }
            if (size != 0)
            {
                SprotoHelper.Error("[SprotoCodec.DecodeSprotoObjectList] fail");
            }
            return(list);
        }
Esempio n. 30
0
 private UInt32 EncodeString(string str, SprotoStream writer)
 {
     byte[] bytes = Encoding.UTF8.GetBytes(str);
     return(this.EncodeBinary(bytes, writer));
 }
Esempio n. 31
0
        private bool DecodeBoolean(SprotoStream reader)
        {
            byte b = reader.ReadByte();

            return(Convert.ToBoolean(b));
        }
Esempio n. 32
0
		public override int encode (SprotoStream stream) {
			base.serialize.open (stream);

			if (base.has_field.has_field (0)) {
				base.serialize.write_string (this.a, 0);
			}

			if (base.has_field.has_field (1)) {
				base.serialize.write_integer (this.b, 1);
			}

			if (base.has_field.has_field (2)) {
				base.serialize.write_boolean (this.c, 2);
			}

			if (base.has_field.has_field (3)) {
				base.serialize.write_obj (this.d, 3);
			}

			if (base.has_field.has_field (4)) {
				base.serialize.write_string (this.e, 4);
			}

			if (base.has_field.has_field (5)) {
				base.serialize.write_integer (this.f, 5);
			}

			if (base.has_field.has_field (6)) {
				base.serialize.write_boolean (this.g, 6);
			}

			if (base.has_field.has_field (7)) {
				base.serialize.write_obj (this.h, 7);
			}

			return base.serialize.close ();
		}
		private void test_array() {
			/*
			 * .Test {
			 * 	var1 0: *boolean
			 *  var2 4: *integer
			 *  var3 5: *string
			 * }
			 * */

			SprotoTypeSerialize serialize = new SprotoTypeSerialize (20);

			List<Int64> data = new List<Int64> ();
			data.Add (4);
			data.Add (0x1123);
			data.Add (0x1122334455);
			data.Add (-0x778899aabb);
			data.Add (-6);

			List<bool> b_data = new List<bool> ();
			b_data.Add (true);
			b_data.Add (false);
			b_data.Add (true);

			List<string> str_data = new List<string> ();
			str_data.Add ("中文显示");
			str_data.Add ("1234");
			str_data.Add ("fgcbvb");

			byte[] test_result_data = {
				0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x29, 0x00, 0x00,
				0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x23, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x44,
				0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x45, 0x55, 0x66, 0x77,
				0x88, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff,
				0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
				0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87, 0xe6, 0x98, 0xbe, 0xe7,
				0xa4, 0xba, 0x04, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33, 0x34,
				0x06, 0x00, 0x00, 0x00, 0x66, 0x67, 0x63, 0x62, 0x76, 0x62,
			};

			SprotoStream stream = new SprotoStream ();
			serialize.open (stream);

			serialize.write_boolean (b_data, 0);
			serialize.write_integer (data, 4);
			serialize.write_string (str_data, 5);

			int len = serialize.close ();
			byte[] buffer = new byte[len];
			stream.Seek (0, System.IO.SeekOrigin.Begin);
			stream.Read (buffer, 0, len);


			Console.Write ("====== array dump ========");
			dump_bytes (buffer);

			assert(buffer, test_result_data);
		}
Esempio n. 34
0
 private string DecodeString(SprotoStream reader)
 {
     byte[] bytes = this.DecodeBinary(reader);
     return(Encoding.UTF8.GetString(bytes));
 }
Esempio n. 35
0
		public override int encode (SprotoStream stream) {
			base.serialize.open (stream);

			return base.serialize.close ();
		}
Esempio n. 36
0
		public override int encode (SprotoStream stream) {
			base.serialize.open (stream);

			if (base.has_field.has_field (0)) {
				base.serialize.write_string (this.name, 0);
			}

			if (base.has_field.has_field (1)) {
				base.serialize.write_integer (this.id, 1);
			}

			if (base.has_field.has_field (2)) {
				base.serialize.write_obj (this.d1, 2);
			}

			if (base.has_field.has_field (3)) {
				base.serialize.write_obj (this.d2, 3);
			}

			if (base.has_field.has_field (4)) {

				base.serialize.write_obj (this.d3, 4);
			}

			if (base.has_field.has_field (5)) {
				base.serialize.write_obj (this.a1, 5);
			}

			return base.serialize.close ();
		}
Esempio n. 37
0
        private UInt32 EncodeSprotoObjectDict <T> (SprotoMgr sprotomgr, Dictionary <T, SprotoObject> dict, SprotoField field, SprotoStream writer)
        {
            UInt32   size = 0;
            List <T> keys = new List <T>(dict.Keys);

            keys.Sort();             // keep encode stable
            foreach (var key in keys)
            {
                SprotoObject elemobj = dict[key];
                if (elemobj.Get(field.key) == null)
                {
                    SprotoHelper.Error("[SprotoCodec.EncodeSprotoObjectDict] exist null mainindex '{0}' in field '{1}'", field.key, field.name);
                }
                SprotoType elemtype     = sprotomgr.GetType(elemobj.type);
                int        elemsize_pos = writer.Position;
                writer.Seek(SprotoCodec.SIZEOF_LENGTH, SprotoStream.SEEK_CUR);
                UInt32 elemsize = this.EncodeSprotoObject(sprotomgr, elemtype, elemobj, writer);
                this.FillSize(writer, elemsize_pos, elemsize);
                size += (SprotoCodec.SIZEOF_LENGTH + elemsize);
            }
            return(size);
        }
Esempio n. 38
0
		public abstract int encode (SprotoStream stream);
Esempio n. 39
0
        // Parser from binary(*.spb)
        private static void _ParseFromBinary(SprotoMgr sprotomgr, byte[] bytes, int length)
        {
            SprotoMgr    meta   = SprotoParser.Parse(meta_proto);
            SprotoStream reader = new SprotoStream();

            reader.Write(bytes, 0, length);
            reader.Seek(0, SprotoStream.SEEK_BEGIN);
            SprotoObject        group     = meta.Decode("group", reader);
            List <SprotoObject> types     = null;
            List <SprotoObject> protocols = null;

            if (group.Get("type") != null)
            {
                types = group.Get("type");
                foreach (SprotoObject meta_type in types)
                {
                    SprotoType type = new SprotoType();
                    type.name = meta_type["name"];
                    if (meta_type.Has("fields"))
                    {
                        List <SprotoObject> fields = meta_type["fields"];
                        foreach (SprotoObject meta_field in fields)
                        {
                            SprotoField field = new SprotoField();
                            field.name     = meta_field["name"];
                            field.tag      = (UInt16)meta_field["tag"];
                            field.is_array = false;
                            if (meta_field.Has("array"))
                            {
                                field.is_array = (bool)meta_field["array"];
                            }
                            Int64 type_id;
                            if (meta_field.Has("buildin"))
                            {
                                type_id    = meta_field["buildin"];
                                field.type = SprotoParser.BuildInTypeId2Name[type_id];
                                if (type_id == 0 && meta_field.Has("type"))
                                {
                                    // fixed float
                                    field.digit = (UInt16)meta_field["type"];
                                }
                                else if (type_id == 2 && meta_field.Has("type"))
                                {
                                    // binary
                                    field.type = "binary";
                                }
                            }
                            else
                            {
                                type_id = meta_field["type"];
                                SprotoObject t = types[(int)type_id];
                                field.type = t["name"];
                                // map
                                if (meta_field.Has("key"))
                                {
                                    SprotoHelper.Assert(field.is_array);
                                    UInt16 map_index             = (UInt16)meta_field["key"];
                                    List <SprotoObject> t_fields = t["fields"];
                                    string name = null;
                                    foreach (SprotoObject f in t_fields)
                                    {
                                        if (f["tag"] == map_index)
                                        {
                                            name = f["name"];
                                            break;
                                        }
                                    }
                                    SprotoHelper.Assert(name != null, String.Format("map index {0} cann't find in type '{1}'", map_index, field.type));
                                    field.key = name;
                                }
                            }
                            type.AddField(field);
                        }
                    }
                    sprotomgr.AddType(type);
                }
            }
            if (group.Get("protocol") != null)
            {
                protocols = group.Get("protocol");
                foreach (SprotoObject meta_protocol in protocols)
                {
                    SprotoProtocol protocol = new SprotoProtocol();
                    protocol.name = meta_protocol["name"];
                    protocol.tag  = (UInt16)meta_protocol["tag"];
                    if (meta_protocol["request"] != null)
                    {
                        Int64 request = meta_protocol["request"];
                        protocol.request = types[(int)request]["name"];
                    }
                    if (meta_protocol["response"] != null)
                    {
                        Int64 response = meta_protocol["response"];
                        protocol.response = types[(int)response]["name"];
                    }
                    bool confirm = meta_protocol["confirm"];
                    if (confirm)
                    {
                        protocol.response = null;
                    }
                    sprotomgr.AddProtocol(protocol);
                }
            }
        }
Esempio n. 40
0
        private object DecodeBuildInType(SprotoField field, SprotoStream reader)
        {
            object obj = null;

            switch (field.type)
            {
            case "integer":
                if (field.is_array)
                {
                    List <Int64> integer_list = this.DecodeIntegerList(reader);
                    if (field.digit == 0)
                    {
                        obj = integer_list;
                    }
                    else
                    {
                        List <double> double_list = new List <double>();
                        integer_list.ForEach(v => double_list.Add((double)v / MathPow(10, field.digit)));
                        obj = double_list;
                    }
                }
                else
                {
                    Int64 integer = this.DecodeInteger(reader);
                    if (field.digit == 0)
                    {
                        obj = integer;
                    }
                    else
                    {
                        obj = (double)integer / MathPow(10, field.digit);
                    }
                }
                break;

            case "boolean":
                if (field.is_array)
                {
                    obj = this.DecodeBooleanList(reader);
                }
                else
                {
                    SprotoHelper.Error("[SprotoCodec.DecodeBuildInType] 'boolean' should decode in header part");
                    //obj = this.DecodeBoolean(reader);
                }
                break;

            case "string":
                if (field.is_array)
                {
                    obj = this.DecodeStringList(reader);
                }
                else
                {
                    obj = this.DecodeString(reader);
                }
                break;

            case "binary":
                if (field.is_array)
                {
                    obj = this.DecodeBinaryList(reader);
                }
                else
                {
                    obj = this.DecodeBinary(reader);
                }
                break;

            default:
                SprotoHelper.Error("[SprotoCodec.DecodeBuildInType] invalid buildin-type '{0}'", field.type);
                break;
            }
            return(obj);
        }
Esempio n. 41
0
        public static byte[] DumpToBinary(SprotoMgr sprotomgr)
        {
            SprotoMgr    meta  = SprotoParser.Parse(meta_proto);
            SprotoObject group = meta.NewSprotoObject("group");
            // make result stable
            List <SprotoType> types = new List <SprotoType>(sprotomgr.Types.Values);

            types.Sort(delegate(SprotoType lhs, SprotoType rhs) {
                return(string.Compare(lhs.name, rhs.name));
            });
            if (sprotomgr.Types.Count != 0)
            {
                List <SprotoObject> meta_types = new List <SprotoObject>();
                foreach (SprotoType type in types)
                {
                    SprotoObject meta_type = meta.NewSprotoObject("type");
                    meta_type["name"] = type.name;
                    if (type.fields.Count != 0)
                    {
                        List <SprotoField> fields = new List <SprotoField>(type.fields.Values);
                        fields.Sort(delegate(SprotoField lhs, SprotoField rhs) {
                            return(lhs.tag < rhs.tag ? -1 : 1);
                        });
                        List <SprotoObject> meta_fields = new List <SprotoObject>();
                        foreach (SprotoField field in fields)
                        {
                            SprotoObject meta_field = meta.NewSprotoObject("type.field");
                            meta_field["name"] = field.name;
                            meta_field["tag"]  = field.tag;
                            if (SprotoParser.BuildInTypeName2Id.ContainsKey(field.type))
                            {
                                meta_field["buildin"] = SprotoParser.BuildInTypeName2Id[field.type];
                                if (field.type == "binary")
                                {
                                    meta_field["type"] = 1;
                                }
                                else if (field.type == "integer" && field.digit > 0)
                                {
                                    meta_field["type"] = field.digit;
                                }
                            }
                            else
                            {
                                meta_field["type"] = types.IndexOf(sprotomgr.Types[field.type]);
                            }
                            if (field.is_array)
                            {
                                meta_field["array"] = true;
                                if (field.key != null)
                                {
                                    SprotoType  t = sprotomgr.Types[field.type];
                                    SprotoField f = t.fields[field.key];
                                    meta_field["key"] = f.tag;
                                }
                            }
                            meta_fields.Add(meta_field);
                        }
                        meta_type["fields"] = meta_fields;
                    }
                    meta_types.Add(meta_type);
                }
                group["type"] = meta_types;
            }
            if (sprotomgr.Protocols.Count != 0)
            {
                // make result stable
                List <SprotoProtocol> protocols = new List <SprotoProtocol>(sprotomgr.Protocols.Values);
                protocols.Sort(delegate(SprotoProtocol lhs, SprotoProtocol rhs) {
                    return(lhs.tag < rhs.tag ? -1 : 1);
                });
                List <SprotoObject> meta_protocols = new List <SprotoObject>();
                foreach (SprotoProtocol protocol in protocols)
                {
                    SprotoObject meta_protocol = meta.NewSprotoObject("protocol");
                    meta_protocol["name"] = protocol.name;
                    meta_protocol["tag"]  = protocol.tag;
                    if (protocol.request != null)
                    {
                        meta_protocol["request"] = types.IndexOf(sprotomgr.Types[protocol.request]);
                    }
                    if (protocol.response != null)
                    {
                        meta_protocol["response"] = types.IndexOf(sprotomgr.Types[protocol.response]);
                    }
                    else
                    {
                        meta_protocol["confirm"] = true;
                    }
                    meta_protocols.Add(meta_protocol);
                }
                group["protocol"] = meta_protocols;
            }
            SprotoStream writer = new SprotoStream();

            meta.Encode(group, writer);
            byte[] result = new byte[writer.Position];
            for (int i = 0; i < writer.Position; i++)
            {
                result[i] = writer.Buffer[i];
            }
            return(result);
        }
Esempio n. 42
0
        private Dictionary <T, SprotoObject> DecodeSprotoObjectDict <T> (SprotoMgr sprotomgr, SprotoType type, SprotoField field, SprotoStream reader)
        {
            Dictionary <T, SprotoObject> dict = new Dictionary <T, SprotoObject>();
            UInt32 size = this.ReadUInt32(reader);

            while (size > 0)
            {
                UInt32 elem_size = this.ReadUInt32(reader);
                UInt32 need_size = elem_size + SprotoCodec.SIZEOF_LENGTH;
                size = size - need_size;
                if (size < 0)
                {
                    SprotoHelper.Error("[SprotoCodec.DecodeSprotoObjectDict] fail");
                }
                SprotoObject elemobj = this.DecodeSprotoObject(sprotomgr, type, reader);
                SprotoObject keyobj  = elemobj.Get(field.key);
                T            key     = (T)keyobj.val;
                dict[key] = elemobj;
            }
            if (size != 0)
            {
                SprotoHelper.Error("[SprotoCodec.DecodeSprotoObjectDict] fail");
            }
            return(dict);
        }