Example #1
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.String)
                    {
                        SquareMid = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        Status = new NoteStatus();
                        Status.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Example #2
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Squares = new List <Square>();
                            TList _list478 = iprot.ReadListBegin();
                            for (int _i479 = 0; _i479 < _list478.Count; ++_i479)
                            {
                                Square _elem480;
                                _elem480 = new Square();
                                _elem480.Read(iprot);
                                Squares.Add(_elem480);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Map)
                    {
                        {
                            SquareStatuses = new Dictionary <string, SquareStatus>();
                            TMap _map481 = iprot.ReadMapBegin();
                            for (int _i482 = 0; _i482 < _map481.Count; ++_i482)
                            {
                                string       _key483;
                                SquareStatus _val484;
                                _key483 = iprot.ReadString();
                                _val484 = new SquareStatus();
                                _val484.Read(iprot);
                                SquareStatuses[_key483] = _val484;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Map)
                    {
                        {
                            MyMemberships = new Dictionary <string, SquareMember>();
                            TMap _map485 = iprot.ReadMapBegin();
                            for (int _i486 = 0; _i486 < _map485.Count; ++_i486)
                            {
                                string       _key487;
                                SquareMember _val488;
                                _key487 = iprot.ReadString();
                                _val488 = new SquareMember();
                                _val488.Read(iprot);
                                MyMemberships[_key487] = _val488;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.String)
                    {
                        ContinuationToken = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.Map)
                    {
                        {
                            NoteStatuses = new Dictionary <string, NoteStatus>();
                            TMap _map489 = iprot.ReadMapBegin();
                            for (int _i490 = 0; _i490 < _map489.Count; ++_i490)
                            {
                                string     _key491;
                                NoteStatus _val492;
                                _key491 = iprot.ReadString();
                                _val492 = new NoteStatus();
                                _val492.Read(iprot);
                                NoteStatuses[_key491] = _val492;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Example #3
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.Struct)
                    {
                        Square = new Square();
                        Square.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        MyMembership = new SquareMember();
                        MyMembership.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Struct)
                    {
                        SquareAuthority = new SquareAuthority();
                        SquareAuthority.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.Struct)
                    {
                        SquareStatus = new SquareStatus();
                        SquareStatus.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.Struct)
                    {
                        SquareFeatureSet = new SquareFeatureSet();
                        SquareFeatureSet.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.Struct)
                    {
                        NoteStatus = new NoteStatus();
                        NoteStatus.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Example #4
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Squares = new List <Square>();
                            TList _list384 = iprot.ReadListBegin();
                            for (int _i385 = 0; _i385 < _list384.Count; ++_i385)
                            {
                                Square _elem386;
                                _elem386 = new Square();
                                _elem386.Read(iprot);
                                Squares.Add(_elem386);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Map)
                    {
                        {
                            Members = new Dictionary <string, SquareMember>();
                            TMap _map387 = iprot.ReadMapBegin();
                            for (int _i388 = 0; _i388 < _map387.Count; ++_i388)
                            {
                                string       _key389;
                                SquareMember _val390;
                                _key389 = iprot.ReadString();
                                _val390 = new SquareMember();
                                _val390.Read(iprot);
                                Members[_key389] = _val390;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Map)
                    {
                        {
                            Authorities = new Dictionary <string, SquareAuthority>();
                            TMap _map391 = iprot.ReadMapBegin();
                            for (int _i392 = 0; _i392 < _map391.Count; ++_i392)
                            {
                                string          _key393;
                                SquareAuthority _val394;
                                _key393 = iprot.ReadString();
                                _val394 = new SquareAuthority();
                                _val394.Read(iprot);
                                Authorities[_key393] = _val394;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.Map)
                    {
                        {
                            Statuses = new Dictionary <string, SquareStatus>();
                            TMap _map395 = iprot.ReadMapBegin();
                            for (int _i396 = 0; _i396 < _map395.Count; ++_i396)
                            {
                                string       _key397;
                                SquareStatus _val398;
                                _key397 = iprot.ReadString();
                                _val398 = new SquareStatus();
                                _val398.Read(iprot);
                                Statuses[_key397] = _val398;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.String)
                    {
                        ContinuationToken = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.Map)
                    {
                        {
                            NoteStatuses = new Dictionary <string, NoteStatus>();
                            TMap _map399 = iprot.ReadMapBegin();
                            for (int _i400 = 0; _i400 < _map399.Count; ++_i400)
                            {
                                string     _key401;
                                NoteStatus _val402;
                                _key401 = iprot.ReadString();
                                _val402 = new NoteStatus();
                                _val402.Read(iprot);
                                NoteStatuses[_key401] = _val402;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Example #5
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Squares = new List <Square>();
                            TList _list390 = iprot.ReadListBegin();
                            for (int _i391 = 0; _i391 < _list390.Count; ++_i391)
                            {
                                Square _elem392;
                                _elem392 = new Square();
                                _elem392.Read(iprot);
                                Squares.Add(_elem392);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Map)
                    {
                        {
                            SquareStatuses = new Dictionary <string, SquareStatus>();
                            TMap _map393 = iprot.ReadMapBegin();
                            for (int _i394 = 0; _i394 < _map393.Count; ++_i394)
                            {
                                string       _key395;
                                SquareStatus _val396;
                                _key395 = iprot.ReadString();
                                _val396 = new SquareStatus();
                                _val396.Read(iprot);
                                SquareStatuses[_key395] = _val396;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Map)
                    {
                        {
                            MyMemberships = new Dictionary <string, SquareMember>();
                            TMap _map397 = iprot.ReadMapBegin();
                            for (int _i398 = 0; _i398 < _map397.Count; ++_i398)
                            {
                                string       _key399;
                                SquareMember _val400;
                                _key399 = iprot.ReadString();
                                _val400 = new SquareMember();
                                _val400.Read(iprot);
                                MyMemberships[_key399] = _val400;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.String)
                    {
                        ContinuationToken = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.Map)
                    {
                        {
                            NoteStatuses = new Dictionary <string, NoteStatus>();
                            TMap _map401 = iprot.ReadMapBegin();
                            for (int _i402 = 0; _i402 < _map401.Count; ++_i402)
                            {
                                string     _key403;
                                NoteStatus _val404;
                                _key403 = iprot.ReadString();
                                _val404 = new NoteStatus();
                                _val404.Read(iprot);
                                NoteStatuses[_key403] = _val404;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Example #6
0
    public void Read(TProtocol iprot)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Squares = new List <Square>();
                            TList _list296 = iprot.ReadListBegin();
                            for (int _i297 = 0; _i297 < _list296.Count; ++_i297)
                            {
                                Square _elem298;
                                _elem298 = new Square();
                                _elem298.Read(iprot);
                                Squares.Add(_elem298);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Map)
                    {
                        {
                            Members = new Dictionary <string, SquareMember>();
                            TMap _map299 = iprot.ReadMapBegin();
                            for (int _i300 = 0; _i300 < _map299.Count; ++_i300)
                            {
                                string       _key301;
                                SquareMember _val302;
                                _key301 = iprot.ReadString();
                                _val302 = new SquareMember();
                                _val302.Read(iprot);
                                Members[_key301] = _val302;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Map)
                    {
                        {
                            Authorities = new Dictionary <string, SquareAuthority>();
                            TMap _map303 = iprot.ReadMapBegin();
                            for (int _i304 = 0; _i304 < _map303.Count; ++_i304)
                            {
                                string          _key305;
                                SquareAuthority _val306;
                                _key305 = iprot.ReadString();
                                _val306 = new SquareAuthority();
                                _val306.Read(iprot);
                                Authorities[_key305] = _val306;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.Map)
                    {
                        {
                            Statuses = new Dictionary <string, SquareStatus>();
                            TMap _map307 = iprot.ReadMapBegin();
                            for (int _i308 = 0; _i308 < _map307.Count; ++_i308)
                            {
                                string       _key309;
                                SquareStatus _val310;
                                _key309 = iprot.ReadString();
                                _val310 = new SquareStatus();
                                _val310.Read(iprot);
                                Statuses[_key309] = _val310;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.String)
                    {
                        ContinuationToken = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.Map)
                    {
                        {
                            NoteStatuses = new Dictionary <string, NoteStatus>();
                            TMap _map311 = iprot.ReadMapBegin();
                            for (int _i312 = 0; _i312 < _map311.Count; ++_i312)
                            {
                                string     _key313;
                                NoteStatus _val314;
                                _key313 = iprot.ReadString();
                                _val314 = new NoteStatus();
                                _val314.Read(iprot);
                                NoteStatuses[_key313] = _val314;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }