Beispiel #1
0
 public void Read(TProtocol iprot)
 {
     TField field;
       iprot.ReadStructBegin();
       while (true)
       {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) {
       break;
     }
     switch (field.ID)
     {
       case 1:
     if (field.Type == TType.I64) {
       this.currentTime = iprot.ReadI64();
       this.__isset.currentTime = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 2:
     if (field.Type == TType.I32) {
       this.chunkHighUSN = iprot.ReadI32();
       this.__isset.chunkHighUSN = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 3:
     if (field.Type == TType.I32) {
       this.updateCount = iprot.ReadI32();
       this.__isset.updateCount = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 4:
     if (field.Type == TType.List) {
       {
         this.notes = new List<Evernote.EDAM.Type.Note>();
         TList _list0 = iprot.ReadListBegin();
         for( int _i1 = 0; _i1 < _list0.Count; ++_i1)
         {
           Evernote.EDAM.Type.Note _elem2 = new Evernote.EDAM.Type.Note();
           _elem2 = new Evernote.EDAM.Type.Note();
           _elem2.Read(iprot);
           this.notes.Add(_elem2);
         }
         iprot.ReadListEnd();
       }
       this.__isset.notes = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 5:
     if (field.Type == TType.List) {
       {
         this.notebooks = new List<Evernote.EDAM.Type.Notebook>();
         TList _list3 = iprot.ReadListBegin();
         for( int _i4 = 0; _i4 < _list3.Count; ++_i4)
         {
           Evernote.EDAM.Type.Notebook _elem5 = new Evernote.EDAM.Type.Notebook();
           _elem5 = new Evernote.EDAM.Type.Notebook();
           _elem5.Read(iprot);
           this.notebooks.Add(_elem5);
         }
         iprot.ReadListEnd();
       }
       this.__isset.notebooks = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 6:
     if (field.Type == TType.List) {
       {
         this.tags = new List<Evernote.EDAM.Type.Tag>();
         TList _list6 = iprot.ReadListBegin();
         for( int _i7 = 0; _i7 < _list6.Count; ++_i7)
         {
           Evernote.EDAM.Type.Tag _elem8 = new Evernote.EDAM.Type.Tag();
           _elem8 = new Evernote.EDAM.Type.Tag();
           _elem8.Read(iprot);
           this.tags.Add(_elem8);
         }
         iprot.ReadListEnd();
       }
       this.__isset.tags = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 7:
     if (field.Type == TType.List) {
       {
         this.searches = new List<Evernote.EDAM.Type.SavedSearch>();
         TList _list9 = iprot.ReadListBegin();
         for( int _i10 = 0; _i10 < _list9.Count; ++_i10)
         {
           Evernote.EDAM.Type.SavedSearch _elem11 = new Evernote.EDAM.Type.SavedSearch();
           _elem11 = new Evernote.EDAM.Type.SavedSearch();
           _elem11.Read(iprot);
           this.searches.Add(_elem11);
         }
         iprot.ReadListEnd();
       }
       this.__isset.searches = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 8:
     if (field.Type == TType.List) {
       {
         this.resources = new List<Evernote.EDAM.Type.Resource>();
         TList _list12 = iprot.ReadListBegin();
         for( int _i13 = 0; _i13 < _list12.Count; ++_i13)
         {
           Evernote.EDAM.Type.Resource _elem14 = new Evernote.EDAM.Type.Resource();
           _elem14 = new Evernote.EDAM.Type.Resource();
           _elem14.Read(iprot);
           this.resources.Add(_elem14);
         }
         iprot.ReadListEnd();
       }
       this.__isset.resources = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 9:
     if (field.Type == TType.List) {
       {
         this.expungedNotes = new List<string>();
         TList _list15 = iprot.ReadListBegin();
         for( int _i16 = 0; _i16 < _list15.Count; ++_i16)
         {
           string _elem17 = null;
           _elem17 = iprot.ReadString();
           this.expungedNotes.Add(_elem17);
         }
         iprot.ReadListEnd();
       }
       this.__isset.expungedNotes = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 10:
     if (field.Type == TType.List) {
       {
         this.expungedNotebooks = new List<string>();
         TList _list18 = iprot.ReadListBegin();
         for( int _i19 = 0; _i19 < _list18.Count; ++_i19)
         {
           string _elem20 = null;
           _elem20 = iprot.ReadString();
           this.expungedNotebooks.Add(_elem20);
         }
         iprot.ReadListEnd();
       }
       this.__isset.expungedNotebooks = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 11:
     if (field.Type == TType.List) {
       {
         this.expungedTags = new List<string>();
         TList _list21 = iprot.ReadListBegin();
         for( int _i22 = 0; _i22 < _list21.Count; ++_i22)
         {
           string _elem23 = null;
           _elem23 = iprot.ReadString();
           this.expungedTags.Add(_elem23);
         }
         iprot.ReadListEnd();
       }
       this.__isset.expungedTags = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 12:
     if (field.Type == TType.List) {
       {
         this.expungedSearches = new List<string>();
         TList _list24 = iprot.ReadListBegin();
         for( int _i25 = 0; _i25 < _list24.Count; ++_i25)
         {
           string _elem26 = null;
           _elem26 = iprot.ReadString();
           this.expungedSearches.Add(_elem26);
         }
         iprot.ReadListEnd();
       }
       this.__isset.expungedSearches = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       default:
     TProtocolUtil.Skip(iprot, field.Type);
     break;
     }
     iprot.ReadFieldEnd();
       }
       iprot.ReadStructEnd();
 }
 public void Read (TProtocol iprot)
 {
   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) {
           AuthenticationToken = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.Struct) {
           Resource = new Evernote.EDAM.Type.Resource();
           Resource.Read(iprot);
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 public void Read (TProtocol iprot)
 {
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 0:
         if (field.Type == TType.Struct) {
           Success = new Evernote.EDAM.Type.Resource();
           Success.Read(iprot);
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 1:
         if (field.Type == TType.Struct) {
           UserException = new Evernote.EDAM.Error.EDAMUserException();
           UserException.Read(iprot);
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.Struct) {
           SystemException = new Evernote.EDAM.Error.EDAMSystemException();
           SystemException.Read(iprot);
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 3:
         if (field.Type == TType.Struct) {
           NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
           NotFoundException.Read(iprot);
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
        public void Read(TProtocol iprot)
        {
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.I64)
                    {
                        CurrentTime = iprot.ReadI64();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.I32)
                    {
                        ChunkHighUSN = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.I32)
                    {
                        UpdateCount = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.List)
                    {
                        {
                            Notes = new List <Evernote.EDAM.Type.Note>();
                            TList _list0 = iprot.ReadListBegin();
                            for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
                            {
                                Evernote.EDAM.Type.Note _elem2 = new Evernote.EDAM.Type.Note();
                                _elem2 = new Evernote.EDAM.Type.Note();
                                _elem2.Read(iprot);
                                Notes.Add(_elem2);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.List)
                    {
                        {
                            Notebooks = new List <Evernote.EDAM.Type.Notebook>();
                            TList _list3 = iprot.ReadListBegin();
                            for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
                            {
                                Evernote.EDAM.Type.Notebook _elem5 = new Evernote.EDAM.Type.Notebook();
                                _elem5 = new Evernote.EDAM.Type.Notebook();
                                _elem5.Read(iprot);
                                Notebooks.Add(_elem5);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.List)
                    {
                        {
                            Tags = new List <Evernote.EDAM.Type.Tag>();
                            TList _list6 = iprot.ReadListBegin();
                            for (int _i7 = 0; _i7 < _list6.Count; ++_i7)
                            {
                                Evernote.EDAM.Type.Tag _elem8 = new Evernote.EDAM.Type.Tag();
                                _elem8 = new Evernote.EDAM.Type.Tag();
                                _elem8.Read(iprot);
                                Tags.Add(_elem8);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 7:
                    if (field.Type == TType.List)
                    {
                        {
                            Searches = new List <Evernote.EDAM.Type.SavedSearch>();
                            TList _list9 = iprot.ReadListBegin();
                            for (int _i10 = 0; _i10 < _list9.Count; ++_i10)
                            {
                                Evernote.EDAM.Type.SavedSearch _elem11 = new Evernote.EDAM.Type.SavedSearch();
                                _elem11 = new Evernote.EDAM.Type.SavedSearch();
                                _elem11.Read(iprot);
                                Searches.Add(_elem11);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 8:
                    if (field.Type == TType.List)
                    {
                        {
                            Resources = new List <Evernote.EDAM.Type.Resource>();
                            TList _list12 = iprot.ReadListBegin();
                            for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
                            {
                                Evernote.EDAM.Type.Resource _elem14 = new Evernote.EDAM.Type.Resource();
                                _elem14 = new Evernote.EDAM.Type.Resource();
                                _elem14.Read(iprot);
                                Resources.Add(_elem14);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 9:
                    if (field.Type == TType.List)
                    {
                        {
                            ExpungedNotes = new List <string>();
                            TList _list15 = iprot.ReadListBegin();
                            for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
                            {
                                string _elem17 = null;
                                _elem17 = iprot.ReadString();
                                ExpungedNotes.Add(_elem17);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 10:
                    if (field.Type == TType.List)
                    {
                        {
                            ExpungedNotebooks = new List <string>();
                            TList _list18 = iprot.ReadListBegin();
                            for (int _i19 = 0; _i19 < _list18.Count; ++_i19)
                            {
                                string _elem20 = null;
                                _elem20 = iprot.ReadString();
                                ExpungedNotebooks.Add(_elem20);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 11:
                    if (field.Type == TType.List)
                    {
                        {
                            ExpungedTags = new List <string>();
                            TList _list21 = iprot.ReadListBegin();
                            for (int _i22 = 0; _i22 < _list21.Count; ++_i22)
                            {
                                string _elem23 = null;
                                _elem23 = iprot.ReadString();
                                ExpungedTags.Add(_elem23);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 12:
                    if (field.Type == TType.List)
                    {
                        {
                            ExpungedSearches = new List <string>();
                            TList _list24 = iprot.ReadListBegin();
                            for (int _i25 = 0; _i25 < _list24.Count; ++_i25)
                            {
                                string _elem26 = null;
                                _elem26 = iprot.ReadString();
                                ExpungedSearches.Add(_elem26);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 13:
                    if (field.Type == TType.List)
                    {
                        {
                            LinkedNotebooks = new List <Evernote.EDAM.Type.LinkedNotebook>();
                            TList _list27 = iprot.ReadListBegin();
                            for (int _i28 = 0; _i28 < _list27.Count; ++_i28)
                            {
                                Evernote.EDAM.Type.LinkedNotebook _elem29 = new Evernote.EDAM.Type.LinkedNotebook();
                                _elem29 = new Evernote.EDAM.Type.LinkedNotebook();
                                _elem29.Read(iprot);
                                LinkedNotebooks.Add(_elem29);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 14:
                    if (field.Type == TType.List)
                    {
                        {
                            ExpungedLinkedNotebooks = new List <string>();
                            TList _list30 = iprot.ReadListBegin();
                            for (int _i31 = 0; _i31 < _list30.Count; ++_i31)
                            {
                                string _elem32 = null;
                                _elem32 = iprot.ReadString();
                                ExpungedLinkedNotebooks.Add(_elem32);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

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