Example #1
0
        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);
        }
Example #2
0
 public SpRpcResult()
 {
     Session  = 0;
     Protocol = null;
     Op       = SpRpcOp.Unknown;
     Arg      = null;
 }
Example #3
0
 public SpRpcResult(int s, SpProtocol p, SpRpcOp o, SpObject a)
 {
     Session  = s;
     Protocol = p;
     Op       = o;
     Arg      = a;
 }
Example #4
0
        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));
        }
Example #5
0
 public void Append(SpObject obj)
 {
     if (IsTable() == false)
     {
         mType  = ArgType.Table;
         mValue = new Dictionary <object, SpObject>();
     }
     Insert(AsTable().Count, obj);
 }
Example #6
0
 public void Insert(object key, SpObject obj)
 {
     if (IsTable() == false)
     {
         mType  = ArgType.Table;
         mValue = new Dictionary <object, SpObject>();
     }
     AsTable()[key] = obj;
 }
Example #7
0
        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);
        }
Example #8
0
        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));
            }
        }
Example #9
0
        private bool IsTypeMatch(SpField f, SpObject o)
        {
            if (f == null || f.Type == null || o == null)
            {
                return(false);
            }

            if (f.IsTable && o.IsTable())
            {
                return(true);
            }
            else if (f.Type == mTypeManager.String)
            {
                if (o.IsString())
                {
                    return(true);
                }
            }
            else if (f.Type == mTypeManager.Boolean)
            {
                if (o.IsBoolean())
                {
                    return(true);
                }
            }
            else if (f.Type == mTypeManager.Integer)
            {
                if (o.IsInt() || o.IsLong())
                {
                    return(true);
                }
            }
            else if (o.IsTable())
            {
                return(true);
            }

            return(false);
        }
Example #10
0
        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);
        }
Example #11
0
 public SpStream Encode(string proto, SpObject obj)
 {
     return(Encode(mTypeManager.GetType(proto), obj));
 }
Example #12
0
        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);
        }
Example #13
0
 public bool Encode(string proto, SpObject obj, byte[] buffer, int offset, int size)
 {
     return(Encode(proto, obj, new SpStream(buffer, offset, size)));
 }
Example #14
0
        private SpObject DecodeInternal(SpType type)
        {
            if (mStream == null || type == null)
            {
                return(null);
            }

            // buildin type decoding should not be here
            if (mTypeManager.IsBuildinType(type))
            {
                return(null);
            }

            SpObject obj = new SpObject();

            List <int> tags        = new List <int>();
            int        current_tag = 0;

            short fn = mStream.ReadInt16();

            for (short i = 0; i < fn; i++)
            {
                int value = (int)mStream.ReadUInt16();

                if (value == 0)
                {
                    tags.Add(current_tag);
                    current_tag++;
                }
                else
                {
                    if (value % 2 == 0)
                    {
                        SpField f = type.GetFieldByTag(current_tag);
                        if (f == null)
                        {
                            return(null);
                        }

                        value = value / 2 - 1;
                        if (f.Type == mTypeManager.Integer)
                        {
                            obj.Insert(f.Name, value);
                        }
                        else if (f.Type == mTypeManager.Boolean)
                        {
                            obj.Insert(f.Name, (value == 0 ? false : true));
                        }
                        else
                        {
                            return(null);
                        }
                        current_tag++;
                    }
                    else
                    {
                        current_tag += (value + 1) / 2;
                    }
                }
            }

            for (int c = 0; c < tags.Count; c++)
            {
                int tag = tags[c];

                SpField f = type.GetFieldByTag(tag);
                if (f == null)
                {
                    return(null);
                }

                if (f.IsTable)
                {
                    int size = mStream.ReadInt32();

                    if (f.Type == mTypeManager.Integer)
                    {
                        byte n     = mStream.ReadByte();
                        int  count = (size - 1) / n;

                        SpObject tbl = new SpObject();
                        for (int i = 0; i < count; i++)
                        {
                            switch (n)
                            {
                            case 4:
                                tbl.Insert(i, mStream.ReadInt32());
                                break;

                            case 8:
                                tbl.Insert(i, mStream.ReadInt64());
                                break;

                            default:
                                return(null);
                            }
                        }
                        obj.Insert(f.Name, tbl);
                    }
                    else if (f.Type == mTypeManager.Boolean)
                    {
                        SpObject tbl = new SpObject();
                        for (int i = 0; i < size; i++)
                        {
                            tbl.Insert(i, mStream.ReadBoolean());
                        }
                        obj.Insert(f.Name, tbl);
                    }
                    else if (f.Type == mTypeManager.String)
                    {
                        SpObject tbl = new SpObject();
                        int      k   = 0;
                        while (size > 0)
                        {
                            int str_len = mStream.ReadInt32();
                            size -= 4;
                            tbl.Insert(k, Encoding.UTF8.GetString(mStream.ReadBytes(str_len), 0, str_len));
                            k++;
                            size -= str_len;
                        }
                        obj.Insert(f.Name, tbl);
                    }
                    else if (f.Type == null)
                    {
                        // unknown type
                        mStream.ReadBytes(size);
                    }
                    else
                    {
                        SpObject tbl = new SpObject();
                        int      k   = 0;
                        while (size > 0)
                        {
                            int obj_len = mStream.ReadInt32();
                            size -= 4;

                            SpObject o = DecodeInternal(f.Type);
                            if (f.KeyName != null)
                            {
                                tbl.Insert(o.AsTable()[f.KeyName].Value, o);
                            }
                            else
                            {
                                tbl.Insert(k, o);
                            }
                            k++;
                            size -= obj_len;
                        }
                        obj.Insert(f.Name, tbl);
                    }
                }
                else
                {
                    int size = mStream.ReadInt32();

                    if (f.Type == mTypeManager.Integer)
                    {
                        switch (size)
                        {
                        case 4:
                            obj.Insert(f.Name, mStream.ReadInt32());
                            break;

                        case 8:
                            obj.Insert(f.Name, mStream.ReadInt64());
                            break;

                        default:
                            return(null);
                        }
                    }
                    else if (f.Type == mTypeManager.Boolean)
                    {
                        // boolean should not be here
                        return(null);
                    }
                    else if (f.Type == mTypeManager.String)
                    {
                        obj.Insert(f.Name, Encoding.UTF8.GetString(mStream.ReadBytes(size), 0, size));
                    }
                    else if (f.Type == null)
                    {
                        // unknown type
                        mStream.ReadBytes(size);
                    }
                    else
                    {
                        obj.Insert(f.Name, DecodeInternal(f.Type));
                    }
                }
            }

            return(obj);
        }
Example #15
0
 public SpStream Request(string proto, SpObject args)
 {
     return(Request(proto, args, 0));
 }
Example #16
0
 public bool Encode(string proto, SpObject obj, SpStream stream)
 {
     return(Encode(mTypeManager.GetType(proto), obj, stream));
 }
Example #17
0
        private bool EncodeInternal(SpType type, SpObject obj)
        {
            if (mStream == null || type == null || obj == null)
            {
                return(false);
            }

            // buildin type decoding should not be here
            if (mTypeManager.IsBuildinType(type))
            {
                return(false);
            }

            int begin = mStream.Position;

            // fn. will be update later
            short fn = 0;

            mStream.Write(fn);

            List <KeyValuePair <SpObject, SpField> > objs = new List <KeyValuePair <SpObject, SpField> >();
            int current_tag = -1;

            Dictionary <int, SpField> .ValueCollection.Enumerator en = type.Fields.Values.GetEnumerator();
            while (en.MoveNext())
            {
                SpField f = en.Current;

                if (f == null)
                {
                    return(false);
                }

                SpObject o = obj[f.Name];
                if (o == null || IsTypeMatch(f, o) == false)
                {
                    continue;
                }

                if (f.Tag <= current_tag)
                {
                    return(false);
                }

                if (f.Tag - current_tag > 1)
                {
                    mStream.Write((short)(2 * (f.Tag - current_tag - 1) - 1));
                    fn++;
                }

                bool standalone = true;
                if (f.IsTable == false)
                {
                    if (f.Type == mTypeManager.Boolean)
                    {
                        int value = o.AsBoolean() ? 1 : 0;
                        mStream.Write((short)((value + 1) * 2));
                        standalone = false;
                    }
                    else if (f.Type == mTypeManager.Integer)
                    {
                        int value = o.AsInt();
                        if (value >= 0 && value < 0x7fff)
                        {
                            mStream.Write((short)((value + 1) * 2));
                            standalone = false;
                        }
                    }
                }

                if (standalone)
                {
                    objs.Add(new KeyValuePair <SpObject, SpField>(o, f));
                    mStream.Write((short)0);
                }

                fn++;
                current_tag = f.Tag;
            }

            List <KeyValuePair <SpObject, SpField> > .Enumerator e = objs.GetEnumerator();
            while (e.MoveNext())
            {
                KeyValuePair <SpObject, SpField> entry = e.Current;

                if (entry.Value.IsTable)
                {
                    int array_begin = mStream.Position;
                    int size        = 0;
                    mStream.Write(size);

                    if (entry.Value.Type == mTypeManager.Integer)
                    {
                        byte len = 4;

                        Dictionary <object, SpObject> .Enumerator enumerator = entry.Key.AsTable().GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            SpObject o = enumerator.Current.Value;
                            if (o.IsLong())
                            {
                                len = 8;
                                break;
                            }
                        }

                        mStream.Write(len);
                        enumerator = entry.Key.AsTable().GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            SpObject o = enumerator.Current.Value;
                            if (len == 4)
                            {
                                mStream.Write(o.AsInt());
                            }
                            else
                            {
                                mStream.Write(o.AsLong());
                            }
                        }
                    }
                    else if (entry.Value.Type == mTypeManager.Boolean)
                    {
                        Dictionary <object, SpObject> .Enumerator enumerator = entry.Key.AsTable().GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            SpObject o = enumerator.Current.Value;
                            mStream.Write((byte)(o.AsBoolean() ? 1 : 0));
                        }
                    }
                    else if (entry.Value.Type == mTypeManager.String)
                    {
                        Dictionary <object, SpObject> .Enumerator enumerator = entry.Key.AsTable().GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            SpObject o = enumerator.Current.Value;
                            byte[]   b = Encoding.UTF8.GetBytes(o.AsString());
                            mStream.Write(b.Length);
                            mStream.Write(b);
                        }
                    }
                    else
                    {
                        Dictionary <object, SpObject> .Enumerator enumerator = entry.Key.AsTable().GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            SpObject o = enumerator.Current.Value;

                            int obj_begin = mStream.Position;
                            int obj_size  = 0;
                            mStream.Write(obj_size);

                            if (EncodeInternal(entry.Value.Type, o) == false)
                            {
                                return(false);
                            }

                            int obj_end = mStream.Position;
                            obj_size         = (int)(obj_end - obj_begin - 4);
                            mStream.Position = obj_begin;
                            mStream.Write(obj_size);
                            mStream.Position = obj_end;
                        }
                    }

                    int array_end = mStream.Position;
                    size             = (int)(array_end - array_begin - 4);
                    mStream.Position = array_begin;
                    mStream.Write(size);
                    mStream.Position = array_end;
                }
                else
                {
                    if (entry.Key.IsString())
                    {
                        byte[] b = Encoding.UTF8.GetBytes(entry.Key.AsString());
                        mStream.Write(b.Length);
                        mStream.Write(b);
                    }
                    else if (entry.Key.IsInt())
                    {
                        mStream.Write((int)4);
                        mStream.Write(entry.Key.AsInt());
                    }
                    else if (entry.Key.IsLong())
                    {
                        mStream.Write((int)8);
                        mStream.Write(entry.Key.AsLong());
                    }
                    else if (entry.Key.IsBoolean())
                    {
                        // boolean should not be here
                        return(false);
                    }
                    else
                    {
                        int obj_begin = mStream.Position;
                        int obj_size  = 0;
                        mStream.Write(obj_size);

                        if (EncodeInternal(entry.Value.Type, entry.Key) == false)
                        {
                            return(false);
                        }

                        int obj_end = mStream.Position;
                        obj_size         = (int)(obj_end - obj_begin - 4);
                        mStream.Position = obj_begin;
                        mStream.Write(obj_size);
                        mStream.Position = obj_end;
                    }
                }
            }

            int end = mStream.Position;

            mStream.Position = begin;
            mStream.Write(fn);
            mStream.Position = end;

            return(true);
        }
Example #18
0
 public bool Encode(string proto, SpObject obj, byte[] buffer)
 {
     return(Encode(proto, obj, buffer, 0, buffer.Length));
 }