Subversion Repositories SmartDukaan

Rev

Rev 4910 | Rev 4999 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4910 Rev 4983
Line 11776... Line 11776...
11776
        }
11776
        }
11777
        switch (field.id) {
11777
        switch (field.id) {
11778
          case 0: // SUCCESS
11778
          case 0: // SUCCESS
11779
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11779
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11780
              {
11780
              {
11781
                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
11781
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
11782
                this.success = new ArrayList<Transaction>(_list24.size);
11782
                this.success = new ArrayList<Transaction>(_list32.size);
11783
                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
11783
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
11784
                {
11784
                {
11785
                  Transaction _elem26; // required
11785
                  Transaction _elem34; // required
11786
                  _elem26 = new Transaction();
11786
                  _elem34 = new Transaction();
11787
                  _elem26.read(iprot);
11787
                  _elem34.read(iprot);
11788
                  this.success.add(_elem26);
11788
                  this.success.add(_elem34);
11789
                }
11789
                }
11790
                iprot.readListEnd();
11790
                iprot.readListEnd();
11791
              }
11791
              }
11792
            } else { 
11792
            } else { 
11793
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
11793
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11815... Line 11815...
11815
 
11815
 
11816
      if (this.isSetSuccess()) {
11816
      if (this.isSetSuccess()) {
11817
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11817
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11818
        {
11818
        {
11819
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
11819
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
11820
          for (Transaction _iter27 : this.success)
11820
          for (Transaction _iter35 : this.success)
11821
          {
11821
          {
11822
            _iter27.write(oprot);
11822
            _iter35.write(oprot);
11823
          }
11823
          }
11824
          oprot.writeListEnd();
11824
          oprot.writeListEnd();
11825
        }
11825
        }
11826
        oprot.writeFieldEnd();
11826
        oprot.writeFieldEnd();
11827
      } else if (this.isSetEx()) {
11827
      } else if (this.isSetEx()) {
Line 12489... Line 12489...
12489
        }
12489
        }
12490
        switch (field.id) {
12490
        switch (field.id) {
12491
          case 0: // SUCCESS
12491
          case 0: // SUCCESS
12492
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
12492
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
12493
              {
12493
              {
12494
                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
12494
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
12495
                this.success = new ArrayList<Transaction>(_list28.size);
12495
                this.success = new ArrayList<Transaction>(_list36.size);
12496
                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
12496
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
12497
                {
12497
                {
12498
                  Transaction _elem30; // required
12498
                  Transaction _elem38; // required
12499
                  _elem30 = new Transaction();
12499
                  _elem38 = new Transaction();
12500
                  _elem30.read(iprot);
12500
                  _elem38.read(iprot);
12501
                  this.success.add(_elem30);
12501
                  this.success.add(_elem38);
12502
                }
12502
                }
12503
                iprot.readListEnd();
12503
                iprot.readListEnd();
12504
              }
12504
              }
12505
            } else { 
12505
            } else { 
12506
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
12506
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 12528... Line 12528...
12528
 
12528
 
12529
      if (this.isSetSuccess()) {
12529
      if (this.isSetSuccess()) {
12530
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12530
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12531
        {
12531
        {
12532
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
12532
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
12533
          for (Transaction _iter31 : this.success)
12533
          for (Transaction _iter39 : this.success)
12534
          {
12534
          {
12535
            _iter31.write(oprot);
12535
            _iter39.write(oprot);
12536
          }
12536
          }
12537
          oprot.writeListEnd();
12537
          oprot.writeListEnd();
12538
        }
12538
        }
12539
        oprot.writeFieldEnd();
12539
        oprot.writeFieldEnd();
12540
      } else if (this.isSetEx()) {
12540
      } else if (this.isSetEx()) {
Line 15272... Line 15272...
15272
        }
15272
        }
15273
        switch (field.id) {
15273
        switch (field.id) {
15274
          case 1: // STATUSES
15274
          case 1: // STATUSES
15275
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
15275
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
15276
              {
15276
              {
15277
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
15277
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
15278
                this.statuses = new ArrayList<OrderStatus>(_list32.size);
15278
                this.statuses = new ArrayList<OrderStatus>(_list40.size);
15279
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
15279
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
15280
                {
15280
                {
15281
                  OrderStatus _elem34; // required
15281
                  OrderStatus _elem42; // required
15282
                  _elem34 = OrderStatus.findByValue(iprot.readI32());
15282
                  _elem42 = OrderStatus.findByValue(iprot.readI32());
15283
                  this.statuses.add(_elem34);
15283
                  this.statuses.add(_elem42);
15284
                }
15284
                }
15285
                iprot.readListEnd();
15285
                iprot.readListEnd();
15286
              }
15286
              }
15287
            } else { 
15287
            } else { 
15288
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
15288
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 15327... Line 15327...
15327
      oprot.writeStructBegin(STRUCT_DESC);
15327
      oprot.writeStructBegin(STRUCT_DESC);
15328
      if (this.statuses != null) {
15328
      if (this.statuses != null) {
15329
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
15329
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
15330
        {
15330
        {
15331
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
15331
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
15332
          for (OrderStatus _iter35 : this.statuses)
15332
          for (OrderStatus _iter43 : this.statuses)
15333
          {
15333
          {
15334
            oprot.writeI32(_iter35.getValue());
15334
            oprot.writeI32(_iter43.getValue());
15335
          }
15335
          }
15336
          oprot.writeListEnd();
15336
          oprot.writeListEnd();
15337
        }
15337
        }
15338
        oprot.writeFieldEnd();
15338
        oprot.writeFieldEnd();
15339
      }
15339
      }
Line 15718... Line 15718...
15718
        }
15718
        }
15719
        switch (field.id) {
15719
        switch (field.id) {
15720
          case 0: // SUCCESS
15720
          case 0: // SUCCESS
15721
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
15721
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
15722
              {
15722
              {
15723
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
15723
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
15724
                this.success = new ArrayList<Order>(_list36.size);
15724
                this.success = new ArrayList<Order>(_list44.size);
15725
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
15725
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
15726
                {
15726
                {
15727
                  Order _elem38; // required
15727
                  Order _elem46; // required
15728
                  _elem38 = new Order();
15728
                  _elem46 = new Order();
15729
                  _elem38.read(iprot);
15729
                  _elem46.read(iprot);
15730
                  this.success.add(_elem38);
15730
                  this.success.add(_elem46);
15731
                }
15731
                }
15732
                iprot.readListEnd();
15732
                iprot.readListEnd();
15733
              }
15733
              }
15734
            } else { 
15734
            } else { 
15735
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
15735
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 15757... Line 15757...
15757
 
15757
 
15758
      if (this.isSetSuccess()) {
15758
      if (this.isSetSuccess()) {
15759
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15759
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15760
        {
15760
        {
15761
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
15761
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
15762
          for (Order _iter39 : this.success)
15762
          for (Order _iter47 : this.success)
15763
          {
15763
          {
15764
            _iter39.write(oprot);
15764
            _iter47.write(oprot);
15765
          }
15765
          }
15766
          oprot.writeListEnd();
15766
          oprot.writeListEnd();
15767
        }
15767
        }
15768
        oprot.writeFieldEnd();
15768
        oprot.writeFieldEnd();
15769
      } else if (this.isSetEx()) {
15769
      } else if (this.isSetEx()) {
Line 16276... Line 16276...
16276
        }
16276
        }
16277
        switch (field.id) {
16277
        switch (field.id) {
16278
          case 1: // STATUSES
16278
          case 1: // STATUSES
16279
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16279
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16280
              {
16280
              {
16281
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
16281
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
16282
                this.statuses = new ArrayList<OrderStatus>(_list40.size);
16282
                this.statuses = new ArrayList<OrderStatus>(_list48.size);
16283
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
16283
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
16284
                {
16284
                {
16285
                  OrderStatus _elem42; // required
16285
                  OrderStatus _elem50; // required
16286
                  _elem42 = OrderStatus.findByValue(iprot.readI32());
16286
                  _elem50 = OrderStatus.findByValue(iprot.readI32());
16287
                  this.statuses.add(_elem42);
16287
                  this.statuses.add(_elem50);
16288
                }
16288
                }
16289
                iprot.readListEnd();
16289
                iprot.readListEnd();
16290
              }
16290
              }
16291
            } else { 
16291
            } else { 
16292
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
16292
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 16331... Line 16331...
16331
      oprot.writeStructBegin(STRUCT_DESC);
16331
      oprot.writeStructBegin(STRUCT_DESC);
16332
      if (this.statuses != null) {
16332
      if (this.statuses != null) {
16333
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
16333
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
16334
        {
16334
        {
16335
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
16335
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
16336
          for (OrderStatus _iter43 : this.statuses)
16336
          for (OrderStatus _iter51 : this.statuses)
16337
          {
16337
          {
16338
            oprot.writeI32(_iter43.getValue());
16338
            oprot.writeI32(_iter51.getValue());
16339
          }
16339
          }
16340
          oprot.writeListEnd();
16340
          oprot.writeListEnd();
16341
        }
16341
        }
16342
        oprot.writeFieldEnd();
16342
        oprot.writeFieldEnd();
16343
      }
16343
      }
Line 16720... Line 16720...
16720
        }
16720
        }
16721
        switch (field.id) {
16721
        switch (field.id) {
16722
          case 0: // SUCCESS
16722
          case 0: // SUCCESS
16723
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16723
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16724
              {
16724
              {
16725
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
16725
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
16726
                this.success = new ArrayList<Order>(_list44.size);
16726
                this.success = new ArrayList<Order>(_list52.size);
16727
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
16727
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
16728
                {
16728
                {
16729
                  Order _elem46; // required
16729
                  Order _elem54; // required
16730
                  _elem46 = new Order();
16730
                  _elem54 = new Order();
16731
                  _elem46.read(iprot);
16731
                  _elem54.read(iprot);
16732
                  this.success.add(_elem46);
16732
                  this.success.add(_elem54);
16733
                }
16733
                }
16734
                iprot.readListEnd();
16734
                iprot.readListEnd();
16735
              }
16735
              }
16736
            } else { 
16736
            } else { 
16737
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
16737
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 16759... Line 16759...
16759
 
16759
 
16760
      if (this.isSetSuccess()) {
16760
      if (this.isSetSuccess()) {
16761
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16761
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16762
        {
16762
        {
16763
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
16763
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
16764
          for (Order _iter47 : this.success)
16764
          for (Order _iter55 : this.success)
16765
          {
16765
          {
16766
            _iter47.write(oprot);
16766
            _iter55.write(oprot);
16767
          }
16767
          }
16768
          oprot.writeListEnd();
16768
          oprot.writeListEnd();
16769
        }
16769
        }
16770
        oprot.writeFieldEnd();
16770
        oprot.writeFieldEnd();
16771
      } else if (this.isSetEx()) {
16771
      } else if (this.isSetEx()) {
Line 17142... Line 17142...
17142
        }
17142
        }
17143
        switch (field.id) {
17143
        switch (field.id) {
17144
          case 1: // STATUSES
17144
          case 1: // STATUSES
17145
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17145
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17146
              {
17146
              {
17147
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
17147
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
17148
                this.statuses = new ArrayList<OrderStatus>(_list48.size);
17148
                this.statuses = new ArrayList<OrderStatus>(_list56.size);
17149
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
17149
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
17150
                {
17150
                {
17151
                  OrderStatus _elem50; // required
17151
                  OrderStatus _elem58; // required
17152
                  _elem50 = OrderStatus.findByValue(iprot.readI32());
17152
                  _elem58 = OrderStatus.findByValue(iprot.readI32());
17153
                  this.statuses.add(_elem50);
17153
                  this.statuses.add(_elem58);
17154
                }
17154
                }
17155
                iprot.readListEnd();
17155
                iprot.readListEnd();
17156
              }
17156
              }
17157
            } else { 
17157
            } else { 
17158
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
17158
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17181... Line 17181...
17181
      oprot.writeStructBegin(STRUCT_DESC);
17181
      oprot.writeStructBegin(STRUCT_DESC);
17182
      if (this.statuses != null) {
17182
      if (this.statuses != null) {
17183
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
17183
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
17184
        {
17184
        {
17185
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
17185
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
17186
          for (OrderStatus _iter51 : this.statuses)
17186
          for (OrderStatus _iter59 : this.statuses)
17187
          {
17187
          {
17188
            oprot.writeI32(_iter51.getValue());
17188
            oprot.writeI32(_iter59.getValue());
17189
          }
17189
          }
17190
          oprot.writeListEnd();
17190
          oprot.writeListEnd();
17191
        }
17191
        }
17192
        oprot.writeFieldEnd();
17192
        oprot.writeFieldEnd();
17193
      }
17193
      }
Line 18497... Line 18497...
18497
        }
18497
        }
18498
        switch (field.id) {
18498
        switch (field.id) {
18499
          case 0: // SUCCESS
18499
          case 0: // SUCCESS
18500
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18500
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18501
              {
18501
              {
18502
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
18502
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
18503
                this.success = new ArrayList<Order>(_list52.size);
18503
                this.success = new ArrayList<Order>(_list60.size);
18504
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
18504
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
18505
                {
18505
                {
18506
                  Order _elem54; // required
18506
                  Order _elem62; // required
18507
                  _elem54 = new Order();
18507
                  _elem62 = new Order();
18508
                  _elem54.read(iprot);
18508
                  _elem62.read(iprot);
18509
                  this.success.add(_elem54);
18509
                  this.success.add(_elem62);
18510
                }
18510
                }
18511
                iprot.readListEnd();
18511
                iprot.readListEnd();
18512
              }
18512
              }
18513
            } else { 
18513
            } else { 
18514
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
18514
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 18536... Line 18536...
18536
 
18536
 
18537
      if (this.isSetSuccess()) {
18537
      if (this.isSetSuccess()) {
18538
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18538
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18539
        {
18539
        {
18540
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18540
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18541
          for (Order _iter55 : this.success)
18541
          for (Order _iter63 : this.success)
18542
          {
18542
          {
18543
            _iter55.write(oprot);
18543
            _iter63.write(oprot);
18544
          }
18544
          }
18545
          oprot.writeListEnd();
18545
          oprot.writeListEnd();
18546
        }
18546
        }
18547
        oprot.writeFieldEnd();
18547
        oprot.writeFieldEnd();
18548
      } else if (this.isSetEx()) {
18548
      } else if (this.isSetEx()) {
Line 19540... Line 19540...
19540
        }
19540
        }
19541
        switch (field.id) {
19541
        switch (field.id) {
19542
          case 0: // SUCCESS
19542
          case 0: // SUCCESS
19543
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19543
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19544
              {
19544
              {
19545
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
19545
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
19546
                this.success = new ArrayList<Order>(_list56.size);
19546
                this.success = new ArrayList<Order>(_list64.size);
19547
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
19547
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
19548
                {
19548
                {
19549
                  Order _elem58; // required
19549
                  Order _elem66; // required
19550
                  _elem58 = new Order();
19550
                  _elem66 = new Order();
19551
                  _elem58.read(iprot);
19551
                  _elem66.read(iprot);
19552
                  this.success.add(_elem58);
19552
                  this.success.add(_elem66);
19553
                }
19553
                }
19554
                iprot.readListEnd();
19554
                iprot.readListEnd();
19555
              }
19555
              }
19556
            } else { 
19556
            } else { 
19557
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
19557
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 19579... Line 19579...
19579
 
19579
 
19580
      if (this.isSetSuccess()) {
19580
      if (this.isSetSuccess()) {
19581
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19581
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19582
        {
19582
        {
19583
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19583
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19584
          for (Order _iter59 : this.success)
19584
          for (Order _iter67 : this.success)
19585
          {
19585
          {
19586
            _iter59.write(oprot);
19586
            _iter67.write(oprot);
19587
          }
19587
          }
19588
          oprot.writeListEnd();
19588
          oprot.writeListEnd();
19589
        }
19589
        }
19590
        oprot.writeFieldEnd();
19590
        oprot.writeFieldEnd();
19591
      } else if (this.isSetEx()) {
19591
      } else if (this.isSetEx()) {
Line 20336... Line 20336...
20336
        }
20336
        }
20337
        switch (field.id) {
20337
        switch (field.id) {
20338
          case 0: // SUCCESS
20338
          case 0: // SUCCESS
20339
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20339
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20340
              {
20340
              {
20341
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
20341
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
20342
                this.success = new ArrayList<Long>(_list60.size);
20342
                this.success = new ArrayList<Long>(_list68.size);
20343
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
20343
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
20344
                {
20344
                {
20345
                  long _elem62; // required
20345
                  long _elem70; // required
20346
                  _elem62 = iprot.readI64();
20346
                  _elem70 = iprot.readI64();
20347
                  this.success.add(_elem62);
20347
                  this.success.add(_elem70);
20348
                }
20348
                }
20349
                iprot.readListEnd();
20349
                iprot.readListEnd();
20350
              }
20350
              }
20351
            } else { 
20351
            } else { 
20352
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
20352
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 20374... Line 20374...
20374
 
20374
 
20375
      if (this.isSetSuccess()) {
20375
      if (this.isSetSuccess()) {
20376
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20376
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20377
        {
20377
        {
20378
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
20378
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
20379
          for (long _iter63 : this.success)
20379
          for (long _iter71 : this.success)
20380
          {
20380
          {
20381
            oprot.writeI64(_iter63);
20381
            oprot.writeI64(_iter71);
20382
          }
20382
          }
20383
          oprot.writeListEnd();
20383
          oprot.writeListEnd();
20384
        }
20384
        }
20385
        oprot.writeFieldEnd();
20385
        oprot.writeFieldEnd();
20386
      } else if (this.isSetEx()) {
20386
      } else if (this.isSetEx()) {
Line 21131... Line 21131...
21131
        }
21131
        }
21132
        switch (field.id) {
21132
        switch (field.id) {
21133
          case 0: // SUCCESS
21133
          case 0: // SUCCESS
21134
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
21134
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
21135
              {
21135
              {
21136
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
21136
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
21137
                this.success = new ArrayList<Long>(_list64.size);
21137
                this.success = new ArrayList<Long>(_list72.size);
21138
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
21138
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
21139
                {
21139
                {
21140
                  long _elem66; // required
21140
                  long _elem74; // required
21141
                  _elem66 = iprot.readI64();
21141
                  _elem74 = iprot.readI64();
21142
                  this.success.add(_elem66);
21142
                  this.success.add(_elem74);
21143
                }
21143
                }
21144
                iprot.readListEnd();
21144
                iprot.readListEnd();
21145
              }
21145
              }
21146
            } else { 
21146
            } else { 
21147
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
21147
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 21169... Line 21169...
21169
 
21169
 
21170
      if (this.isSetSuccess()) {
21170
      if (this.isSetSuccess()) {
21171
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
21171
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
21172
        {
21172
        {
21173
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
21173
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
21174
          for (long _iter67 : this.success)
21174
          for (long _iter75 : this.success)
21175
          {
21175
          {
21176
            oprot.writeI64(_iter67);
21176
            oprot.writeI64(_iter75);
21177
          }
21177
          }
21178
          oprot.writeListEnd();
21178
          oprot.writeListEnd();
21179
        }
21179
        }
21180
        oprot.writeFieldEnd();
21180
        oprot.writeFieldEnd();
21181
      } else if (this.isSetEx()) {
21181
      } else if (this.isSetEx()) {
Line 22787... Line 22787...
22787
        }
22787
        }
22788
        switch (field.id) {
22788
        switch (field.id) {
22789
          case 0: // SUCCESS
22789
          case 0: // SUCCESS
22790
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22790
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22791
              {
22791
              {
22792
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
22792
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
22793
                this.success = new ArrayList<Order>(_list68.size);
22793
                this.success = new ArrayList<Order>(_list76.size);
22794
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
22794
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
22795
                {
22795
                {
22796
                  Order _elem70; // required
22796
                  Order _elem78; // required
22797
                  _elem70 = new Order();
22797
                  _elem78 = new Order();
22798
                  _elem70.read(iprot);
22798
                  _elem78.read(iprot);
22799
                  this.success.add(_elem70);
22799
                  this.success.add(_elem78);
22800
                }
22800
                }
22801
                iprot.readListEnd();
22801
                iprot.readListEnd();
22802
              }
22802
              }
22803
            } else { 
22803
            } else { 
22804
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22804
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22826... Line 22826...
22826
 
22826
 
22827
      if (this.isSetSuccess()) {
22827
      if (this.isSetSuccess()) {
22828
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22828
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22829
        {
22829
        {
22830
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22830
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22831
          for (Order _iter71 : this.success)
22831
          for (Order _iter79 : this.success)
22832
          {
22832
          {
22833
            _iter71.write(oprot);
22833
            _iter79.write(oprot);
22834
          }
22834
          }
22835
          oprot.writeListEnd();
22835
          oprot.writeListEnd();
22836
        }
22836
        }
22837
        oprot.writeFieldEnd();
22837
        oprot.writeFieldEnd();
22838
      } else if (this.isSetEx()) {
22838
      } else if (this.isSetEx()) {
Line 23369... Line 23369...
23369
            }
23369
            }
23370
            break;
23370
            break;
23371
          case 4: // STATUSES
23371
          case 4: // STATUSES
23372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23373
              {
23373
              {
23374
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
23374
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
23375
                this.statuses = new ArrayList<OrderStatus>(_list72.size);
23375
                this.statuses = new ArrayList<OrderStatus>(_list80.size);
23376
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
23376
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
23377
                {
23377
                {
23378
                  OrderStatus _elem74; // required
23378
                  OrderStatus _elem82; // required
23379
                  _elem74 = OrderStatus.findByValue(iprot.readI32());
23379
                  _elem82 = OrderStatus.findByValue(iprot.readI32());
23380
                  this.statuses.add(_elem74);
23380
                  this.statuses.add(_elem82);
23381
                }
23381
                }
23382
                iprot.readListEnd();
23382
                iprot.readListEnd();
23383
              }
23383
              }
23384
            } else { 
23384
            } else { 
23385
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23385
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23409... Line 23409...
23409
      oprot.writeFieldEnd();
23409
      oprot.writeFieldEnd();
23410
      if (this.statuses != null) {
23410
      if (this.statuses != null) {
23411
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
23411
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
23412
        {
23412
        {
23413
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
23413
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
23414
          for (OrderStatus _iter75 : this.statuses)
23414
          for (OrderStatus _iter83 : this.statuses)
23415
          {
23415
          {
23416
            oprot.writeI32(_iter75.getValue());
23416
            oprot.writeI32(_iter83.getValue());
23417
          }
23417
          }
23418
          oprot.writeListEnd();
23418
          oprot.writeListEnd();
23419
        }
23419
        }
23420
        oprot.writeFieldEnd();
23420
        oprot.writeFieldEnd();
23421
      }
23421
      }
Line 23789... Line 23789...
23789
        }
23789
        }
23790
        switch (field.id) {
23790
        switch (field.id) {
23791
          case 0: // SUCCESS
23791
          case 0: // SUCCESS
23792
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23792
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23793
              {
23793
              {
23794
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
23794
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
23795
                this.success = new ArrayList<Order>(_list76.size);
23795
                this.success = new ArrayList<Order>(_list84.size);
23796
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
23796
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
23797
                {
23797
                {
23798
                  Order _elem78; // required
23798
                  Order _elem86; // required
23799
                  _elem78 = new Order();
23799
                  _elem86 = new Order();
23800
                  _elem78.read(iprot);
23800
                  _elem86.read(iprot);
23801
                  this.success.add(_elem78);
23801
                  this.success.add(_elem86);
23802
                }
23802
                }
23803
                iprot.readListEnd();
23803
                iprot.readListEnd();
23804
              }
23804
              }
23805
            } else { 
23805
            } else { 
23806
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23806
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23828... Line 23828...
23828
 
23828
 
23829
      if (this.isSetSuccess()) {
23829
      if (this.isSetSuccess()) {
23830
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23830
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23831
        {
23831
        {
23832
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23832
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23833
          for (Order _iter79 : this.success)
23833
          for (Order _iter87 : this.success)
23834
          {
23834
          {
23835
            _iter79.write(oprot);
23835
            _iter87.write(oprot);
23836
          }
23836
          }
23837
          oprot.writeListEnd();
23837
          oprot.writeListEnd();
23838
        }
23838
        }
23839
        oprot.writeFieldEnd();
23839
        oprot.writeFieldEnd();
23840
      } else if (this.isSetEx()) {
23840
      } else if (this.isSetEx()) {
Line 25854... Line 25854...
25854
        }
25854
        }
25855
        switch (field.id) {
25855
        switch (field.id) {
25856
          case 0: // SUCCESS
25856
          case 0: // SUCCESS
25857
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25857
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25858
              {
25858
              {
25859
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
25859
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
25860
                this.success = new ArrayList<LineItem>(_list80.size);
25860
                this.success = new ArrayList<LineItem>(_list88.size);
25861
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
25861
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
25862
                {
25862
                {
25863
                  LineItem _elem82; // required
25863
                  LineItem _elem90; // required
25864
                  _elem82 = new LineItem();
25864
                  _elem90 = new LineItem();
25865
                  _elem82.read(iprot);
25865
                  _elem90.read(iprot);
25866
                  this.success.add(_elem82);
25866
                  this.success.add(_elem90);
25867
                }
25867
                }
25868
                iprot.readListEnd();
25868
                iprot.readListEnd();
25869
              }
25869
              }
25870
            } else { 
25870
            } else { 
25871
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
25871
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25893... Line 25893...
25893
 
25893
 
25894
      if (this.isSetSuccess()) {
25894
      if (this.isSetSuccess()) {
25895
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25895
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25896
        {
25896
        {
25897
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
25897
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
25898
          for (LineItem _iter83 : this.success)
25898
          for (LineItem _iter91 : this.success)
25899
          {
25899
          {
25900
            _iter83.write(oprot);
25900
            _iter91.write(oprot);
25901
          }
25901
          }
25902
          oprot.writeListEnd();
25902
          oprot.writeListEnd();
25903
        }
25903
        }
25904
        oprot.writeFieldEnd();
25904
        oprot.writeFieldEnd();
25905
      } else if (this.isSetEx()) {
25905
      } else if (this.isSetEx()) {
Line 27505... Line 27505...
27505
        }
27505
        }
27506
        switch (field.id) {
27506
        switch (field.id) {
27507
          case 0: // SUCCESS
27507
          case 0: // SUCCESS
27508
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
27508
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
27509
              {
27509
              {
27510
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
27510
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
27511
                this.success = new ArrayList<Alert>(_list84.size);
27511
                this.success = new ArrayList<Alert>(_list92.size);
27512
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
27512
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
27513
                {
27513
                {
27514
                  Alert _elem86; // required
27514
                  Alert _elem94; // required
27515
                  _elem86 = new Alert();
27515
                  _elem94 = new Alert();
27516
                  _elem86.read(iprot);
27516
                  _elem94.read(iprot);
27517
                  this.success.add(_elem86);
27517
                  this.success.add(_elem94);
27518
                }
27518
                }
27519
                iprot.readListEnd();
27519
                iprot.readListEnd();
27520
              }
27520
              }
27521
            } else { 
27521
            } else { 
27522
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
27522
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 27536... Line 27536...
27536
 
27536
 
27537
      if (this.isSetSuccess()) {
27537
      if (this.isSetSuccess()) {
27538
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27538
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27539
        {
27539
        {
27540
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
27540
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
27541
          for (Alert _iter87 : this.success)
27541
          for (Alert _iter95 : this.success)
27542
          {
27542
          {
27543
            _iter87.write(oprot);
27543
            _iter95.write(oprot);
27544
          }
27544
          }
27545
          oprot.writeListEnd();
27545
          oprot.writeListEnd();
27546
        }
27546
        }
27547
        oprot.writeFieldEnd();
27547
        oprot.writeFieldEnd();
27548
      }
27548
      }
Line 30179... Line 30179...
30179
        }
30179
        }
30180
        switch (field.id) {
30180
        switch (field.id) {
30181
          case 0: // SUCCESS
30181
          case 0: // SUCCESS
30182
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30182
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30183
              {
30183
              {
30184
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
30184
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
30185
                this.success = new ArrayList<Double>(_list88.size);
30185
                this.success = new ArrayList<Double>(_list96.size);
30186
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
30186
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
30187
                {
30187
                {
30188
                  double _elem90; // required
30188
                  double _elem98; // required
30189
                  _elem90 = iprot.readDouble();
30189
                  _elem98 = iprot.readDouble();
30190
                  this.success.add(_elem90);
30190
                  this.success.add(_elem98);
30191
                }
30191
                }
30192
                iprot.readListEnd();
30192
                iprot.readListEnd();
30193
              }
30193
              }
30194
            } else { 
30194
            } else { 
30195
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
30195
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30209... Line 30209...
30209
 
30209
 
30210
      if (this.isSetSuccess()) {
30210
      if (this.isSetSuccess()) {
30211
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30211
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30212
        {
30212
        {
30213
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
30213
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
30214
          for (double _iter91 : this.success)
30214
          for (double _iter99 : this.success)
30215
          {
30215
          {
30216
            oprot.writeDouble(_iter91);
30216
            oprot.writeDouble(_iter99);
30217
          }
30217
          }
30218
          oprot.writeListEnd();
30218
          oprot.writeListEnd();
30219
        }
30219
        }
30220
        oprot.writeFieldEnd();
30220
        oprot.writeFieldEnd();
30221
      }
30221
      }
Line 30801... Line 30801...
30801
        }
30801
        }
30802
        switch (field.id) {
30802
        switch (field.id) {
30803
          case 0: // SUCCESS
30803
          case 0: // SUCCESS
30804
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30804
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30805
              {
30805
              {
30806
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
30806
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
30807
                this.success = new ArrayList<Order>(_list92.size);
30807
                this.success = new ArrayList<Order>(_list100.size);
30808
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
30808
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
30809
                {
30809
                {
30810
                  Order _elem94; // required
30810
                  Order _elem102; // required
30811
                  _elem94 = new Order();
30811
                  _elem102 = new Order();
30812
                  _elem94.read(iprot);
30812
                  _elem102.read(iprot);
30813
                  this.success.add(_elem94);
30813
                  this.success.add(_elem102);
30814
                }
30814
                }
30815
                iprot.readListEnd();
30815
                iprot.readListEnd();
30816
              }
30816
              }
30817
            } else { 
30817
            } else { 
30818
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
30818
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30832... Line 30832...
30832
 
30832
 
30833
      if (this.isSetSuccess()) {
30833
      if (this.isSetSuccess()) {
30834
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30834
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30835
        {
30835
        {
30836
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30836
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30837
          for (Order _iter95 : this.success)
30837
          for (Order _iter103 : this.success)
30838
          {
30838
          {
30839
            _iter95.write(oprot);
30839
            _iter103.write(oprot);
30840
          }
30840
          }
30841
          oprot.writeListEnd();
30841
          oprot.writeListEnd();
30842
        }
30842
        }
30843
        oprot.writeFieldEnd();
30843
        oprot.writeFieldEnd();
30844
      }
30844
      }
Line 31494... Line 31494...
31494
        }
31494
        }
31495
        switch (field.id) {
31495
        switch (field.id) {
31496
          case 0: // SUCCESS
31496
          case 0: // SUCCESS
31497
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31497
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31498
              {
31498
              {
31499
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
31499
                org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
31500
                this.success = new ArrayList<Order>(_list96.size);
31500
                this.success = new ArrayList<Order>(_list104.size);
31501
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
31501
                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
31502
                {
31502
                {
31503
                  Order _elem98; // required
31503
                  Order _elem106; // required
31504
                  _elem98 = new Order();
31504
                  _elem106 = new Order();
31505
                  _elem98.read(iprot);
31505
                  _elem106.read(iprot);
31506
                  this.success.add(_elem98);
31506
                  this.success.add(_elem106);
31507
                }
31507
                }
31508
                iprot.readListEnd();
31508
                iprot.readListEnd();
31509
              }
31509
              }
31510
            } else { 
31510
            } else { 
31511
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
31511
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 31533... Line 31533...
31533
 
31533
 
31534
      if (this.isSetSuccess()) {
31534
      if (this.isSetSuccess()) {
31535
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31535
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31536
        {
31536
        {
31537
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
31537
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
31538
          for (Order _iter99 : this.success)
31538
          for (Order _iter107 : this.success)
31539
          {
31539
          {
31540
            _iter99.write(oprot);
31540
            _iter107.write(oprot);
31541
          }
31541
          }
31542
          oprot.writeListEnd();
31542
          oprot.writeListEnd();
31543
        }
31543
        }
31544
        oprot.writeFieldEnd();
31544
        oprot.writeFieldEnd();
31545
      } else if (this.isSetEx()) {
31545
      } else if (this.isSetEx()) {
Line 36216... Line 36216...
36216
            }
36216
            }
36217
            break;
36217
            break;
36218
          case 4: // ORDER_IDS
36218
          case 4: // ORDER_IDS
36219
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36219
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36220
              {
36220
              {
36221
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
36221
                org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();
36222
                this.orderIds = new ArrayList<Long>(_list100.size);
36222
                this.orderIds = new ArrayList<Long>(_list108.size);
36223
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
36223
                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
36224
                {
36224
                {
36225
                  long _elem102; // required
36225
                  long _elem110; // required
36226
                  _elem102 = iprot.readI64();
36226
                  _elem110 = iprot.readI64();
36227
                  this.orderIds.add(_elem102);
36227
                  this.orderIds.add(_elem110);
36228
                }
36228
                }
36229
                iprot.readListEnd();
36229
                iprot.readListEnd();
36230
              }
36230
              }
36231
            } else { 
36231
            } else { 
36232
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
36232
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 36256... Line 36256...
36256
      oprot.writeFieldEnd();
36256
      oprot.writeFieldEnd();
36257
      if (this.orderIds != null) {
36257
      if (this.orderIds != null) {
36258
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
36258
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
36259
        {
36259
        {
36260
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
36260
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
36261
          for (long _iter103 : this.orderIds)
36261
          for (long _iter111 : this.orderIds)
36262
          {
36262
          {
36263
            oprot.writeI64(_iter103);
36263
            oprot.writeI64(_iter111);
36264
          }
36264
          }
36265
          oprot.writeListEnd();
36265
          oprot.writeListEnd();
36266
        }
36266
        }
36267
        oprot.writeFieldEnd();
36267
        oprot.writeFieldEnd();
36268
      }
36268
      }
Line 37033... Line 37033...
37033
            }
37033
            }
37034
            break;
37034
            break;
37035
          case 2: // PICKUP_DETAILS
37035
          case 2: // PICKUP_DETAILS
37036
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37036
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37037
              {
37037
              {
37038
                org.apache.thrift.protocol.TMap _map104 = iprot.readMapBegin();
37038
                org.apache.thrift.protocol.TMap _map112 = iprot.readMapBegin();
37039
                this.pickupDetails = new HashMap<String,String>(2*_map104.size);
37039
                this.pickupDetails = new HashMap<String,String>(2*_map112.size);
37040
                for (int _i105 = 0; _i105 < _map104.size; ++_i105)
37040
                for (int _i113 = 0; _i113 < _map112.size; ++_i113)
37041
                {
37041
                {
37042
                  String _key106; // required
37042
                  String _key114; // required
37043
                  String _val107; // required
37043
                  String _val115; // required
37044
                  _key106 = iprot.readString();
37044
                  _key114 = iprot.readString();
37045
                  _val107 = iprot.readString();
37045
                  _val115 = iprot.readString();
37046
                  this.pickupDetails.put(_key106, _val107);
37046
                  this.pickupDetails.put(_key114, _val115);
37047
                }
37047
                }
37048
                iprot.readMapEnd();
37048
                iprot.readMapEnd();
37049
              }
37049
              }
37050
            } else { 
37050
            } else { 
37051
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37051
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37069... Line 37069...
37069
      oprot.writeFieldEnd();
37069
      oprot.writeFieldEnd();
37070
      if (this.pickupDetails != null) {
37070
      if (this.pickupDetails != null) {
37071
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
37071
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
37072
        {
37072
        {
37073
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
37073
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
37074
          for (Map.Entry<String, String> _iter108 : this.pickupDetails.entrySet())
37074
          for (Map.Entry<String, String> _iter116 : this.pickupDetails.entrySet())
37075
          {
37075
          {
37076
            oprot.writeString(_iter108.getKey());
37076
            oprot.writeString(_iter116.getKey());
37077
            oprot.writeString(_iter108.getValue());
37077
            oprot.writeString(_iter116.getValue());
37078
          }
37078
          }
37079
          oprot.writeMapEnd();
37079
          oprot.writeMapEnd();
37080
        }
37080
        }
37081
        oprot.writeFieldEnd();
37081
        oprot.writeFieldEnd();
37082
      }
37082
      }
Line 37962... Line 37962...
37962
        }
37962
        }
37963
        switch (field.id) {
37963
        switch (field.id) {
37964
          case 0: // SUCCESS
37964
          case 0: // SUCCESS
37965
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37965
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37966
              {
37966
              {
37967
                org.apache.thrift.protocol.TList _list109 = iprot.readListBegin();
37967
                org.apache.thrift.protocol.TList _list117 = iprot.readListBegin();
37968
                this.success = new ArrayList<Order>(_list109.size);
37968
                this.success = new ArrayList<Order>(_list117.size);
37969
                for (int _i110 = 0; _i110 < _list109.size; ++_i110)
37969
                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
37970
                {
37970
                {
37971
                  Order _elem111; // required
37971
                  Order _elem119; // required
37972
                  _elem111 = new Order();
37972
                  _elem119 = new Order();
37973
                  _elem111.read(iprot);
37973
                  _elem119.read(iprot);
37974
                  this.success.add(_elem111);
37974
                  this.success.add(_elem119);
37975
                }
37975
                }
37976
                iprot.readListEnd();
37976
                iprot.readListEnd();
37977
              }
37977
              }
37978
            } else { 
37978
            } else { 
37979
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37979
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37993... Line 37993...
37993
 
37993
 
37994
      if (this.isSetSuccess()) {
37994
      if (this.isSetSuccess()) {
37995
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37995
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37996
        {
37996
        {
37997
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
37997
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
37998
          for (Order _iter112 : this.success)
37998
          for (Order _iter120 : this.success)
37999
          {
37999
          {
38000
            _iter112.write(oprot);
38000
            _iter120.write(oprot);
38001
          }
38001
          }
38002
          oprot.writeListEnd();
38002
          oprot.writeListEnd();
38003
        }
38003
        }
38004
        oprot.writeFieldEnd();
38004
        oprot.writeFieldEnd();
38005
      }
38005
      }
Line 38377... Line 38377...
38377
            }
38377
            }
38378
            break;
38378
            break;
38379
          case 2: // DELIVERED_ORDERS
38379
          case 2: // DELIVERED_ORDERS
38380
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
38380
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
38381
              {
38381
              {
38382
                org.apache.thrift.protocol.TMap _map113 = iprot.readMapBegin();
38382
                org.apache.thrift.protocol.TMap _map121 = iprot.readMapBegin();
38383
                this.deliveredOrders = new HashMap<String,String>(2*_map113.size);
38383
                this.deliveredOrders = new HashMap<String,String>(2*_map121.size);
38384
                for (int _i114 = 0; _i114 < _map113.size; ++_i114)
38384
                for (int _i122 = 0; _i122 < _map121.size; ++_i122)
38385
                {
38385
                {
38386
                  String _key115; // required
38386
                  String _key123; // required
38387
                  String _val116; // required
38387
                  String _val124; // required
38388
                  _key115 = iprot.readString();
38388
                  _key123 = iprot.readString();
38389
                  _val116 = iprot.readString();
38389
                  _val124 = iprot.readString();
38390
                  this.deliveredOrders.put(_key115, _val116);
38390
                  this.deliveredOrders.put(_key123, _val124);
38391
                }
38391
                }
38392
                iprot.readMapEnd();
38392
                iprot.readMapEnd();
38393
              }
38393
              }
38394
            } else { 
38394
            } else { 
38395
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38395
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 38413... Line 38413...
38413
      oprot.writeFieldEnd();
38413
      oprot.writeFieldEnd();
38414
      if (this.deliveredOrders != null) {
38414
      if (this.deliveredOrders != null) {
38415
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
38415
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
38416
        {
38416
        {
38417
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.deliveredOrders.size()));
38417
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.deliveredOrders.size()));
38418
          for (Map.Entry<String, String> _iter117 : this.deliveredOrders.entrySet())
38418
          for (Map.Entry<String, String> _iter125 : this.deliveredOrders.entrySet())
38419
          {
38419
          {
38420
            oprot.writeString(_iter117.getKey());
38420
            oprot.writeString(_iter125.getKey());
38421
            oprot.writeString(_iter117.getValue());
38421
            oprot.writeString(_iter125.getValue());
38422
          }
38422
          }
38423
          oprot.writeMapEnd();
38423
          oprot.writeMapEnd();
38424
        }
38424
        }
38425
        oprot.writeFieldEnd();
38425
        oprot.writeFieldEnd();
38426
      }
38426
      }
Line 39096... Line 39096...
39096
            }
39096
            }
39097
            break;
39097
            break;
39098
          case 2: // RETURNED_ORDERS
39098
          case 2: // RETURNED_ORDERS
39099
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
39099
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
39100
              {
39100
              {
39101
                org.apache.thrift.protocol.TMap _map118 = iprot.readMapBegin();
39101
                org.apache.thrift.protocol.TMap _map126 = iprot.readMapBegin();
39102
                this.returnedOrders = new HashMap<String,String>(2*_map118.size);
39102
                this.returnedOrders = new HashMap<String,String>(2*_map126.size);
39103
                for (int _i119 = 0; _i119 < _map118.size; ++_i119)
39103
                for (int _i127 = 0; _i127 < _map126.size; ++_i127)
39104
                {
39104
                {
39105
                  String _key120; // required
39105
                  String _key128; // required
39106
                  String _val121; // required
39106
                  String _val129; // required
39107
                  _key120 = iprot.readString();
39107
                  _key128 = iprot.readString();
39108
                  _val121 = iprot.readString();
39108
                  _val129 = iprot.readString();
39109
                  this.returnedOrders.put(_key120, _val121);
39109
                  this.returnedOrders.put(_key128, _val129);
39110
                }
39110
                }
39111
                iprot.readMapEnd();
39111
                iprot.readMapEnd();
39112
              }
39112
              }
39113
            } else { 
39113
            } else { 
39114
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
39114
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39132... Line 39132...
39132
      oprot.writeFieldEnd();
39132
      oprot.writeFieldEnd();
39133
      if (this.returnedOrders != null) {
39133
      if (this.returnedOrders != null) {
39134
        oprot.writeFieldBegin(RETURNED_ORDERS_FIELD_DESC);
39134
        oprot.writeFieldBegin(RETURNED_ORDERS_FIELD_DESC);
39135
        {
39135
        {
39136
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.returnedOrders.size()));
39136
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.returnedOrders.size()));
39137
          for (Map.Entry<String, String> _iter122 : this.returnedOrders.entrySet())
39137
          for (Map.Entry<String, String> _iter130 : this.returnedOrders.entrySet())
39138
          {
39138
          {
39139
            oprot.writeString(_iter122.getKey());
39139
            oprot.writeString(_iter130.getKey());
39140
            oprot.writeString(_iter122.getValue());
39140
            oprot.writeString(_iter130.getValue());
39141
          }
39141
          }
39142
          oprot.writeMapEnd();
39142
          oprot.writeMapEnd();
39143
        }
39143
        }
39144
        oprot.writeFieldEnd();
39144
        oprot.writeFieldEnd();
39145
      }
39145
      }
Line 40025... Line 40025...
40025
        }
40025
        }
40026
        switch (field.id) {
40026
        switch (field.id) {
40027
          case 0: // SUCCESS
40027
          case 0: // SUCCESS
40028
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
40028
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
40029
              {
40029
              {
40030
                org.apache.thrift.protocol.TList _list123 = iprot.readListBegin();
40030
                org.apache.thrift.protocol.TList _list131 = iprot.readListBegin();
40031
                this.success = new ArrayList<Order>(_list123.size);
40031
                this.success = new ArrayList<Order>(_list131.size);
40032
                for (int _i124 = 0; _i124 < _list123.size; ++_i124)
40032
                for (int _i132 = 0; _i132 < _list131.size; ++_i132)
40033
                {
40033
                {
40034
                  Order _elem125; // required
40034
                  Order _elem133; // required
40035
                  _elem125 = new Order();
40035
                  _elem133 = new Order();
40036
                  _elem125.read(iprot);
40036
                  _elem133.read(iprot);
40037
                  this.success.add(_elem125);
40037
                  this.success.add(_elem133);
40038
                }
40038
                }
40039
                iprot.readListEnd();
40039
                iprot.readListEnd();
40040
              }
40040
              }
40041
            } else { 
40041
            } else { 
40042
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
40042
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 40056... Line 40056...
40056
 
40056
 
40057
      if (this.isSetSuccess()) {
40057
      if (this.isSetSuccess()) {
40058
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
40058
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
40059
        {
40059
        {
40060
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
40060
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
40061
          for (Order _iter126 : this.success)
40061
          for (Order _iter134 : this.success)
40062
          {
40062
          {
40063
            _iter126.write(oprot);
40063
            _iter134.write(oprot);
40064
          }
40064
          }
40065
          oprot.writeListEnd();
40065
          oprot.writeListEnd();
40066
        }
40066
        }
40067
        oprot.writeFieldEnd();
40067
        oprot.writeFieldEnd();
40068
      }
40068
      }
Line 40440... Line 40440...
40440
            }
40440
            }
40441
            break;
40441
            break;
40442
          case 2: // UNDELIVERED_ORDERS
40442
          case 2: // UNDELIVERED_ORDERS
40443
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
40443
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
40444
              {
40444
              {
40445
                org.apache.thrift.protocol.TMap _map127 = iprot.readMapBegin();
40445
                org.apache.thrift.protocol.TMap _map135 = iprot.readMapBegin();
40446
                this.undeliveredOrders = new HashMap<String,String>(2*_map127.size);
40446
                this.undeliveredOrders = new HashMap<String,String>(2*_map135.size);
40447
                for (int _i128 = 0; _i128 < _map127.size; ++_i128)
40447
                for (int _i136 = 0; _i136 < _map135.size; ++_i136)
40448
                {
40448
                {
40449
                  String _key129; // required
40449
                  String _key137; // required
40450
                  String _val130; // required
40450
                  String _val138; // required
40451
                  _key129 = iprot.readString();
40451
                  _key137 = iprot.readString();
40452
                  _val130 = iprot.readString();
40452
                  _val138 = iprot.readString();
40453
                  this.undeliveredOrders.put(_key129, _val130);
40453
                  this.undeliveredOrders.put(_key137, _val138);
40454
                }
40454
                }
40455
                iprot.readMapEnd();
40455
                iprot.readMapEnd();
40456
              }
40456
              }
40457
            } else { 
40457
            } else { 
40458
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
40458
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 40476... Line 40476...
40476
      oprot.writeFieldEnd();
40476
      oprot.writeFieldEnd();
40477
      if (this.undeliveredOrders != null) {
40477
      if (this.undeliveredOrders != null) {
40478
        oprot.writeFieldBegin(UNDELIVERED_ORDERS_FIELD_DESC);
40478
        oprot.writeFieldBegin(UNDELIVERED_ORDERS_FIELD_DESC);
40479
        {
40479
        {
40480
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.undeliveredOrders.size()));
40480
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.undeliveredOrders.size()));
40481
          for (Map.Entry<String, String> _iter131 : this.undeliveredOrders.entrySet())
40481
          for (Map.Entry<String, String> _iter139 : this.undeliveredOrders.entrySet())
40482
          {
40482
          {
40483
            oprot.writeString(_iter131.getKey());
40483
            oprot.writeString(_iter139.getKey());
40484
            oprot.writeString(_iter131.getValue());
40484
            oprot.writeString(_iter139.getValue());
40485
          }
40485
          }
40486
          oprot.writeMapEnd();
40486
          oprot.writeMapEnd();
40487
        }
40487
        }
40488
        oprot.writeFieldEnd();
40488
        oprot.writeFieldEnd();
40489
      }
40489
      }
Line 41369... Line 41369...
41369
        }
41369
        }
41370
        switch (field.id) {
41370
        switch (field.id) {
41371
          case 0: // SUCCESS
41371
          case 0: // SUCCESS
41372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41373
              {
41373
              {
41374
                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
41374
                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
41375
                this.success = new ArrayList<Order>(_list132.size);
41375
                this.success = new ArrayList<Order>(_list140.size);
41376
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
41376
                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
41377
                {
41377
                {
41378
                  Order _elem134; // required
41378
                  Order _elem142; // required
41379
                  _elem134 = new Order();
41379
                  _elem142 = new Order();
41380
                  _elem134.read(iprot);
41380
                  _elem142.read(iprot);
41381
                  this.success.add(_elem134);
41381
                  this.success.add(_elem142);
41382
                }
41382
                }
41383
                iprot.readListEnd();
41383
                iprot.readListEnd();
41384
              }
41384
              }
41385
            } else { 
41385
            } else { 
41386
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41386
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41400... Line 41400...
41400
 
41400
 
41401
      if (this.isSetSuccess()) {
41401
      if (this.isSetSuccess()) {
41402
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41402
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41403
        {
41403
        {
41404
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41404
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41405
          for (Order _iter135 : this.success)
41405
          for (Order _iter143 : this.success)
41406
          {
41406
          {
41407
            _iter135.write(oprot);
41407
            _iter143.write(oprot);
41408
          }
41408
          }
41409
          oprot.writeListEnd();
41409
          oprot.writeListEnd();
41410
        }
41410
        }
41411
        oprot.writeFieldEnd();
41411
        oprot.writeFieldEnd();
41412
      }
41412
      }
Line 41784... Line 41784...
41784
            }
41784
            }
41785
            break;
41785
            break;
41786
          case 2: // LOCAL_CONNECTED_ORDERS
41786
          case 2: // LOCAL_CONNECTED_ORDERS
41787
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
41787
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
41788
              {
41788
              {
41789
                org.apache.thrift.protocol.TMap _map136 = iprot.readMapBegin();
41789
                org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin();
41790
                this.local_connected_orders = new HashMap<String,String>(2*_map136.size);
41790
                this.local_connected_orders = new HashMap<String,String>(2*_map144.size);
41791
                for (int _i137 = 0; _i137 < _map136.size; ++_i137)
41791
                for (int _i145 = 0; _i145 < _map144.size; ++_i145)
41792
                {
41792
                {
41793
                  String _key138; // required
41793
                  String _key146; // required
41794
                  String _val139; // required
41794
                  String _val147; // required
41795
                  _key138 = iprot.readString();
41795
                  _key146 = iprot.readString();
41796
                  _val139 = iprot.readString();
41796
                  _val147 = iprot.readString();
41797
                  this.local_connected_orders.put(_key138, _val139);
41797
                  this.local_connected_orders.put(_key146, _val147);
41798
                }
41798
                }
41799
                iprot.readMapEnd();
41799
                iprot.readMapEnd();
41800
              }
41800
              }
41801
            } else { 
41801
            } else { 
41802
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41802
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41820... Line 41820...
41820
      oprot.writeFieldEnd();
41820
      oprot.writeFieldEnd();
41821
      if (this.local_connected_orders != null) {
41821
      if (this.local_connected_orders != null) {
41822
        oprot.writeFieldBegin(LOCAL_CONNECTED_ORDERS_FIELD_DESC);
41822
        oprot.writeFieldBegin(LOCAL_CONNECTED_ORDERS_FIELD_DESC);
41823
        {
41823
        {
41824
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.local_connected_orders.size()));
41824
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.local_connected_orders.size()));
41825
          for (Map.Entry<String, String> _iter140 : this.local_connected_orders.entrySet())
41825
          for (Map.Entry<String, String> _iter148 : this.local_connected_orders.entrySet())
41826
          {
41826
          {
41827
            oprot.writeString(_iter140.getKey());
41827
            oprot.writeString(_iter148.getKey());
41828
            oprot.writeString(_iter140.getValue());
41828
            oprot.writeString(_iter148.getValue());
41829
          }
41829
          }
41830
          oprot.writeMapEnd();
41830
          oprot.writeMapEnd();
41831
        }
41831
        }
41832
        oprot.writeFieldEnd();
41832
        oprot.writeFieldEnd();
41833
      }
41833
      }
Line 42713... Line 42713...
42713
        }
42713
        }
42714
        switch (field.id) {
42714
        switch (field.id) {
42715
          case 0: // SUCCESS
42715
          case 0: // SUCCESS
42716
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
42716
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
42717
              {
42717
              {
42718
                org.apache.thrift.protocol.TList _list141 = iprot.readListBegin();
42718
                org.apache.thrift.protocol.TList _list149 = iprot.readListBegin();
42719
                this.success = new ArrayList<Order>(_list141.size);
42719
                this.success = new ArrayList<Order>(_list149.size);
42720
                for (int _i142 = 0; _i142 < _list141.size; ++_i142)
42720
                for (int _i150 = 0; _i150 < _list149.size; ++_i150)
42721
                {
42721
                {
42722
                  Order _elem143; // required
42722
                  Order _elem151; // required
42723
                  _elem143 = new Order();
42723
                  _elem151 = new Order();
42724
                  _elem143.read(iprot);
42724
                  _elem151.read(iprot);
42725
                  this.success.add(_elem143);
42725
                  this.success.add(_elem151);
42726
                }
42726
                }
42727
                iprot.readListEnd();
42727
                iprot.readListEnd();
42728
              }
42728
              }
42729
            } else { 
42729
            } else { 
42730
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
42730
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 42744... Line 42744...
42744
 
42744
 
42745
      if (this.isSetSuccess()) {
42745
      if (this.isSetSuccess()) {
42746
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
42746
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
42747
        {
42747
        {
42748
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
42748
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
42749
          for (Order _iter144 : this.success)
42749
          for (Order _iter152 : this.success)
42750
          {
42750
          {
42751
            _iter144.write(oprot);
42751
            _iter152.write(oprot);
42752
          }
42752
          }
42753
          oprot.writeListEnd();
42753
          oprot.writeListEnd();
42754
        }
42754
        }
42755
        oprot.writeFieldEnd();
42755
        oprot.writeFieldEnd();
42756
      }
42756
      }
Line 43128... Line 43128...
43128
            }
43128
            }
43129
            break;
43129
            break;
43130
          case 2: // DESTINATION_CITY_REACHED_ORDERS
43130
          case 2: // DESTINATION_CITY_REACHED_ORDERS
43131
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
43131
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
43132
              {
43132
              {
43133
                org.apache.thrift.protocol.TMap _map145 = iprot.readMapBegin();
43133
                org.apache.thrift.protocol.TMap _map153 = iprot.readMapBegin();
43134
                this.destination_city_reached_orders = new HashMap<String,String>(2*_map145.size);
43134
                this.destination_city_reached_orders = new HashMap<String,String>(2*_map153.size);
43135
                for (int _i146 = 0; _i146 < _map145.size; ++_i146)
43135
                for (int _i154 = 0; _i154 < _map153.size; ++_i154)
43136
                {
43136
                {
43137
                  String _key147; // required
43137
                  String _key155; // required
43138
                  String _val148; // required
43138
                  String _val156; // required
43139
                  _key147 = iprot.readString();
43139
                  _key155 = iprot.readString();
43140
                  _val148 = iprot.readString();
43140
                  _val156 = iprot.readString();
43141
                  this.destination_city_reached_orders.put(_key147, _val148);
43141
                  this.destination_city_reached_orders.put(_key155, _val156);
43142
                }
43142
                }
43143
                iprot.readMapEnd();
43143
                iprot.readMapEnd();
43144
              }
43144
              }
43145
            } else { 
43145
            } else { 
43146
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
43146
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 43164... Line 43164...
43164
      oprot.writeFieldEnd();
43164
      oprot.writeFieldEnd();
43165
      if (this.destination_city_reached_orders != null) {
43165
      if (this.destination_city_reached_orders != null) {
43166
        oprot.writeFieldBegin(DESTINATION_CITY_REACHED_ORDERS_FIELD_DESC);
43166
        oprot.writeFieldBegin(DESTINATION_CITY_REACHED_ORDERS_FIELD_DESC);
43167
        {
43167
        {
43168
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.destination_city_reached_orders.size()));
43168
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.destination_city_reached_orders.size()));
43169
          for (Map.Entry<String, String> _iter149 : this.destination_city_reached_orders.entrySet())
43169
          for (Map.Entry<String, String> _iter157 : this.destination_city_reached_orders.entrySet())
43170
          {
43170
          {
43171
            oprot.writeString(_iter149.getKey());
43171
            oprot.writeString(_iter157.getKey());
43172
            oprot.writeString(_iter149.getValue());
43172
            oprot.writeString(_iter157.getValue());
43173
          }
43173
          }
43174
          oprot.writeMapEnd();
43174
          oprot.writeMapEnd();
43175
        }
43175
        }
43176
        oprot.writeFieldEnd();
43176
        oprot.writeFieldEnd();
43177
      }
43177
      }
Line 43847... Line 43847...
43847
            }
43847
            }
43848
            break;
43848
            break;
43849
          case 2: // FIRST_ATDL_ORDERS
43849
          case 2: // FIRST_ATDL_ORDERS
43850
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
43850
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
43851
              {
43851
              {
43852
                org.apache.thrift.protocol.TMap _map150 = iprot.readMapBegin();
43852
                org.apache.thrift.protocol.TMap _map158 = iprot.readMapBegin();
43853
                this.first_atdl_orders = new HashMap<String,String>(2*_map150.size);
43853
                this.first_atdl_orders = new HashMap<String,String>(2*_map158.size);
43854
                for (int _i151 = 0; _i151 < _map150.size; ++_i151)
43854
                for (int _i159 = 0; _i159 < _map158.size; ++_i159)
43855
                {
43855
                {
43856
                  String _key152; // required
43856
                  String _key160; // required
43857
                  String _val153; // required
43857
                  String _val161; // required
43858
                  _key152 = iprot.readString();
43858
                  _key160 = iprot.readString();
43859
                  _val153 = iprot.readString();
43859
                  _val161 = iprot.readString();
43860
                  this.first_atdl_orders.put(_key152, _val153);
43860
                  this.first_atdl_orders.put(_key160, _val161);
43861
                }
43861
                }
43862
                iprot.readMapEnd();
43862
                iprot.readMapEnd();
43863
              }
43863
              }
43864
            } else { 
43864
            } else { 
43865
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
43865
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 43883... Line 43883...
43883
      oprot.writeFieldEnd();
43883
      oprot.writeFieldEnd();
43884
      if (this.first_atdl_orders != null) {
43884
      if (this.first_atdl_orders != null) {
43885
        oprot.writeFieldBegin(FIRST_ATDL_ORDERS_FIELD_DESC);
43885
        oprot.writeFieldBegin(FIRST_ATDL_ORDERS_FIELD_DESC);
43886
        {
43886
        {
43887
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.first_atdl_orders.size()));
43887
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.first_atdl_orders.size()));
43888
          for (Map.Entry<String, String> _iter154 : this.first_atdl_orders.entrySet())
43888
          for (Map.Entry<String, String> _iter162 : this.first_atdl_orders.entrySet())
43889
          {
43889
          {
43890
            oprot.writeString(_iter154.getKey());
43890
            oprot.writeString(_iter162.getKey());
43891
            oprot.writeString(_iter154.getValue());
43891
            oprot.writeString(_iter162.getValue());
43892
          }
43892
          }
43893
          oprot.writeMapEnd();
43893
          oprot.writeMapEnd();
43894
        }
43894
        }
43895
        oprot.writeFieldEnd();
43895
        oprot.writeFieldEnd();
43896
      }
43896
      }
Line 44857... Line 44857...
44857
        }
44857
        }
44858
        switch (field.id) {
44858
        switch (field.id) {
44859
          case 0: // SUCCESS
44859
          case 0: // SUCCESS
44860
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44860
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44861
              {
44861
              {
44862
                org.apache.thrift.protocol.TList _list155 = iprot.readListBegin();
44862
                org.apache.thrift.protocol.TList _list163 = iprot.readListBegin();
44863
                this.success = new ArrayList<Order>(_list155.size);
44863
                this.success = new ArrayList<Order>(_list163.size);
44864
                for (int _i156 = 0; _i156 < _list155.size; ++_i156)
44864
                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
44865
                {
44865
                {
44866
                  Order _elem157; // required
44866
                  Order _elem165; // required
44867
                  _elem157 = new Order();
44867
                  _elem165 = new Order();
44868
                  _elem157.read(iprot);
44868
                  _elem165.read(iprot);
44869
                  this.success.add(_elem157);
44869
                  this.success.add(_elem165);
44870
                }
44870
                }
44871
                iprot.readListEnd();
44871
                iprot.readListEnd();
44872
              }
44872
              }
44873
            } else { 
44873
            } else { 
44874
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
44874
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 44888... Line 44888...
44888
 
44888
 
44889
      if (this.isSetSuccess()) {
44889
      if (this.isSetSuccess()) {
44890
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44890
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44891
        {
44891
        {
44892
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
44892
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
44893
          for (Order _iter158 : this.success)
44893
          for (Order _iter166 : this.success)
44894
          {
44894
          {
44895
            _iter158.write(oprot);
44895
            _iter166.write(oprot);
44896
          }
44896
          }
44897
          oprot.writeListEnd();
44897
          oprot.writeListEnd();
44898
        }
44898
        }
44899
        oprot.writeFieldEnd();
44899
        oprot.writeFieldEnd();
44900
      }
44900
      }
Line 45388... Line 45388...
45388
        }
45388
        }
45389
        switch (field.id) {
45389
        switch (field.id) {
45390
          case 0: // SUCCESS
45390
          case 0: // SUCCESS
45391
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
45391
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
45392
              {
45392
              {
45393
                org.apache.thrift.protocol.TList _list159 = iprot.readListBegin();
45393
                org.apache.thrift.protocol.TList _list167 = iprot.readListBegin();
45394
                this.success = new ArrayList<Order>(_list159.size);
45394
                this.success = new ArrayList<Order>(_list167.size);
45395
                for (int _i160 = 0; _i160 < _list159.size; ++_i160)
45395
                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
45396
                {
45396
                {
45397
                  Order _elem161; // required
45397
                  Order _elem169; // required
45398
                  _elem161 = new Order();
45398
                  _elem169 = new Order();
45399
                  _elem161.read(iprot);
45399
                  _elem169.read(iprot);
45400
                  this.success.add(_elem161);
45400
                  this.success.add(_elem169);
45401
                }
45401
                }
45402
                iprot.readListEnd();
45402
                iprot.readListEnd();
45403
              }
45403
              }
45404
            } else { 
45404
            } else { 
45405
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
45405
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 45419... Line 45419...
45419
 
45419
 
45420
      if (this.isSetSuccess()) {
45420
      if (this.isSetSuccess()) {
45421
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45421
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45422
        {
45422
        {
45423
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
45423
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
45424
          for (Order _iter162 : this.success)
45424
          for (Order _iter170 : this.success)
45425
          {
45425
          {
45426
            _iter162.write(oprot);
45426
            _iter170.write(oprot);
45427
          }
45427
          }
45428
          oprot.writeListEnd();
45428
          oprot.writeListEnd();
45429
        }
45429
        }
45430
        oprot.writeFieldEnd();
45430
        oprot.writeFieldEnd();
45431
      }
45431
      }
Line 51697... Line 51697...
51697
            }
51697
            }
51698
            break;
51698
            break;
51699
          case 2: // PICKUP_DETAILS
51699
          case 2: // PICKUP_DETAILS
51700
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
51700
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
51701
              {
51701
              {
51702
                org.apache.thrift.protocol.TMap _map163 = iprot.readMapBegin();
51702
                org.apache.thrift.protocol.TMap _map171 = iprot.readMapBegin();
51703
                this.pickupDetails = new HashMap<String,String>(2*_map163.size);
51703
                this.pickupDetails = new HashMap<String,String>(2*_map171.size);
51704
                for (int _i164 = 0; _i164 < _map163.size; ++_i164)
51704
                for (int _i172 = 0; _i172 < _map171.size; ++_i172)
51705
                {
51705
                {
51706
                  String _key165; // required
51706
                  String _key173; // required
51707
                  String _val166; // required
51707
                  String _val174; // required
51708
                  _key165 = iprot.readString();
51708
                  _key173 = iprot.readString();
51709
                  _val166 = iprot.readString();
51709
                  _val174 = iprot.readString();
51710
                  this.pickupDetails.put(_key165, _val166);
51710
                  this.pickupDetails.put(_key173, _val174);
51711
                }
51711
                }
51712
                iprot.readMapEnd();
51712
                iprot.readMapEnd();
51713
              }
51713
              }
51714
            } else { 
51714
            } else { 
51715
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
51715
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 51733... Line 51733...
51733
      oprot.writeFieldEnd();
51733
      oprot.writeFieldEnd();
51734
      if (this.pickupDetails != null) {
51734
      if (this.pickupDetails != null) {
51735
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
51735
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
51736
        {
51736
        {
51737
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
51737
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
51738
          for (Map.Entry<String, String> _iter167 : this.pickupDetails.entrySet())
51738
          for (Map.Entry<String, String> _iter175 : this.pickupDetails.entrySet())
51739
          {
51739
          {
51740
            oprot.writeString(_iter167.getKey());
51740
            oprot.writeString(_iter175.getKey());
51741
            oprot.writeString(_iter167.getValue());
51741
            oprot.writeString(_iter175.getValue());
51742
          }
51742
          }
51743
          oprot.writeMapEnd();
51743
          oprot.writeMapEnd();
51744
        }
51744
        }
51745
        oprot.writeFieldEnd();
51745
        oprot.writeFieldEnd();
51746
      }
51746
      }
Line 52529... Line 52529...
52529
        }
52529
        }
52530
        switch (field.id) {
52530
        switch (field.id) {
52531
          case 0: // SUCCESS
52531
          case 0: // SUCCESS
52532
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52532
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52533
              {
52533
              {
52534
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
52534
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
52535
                this.success = new ArrayList<Order>(_list168.size);
52535
                this.success = new ArrayList<Order>(_list176.size);
52536
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
52536
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
52537
                {
52537
                {
52538
                  Order _elem170; // required
52538
                  Order _elem178; // required
52539
                  _elem170 = new Order();
52539
                  _elem178 = new Order();
52540
                  _elem170.read(iprot);
52540
                  _elem178.read(iprot);
52541
                  this.success.add(_elem170);
52541
                  this.success.add(_elem178);
52542
                }
52542
                }
52543
                iprot.readListEnd();
52543
                iprot.readListEnd();
52544
              }
52544
              }
52545
            } else { 
52545
            } else { 
52546
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
52546
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 52560... Line 52560...
52560
 
52560
 
52561
      if (this.isSetSuccess()) {
52561
      if (this.isSetSuccess()) {
52562
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
52562
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
52563
        {
52563
        {
52564
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
52564
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
52565
          for (Order _iter171 : this.success)
52565
          for (Order _iter179 : this.success)
52566
          {
52566
          {
52567
            _iter171.write(oprot);
52567
            _iter179.write(oprot);
52568
          }
52568
          }
52569
          oprot.writeListEnd();
52569
          oprot.writeListEnd();
52570
        }
52570
        }
52571
        oprot.writeFieldEnd();
52571
        oprot.writeFieldEnd();
52572
      }
52572
      }
Line 52944... Line 52944...
52944
            }
52944
            }
52945
            break;
52945
            break;
52946
          case 2: // PICKUP_DETAILS
52946
          case 2: // PICKUP_DETAILS
52947
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
52947
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
52948
              {
52948
              {
52949
                org.apache.thrift.protocol.TMap _map172 = iprot.readMapBegin();
52949
                org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin();
52950
                this.pickupDetails = new HashMap<String,String>(2*_map172.size);
52950
                this.pickupDetails = new HashMap<String,String>(2*_map180.size);
52951
                for (int _i173 = 0; _i173 < _map172.size; ++_i173)
52951
                for (int _i181 = 0; _i181 < _map180.size; ++_i181)
52952
                {
52952
                {
52953
                  String _key174; // required
52953
                  String _key182; // required
52954
                  String _val175; // required
52954
                  String _val183; // required
52955
                  _key174 = iprot.readString();
52955
                  _key182 = iprot.readString();
52956
                  _val175 = iprot.readString();
52956
                  _val183 = iprot.readString();
52957
                  this.pickupDetails.put(_key174, _val175);
52957
                  this.pickupDetails.put(_key182, _val183);
52958
                }
52958
                }
52959
                iprot.readMapEnd();
52959
                iprot.readMapEnd();
52960
              }
52960
              }
52961
            } else { 
52961
            } else { 
52962
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
52962
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 52980... Line 52980...
52980
      oprot.writeFieldEnd();
52980
      oprot.writeFieldEnd();
52981
      if (this.pickupDetails != null) {
52981
      if (this.pickupDetails != null) {
52982
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
52982
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
52983
        {
52983
        {
52984
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
52984
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
52985
          for (Map.Entry<String, String> _iter176 : this.pickupDetails.entrySet())
52985
          for (Map.Entry<String, String> _iter184 : this.pickupDetails.entrySet())
52986
          {
52986
          {
52987
            oprot.writeString(_iter176.getKey());
52987
            oprot.writeString(_iter184.getKey());
52988
            oprot.writeString(_iter176.getValue());
52988
            oprot.writeString(_iter184.getValue());
52989
          }
52989
          }
52990
          oprot.writeMapEnd();
52990
          oprot.writeMapEnd();
52991
        }
52991
        }
52992
        oprot.writeFieldEnd();
52992
        oprot.writeFieldEnd();
52993
      }
52993
      }
Line 53776... Line 53776...
53776
        }
53776
        }
53777
        switch (field.id) {
53777
        switch (field.id) {
53778
          case 0: // SUCCESS
53778
          case 0: // SUCCESS
53779
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53779
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53780
              {
53780
              {
53781
                org.apache.thrift.protocol.TList _list177 = iprot.readListBegin();
53781
                org.apache.thrift.protocol.TList _list185 = iprot.readListBegin();
53782
                this.success = new ArrayList<Order>(_list177.size);
53782
                this.success = new ArrayList<Order>(_list185.size);
53783
                for (int _i178 = 0; _i178 < _list177.size; ++_i178)
53783
                for (int _i186 = 0; _i186 < _list185.size; ++_i186)
53784
                {
53784
                {
53785
                  Order _elem179; // required
53785
                  Order _elem187; // required
53786
                  _elem179 = new Order();
53786
                  _elem187 = new Order();
53787
                  _elem179.read(iprot);
53787
                  _elem187.read(iprot);
53788
                  this.success.add(_elem179);
53788
                  this.success.add(_elem187);
53789
                }
53789
                }
53790
                iprot.readListEnd();
53790
                iprot.readListEnd();
53791
              }
53791
              }
53792
            } else { 
53792
            } else { 
53793
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
53793
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 53807... Line 53807...
53807
 
53807
 
53808
      if (this.isSetSuccess()) {
53808
      if (this.isSetSuccess()) {
53809
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53809
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53810
        {
53810
        {
53811
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53811
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53812
          for (Order _iter180 : this.success)
53812
          for (Order _iter188 : this.success)
53813
          {
53813
          {
53814
            _iter180.write(oprot);
53814
            _iter188.write(oprot);
53815
          }
53815
          }
53816
          oprot.writeListEnd();
53816
          oprot.writeListEnd();
53817
        }
53817
        }
53818
        oprot.writeFieldEnd();
53818
        oprot.writeFieldEnd();
53819
      }
53819
      }
Line 58357... Line 58357...
58357
        }
58357
        }
58358
        switch (field.id) {
58358
        switch (field.id) {
58359
          case 0: // SUCCESS
58359
          case 0: // SUCCESS
58360
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58360
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58361
              {
58361
              {
58362
                org.apache.thrift.protocol.TList _list181 = iprot.readListBegin();
58362
                org.apache.thrift.protocol.TList _list189 = iprot.readListBegin();
58363
                this.success = new ArrayList<ReturnOrder>(_list181.size);
58363
                this.success = new ArrayList<ReturnOrder>(_list189.size);
58364
                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
58364
                for (int _i190 = 0; _i190 < _list189.size; ++_i190)
58365
                {
58365
                {
58366
                  ReturnOrder _elem183; // required
58366
                  ReturnOrder _elem191; // required
58367
                  _elem183 = new ReturnOrder();
58367
                  _elem191 = new ReturnOrder();
58368
                  _elem183.read(iprot);
58368
                  _elem191.read(iprot);
58369
                  this.success.add(_elem183);
58369
                  this.success.add(_elem191);
58370
                }
58370
                }
58371
                iprot.readListEnd();
58371
                iprot.readListEnd();
58372
              }
58372
              }
58373
            } else { 
58373
            } else { 
58374
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
58374
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58388... Line 58388...
58388
 
58388
 
58389
      if (this.isSetSuccess()) {
58389
      if (this.isSetSuccess()) {
58390
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58390
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58391
        {
58391
        {
58392
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58392
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58393
          for (ReturnOrder _iter184 : this.success)
58393
          for (ReturnOrder _iter192 : this.success)
58394
          {
58394
          {
58395
            _iter184.write(oprot);
58395
            _iter192.write(oprot);
58396
          }
58396
          }
58397
          oprot.writeListEnd();
58397
          oprot.writeListEnd();
58398
        }
58398
        }
58399
        oprot.writeFieldEnd();
58399
        oprot.writeFieldEnd();
58400
      }
58400
      }
Line 63375... Line 63375...
63375
        }
63375
        }
63376
        switch (field.id) {
63376
        switch (field.id) {
63377
          case 1: // COLLECTED_AMOUNT_MAP
63377
          case 1: // COLLECTED_AMOUNT_MAP
63378
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
63378
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
63379
              {
63379
              {
63380
                org.apache.thrift.protocol.TMap _map185 = iprot.readMapBegin();
63380
                org.apache.thrift.protocol.TMap _map193 = iprot.readMapBegin();
63381
                this.collectedAmountMap = new HashMap<String,Double>(2*_map185.size);
63381
                this.collectedAmountMap = new HashMap<String,Double>(2*_map193.size);
63382
                for (int _i186 = 0; _i186 < _map185.size; ++_i186)
63382
                for (int _i194 = 0; _i194 < _map193.size; ++_i194)
63383
                {
63383
                {
63384
                  String _key187; // required
63384
                  String _key195; // required
63385
                  double _val188; // required
63385
                  double _val196; // required
63386
                  _key187 = iprot.readString();
63386
                  _key195 = iprot.readString();
63387
                  _val188 = iprot.readDouble();
63387
                  _val196 = iprot.readDouble();
63388
                  this.collectedAmountMap.put(_key187, _val188);
63388
                  this.collectedAmountMap.put(_key195, _val196);
63389
                }
63389
                }
63390
                iprot.readMapEnd();
63390
                iprot.readMapEnd();
63391
              }
63391
              }
63392
            } else { 
63392
            } else { 
63393
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
63393
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 63430... Line 63430...
63430
      oprot.writeStructBegin(STRUCT_DESC);
63430
      oprot.writeStructBegin(STRUCT_DESC);
63431
      if (this.collectedAmountMap != null) {
63431
      if (this.collectedAmountMap != null) {
63432
        oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
63432
        oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
63433
        {
63433
        {
63434
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
63434
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
63435
          for (Map.Entry<String, Double> _iter189 : this.collectedAmountMap.entrySet())
63435
          for (Map.Entry<String, Double> _iter197 : this.collectedAmountMap.entrySet())
63436
          {
63436
          {
63437
            oprot.writeString(_iter189.getKey());
63437
            oprot.writeString(_iter197.getKey());
63438
            oprot.writeDouble(_iter189.getValue());
63438
            oprot.writeDouble(_iter197.getValue());
63439
          }
63439
          }
63440
          oprot.writeMapEnd();
63440
          oprot.writeMapEnd();
63441
        }
63441
        }
63442
        oprot.writeFieldEnd();
63442
        oprot.writeFieldEnd();
63443
      }
63443
      }
Line 63837... Line 63837...
63837
        }
63837
        }
63838
        switch (field.id) {
63838
        switch (field.id) {
63839
          case 0: // SUCCESS
63839
          case 0: // SUCCESS
63840
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
63840
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
63841
              {
63841
              {
63842
                org.apache.thrift.protocol.TMap _map190 = iprot.readMapBegin();
63842
                org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin();
63843
                this.success = new HashMap<String,String>(2*_map190.size);
63843
                this.success = new HashMap<String,String>(2*_map198.size);
63844
                for (int _i191 = 0; _i191 < _map190.size; ++_i191)
63844
                for (int _i199 = 0; _i199 < _map198.size; ++_i199)
63845
                {
63845
                {
63846
                  String _key192; // required
63846
                  String _key200; // required
63847
                  String _val193; // required
63847
                  String _val201; // required
63848
                  _key192 = iprot.readString();
63848
                  _key200 = iprot.readString();
63849
                  _val193 = iprot.readString();
63849
                  _val201 = iprot.readString();
63850
                  this.success.put(_key192, _val193);
63850
                  this.success.put(_key200, _val201);
63851
                }
63851
                }
63852
                iprot.readMapEnd();
63852
                iprot.readMapEnd();
63853
              }
63853
              }
63854
            } else { 
63854
            } else { 
63855
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
63855
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 63877... Line 63877...
63877
 
63877
 
63878
      if (this.isSetSuccess()) {
63878
      if (this.isSetSuccess()) {
63879
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63879
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63880
        {
63880
        {
63881
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
63881
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
63882
          for (Map.Entry<String, String> _iter194 : this.success.entrySet())
63882
          for (Map.Entry<String, String> _iter202 : this.success.entrySet())
63883
          {
63883
          {
63884
            oprot.writeString(_iter194.getKey());
63884
            oprot.writeString(_iter202.getKey());
63885
            oprot.writeString(_iter194.getValue());
63885
            oprot.writeString(_iter202.getValue());
63886
          }
63886
          }
63887
          oprot.writeMapEnd();
63887
          oprot.writeMapEnd();
63888
        }
63888
        }
63889
        oprot.writeFieldEnd();
63889
        oprot.writeFieldEnd();
63890
      } else if (this.isSetEx()) {
63890
      } else if (this.isSetEx()) {
Line 64496... Line 64496...
64496
        }
64496
        }
64497
        switch (field.id) {
64497
        switch (field.id) {
64498
          case 0: // SUCCESS
64498
          case 0: // SUCCESS
64499
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
64499
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
64500
              {
64500
              {
64501
                org.apache.thrift.protocol.TList _list195 = iprot.readListBegin();
64501
                org.apache.thrift.protocol.TList _list203 = iprot.readListBegin();
64502
                this.success = new ArrayList<Long>(_list195.size);
64502
                this.success = new ArrayList<Long>(_list203.size);
64503
                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
64503
                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
64504
                {
64504
                {
64505
                  long _elem197; // required
64505
                  long _elem205; // required
64506
                  _elem197 = iprot.readI64();
64506
                  _elem205 = iprot.readI64();
64507
                  this.success.add(_elem197);
64507
                  this.success.add(_elem205);
64508
                }
64508
                }
64509
                iprot.readListEnd();
64509
                iprot.readListEnd();
64510
              }
64510
              }
64511
            } else { 
64511
            } else { 
64512
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
64512
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 64526... Line 64526...
64526
 
64526
 
64527
      if (this.isSetSuccess()) {
64527
      if (this.isSetSuccess()) {
64528
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
64528
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
64529
        {
64529
        {
64530
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
64530
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
64531
          for (long _iter198 : this.success)
64531
          for (long _iter206 : this.success)
64532
          {
64532
          {
64533
            oprot.writeI64(_iter198);
64533
            oprot.writeI64(_iter206);
64534
          }
64534
          }
64535
          oprot.writeListEnd();
64535
          oprot.writeListEnd();
64536
        }
64536
        }
64537
        oprot.writeFieldEnd();
64537
        oprot.writeFieldEnd();
64538
      }
64538
      }
Line 65622... Line 65622...
65622
        }
65622
        }
65623
        switch (field.id) {
65623
        switch (field.id) {
65624
          case 0: // SUCCESS
65624
          case 0: // SUCCESS
65625
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
65625
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
65626
              {
65626
              {
65627
                org.apache.thrift.protocol.TMap _map199 = iprot.readMapBegin();
65627
                org.apache.thrift.protocol.TMap _map207 = iprot.readMapBegin();
65628
                this.success = new HashMap<Long,Long>(2*_map199.size);
65628
                this.success = new HashMap<Long,Long>(2*_map207.size);
65629
                for (int _i200 = 0; _i200 < _map199.size; ++_i200)
65629
                for (int _i208 = 0; _i208 < _map207.size; ++_i208)
65630
                {
65630
                {
65631
                  long _key201; // required
65631
                  long _key209; // required
65632
                  long _val202; // required
65632
                  long _val210; // required
65633
                  _key201 = iprot.readI64();
65633
                  _key209 = iprot.readI64();
65634
                  _val202 = iprot.readI64();
65634
                  _val210 = iprot.readI64();
65635
                  this.success.put(_key201, _val202);
65635
                  this.success.put(_key209, _val210);
65636
                }
65636
                }
65637
                iprot.readMapEnd();
65637
                iprot.readMapEnd();
65638
              }
65638
              }
65639
            } else { 
65639
            } else { 
65640
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
65640
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 65654... Line 65654...
65654
 
65654
 
65655
      if (this.isSetSuccess()) {
65655
      if (this.isSetSuccess()) {
65656
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65656
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65657
        {
65657
        {
65658
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
65658
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
65659
          for (Map.Entry<Long, Long> _iter203 : this.success.entrySet())
65659
          for (Map.Entry<Long, Long> _iter211 : this.success.entrySet())
65660
          {
65660
          {
65661
            oprot.writeI64(_iter203.getKey());
65661
            oprot.writeI64(_iter211.getKey());
65662
            oprot.writeI64(_iter203.getValue());
65662
            oprot.writeI64(_iter211.getValue());
65663
          }
65663
          }
65664
          oprot.writeMapEnd();
65664
          oprot.writeMapEnd();
65665
        }
65665
        }
65666
        oprot.writeFieldEnd();
65666
        oprot.writeFieldEnd();
65667
      }
65667
      }
Line 65955... Line 65955...
65955
        }
65955
        }
65956
        switch (field.id) {
65956
        switch (field.id) {
65957
          case 1: // ITEM_IDS
65957
          case 1: // ITEM_IDS
65958
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65958
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65959
              {
65959
              {
65960
                org.apache.thrift.protocol.TList _list204 = iprot.readListBegin();
65960
                org.apache.thrift.protocol.TList _list212 = iprot.readListBegin();
65961
                this.itemIds = new ArrayList<Long>(_list204.size);
65961
                this.itemIds = new ArrayList<Long>(_list212.size);
65962
                for (int _i205 = 0; _i205 < _list204.size; ++_i205)
65962
                for (int _i213 = 0; _i213 < _list212.size; ++_i213)
65963
                {
65963
                {
65964
                  long _elem206; // required
65964
                  long _elem214; // required
65965
                  _elem206 = iprot.readI64();
65965
                  _elem214 = iprot.readI64();
65966
                  this.itemIds.add(_elem206);
65966
                  this.itemIds.add(_elem214);
65967
                }
65967
                }
65968
                iprot.readListEnd();
65968
                iprot.readListEnd();
65969
              }
65969
              }
65970
            } else { 
65970
            } else { 
65971
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
65971
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 65986... Line 65986...
65986
      oprot.writeStructBegin(STRUCT_DESC);
65986
      oprot.writeStructBegin(STRUCT_DESC);
65987
      if (this.itemIds != null) {
65987
      if (this.itemIds != null) {
65988
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
65988
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
65989
        {
65989
        {
65990
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
65990
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
65991
          for (long _iter207 : this.itemIds)
65991
          for (long _iter215 : this.itemIds)
65992
          {
65992
          {
65993
            oprot.writeI64(_iter207);
65993
            oprot.writeI64(_iter215);
65994
          }
65994
          }
65995
          oprot.writeListEnd();
65995
          oprot.writeListEnd();
65996
        }
65996
        }
65997
        oprot.writeFieldEnd();
65997
        oprot.writeFieldEnd();
65998
      }
65998
      }
Line 66286... Line 66286...
66286
        }
66286
        }
66287
        switch (field.id) {
66287
        switch (field.id) {
66288
          case 0: // SUCCESS
66288
          case 0: // SUCCESS
66289
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66289
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66290
              {
66290
              {
66291
                org.apache.thrift.protocol.TList _list208 = iprot.readListBegin();
66291
                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
66292
                this.success = new ArrayList<Order>(_list208.size);
66292
                this.success = new ArrayList<Order>(_list216.size);
66293
                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
66293
                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
66294
                {
66294
                {
66295
                  Order _elem210; // required
66295
                  Order _elem218; // required
66296
                  _elem210 = new Order();
66296
                  _elem218 = new Order();
66297
                  _elem210.read(iprot);
66297
                  _elem218.read(iprot);
66298
                  this.success.add(_elem210);
66298
                  this.success.add(_elem218);
66299
                }
66299
                }
66300
                iprot.readListEnd();
66300
                iprot.readListEnd();
66301
              }
66301
              }
66302
            } else { 
66302
            } else { 
66303
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
66303
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 66317... Line 66317...
66317
 
66317
 
66318
      if (this.isSetSuccess()) {
66318
      if (this.isSetSuccess()) {
66319
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66319
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66320
        {
66320
        {
66321
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66321
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66322
          for (Order _iter211 : this.success)
66322
          for (Order _iter219 : this.success)
66323
          {
66323
          {
66324
            _iter211.write(oprot);
66324
            _iter219.write(oprot);
66325
          }
66325
          }
66326
          oprot.writeListEnd();
66326
          oprot.writeListEnd();
66327
        }
66327
        }
66328
        oprot.writeFieldEnd();
66328
        oprot.writeFieldEnd();
66329
      }
66329
      }
Line 74275... Line 74275...
74275
        }
74275
        }
74276
        switch (field.id) {
74276
        switch (field.id) {
74277
          case 0: // SUCCESS
74277
          case 0: // SUCCESS
74278
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
74278
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
74279
              {
74279
              {
74280
                org.apache.thrift.protocol.TMap _map212 = iprot.readMapBegin();
74280
                org.apache.thrift.protocol.TMap _map220 = iprot.readMapBegin();
74281
                this.success = new HashMap<Integer,TimeoutSummary>(2*_map212.size);
74281
                this.success = new HashMap<Integer,TimeoutSummary>(2*_map220.size);
74282
                for (int _i213 = 0; _i213 < _map212.size; ++_i213)
74282
                for (int _i221 = 0; _i221 < _map220.size; ++_i221)
74283
                {
74283
                {
74284
                  int _key214; // required
74284
                  int _key222; // required
74285
                  TimeoutSummary _val215; // required
74285
                  TimeoutSummary _val223; // required
74286
                  _key214 = iprot.readI32();
74286
                  _key222 = iprot.readI32();
74287
                  _val215 = new TimeoutSummary();
74287
                  _val223 = new TimeoutSummary();
74288
                  _val215.read(iprot);
74288
                  _val223.read(iprot);
74289
                  this.success.put(_key214, _val215);
74289
                  this.success.put(_key222, _val223);
74290
                }
74290
                }
74291
                iprot.readMapEnd();
74291
                iprot.readMapEnd();
74292
              }
74292
              }
74293
            } else { 
74293
            } else { 
74294
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
74294
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 74316... Line 74316...
74316
 
74316
 
74317
      if (this.isSetSuccess()) {
74317
      if (this.isSetSuccess()) {
74318
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
74318
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
74319
        {
74319
        {
74320
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
74320
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
74321
          for (Map.Entry<Integer, TimeoutSummary> _iter216 : this.success.entrySet())
74321
          for (Map.Entry<Integer, TimeoutSummary> _iter224 : this.success.entrySet())
74322
          {
74322
          {
74323
            oprot.writeI32(_iter216.getKey());
74323
            oprot.writeI32(_iter224.getKey());
74324
            _iter216.getValue().write(oprot);
74324
            _iter224.getValue().write(oprot);
74325
          }
74325
          }
74326
          oprot.writeMapEnd();
74326
          oprot.writeMapEnd();
74327
        }
74327
        }
74328
        oprot.writeFieldEnd();
74328
        oprot.writeFieldEnd();
74329
      } else if (this.isSetEx()) {
74329
      } else if (this.isSetEx()) {
Line 76059... Line 76059...
76059
            }
76059
            }
76060
            break;
76060
            break;
76061
          case 2: // ORDER_STATUS_LIST
76061
          case 2: // ORDER_STATUS_LIST
76062
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76062
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76063
              {
76063
              {
76064
                org.apache.thrift.protocol.TList _list217 = iprot.readListBegin();
76064
                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
76065
                this.order_status_list = new ArrayList<OrderStatus>(_list217.size);
76065
                this.order_status_list = new ArrayList<OrderStatus>(_list225.size);
76066
                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
76066
                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
76067
                {
76067
                {
76068
                  OrderStatus _elem219; // required
76068
                  OrderStatus _elem227; // required
76069
                  _elem219 = OrderStatus.findByValue(iprot.readI32());
76069
                  _elem227 = OrderStatus.findByValue(iprot.readI32());
76070
                  this.order_status_list.add(_elem219);
76070
                  this.order_status_list.add(_elem227);
76071
                }
76071
                }
76072
                iprot.readListEnd();
76072
                iprot.readListEnd();
76073
              }
76073
              }
76074
            } else { 
76074
            } else { 
76075
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
76075
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 76093... Line 76093...
76093
      oprot.writeFieldEnd();
76093
      oprot.writeFieldEnd();
76094
      if (this.order_status_list != null) {
76094
      if (this.order_status_list != null) {
76095
        oprot.writeFieldBegin(ORDER_STATUS_LIST_FIELD_DESC);
76095
        oprot.writeFieldBegin(ORDER_STATUS_LIST_FIELD_DESC);
76096
        {
76096
        {
76097
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.order_status_list.size()));
76097
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.order_status_list.size()));
76098
          for (OrderStatus _iter220 : this.order_status_list)
76098
          for (OrderStatus _iter228 : this.order_status_list)
76099
          {
76099
          {
76100
            oprot.writeI32(_iter220.getValue());
76100
            oprot.writeI32(_iter228.getValue());
76101
          }
76101
          }
76102
          oprot.writeListEnd();
76102
          oprot.writeListEnd();
76103
        }
76103
        }
76104
        oprot.writeFieldEnd();
76104
        oprot.writeFieldEnd();
76105
      }
76105
      }
Line 76467... Line 76467...
76467
        }
76467
        }
76468
        switch (field.id) {
76468
        switch (field.id) {
76469
          case 0: // SUCCESS
76469
          case 0: // SUCCESS
76470
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76470
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76471
              {
76471
              {
76472
                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
76472
                org.apache.thrift.protocol.TList _list229 = iprot.readListBegin();
76473
                this.success = new ArrayList<Order>(_list221.size);
76473
                this.success = new ArrayList<Order>(_list229.size);
76474
                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
76474
                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
76475
                {
76475
                {
76476
                  Order _elem223; // required
76476
                  Order _elem231; // required
76477
                  _elem223 = new Order();
76477
                  _elem231 = new Order();
76478
                  _elem223.read(iprot);
76478
                  _elem231.read(iprot);
76479
                  this.success.add(_elem223);
76479
                  this.success.add(_elem231);
76480
                }
76480
                }
76481
                iprot.readListEnd();
76481
                iprot.readListEnd();
76482
              }
76482
              }
76483
            } else { 
76483
            } else { 
76484
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
76484
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 76506... Line 76506...
76506
 
76506
 
76507
      if (this.isSetSuccess()) {
76507
      if (this.isSetSuccess()) {
76508
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76508
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76509
        {
76509
        {
76510
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76510
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76511
          for (Order _iter224 : this.success)
76511
          for (Order _iter232 : this.success)
76512
          {
76512
          {
76513
            _iter224.write(oprot);
76513
            _iter232.write(oprot);
76514
          }
76514
          }
76515
          oprot.writeListEnd();
76515
          oprot.writeListEnd();
76516
        }
76516
        }
76517
        oprot.writeFieldEnd();
76517
        oprot.writeFieldEnd();
76518
      } else if (this.isSetEx()) {
76518
      } else if (this.isSetEx()) {
Line 77346... Line 77346...
77346
        }
77346
        }
77347
        switch (field.id) {
77347
        switch (field.id) {
77348
          case 0: // SUCCESS
77348
          case 0: // SUCCESS
77349
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77349
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77350
              {
77350
              {
77351
                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
77351
                org.apache.thrift.protocol.TList _list233 = iprot.readListBegin();
77352
                this.success = new ArrayList<Order>(_list225.size);
77352
                this.success = new ArrayList<Order>(_list233.size);
77353
                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
77353
                for (int _i234 = 0; _i234 < _list233.size; ++_i234)
77354
                {
77354
                {
77355
                  Order _elem227; // required
77355
                  Order _elem235; // required
77356
                  _elem227 = new Order();
77356
                  _elem235 = new Order();
77357
                  _elem227.read(iprot);
77357
                  _elem235.read(iprot);
77358
                  this.success.add(_elem227);
77358
                  this.success.add(_elem235);
77359
                }
77359
                }
77360
                iprot.readListEnd();
77360
                iprot.readListEnd();
77361
              }
77361
              }
77362
            } else { 
77362
            } else { 
77363
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
77363
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 77385... Line 77385...
77385
 
77385
 
77386
      if (this.isSetSuccess()) {
77386
      if (this.isSetSuccess()) {
77387
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77387
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77388
        {
77388
        {
77389
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77389
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77390
          for (Order _iter228 : this.success)
77390
          for (Order _iter236 : this.success)
77391
          {
77391
          {
77392
            _iter228.write(oprot);
77392
            _iter236.write(oprot);
77393
          }
77393
          }
77394
          oprot.writeListEnd();
77394
          oprot.writeListEnd();
77395
        }
77395
        }
77396
        oprot.writeFieldEnd();
77396
        oprot.writeFieldEnd();
77397
      } else if (this.isSetEx()) {
77397
      } else if (this.isSetEx()) {
Line 77965... Line 77965...
77965
        }
77965
        }
77966
        switch (field.id) {
77966
        switch (field.id) {
77967
          case 0: // SUCCESS
77967
          case 0: // SUCCESS
77968
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77968
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77969
              {
77969
              {
77970
                org.apache.thrift.protocol.TList _list229 = iprot.readListBegin();
77970
                org.apache.thrift.protocol.TList _list237 = iprot.readListBegin();
77971
                this.success = new ArrayList<Order>(_list229.size);
77971
                this.success = new ArrayList<Order>(_list237.size);
77972
                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
77972
                for (int _i238 = 0; _i238 < _list237.size; ++_i238)
77973
                {
77973
                {
77974
                  Order _elem231; // required
77974
                  Order _elem239; // required
77975
                  _elem231 = new Order();
77975
                  _elem239 = new Order();
77976
                  _elem231.read(iprot);
77976
                  _elem239.read(iprot);
77977
                  this.success.add(_elem231);
77977
                  this.success.add(_elem239);
77978
                }
77978
                }
77979
                iprot.readListEnd();
77979
                iprot.readListEnd();
77980
              }
77980
              }
77981
            } else { 
77981
            } else { 
77982
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
77982
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 78004... Line 78004...
78004
 
78004
 
78005
      if (this.isSetSuccess()) {
78005
      if (this.isSetSuccess()) {
78006
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
78006
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
78007
        {
78007
        {
78008
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
78008
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
78009
          for (Order _iter232 : this.success)
78009
          for (Order _iter240 : this.success)
78010
          {
78010
          {
78011
            _iter232.write(oprot);
78011
            _iter240.write(oprot);
78012
          }
78012
          }
78013
          oprot.writeListEnd();
78013
          oprot.writeListEnd();
78014
        }
78014
        }
78015
        oprot.writeFieldEnd();
78015
        oprot.writeFieldEnd();
78016
      } else if (this.isSetEx()) {
78016
      } else if (this.isSetEx()) {
Line 78761... Line 78761...
78761
        }
78761
        }
78762
        switch (field.id) {
78762
        switch (field.id) {
78763
          case 0: // SUCCESS
78763
          case 0: // SUCCESS
78764
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
78764
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
78765
              {
78765
              {
78766
                org.apache.thrift.protocol.TList _list233 = iprot.readListBegin();
78766
                org.apache.thrift.protocol.TList _list241 = iprot.readListBegin();
78767
                this.success = new ArrayList<Order>(_list233.size);
78767
                this.success = new ArrayList<Order>(_list241.size);
78768
                for (int _i234 = 0; _i234 < _list233.size; ++_i234)
78768
                for (int _i242 = 0; _i242 < _list241.size; ++_i242)
78769
                {
78769
                {
78770
                  Order _elem235; // required
78770
                  Order _elem243; // required
78771
                  _elem235 = new Order();
78771
                  _elem243 = new Order();
78772
                  _elem235.read(iprot);
78772
                  _elem243.read(iprot);
78773
                  this.success.add(_elem235);
78773
                  this.success.add(_elem243);
78774
                }
78774
                }
78775
                iprot.readListEnd();
78775
                iprot.readListEnd();
78776
              }
78776
              }
78777
            } else { 
78777
            } else { 
78778
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
78778
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 78800... Line 78800...
78800
 
78800
 
78801
      if (this.isSetSuccess()) {
78801
      if (this.isSetSuccess()) {
78802
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
78802
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
78803
        {
78803
        {
78804
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
78804
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
78805
          for (Order _iter236 : this.success)
78805
          for (Order _iter244 : this.success)
78806
          {
78806
          {
78807
            _iter236.write(oprot);
78807
            _iter244.write(oprot);
78808
          }
78808
          }
78809
          oprot.writeListEnd();
78809
          oprot.writeListEnd();
78810
        }
78810
        }
78811
        oprot.writeFieldEnd();
78811
        oprot.writeFieldEnd();
78812
      } else if (this.isSetEx()) {
78812
      } else if (this.isSetEx()) {
Line 79117... Line 79117...
79117
        }
79117
        }
79118
        switch (field.id) {
79118
        switch (field.id) {
79119
          case 1: // MAP_AWBAND_AMOUNT
79119
          case 1: // MAP_AWBAND_AMOUNT
79120
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
79120
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
79121
              {
79121
              {
79122
                org.apache.thrift.protocol.TMap _map237 = iprot.readMapBegin();
79122
                org.apache.thrift.protocol.TMap _map245 = iprot.readMapBegin();
79123
                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map237.size);
79123
                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map245.size);
79124
                for (int _i238 = 0; _i238 < _map237.size; ++_i238)
79124
                for (int _i246 = 0; _i246 < _map245.size; ++_i246)
79125
                {
79125
                {
79126
                  long _key239; // required
79126
                  long _key247; // required
79127
                  double _val240; // required
79127
                  double _val248; // required
79128
                  _key239 = iprot.readI64();
79128
                  _key247 = iprot.readI64();
79129
                  _val240 = iprot.readDouble();
79129
                  _val248 = iprot.readDouble();
79130
                  this.mapAWBAndAmount.put(_key239, _val240);
79130
                  this.mapAWBAndAmount.put(_key247, _val248);
79131
                }
79131
                }
79132
                iprot.readMapEnd();
79132
                iprot.readMapEnd();
79133
              }
79133
              }
79134
            } else { 
79134
            } else { 
79135
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
79135
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 79150... Line 79150...
79150
      oprot.writeStructBegin(STRUCT_DESC);
79150
      oprot.writeStructBegin(STRUCT_DESC);
79151
      if (this.mapAWBAndAmount != null) {
79151
      if (this.mapAWBAndAmount != null) {
79152
        oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
79152
        oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
79153
        {
79153
        {
79154
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
79154
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
79155
          for (Map.Entry<Long, Double> _iter241 : this.mapAWBAndAmount.entrySet())
79155
          for (Map.Entry<Long, Double> _iter249 : this.mapAWBAndAmount.entrySet())
79156
          {
79156
          {
79157
            oprot.writeI64(_iter241.getKey());
79157
            oprot.writeI64(_iter249.getKey());
79158
            oprot.writeDouble(_iter241.getValue());
79158
            oprot.writeDouble(_iter249.getValue());
79159
          }
79159
          }
79160
          oprot.writeMapEnd();
79160
          oprot.writeMapEnd();
79161
        }
79161
        }
79162
        oprot.writeFieldEnd();
79162
        oprot.writeFieldEnd();
79163
      }
79163
      }
Line 82617... Line 82617...
82617
        }
82617
        }
82618
        switch (field.id) {
82618
        switch (field.id) {
82619
          case 0: // SUCCESS
82619
          case 0: // SUCCESS
82620
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
82620
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
82621
              {
82621
              {
82622
                org.apache.thrift.protocol.TMap _map242 = iprot.readMapBegin();
82622
                org.apache.thrift.protocol.TMap _map250 = iprot.readMapBegin();
82623
                this.success = new HashMap<Long,String>(2*_map242.size);
82623
                this.success = new HashMap<Long,String>(2*_map250.size);
82624
                for (int _i243 = 0; _i243 < _map242.size; ++_i243)
82624
                for (int _i251 = 0; _i251 < _map250.size; ++_i251)
82625
                {
82625
                {
82626
                  long _key244; // required
82626
                  long _key252; // required
82627
                  String _val245; // required
82627
                  String _val253; // required
82628
                  _key244 = iprot.readI64();
82628
                  _key252 = iprot.readI64();
82629
                  _val245 = iprot.readString();
82629
                  _val253 = iprot.readString();
82630
                  this.success.put(_key244, _val245);
82630
                  this.success.put(_key252, _val253);
82631
                }
82631
                }
82632
                iprot.readMapEnd();
82632
                iprot.readMapEnd();
82633
              }
82633
              }
82634
            } else { 
82634
            } else { 
82635
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
82635
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 82657... Line 82657...
82657
 
82657
 
82658
      if (this.isSetSuccess()) {
82658
      if (this.isSetSuccess()) {
82659
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
82659
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
82660
        {
82660
        {
82661
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, this.success.size()));
82661
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, this.success.size()));
82662
          for (Map.Entry<Long, String> _iter246 : this.success.entrySet())
82662
          for (Map.Entry<Long, String> _iter254 : this.success.entrySet())
82663
          {
82663
          {
82664
            oprot.writeI64(_iter246.getKey());
82664
            oprot.writeI64(_iter254.getKey());
82665
            oprot.writeString(_iter246.getValue());
82665
            oprot.writeString(_iter254.getValue());
82666
          }
82666
          }
82667
          oprot.writeMapEnd();
82667
          oprot.writeMapEnd();
82668
        }
82668
        }
82669
        oprot.writeFieldEnd();
82669
        oprot.writeFieldEnd();
82670
      } else if (this.isSetEx()) {
82670
      } else if (this.isSetEx()) {
Line 84761... Line 84761...
84761
        }
84761
        }
84762
        switch (field.id) {
84762
        switch (field.id) {
84763
          case 0: // SUCCESS
84763
          case 0: // SUCCESS
84764
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84764
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84765
              {
84765
              {
84766
                org.apache.thrift.protocol.TList _list247 = iprot.readListBegin();
84766
                org.apache.thrift.protocol.TList _list255 = iprot.readListBegin();
84767
                this.success = new ArrayList<PaymentSettlement>(_list247.size);
84767
                this.success = new ArrayList<PaymentSettlement>(_list255.size);
84768
                for (int _i248 = 0; _i248 < _list247.size; ++_i248)
84768
                for (int _i256 = 0; _i256 < _list255.size; ++_i256)
84769
                {
84769
                {
84770
                  PaymentSettlement _elem249; // required
84770
                  PaymentSettlement _elem257; // required
84771
                  _elem249 = new PaymentSettlement();
84771
                  _elem257 = new PaymentSettlement();
84772
                  _elem249.read(iprot);
84772
                  _elem257.read(iprot);
84773
                  this.success.add(_elem249);
84773
                  this.success.add(_elem257);
84774
                }
84774
                }
84775
                iprot.readListEnd();
84775
                iprot.readListEnd();
84776
              }
84776
              }
84777
            } else { 
84777
            } else { 
84778
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
84778
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 84800... Line 84800...
84800
 
84800
 
84801
      if (this.isSetSuccess()) {
84801
      if (this.isSetSuccess()) {
84802
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
84802
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
84803
        {
84803
        {
84804
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
84804
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
84805
          for (PaymentSettlement _iter250 : this.success)
84805
          for (PaymentSettlement _iter258 : this.success)
84806
          {
84806
          {
84807
            _iter250.write(oprot);
84807
            _iter258.write(oprot);
84808
          }
84808
          }
84809
          oprot.writeListEnd();
84809
          oprot.writeListEnd();
84810
        }
84810
        }
84811
        oprot.writeFieldEnd();
84811
        oprot.writeFieldEnd();
84812
      } else if (this.isSetEx()) {
84812
      } else if (this.isSetEx()) {
Line 85112... Line 85112...
85112
        }
85112
        }
85113
        switch (field.id) {
85113
        switch (field.id) {
85114
          case 1: // ORDER_IDS
85114
          case 1: // ORDER_IDS
85115
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
85115
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
85116
              {
85116
              {
85117
                org.apache.thrift.protocol.TList _list251 = iprot.readListBegin();
85117
                org.apache.thrift.protocol.TList _list259 = iprot.readListBegin();
85118
                this.orderIds = new ArrayList<Long>(_list251.size);
85118
                this.orderIds = new ArrayList<Long>(_list259.size);
85119
                for (int _i252 = 0; _i252 < _list251.size; ++_i252)
85119
                for (int _i260 = 0; _i260 < _list259.size; ++_i260)
85120
                {
85120
                {
85121
                  long _elem253; // required
85121
                  long _elem261; // required
85122
                  _elem253 = iprot.readI64();
85122
                  _elem261 = iprot.readI64();
85123
                  this.orderIds.add(_elem253);
85123
                  this.orderIds.add(_elem261);
85124
                }
85124
                }
85125
                iprot.readListEnd();
85125
                iprot.readListEnd();
85126
              }
85126
              }
85127
            } else { 
85127
            } else { 
85128
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
85128
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 85143... Line 85143...
85143
      oprot.writeStructBegin(STRUCT_DESC);
85143
      oprot.writeStructBegin(STRUCT_DESC);
85144
      if (this.orderIds != null) {
85144
      if (this.orderIds != null) {
85145
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
85145
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
85146
        {
85146
        {
85147
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
85147
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
85148
          for (long _iter254 : this.orderIds)
85148
          for (long _iter262 : this.orderIds)
85149
          {
85149
          {
85150
            oprot.writeI64(_iter254);
85150
            oprot.writeI64(_iter262);
85151
          }
85151
          }
85152
          oprot.writeListEnd();
85152
          oprot.writeListEnd();
85153
        }
85153
        }
85154
        oprot.writeFieldEnd();
85154
        oprot.writeFieldEnd();
85155
      }
85155
      }
Line 85511... Line 85511...
85511
        }
85511
        }
85512
        switch (field.id) {
85512
        switch (field.id) {
85513
          case 0: // SUCCESS
85513
          case 0: // SUCCESS
85514
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
85514
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
85515
              {
85515
              {
85516
                org.apache.thrift.protocol.TList _list255 = iprot.readListBegin();
85516
                org.apache.thrift.protocol.TList _list263 = iprot.readListBegin();
85517
                this.success = new ArrayList<Long>(_list255.size);
85517
                this.success = new ArrayList<Long>(_list263.size);
85518
                for (int _i256 = 0; _i256 < _list255.size; ++_i256)
85518
                for (int _i264 = 0; _i264 < _list263.size; ++_i264)
85519
                {
85519
                {
85520
                  long _elem257; // required
85520
                  long _elem265; // required
85521
                  _elem257 = iprot.readI64();
85521
                  _elem265 = iprot.readI64();
85522
                  this.success.add(_elem257);
85522
                  this.success.add(_elem265);
85523
                }
85523
                }
85524
                iprot.readListEnd();
85524
                iprot.readListEnd();
85525
              }
85525
              }
85526
            } else { 
85526
            } else { 
85527
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
85527
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 85549... Line 85549...
85549
 
85549
 
85550
      if (this.isSetSuccess()) {
85550
      if (this.isSetSuccess()) {
85551
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
85551
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
85552
        {
85552
        {
85553
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
85553
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
85554
          for (long _iter258 : this.success)
85554
          for (long _iter266 : this.success)
85555
          {
85555
          {
85556
            oprot.writeI64(_iter258);
85556
            oprot.writeI64(_iter266);
85557
          }
85557
          }
85558
          oprot.writeListEnd();
85558
          oprot.writeListEnd();
85559
        }
85559
        }
85560
        oprot.writeFieldEnd();
85560
        oprot.writeFieldEnd();
85561
      } else if (this.isSetEx()) {
85561
      } else if (this.isSetEx()) {
Line 86005... Line 86005...
86005
        }
86005
        }
86006
        switch (field.id) {
86006
        switch (field.id) {
86007
          case 1: // ITEM_ID_QUANTITY_MAP
86007
          case 1: // ITEM_ID_QUANTITY_MAP
86008
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
86008
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
86009
              {
86009
              {
86010
                org.apache.thrift.protocol.TMap _map259 = iprot.readMapBegin();
86010
                org.apache.thrift.protocol.TMap _map267 = iprot.readMapBegin();
86011
                this.itemIdQuantityMap = new HashMap<Long,Long>(2*_map259.size);
86011
                this.itemIdQuantityMap = new HashMap<Long,Long>(2*_map267.size);
86012
                for (int _i260 = 0; _i260 < _map259.size; ++_i260)
86012
                for (int _i268 = 0; _i268 < _map267.size; ++_i268)
86013
                {
86013
                {
86014
                  long _key261; // required
86014
                  long _key269; // required
86015
                  long _val262; // required
86015
                  long _val270; // required
86016
                  _key261 = iprot.readI64();
86016
                  _key269 = iprot.readI64();
86017
                  _val262 = iprot.readI64();
86017
                  _val270 = iprot.readI64();
86018
                  this.itemIdQuantityMap.put(_key261, _val262);
86018
                  this.itemIdQuantityMap.put(_key269, _val270);
86019
                }
86019
                }
86020
                iprot.readMapEnd();
86020
                iprot.readMapEnd();
86021
              }
86021
              }
86022
            } else { 
86022
            } else { 
86023
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
86023
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 86054... Line 86054...
86054
      oprot.writeStructBegin(STRUCT_DESC);
86054
      oprot.writeStructBegin(STRUCT_DESC);
86055
      if (this.itemIdQuantityMap != null) {
86055
      if (this.itemIdQuantityMap != null) {
86056
        oprot.writeFieldBegin(ITEM_ID_QUANTITY_MAP_FIELD_DESC);
86056
        oprot.writeFieldBegin(ITEM_ID_QUANTITY_MAP_FIELD_DESC);
86057
        {
86057
        {
86058
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemIdQuantityMap.size()));
86058
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemIdQuantityMap.size()));
86059
          for (Map.Entry<Long, Long> _iter263 : this.itemIdQuantityMap.entrySet())
86059
          for (Map.Entry<Long, Long> _iter271 : this.itemIdQuantityMap.entrySet())
86060
          {
86060
          {
86061
            oprot.writeI64(_iter263.getKey());
86061
            oprot.writeI64(_iter271.getKey());
86062
            oprot.writeI64(_iter263.getValue());
86062
            oprot.writeI64(_iter271.getValue());
86063
          }
86063
          }
86064
          oprot.writeMapEnd();
86064
          oprot.writeMapEnd();
86065
        }
86065
        }
86066
        oprot.writeFieldEnd();
86066
        oprot.writeFieldEnd();
86067
      }
86067
      }
Line 87027... Line 87027...
87027
        }
87027
        }
87028
        switch (field.id) {
87028
        switch (field.id) {
87029
          case 0: // SUCCESS
87029
          case 0: // SUCCESS
87030
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87030
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87031
              {
87031
              {
87032
                org.apache.thrift.protocol.TList _list264 = iprot.readListBegin();
87032
                org.apache.thrift.protocol.TList _list272 = iprot.readListBegin();
87033
                this.success = new ArrayList<Order>(_list264.size);
87033
                this.success = new ArrayList<Order>(_list272.size);
87034
                for (int _i265 = 0; _i265 < _list264.size; ++_i265)
87034
                for (int _i273 = 0; _i273 < _list272.size; ++_i273)
87035
                {
87035
                {
87036
                  Order _elem266; // required
87036
                  Order _elem274; // required
87037
                  _elem266 = new Order();
87037
                  _elem274 = new Order();
87038
                  _elem266.read(iprot);
87038
                  _elem274.read(iprot);
87039
                  this.success.add(_elem266);
87039
                  this.success.add(_elem274);
87040
                }
87040
                }
87041
                iprot.readListEnd();
87041
                iprot.readListEnd();
87042
              }
87042
              }
87043
            } else { 
87043
            } else { 
87044
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
87044
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 87066... Line 87066...
87066
 
87066
 
87067
      if (this.isSetSuccess()) {
87067
      if (this.isSetSuccess()) {
87068
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87068
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87069
        {
87069
        {
87070
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87070
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87071
          for (Order _iter267 : this.success)
87071
          for (Order _iter275 : this.success)
87072
          {
87072
          {
87073
            _iter267.write(oprot);
87073
            _iter275.write(oprot);
87074
          }
87074
          }
87075
          oprot.writeListEnd();
87075
          oprot.writeListEnd();
87076
        }
87076
        }
87077
        oprot.writeFieldEnd();
87077
        oprot.writeFieldEnd();
87078
      } else if (this.isSetEx()) {
87078
      } else if (this.isSetEx()) {