Subversion Repositories SmartDukaan

Rev

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

Rev 4801 Rev 4815
Line 11053... Line 11053...
11053 
        }
 11053 
        }
11054 
        switch (field.id) {
 11054 
        switch (field.id) {
11055 
          case 0: // SUCCESS
 11055 
          case 0: // SUCCESS
11056 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 11056 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11057 
              {
 11057 
              {
11058 
                org.apache.thrift.protocol.TList _list8 = iprot.readListBegin();
 11058 
                org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
11059 
                this.success = new ArrayList<Transaction>(_list8.size);
 11059 
                this.success = new ArrayList<Transaction>(_list20.size);
11060 
                for (int _i9 = 0; _i9 < _list8.size; ++_i9)
 11060 
                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
11061 
                {
 11061 
                {
11062 
                  Transaction _elem10; // required
 11062 
                  Transaction _elem22; // required
11063 
                  _elem10 = new Transaction();
 11063 
                  _elem22 = new Transaction();
11064 
                  _elem10.read(iprot);
 11064 
                  _elem22.read(iprot);
11065 
                  this.success.add(_elem10);
 11065 
                  this.success.add(_elem22);
11066 
                }
 11066 
                }
11067 
                iprot.readListEnd();
 11067 
                iprot.readListEnd();
11068 
              }
 11068 
              }
11069 
            } else {
11069 
            } else {
11070 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 11070 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11092... Line 11092...
11092 
 
 11092 
 
11093 
      if (this.isSetSuccess()) {
 11093 
      if (this.isSetSuccess()) {
11094 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 11094 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11095 
        {
 11095 
        {
11096 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 11096 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
11097 
          for (Transaction _iter11 : this.success)
 11097 
          for (Transaction _iter23 : this.success)
11098 
          {
 11098 
          {
11099 
            _iter11.write(oprot);
 11099 
            _iter23.write(oprot);
11100 
          }
 11100 
          }
11101 
          oprot.writeListEnd();
 11101 
          oprot.writeListEnd();
11102 
        }
 11102 
        }
11103 
        oprot.writeFieldEnd();
 11103 
        oprot.writeFieldEnd();
11104 
      } else if (this.isSetEx()) {
 11104 
      } else if (this.isSetEx()) {
Line 11766... Line 11766...
11766 
        }
 11766 
        }
11767 
        switch (field.id) {
 11767 
        switch (field.id) {
11768 
          case 0: // SUCCESS
 11768 
          case 0: // SUCCESS
11769 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 11769 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11770 
              {
 11770 
              {
11771 
                org.apache.thrift.protocol.TList _list12 = iprot.readListBegin();
 11771 
                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
11772 
                this.success = new ArrayList<Transaction>(_list12.size);
 11772 
                this.success = new ArrayList<Transaction>(_list24.size);
11773 
                for (int _i13 = 0; _i13 < _list12.size; ++_i13)
 11773 
                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
11774 
                {
 11774 
                {
11775 
                  Transaction _elem14; // required
 11775 
                  Transaction _elem26; // required
11776 
                  _elem14 = new Transaction();
 11776 
                  _elem26 = new Transaction();
11777 
                  _elem14.read(iprot);
 11777 
                  _elem26.read(iprot);
11778 
                  this.success.add(_elem14);
 11778 
                  this.success.add(_elem26);
11779 
                }
 11779 
                }
11780 
                iprot.readListEnd();
 11780 
                iprot.readListEnd();
11781 
              }
 11781 
              }
11782 
            } else {
11782 
            } else {
11783 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 11783 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11805... Line 11805...
11805 
 
 11805 
 
11806 
      if (this.isSetSuccess()) {
 11806 
      if (this.isSetSuccess()) {
11807 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 11807 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11808 
        {
 11808 
        {
11809 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 11809 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
11810 
          for (Transaction _iter15 : this.success)
 11810 
          for (Transaction _iter27 : this.success)
11811 
          {
 11811 
          {
11812 
            _iter15.write(oprot);
 11812 
            _iter27.write(oprot);
11813 
          }
 11813 
          }
11814 
          oprot.writeListEnd();
 11814 
          oprot.writeListEnd();
11815 
        }
 11815 
        }
11816 
        oprot.writeFieldEnd();
 11816 
        oprot.writeFieldEnd();
11817 
      } else if (this.isSetEx()) {
 11817 
      } else if (this.isSetEx()) {
Line 14549... Line 14549...
14549 
        }
 14549 
        }
14550 
        switch (field.id) {
 14550 
        switch (field.id) {
14551 
          case 1: // STATUSES
 14551 
          case 1: // STATUSES
14552 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 14552 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
14553 
              {
 14553 
              {
14554 
                org.apache.thrift.protocol.TList _list16 = iprot.readListBegin();
 14554 
                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
14555 
                this.statuses = new ArrayList<OrderStatus>(_list16.size);
 14555 
                this.statuses = new ArrayList<OrderStatus>(_list28.size);
14556 
                for (int _i17 = 0; _i17 < _list16.size; ++_i17)
 14556 
                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
14557 
                {
 14557 
                {
14558 
                  OrderStatus _elem18; // required
 14558 
                  OrderStatus _elem30; // required
14559 
                  _elem18 = OrderStatus.findByValue(iprot.readI32());
 14559 
                  _elem30 = OrderStatus.findByValue(iprot.readI32());
14560 
                  this.statuses.add(_elem18);
 14560 
                  this.statuses.add(_elem30);
14561 
                }
 14561 
                }
14562 
                iprot.readListEnd();
 14562 
                iprot.readListEnd();
14563 
              }
 14563 
              }
14564 
            } else {
14564 
            } else {
14565 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 14565 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 14604... Line 14604...
14604 
      oprot.writeStructBegin(STRUCT_DESC);
 14604 
      oprot.writeStructBegin(STRUCT_DESC);
14605 
      if (this.statuses != null) {
 14605 
      if (this.statuses != null) {
14606 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
 14606 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
14607 
        {
 14607 
        {
14608 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
 14608 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
14609 
          for (OrderStatus _iter19 : this.statuses)
 14609 
          for (OrderStatus _iter31 : this.statuses)
14610 
          {
 14610 
          {
14611 
            oprot.writeI32(_iter19.getValue());
 14611 
            oprot.writeI32(_iter31.getValue());
14612 
          }
 14612 
          }
14613 
          oprot.writeListEnd();
 14613 
          oprot.writeListEnd();
14614 
        }
 14614 
        }
14615 
        oprot.writeFieldEnd();
 14615 
        oprot.writeFieldEnd();
14616 
      }
 14616 
      }
Line 14995... Line 14995...
14995 
        }
 14995 
        }
14996 
        switch (field.id) {
 14996 
        switch (field.id) {
14997 
          case 0: // SUCCESS
 14997 
          case 0: // SUCCESS
14998 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 14998 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
14999 
              {
 14999 
              {
15000 
                org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
 15000 
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
15001 
                this.success = new ArrayList<Order>(_list20.size);
 15001 
                this.success = new ArrayList<Order>(_list32.size);
15002 
                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
 15002 
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
15003 
                {
 15003 
                {
15004 
                  Order _elem22; // required
 15004 
                  Order _elem34; // required
15005 
                  _elem22 = new Order();
 15005 
                  _elem34 = new Order();
15006 
                  _elem22.read(iprot);
 15006 
                  _elem34.read(iprot);
15007 
                  this.success.add(_elem22);
 15007 
                  this.success.add(_elem34);
15008 
                }
 15008 
                }
15009 
                iprot.readListEnd();
 15009 
                iprot.readListEnd();
15010 
              }
 15010 
              }
15011 
            } else {
15011 
            } else {
15012 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 15012 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 15034... Line 15034...
15034 
 
 15034 
 
15035 
      if (this.isSetSuccess()) {
 15035 
      if (this.isSetSuccess()) {
15036 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 15036 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15037 
        {
 15037 
        {
15038 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 15038 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
15039 
          for (Order _iter23 : this.success)
 15039 
          for (Order _iter35 : this.success)
15040 
          {
 15040 
          {
15041 
            _iter23.write(oprot);
 15041 
            _iter35.write(oprot);
15042 
          }
 15042 
          }
15043 
          oprot.writeListEnd();
 15043 
          oprot.writeListEnd();
15044 
        }
 15044 
        }
15045 
        oprot.writeFieldEnd();
 15045 
        oprot.writeFieldEnd();
15046 
      } else if (this.isSetEx()) {
 15046 
      } else if (this.isSetEx()) {
Line 15553... Line 15553...
15553 
        }
 15553 
        }
15554 
        switch (field.id) {
 15554 
        switch (field.id) {
15555 
          case 1: // STATUSES
 15555 
          case 1: // STATUSES
15556 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 15556 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
15557 
              {
 15557 
              {
15558 
                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
 15558 
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
15559 
                this.statuses = new ArrayList<OrderStatus>(_list24.size);
 15559 
                this.statuses = new ArrayList<OrderStatus>(_list36.size);
15560 
                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
 15560 
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
15561 
                {
 15561 
                {
15562 
                  OrderStatus _elem26; // required
 15562 
                  OrderStatus _elem38; // required
15563 
                  _elem26 = OrderStatus.findByValue(iprot.readI32());
 15563 
                  _elem38 = OrderStatus.findByValue(iprot.readI32());
15564 
                  this.statuses.add(_elem26);
 15564 
                  this.statuses.add(_elem38);
15565 
                }
 15565 
                }
15566 
                iprot.readListEnd();
 15566 
                iprot.readListEnd();
15567 
              }
 15567 
              }
15568 
            } else {
15568 
            } else {
15569 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 15569 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 15608... Line 15608...
15608 
      oprot.writeStructBegin(STRUCT_DESC);
 15608 
      oprot.writeStructBegin(STRUCT_DESC);
15609 
      if (this.statuses != null) {
 15609 
      if (this.statuses != null) {
15610 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
 15610 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
15611 
        {
 15611 
        {
15612 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
 15612 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
15613 
          for (OrderStatus _iter27 : this.statuses)
 15613 
          for (OrderStatus _iter39 : this.statuses)
15614 
          {
 15614 
          {
15615 
            oprot.writeI32(_iter27.getValue());
 15615 
            oprot.writeI32(_iter39.getValue());
15616 
          }
 15616 
          }
15617 
          oprot.writeListEnd();
 15617 
          oprot.writeListEnd();
15618 
        }
 15618 
        }
15619 
        oprot.writeFieldEnd();
 15619 
        oprot.writeFieldEnd();
15620 
      }
 15620 
      }
Line 15997... Line 15997...
15997 
        }
 15997 
        }
15998 
        switch (field.id) {
 15998 
        switch (field.id) {
15999 
          case 0: // SUCCESS
 15999 
          case 0: // SUCCESS
16000 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 16000 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16001 
              {
 16001 
              {
16002 
                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
 16002 
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
16003 
                this.success = new ArrayList<Order>(_list28.size);
 16003 
                this.success = new ArrayList<Order>(_list40.size);
16004 
                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
 16004 
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
16005 
                {
 16005 
                {
16006 
                  Order _elem30; // required
 16006 
                  Order _elem42; // required
16007 
                  _elem30 = new Order();
 16007 
                  _elem42 = new Order();
16008 
                  _elem30.read(iprot);
 16008 
                  _elem42.read(iprot);
16009 
                  this.success.add(_elem30);
 16009 
                  this.success.add(_elem42);
16010 
                }
 16010 
                }
16011 
                iprot.readListEnd();
 16011 
                iprot.readListEnd();
16012 
              }
 16012 
              }
16013 
            } else {
16013 
            } else {
16014 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 16014 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 16036... Line 16036...
16036 
 
 16036 
 
16037 
      if (this.isSetSuccess()) {
 16037 
      if (this.isSetSuccess()) {
16038 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 16038 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16039 
        {
 16039 
        {
16040 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 16040 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
16041 
          for (Order _iter31 : this.success)
 16041 
          for (Order _iter43 : this.success)
16042 
          {
 16042 
          {
16043 
            _iter31.write(oprot);
 16043 
            _iter43.write(oprot);
16044 
          }
 16044 
          }
16045 
          oprot.writeListEnd();
 16045 
          oprot.writeListEnd();
16046 
        }
 16046 
        }
16047 
        oprot.writeFieldEnd();
 16047 
        oprot.writeFieldEnd();
16048 
      } else if (this.isSetEx()) {
 16048 
      } else if (this.isSetEx()) {
Line 16419... Line 16419...
16419 
        }
 16419 
        }
16420 
        switch (field.id) {
 16420 
        switch (field.id) {
16421 
          case 1: // STATUSES
 16421 
          case 1: // STATUSES
16422 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 16422 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16423 
              {
 16423 
              {
16424 
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
 16424 
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
16425 
                this.statuses = new ArrayList<OrderStatus>(_list32.size);
 16425 
                this.statuses = new ArrayList<OrderStatus>(_list44.size);
16426 
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
 16426 
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
16427 
                {
 16427 
                {
16428 
                  OrderStatus _elem34; // required
 16428 
                  OrderStatus _elem46; // required
16429 
                  _elem34 = OrderStatus.findByValue(iprot.readI32());
 16429 
                  _elem46 = OrderStatus.findByValue(iprot.readI32());
16430 
                  this.statuses.add(_elem34);
 16430 
                  this.statuses.add(_elem46);
16431 
                }
 16431 
                }
16432 
                iprot.readListEnd();
 16432 
                iprot.readListEnd();
16433 
              }
 16433 
              }
16434 
            } else {
16434 
            } else {
16435 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 16435 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 16458... Line 16458...
16458 
      oprot.writeStructBegin(STRUCT_DESC);
 16458 
      oprot.writeStructBegin(STRUCT_DESC);
16459 
      if (this.statuses != null) {
 16459 
      if (this.statuses != null) {
16460 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
 16460 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
16461 
        {
 16461 
        {
16462 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
 16462 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
16463 
          for (OrderStatus _iter35 : this.statuses)
 16463 
          for (OrderStatus _iter47 : this.statuses)
16464 
          {
 16464 
          {
16465 
            oprot.writeI32(_iter35.getValue());
 16465 
            oprot.writeI32(_iter47.getValue());
16466 
          }
 16466 
          }
16467 
          oprot.writeListEnd();
 16467 
          oprot.writeListEnd();
16468 
        }
 16468 
        }
16469 
        oprot.writeFieldEnd();
 16469 
        oprot.writeFieldEnd();
16470 
      }
 16470 
      }
Line 17774... Line 17774...
17774 
        }
 17774 
        }
17775 
        switch (field.id) {
 17775 
        switch (field.id) {
17776 
          case 0: // SUCCESS
 17776 
          case 0: // SUCCESS
17777 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 17777 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17778 
              {
 17778 
              {
17779 
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
 17779 
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
17780 
                this.success = new ArrayList<Order>(_list36.size);
 17780 
                this.success = new ArrayList<Order>(_list48.size);
17781 
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
 17781 
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
17782 
                {
 17782 
                {
17783 
                  Order _elem38; // required
 17783 
                  Order _elem50; // required
17784 
                  _elem38 = new Order();
 17784 
                  _elem50 = new Order();
17785 
                  _elem38.read(iprot);
 17785 
                  _elem50.read(iprot);
17786 
                  this.success.add(_elem38);
 17786 
                  this.success.add(_elem50);
17787 
                }
 17787 
                }
17788 
                iprot.readListEnd();
 17788 
                iprot.readListEnd();
17789 
              }
 17789 
              }
17790 
            } else {
17790 
            } else {
17791 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 17791 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17813... Line 17813...
17813 
 
 17813 
 
17814 
      if (this.isSetSuccess()) {
 17814 
      if (this.isSetSuccess()) {
17815 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 17815 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17816 
        {
 17816 
        {
17817 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 17817 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17818 
          for (Order _iter39 : this.success)
 17818 
          for (Order _iter51 : this.success)
17819 
          {
 17819 
          {
17820 
            _iter39.write(oprot);
 17820 
            _iter51.write(oprot);
17821 
          }
 17821 
          }
17822 
          oprot.writeListEnd();
 17822 
          oprot.writeListEnd();
17823 
        }
 17823 
        }
17824 
        oprot.writeFieldEnd();
 17824 
        oprot.writeFieldEnd();
17825 
      } else if (this.isSetEx()) {
 17825 
      } else if (this.isSetEx()) {
Line 18817... Line 18817...
18817 
        }
 18817 
        }
18818 
        switch (field.id) {
 18818 
        switch (field.id) {
18819 
          case 0: // SUCCESS
 18819 
          case 0: // SUCCESS
18820 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 18820 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18821 
              {
 18821 
              {
18822 
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
 18822 
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
18823 
                this.success = new ArrayList<Order>(_list40.size);
 18823 
                this.success = new ArrayList<Order>(_list52.size);
18824 
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
 18824 
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
18825 
                {
 18825 
                {
18826 
                  Order _elem42; // required
 18826 
                  Order _elem54; // required
18827 
                  _elem42 = new Order();
 18827 
                  _elem54 = new Order();
18828 
                  _elem42.read(iprot);
 18828 
                  _elem54.read(iprot);
18829 
                  this.success.add(_elem42);
 18829 
                  this.success.add(_elem54);
18830 
                }
 18830 
                }
18831 
                iprot.readListEnd();
 18831 
                iprot.readListEnd();
18832 
              }
 18832 
              }
18833 
            } else {
18833 
            } else {
18834 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 18834 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 18856... Line 18856...
18856 
 
 18856 
 
18857 
      if (this.isSetSuccess()) {
 18857 
      if (this.isSetSuccess()) {
18858 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 18858 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18859 
        {
 18859 
        {
18860 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 18860 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18861 
          for (Order _iter43 : this.success)
 18861 
          for (Order _iter55 : this.success)
18862 
          {
 18862 
          {
18863 
            _iter43.write(oprot);
 18863 
            _iter55.write(oprot);
18864 
          }
 18864 
          }
18865 
          oprot.writeListEnd();
 18865 
          oprot.writeListEnd();
18866 
        }
 18866 
        }
18867 
        oprot.writeFieldEnd();
 18867 
        oprot.writeFieldEnd();
18868 
      } else if (this.isSetEx()) {
 18868 
      } else if (this.isSetEx()) {
Line 19613... Line 19613...
19613 
        }
 19613 
        }
19614 
        switch (field.id) {
 19614 
        switch (field.id) {
19615 
          case 0: // SUCCESS
 19615 
          case 0: // SUCCESS
19616 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 19616 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19617 
              {
 19617 
              {
19618 
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
 19618 
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
19619 
                this.success = new ArrayList<Long>(_list44.size);
 19619 
                this.success = new ArrayList<Long>(_list56.size);
19620 
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
 19620 
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
19621 
                {
 19621 
                {
19622 
                  long _elem46; // required
 19622 
                  long _elem58; // required
19623 
                  _elem46 = iprot.readI64();
 19623 
                  _elem58 = iprot.readI64();
19624 
                  this.success.add(_elem46);
 19624 
                  this.success.add(_elem58);
19625 
                }
 19625 
                }
19626 
                iprot.readListEnd();
 19626 
                iprot.readListEnd();
19627 
              }
 19627 
              }
19628 
            } else {
19628 
            } else {
19629 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 19629 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 19651... Line 19651...
19651 
 
 19651 
 
19652 
      if (this.isSetSuccess()) {
 19652 
      if (this.isSetSuccess()) {
19653 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 19653 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19654 
        {
 19654 
        {
19655 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 19655 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
19656 
          for (long _iter47 : this.success)
 19656 
          for (long _iter59 : this.success)
19657 
          {
 19657 
          {
19658 
            oprot.writeI64(_iter47);
 19658 
            oprot.writeI64(_iter59);
19659 
          }
 19659 
          }
19660 
          oprot.writeListEnd();
 19660 
          oprot.writeListEnd();
19661 
        }
 19661 
        }
19662 
        oprot.writeFieldEnd();
 19662 
        oprot.writeFieldEnd();
19663 
      } else if (this.isSetEx()) {
 19663 
      } else if (this.isSetEx()) {
Line 20408... Line 20408...
20408 
        }
 20408 
        }
20409 
        switch (field.id) {
 20409 
        switch (field.id) {
20410 
          case 0: // SUCCESS
 20410 
          case 0: // SUCCESS
20411 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 20411 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20412 
              {
 20412 
              {
20413 
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
 20413 
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
20414 
                this.success = new ArrayList<Long>(_list48.size);
 20414 
                this.success = new ArrayList<Long>(_list60.size);
20415 
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
 20415 
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
20416 
                {
 20416 
                {
20417 
                  long _elem50; // required
 20417 
                  long _elem62; // required
20418 
                  _elem50 = iprot.readI64();
 20418 
                  _elem62 = iprot.readI64();
20419 
                  this.success.add(_elem50);
 20419 
                  this.success.add(_elem62);
20420 
                }
 20420 
                }
20421 
                iprot.readListEnd();
 20421 
                iprot.readListEnd();
20422 
              }
 20422 
              }
20423 
            } else {
20423 
            } else {
20424 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 20424 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 20446... Line 20446...
20446 
 
 20446 
 
20447 
      if (this.isSetSuccess()) {
 20447 
      if (this.isSetSuccess()) {
20448 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 20448 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20449 
        {
 20449 
        {
20450 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 20450 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
20451 
          for (long _iter51 : this.success)
 20451 
          for (long _iter63 : this.success)
20452 
          {
 20452 
          {
20453 
            oprot.writeI64(_iter51);
 20453 
            oprot.writeI64(_iter63);
20454 
          }
 20454 
          }
20455 
          oprot.writeListEnd();
 20455 
          oprot.writeListEnd();
20456 
        }
 20456 
        }
20457 
        oprot.writeFieldEnd();
 20457 
        oprot.writeFieldEnd();
20458 
      } else if (this.isSetEx()) {
 20458 
      } else if (this.isSetEx()) {
Line 22064... Line 22064...
22064 
        }
 22064 
        }
22065 
        switch (field.id) {
 22065 
        switch (field.id) {
22066 
          case 0: // SUCCESS
 22066 
          case 0: // SUCCESS
22067 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 22067 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22068 
              {
 22068 
              {
22069 
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
 22069 
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
22070 
                this.success = new ArrayList<Order>(_list52.size);
 22070 
                this.success = new ArrayList<Order>(_list64.size);
22071 
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
 22071 
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
22072 
                {
 22072 
                {
22073 
                  Order _elem54; // required
 22073 
                  Order _elem66; // required
22074 
                  _elem54 = new Order();
 22074 
                  _elem66 = new Order();
22075 
                  _elem54.read(iprot);
 22075 
                  _elem66.read(iprot);
22076 
                  this.success.add(_elem54);
 22076 
                  this.success.add(_elem66);
22077 
                }
 22077 
                }
22078 
                iprot.readListEnd();
 22078 
                iprot.readListEnd();
22079 
              }
 22079 
              }
22080 
            } else {
22080 
            } else {
22081 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 22081 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22103... Line 22103...
22103 
 
 22103 
 
22104 
      if (this.isSetSuccess()) {
 22104 
      if (this.isSetSuccess()) {
22105 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 22105 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22106 
        {
 22106 
        {
22107 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 22107 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22108 
          for (Order _iter55 : this.success)
 22108 
          for (Order _iter67 : this.success)
22109 
          {
 22109 
          {
22110 
            _iter55.write(oprot);
 22110 
            _iter67.write(oprot);
22111 
          }
 22111 
          }
22112 
          oprot.writeListEnd();
 22112 
          oprot.writeListEnd();
22113 
        }
 22113 
        }
22114 
        oprot.writeFieldEnd();
 22114 
        oprot.writeFieldEnd();
22115 
      } else if (this.isSetEx()) {
 22115 
      } else if (this.isSetEx()) {
Line 22646... Line 22646...
22646 
            }
 22646 
            }
22647 
            break;
 22647 
            break;
22648 
          case 4: // STATUSES
 22648 
          case 4: // STATUSES
22649 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 22649 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22650 
              {
 22650 
              {
22651 
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
 22651 
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
22652 
                this.statuses = new ArrayList<OrderStatus>(_list56.size);
 22652 
                this.statuses = new ArrayList<OrderStatus>(_list68.size);
22653 
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
 22653 
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
22654 
                {
 22654 
                {
22655 
                  OrderStatus _elem58; // required
 22655 
                  OrderStatus _elem70; // required
22656 
                  _elem58 = OrderStatus.findByValue(iprot.readI32());
 22656 
                  _elem70 = OrderStatus.findByValue(iprot.readI32());
22657 
                  this.statuses.add(_elem58);
 22657 
                  this.statuses.add(_elem70);
22658 
                }
 22658 
                }
22659 
                iprot.readListEnd();
 22659 
                iprot.readListEnd();
22660 
              }
 22660 
              }
22661 
            } else {
22661 
            } else {
22662 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 22662 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22686... Line 22686...
22686 
      oprot.writeFieldEnd();
 22686 
      oprot.writeFieldEnd();
22687 
      if (this.statuses != null) {
 22687 
      if (this.statuses != null) {
22688 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
 22688 
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
22689 
        {
 22689 
        {
22690 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
 22690 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
22691 
          for (OrderStatus _iter59 : this.statuses)
 22691 
          for (OrderStatus _iter71 : this.statuses)
22692 
          {
 22692 
          {
22693 
            oprot.writeI32(_iter59.getValue());
 22693 
            oprot.writeI32(_iter71.getValue());
22694 
          }
 22694 
          }
22695 
          oprot.writeListEnd();
 22695 
          oprot.writeListEnd();
22696 
        }
 22696 
        }
22697 
        oprot.writeFieldEnd();
 22697 
        oprot.writeFieldEnd();
22698 
      }
 22698 
      }
Line 23066... Line 23066...
23066 
        }
 23066 
        }
23067 
        switch (field.id) {
 23067 
        switch (field.id) {
23068 
          case 0: // SUCCESS
 23068 
          case 0: // SUCCESS
23069 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 23069 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23070 
              {
 23070 
              {
23071 
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
 23071 
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
23072 
                this.success = new ArrayList<Order>(_list60.size);
 23072 
                this.success = new ArrayList<Order>(_list72.size);
23073 
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
 23073 
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
23074 
                {
 23074 
                {
23075 
                  Order _elem62; // required
 23075 
                  Order _elem74; // required
23076 
                  _elem62 = new Order();
 23076 
                  _elem74 = new Order();
23077 
                  _elem62.read(iprot);
 23077 
                  _elem74.read(iprot);
23078 
                  this.success.add(_elem62);
 23078 
                  this.success.add(_elem74);
23079 
                }
 23079 
                }
23080 
                iprot.readListEnd();
 23080 
                iprot.readListEnd();
23081 
              }
 23081 
              }
23082 
            } else {
23082 
            } else {
23083 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 23083 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23105... Line 23105...
23105 
 
 23105 
 
23106 
      if (this.isSetSuccess()) {
 23106 
      if (this.isSetSuccess()) {
23107 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 23107 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23108 
        {
 23108 
        {
23109 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 23109 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23110 
          for (Order _iter63 : this.success)
 23110 
          for (Order _iter75 : this.success)
23111 
          {
 23111 
          {
23112 
            _iter63.write(oprot);
 23112 
            _iter75.write(oprot);
23113 
          }
 23113 
          }
23114 
          oprot.writeListEnd();
 23114 
          oprot.writeListEnd();
23115 
        }
 23115 
        }
23116 
        oprot.writeFieldEnd();
 23116 
        oprot.writeFieldEnd();
23117 
      } else if (this.isSetEx()) {
 23117 
      } else if (this.isSetEx()) {
Line 25131... Line 25131...
25131 
        }
 25131 
        }
25132 
        switch (field.id) {
 25132 
        switch (field.id) {
25133 
          case 0: // SUCCESS
 25133 
          case 0: // SUCCESS
25134 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 25134 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25135 
              {
 25135 
              {
25136 
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
 25136 
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
25137 
                this.success = new ArrayList<LineItem>(_list64.size);
 25137 
                this.success = new ArrayList<LineItem>(_list76.size);
25138 
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
 25138 
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
25139 
                {
 25139 
                {
25140 
                  LineItem _elem66; // required
 25140 
                  LineItem _elem78; // required
25141 
                  _elem66 = new LineItem();
 25141 
                  _elem78 = new LineItem();
25142 
                  _elem66.read(iprot);
 25142 
                  _elem78.read(iprot);
25143 
                  this.success.add(_elem66);
 25143 
                  this.success.add(_elem78);
25144 
                }
 25144 
                }
25145 
                iprot.readListEnd();
 25145 
                iprot.readListEnd();
25146 
              }
 25146 
              }
25147 
            } else {
25147 
            } else {
25148 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 25148 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25170... Line 25170...
25170 
 
 25170 
 
25171 
      if (this.isSetSuccess()) {
 25171 
      if (this.isSetSuccess()) {
25172 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 25172 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25173 
        {
 25173 
        {
25174 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 25174 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
25175 
          for (LineItem _iter67 : this.success)
 25175 
          for (LineItem _iter79 : this.success)
25176 
          {
 25176 
          {
25177 
            _iter67.write(oprot);
 25177 
            _iter79.write(oprot);
25178 
          }
 25178 
          }
25179 
          oprot.writeListEnd();
 25179 
          oprot.writeListEnd();
25180 
        }
 25180 
        }
25181 
        oprot.writeFieldEnd();
 25181 
        oprot.writeFieldEnd();
25182 
      } else if (this.isSetEx()) {
 25182 
      } else if (this.isSetEx()) {
Line 26782... Line 26782...
26782 
        }
 26782 
        }
26783 
        switch (field.id) {
 26783 
        switch (field.id) {
26784 
          case 0: // SUCCESS
 26784 
          case 0: // SUCCESS
26785 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 26785 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
26786 
              {
 26786 
              {
26787 
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
 26787 
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
26788 
                this.success = new ArrayList<Alert>(_list68.size);
 26788 
                this.success = new ArrayList<Alert>(_list80.size);
26789 
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
 26789 
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
26790 
                {
 26790 
                {
26791 
                  Alert _elem70; // required
 26791 
                  Alert _elem82; // required
26792 
                  _elem70 = new Alert();
 26792 
                  _elem82 = new Alert();
26793 
                  _elem70.read(iprot);
 26793 
                  _elem82.read(iprot);
26794 
                  this.success.add(_elem70);
 26794 
                  this.success.add(_elem82);
26795 
                }
 26795 
                }
26796 
                iprot.readListEnd();
 26796 
                iprot.readListEnd();
26797 
              }
 26797 
              }
26798 
            } else {
26798 
            } else {
26799 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 26799 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 26813... Line 26813...
26813 
 
 26813 
 
26814 
      if (this.isSetSuccess()) {
 26814 
      if (this.isSetSuccess()) {
26815 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 26815 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26816 
        {
 26816 
        {
26817 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 26817 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
26818 
          for (Alert _iter71 : this.success)
 26818 
          for (Alert _iter83 : this.success)
26819 
          {
 26819 
          {
26820 
            _iter71.write(oprot);
 26820 
            _iter83.write(oprot);
26821 
          }
 26821 
          }
26822 
          oprot.writeListEnd();
 26822 
          oprot.writeListEnd();
26823 
        }
 26823 
        }
26824 
        oprot.writeFieldEnd();
 26824 
        oprot.writeFieldEnd();
26825 
      }
 26825 
      }
Line 29456... Line 29456...
29456 
        }
 29456 
        }
29457 
        switch (field.id) {
 29457 
        switch (field.id) {
29458 
          case 0: // SUCCESS
 29458 
          case 0: // SUCCESS
29459 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 29459 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
29460 
              {
 29460 
              {
29461 
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
 29461 
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
29462 
                this.success = new ArrayList<Double>(_list72.size);
 29462 
                this.success = new ArrayList<Double>(_list84.size);
29463 
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
 29463 
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
29464 
                {
 29464 
                {
29465 
                  double _elem74; // required
 29465 
                  double _elem86; // required
29466 
                  _elem74 = iprot.readDouble();
 29466 
                  _elem86 = iprot.readDouble();
29467 
                  this.success.add(_elem74);
 29467 
                  this.success.add(_elem86);
29468 
                }
 29468 
                }
29469 
                iprot.readListEnd();
 29469 
                iprot.readListEnd();
29470 
              }
 29470 
              }
29471 
            } else {
29471 
            } else {
29472 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 29472 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 29486... Line 29486...
29486 
 
 29486 
 
29487 
      if (this.isSetSuccess()) {
 29487 
      if (this.isSetSuccess()) {
29488 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 29488 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29489 
        {
 29489 
        {
29490 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
 29490 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
29491 
          for (double _iter75 : this.success)
 29491 
          for (double _iter87 : this.success)
29492 
          {
 29492 
          {
29493 
            oprot.writeDouble(_iter75);
 29493 
            oprot.writeDouble(_iter87);
29494 
          }
 29494 
          }
29495 
          oprot.writeListEnd();
 29495 
          oprot.writeListEnd();
29496 
        }
 29496 
        }
29497 
        oprot.writeFieldEnd();
 29497 
        oprot.writeFieldEnd();
29498 
      }
 29498 
      }
Line 30078... Line 30078...
30078 
        }
 30078 
        }
30079 
        switch (field.id) {
 30079 
        switch (field.id) {
30080 
          case 0: // SUCCESS
 30080 
          case 0: // SUCCESS
30081 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 30081 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30082 
              {
 30082 
              {
30083 
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
 30083 
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
30084 
                this.success = new ArrayList<Order>(_list76.size);
 30084 
                this.success = new ArrayList<Order>(_list88.size);
30085 
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
 30085 
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
30086 
                {
 30086 
                {
30087 
                  Order _elem78; // required
 30087 
                  Order _elem90; // required
30088 
                  _elem78 = new Order();
 30088 
                  _elem90 = new Order();
30089 
                  _elem78.read(iprot);
 30089 
                  _elem90.read(iprot);
30090 
                  this.success.add(_elem78);
 30090 
                  this.success.add(_elem90);
30091 
                }
 30091 
                }
30092 
                iprot.readListEnd();
 30092 
                iprot.readListEnd();
30093 
              }
 30093 
              }
30094 
            } else {
30094 
            } else {
30095 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 30095 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30109... Line 30109...
30109 
 
 30109 
 
30110 
      if (this.isSetSuccess()) {
 30110 
      if (this.isSetSuccess()) {
30111 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 30111 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30112 
        {
 30112 
        {
30113 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 30113 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30114 
          for (Order _iter79 : this.success)
 30114 
          for (Order _iter91 : this.success)
30115 
          {
 30115 
          {
30116 
            _iter79.write(oprot);
 30116 
            _iter91.write(oprot);
30117 
          }
 30117 
          }
30118 
          oprot.writeListEnd();
 30118 
          oprot.writeListEnd();
30119 
        }
 30119 
        }
30120 
        oprot.writeFieldEnd();
 30120 
        oprot.writeFieldEnd();
30121 
      }
 30121 
      }
Line 30443... Line 30443...
30443 
      }
 30443 
      }
30444 
    }
 30444 
    }
30445 
 
 30445 
 
30446 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 30446 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
30447 
      try {
 30447 
      try {
- 
 
 30448 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
- 
 
 30449 
        __isset_bit_vector = new BitSet(1);
30448 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 30450 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
30449 
      } catch (org.apache.thrift.TException te) {
 30451 
      } catch (org.apache.thrift.TException te) {
30450 
        throw new java.io.IOException(te);
 30452 
        throw new java.io.IOException(te);
30451 
      }
 30453 
      }
30452 
    }
 30454 
    }
Line 30769... Line 30771...
30769 
        }
 30771 
        }
30770 
        switch (field.id) {
 30772 
        switch (field.id) {
30771 
          case 0: // SUCCESS
 30773 
          case 0: // SUCCESS
30772 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 30774 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30773 
              {
 30775 
              {
30774 
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
 30776 
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
30775 
                this.success = new ArrayList<Order>(_list80.size);
 30777 
                this.success = new ArrayList<Order>(_list92.size);
30776 
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
 30778 
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
30777 
                {
 30779 
                {
30778 
                  Order _elem82; // required
 30780 
                  Order _elem94; // required
30779 
                  _elem82 = new Order();
 30781 
                  _elem94 = new Order();
30780 
                  _elem82.read(iprot);
 30782 
                  _elem94.read(iprot);
30781 
                  this.success.add(_elem82);
 30783 
                  this.success.add(_elem94);
30782 
                }
 30784 
                }
30783 
                iprot.readListEnd();
 30785 
                iprot.readListEnd();
30784 
              }
 30786 
              }
30785 
            } else {
30787 
            } else {
30786 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 30788 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30808... Line 30810...
30808 
 
 30810 
 
30809 
      if (this.isSetSuccess()) {
 30811 
      if (this.isSetSuccess()) {
30810 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 30812 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30811 
        {
 30813 
        {
30812 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 30814 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30813 
          for (Order _iter83 : this.success)
 30815 
          for (Order _iter95 : this.success)
30814 
          {
 30816 
          {
30815 
            _iter83.write(oprot);
 30817 
            _iter95.write(oprot);
30816 
          }
 30818 
          }
30817 
          oprot.writeListEnd();
 30819 
          oprot.writeListEnd();
30818 
        }
 30820 
        }
30819 
        oprot.writeFieldEnd();
 30821 
        oprot.writeFieldEnd();
30820 
      } else if (this.isSetEx()) {
 30822 
      } else if (this.isSetEx()) {
Line 33857... Line 33859...
33857 
      }
 33859 
      }
33858 
    }
 33860 
    }
33859 
 
 33861 
 
33860 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 33862 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
33861 
      try {
 33863 
      try {
33862 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
33863 
        __isset_bit_vector = new BitSet(1);
 - 
 
33864 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 33864 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
33865 
      } catch (org.apache.thrift.TException te) {
 33865 
      } catch (org.apache.thrift.TException te) {
33866 
        throw new java.io.IOException(te);
 33866 
        throw new java.io.IOException(te);
33867 
      }
 33867 
      }
33868 
    }
 33868 
    }
Line 36332... Line 36332...
36332 
            }
 36332 
            }
36333 
            break;
 36333 
            break;
36334 
          case 4: // ORDER_IDS
 36334 
          case 4: // ORDER_IDS
36335 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 36335 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36336 
              {
 36336 
              {
36337 
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
 36337 
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
36338 
                this.orderIds = new ArrayList<Long>(_list84.size);
 36338 
                this.orderIds = new ArrayList<Long>(_list96.size);
36339 
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
 36339 
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
36340 
                {
 36340 
                {
36341 
                  long _elem86; // required
 36341 
                  long _elem98; // required
36342 
                  _elem86 = iprot.readI64();
 36342 
                  _elem98 = iprot.readI64();
36343 
                  this.orderIds.add(_elem86);
 36343 
                  this.orderIds.add(_elem98);
36344 
                }
 36344 
                }
36345 
                iprot.readListEnd();
 36345 
                iprot.readListEnd();
36346 
              }
 36346 
              }
36347 
            } else {
36347 
            } else {
36348 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 36348 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 36372... Line 36372...
36372 
      oprot.writeFieldEnd();
 36372 
      oprot.writeFieldEnd();
36373 
      if (this.orderIds != null) {
 36373 
      if (this.orderIds != null) {
36374 
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
 36374 
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
36375 
        {
 36375 
        {
36376 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
 36376 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
36377 
          for (long _iter87 : this.orderIds)
 36377 
          for (long _iter99 : this.orderIds)
36378 
          {
 36378 
          {
36379 
            oprot.writeI64(_iter87);
 36379 
            oprot.writeI64(_iter99);
36380 
          }
 36380 
          }
36381 
          oprot.writeListEnd();
 36381 
          oprot.writeListEnd();
36382 
        }
 36382 
        }
36383 
        oprot.writeFieldEnd();
 36383 
        oprot.writeFieldEnd();
36384 
      }
 36384 
      }
Line 37149... Line 37149...
37149 
            }
 37149 
            }
37150 
            break;
 37150 
            break;
37151 
          case 2: // PICKUP_DETAILS
 37151 
          case 2: // PICKUP_DETAILS
37152 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 37152 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37153 
              {
 37153 
              {
37154 
                org.apache.thrift.protocol.TMap _map88 = iprot.readMapBegin();
 37154 
                org.apache.thrift.protocol.TMap _map100 = iprot.readMapBegin();
37155 
                this.pickupDetails = new HashMap<String,String>(2*_map88.size);
 37155 
                this.pickupDetails = new HashMap<String,String>(2*_map100.size);
37156 
                for (int _i89 = 0; _i89 < _map88.size; ++_i89)
 37156 
                for (int _i101 = 0; _i101 < _map100.size; ++_i101)
37157 
                {
 37157 
                {
37158 
                  String _key90; // required
 37158 
                  String _key102; // required
37159 
                  String _val91; // required
 37159 
                  String _val103; // required
37160 
                  _key90 = iprot.readString();
 37160 
                  _key102 = iprot.readString();
37161 
                  _val91 = iprot.readString();
 37161 
                  _val103 = iprot.readString();
37162 
                  this.pickupDetails.put(_key90, _val91);
 37162 
                  this.pickupDetails.put(_key102, _val103);
37163 
                }
 37163 
                }
37164 
                iprot.readMapEnd();
 37164 
                iprot.readMapEnd();
37165 
              }
 37165 
              }
37166 
            } else {
37166 
            } else {
37167 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 37167 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37185... Line 37185...
37185 
      oprot.writeFieldEnd();
 37185 
      oprot.writeFieldEnd();
37186 
      if (this.pickupDetails != null) {
 37186 
      if (this.pickupDetails != null) {
37187 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
 37187 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
37188 
        {
 37188 
        {
37189 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
 37189 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
37190 
          for (Map.Entry<String, String> _iter92 : this.pickupDetails.entrySet())
 37190 
          for (Map.Entry<String, String> _iter104 : this.pickupDetails.entrySet())
37191 
          {
 37191 
          {
37192 
            oprot.writeString(_iter92.getKey());
 37192 
            oprot.writeString(_iter104.getKey());
37193 
            oprot.writeString(_iter92.getValue());
 37193 
            oprot.writeString(_iter104.getValue());
37194 
          }
 37194 
          }
37195 
          oprot.writeMapEnd();
 37195 
          oprot.writeMapEnd();
37196 
        }
 37196 
        }
37197 
        oprot.writeFieldEnd();
 37197 
        oprot.writeFieldEnd();
37198 
      }
 37198 
      }
Line 37558... Line 37558...
37558 
        }
 37558 
        }
37559 
        switch (field.id) {
 37559 
        switch (field.id) {
37560 
          case 0: // SUCCESS
 37560 
          case 0: // SUCCESS
37561 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 37561 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37562 
              {
 37562 
              {
37563 
                org.apache.thrift.protocol.TList _list93 = iprot.readListBegin();
 37563 
                org.apache.thrift.protocol.TList _list105 = iprot.readListBegin();
37564 
                this.success = new ArrayList<Order>(_list93.size);
 37564 
                this.success = new ArrayList<Order>(_list105.size);
37565 
                for (int _i94 = 0; _i94 < _list93.size; ++_i94)
 37565 
                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
37566 
                {
 37566 
                {
37567 
                  Order _elem95; // required
 37567 
                  Order _elem107; // required
37568 
                  _elem95 = new Order();
 37568 
                  _elem107 = new Order();
37569 
                  _elem95.read(iprot);
 37569 
                  _elem107.read(iprot);
37570 
                  this.success.add(_elem95);
 37570 
                  this.success.add(_elem107);
37571 
                }
 37571 
                }
37572 
                iprot.readListEnd();
 37572 
                iprot.readListEnd();
37573 
              }
 37573 
              }
37574 
            } else {
37574 
            } else {
37575 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 37575 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37597... Line 37597...
37597 
 
 37597 
 
37598 
      if (this.isSetSuccess()) {
 37598 
      if (this.isSetSuccess()) {
37599 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 37599 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37600 
        {
 37600 
        {
37601 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 37601 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
37602 
          for (Order _iter96 : this.success)
 37602 
          for (Order _iter108 : this.success)
37603 
          {
 37603 
          {
37604 
            _iter96.write(oprot);
 37604 
            _iter108.write(oprot);
37605 
          }
 37605 
          }
37606 
          oprot.writeListEnd();
 37606 
          oprot.writeListEnd();
37607 
        }
 37607 
        }
37608 
        oprot.writeFieldEnd();
 37608 
        oprot.writeFieldEnd();
37609 
      } else if (this.isSetEx()) {
 37609 
      } else if (this.isSetEx()) {
Line 37993... Line 37993...
37993 
            }
 37993 
            }
37994 
            break;
 37994 
            break;
37995 
          case 2: // DELIVERED_ORDERS
 37995 
          case 2: // DELIVERED_ORDERS
37996 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 37996 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37997 
              {
 37997 
              {
37998 
                org.apache.thrift.protocol.TMap _map97 = iprot.readMapBegin();
 37998 
                org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin();
37999 
                this.deliveredOrders = new HashMap<String,String>(2*_map97.size);
 37999 
                this.deliveredOrders = new HashMap<String,String>(2*_map109.size);
38000 
                for (int _i98 = 0; _i98 < _map97.size; ++_i98)
 38000 
                for (int _i110 = 0; _i110 < _map109.size; ++_i110)
38001 
                {
 38001 
                {
38002 
                  String _key99; // required
 38002 
                  String _key111; // required
38003 
                  String _val100; // required
 38003 
                  String _val112; // required
38004 
                  _key99 = iprot.readString();
 38004 
                  _key111 = iprot.readString();
38005 
                  _val100 = iprot.readString();
 38005 
                  _val112 = iprot.readString();
38006 
                  this.deliveredOrders.put(_key99, _val100);
 38006 
                  this.deliveredOrders.put(_key111, _val112);
38007 
                }
 38007 
                }
38008 
                iprot.readMapEnd();
 38008 
                iprot.readMapEnd();
38009 
              }
 38009 
              }
38010 
            } else {
38010 
            } else {
38011 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 38011 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 38029... Line 38029...
38029 
      oprot.writeFieldEnd();
 38029 
      oprot.writeFieldEnd();
38030 
      if (this.deliveredOrders != null) {
 38030 
      if (this.deliveredOrders != null) {
38031 
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
 38031 
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
38032 
        {
 38032 
        {
38033 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.deliveredOrders.size()));
 38033 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.deliveredOrders.size()));
38034 
          for (Map.Entry<String, String> _iter101 : this.deliveredOrders.entrySet())
 38034 
          for (Map.Entry<String, String> _iter113 : this.deliveredOrders.entrySet())
38035 
          {
 38035 
          {
38036 
            oprot.writeString(_iter101.getKey());
 38036 
            oprot.writeString(_iter113.getKey());
38037 
            oprot.writeString(_iter101.getValue());
 38037 
            oprot.writeString(_iter113.getValue());
38038 
          }
 38038 
          }
38039 
          oprot.writeMapEnd();
 38039 
          oprot.writeMapEnd();
38040 
        }
 38040 
        }
38041 
        oprot.writeFieldEnd();
 38041 
        oprot.writeFieldEnd();
38042 
      }
 38042 
      }
Line 38712... Line 38712...
38712 
            }
 38712 
            }
38713 
            break;
 38713 
            break;
38714 
          case 2: // RETURNED_ORDERS
 38714 
          case 2: // RETURNED_ORDERS
38715 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 38715 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
38716 
              {
 38716 
              {
38717 
                org.apache.thrift.protocol.TMap _map102 = iprot.readMapBegin();
 38717 
                org.apache.thrift.protocol.TMap _map114 = iprot.readMapBegin();
38718 
                this.returnedOrders = new HashMap<String,String>(2*_map102.size);
 38718 
                this.returnedOrders = new HashMap<String,String>(2*_map114.size);
38719 
                for (int _i103 = 0; _i103 < _map102.size; ++_i103)
 38719 
                for (int _i115 = 0; _i115 < _map114.size; ++_i115)
38720 
                {
 38720 
                {
38721 
                  String _key104; // required
 38721 
                  String _key116; // required
38722 
                  String _val105; // required
 38722 
                  String _val117; // required
38723 
                  _key104 = iprot.readString();
 38723 
                  _key116 = iprot.readString();
38724 
                  _val105 = iprot.readString();
 38724 
                  _val117 = iprot.readString();
38725 
                  this.returnedOrders.put(_key104, _val105);
 38725 
                  this.returnedOrders.put(_key116, _val117);
38726 
                }
 38726 
                }
38727 
                iprot.readMapEnd();
 38727 
                iprot.readMapEnd();
38728 
              }
 38728 
              }
38729 
            } else {
38729 
            } else {
38730 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 38730 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 38748... Line 38748...
38748 
      oprot.writeFieldEnd();
 38748 
      oprot.writeFieldEnd();
38749 
      if (this.returnedOrders != null) {
 38749 
      if (this.returnedOrders != null) {
38750 
        oprot.writeFieldBegin(RETURNED_ORDERS_FIELD_DESC);
 38750 
        oprot.writeFieldBegin(RETURNED_ORDERS_FIELD_DESC);
38751 
        {
 38751 
        {
38752 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.returnedOrders.size()));
 38752 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.returnedOrders.size()));
38753 
          for (Map.Entry<String, String> _iter106 : this.returnedOrders.entrySet())
 38753 
          for (Map.Entry<String, String> _iter118 : this.returnedOrders.entrySet())
38754 
          {
 38754 
          {
38755 
            oprot.writeString(_iter106.getKey());
 38755 
            oprot.writeString(_iter118.getKey());
38756 
            oprot.writeString(_iter106.getValue());
 38756 
            oprot.writeString(_iter118.getValue());
38757 
          }
 38757 
          }
38758 
          oprot.writeMapEnd();
 38758 
          oprot.writeMapEnd();
38759 
        }
 38759 
        }
38760 
        oprot.writeFieldEnd();
 38760 
        oprot.writeFieldEnd();
38761 
      }
 38761 
      }
Line 39431... Line 39431...
39431 
            }
 39431 
            }
39432 
            break;
 39432 
            break;
39433 
          case 2: // UNDELIVERED_ORDERS
 39433 
          case 2: // UNDELIVERED_ORDERS
39434 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 39434 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
39435 
              {
 39435 
              {
39436 
                org.apache.thrift.protocol.TMap _map107 = iprot.readMapBegin();
 39436 
                org.apache.thrift.protocol.TMap _map119 = iprot.readMapBegin();
39437 
                this.undeliveredOrders = new HashMap<String,String>(2*_map107.size);
 39437 
                this.undeliveredOrders = new HashMap<String,String>(2*_map119.size);
39438 
                for (int _i108 = 0; _i108 < _map107.size; ++_i108)
 39438 
                for (int _i120 = 0; _i120 < _map119.size; ++_i120)
39439 
                {
 39439 
                {
39440 
                  String _key109; // required
 39440 
                  String _key121; // required
39441 
                  String _val110; // required
 39441 
                  String _val122; // required
39442 
                  _key109 = iprot.readString();
 39442 
                  _key121 = iprot.readString();
39443 
                  _val110 = iprot.readString();
 39443 
                  _val122 = iprot.readString();
39444 
                  this.undeliveredOrders.put(_key109, _val110);
 39444 
                  this.undeliveredOrders.put(_key121, _val122);
39445 
                }
 39445 
                }
39446 
                iprot.readMapEnd();
 39446 
                iprot.readMapEnd();
39447 
              }
 39447 
              }
39448 
            } else {
39448 
            } else {
39449 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 39449 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39467... Line 39467...
39467 
      oprot.writeFieldEnd();
 39467 
      oprot.writeFieldEnd();
39468 
      if (this.undeliveredOrders != null) {
 39468 
      if (this.undeliveredOrders != null) {
39469 
        oprot.writeFieldBegin(UNDELIVERED_ORDERS_FIELD_DESC);
 39469 
        oprot.writeFieldBegin(UNDELIVERED_ORDERS_FIELD_DESC);
39470 
        {
 39470 
        {
39471 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.undeliveredOrders.size()));
 39471 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.undeliveredOrders.size()));
39472 
          for (Map.Entry<String, String> _iter111 : this.undeliveredOrders.entrySet())
 39472 
          for (Map.Entry<String, String> _iter123 : this.undeliveredOrders.entrySet())
39473 
          {
 39473 
          {
39474 
            oprot.writeString(_iter111.getKey());
 39474 
            oprot.writeString(_iter123.getKey());
39475 
            oprot.writeString(_iter111.getValue());
 39475 
            oprot.writeString(_iter123.getValue());
39476 
          }
 39476 
          }
39477 
          oprot.writeMapEnd();
 39477 
          oprot.writeMapEnd();
39478 
        }
 39478 
        }
39479 
        oprot.writeFieldEnd();
 39479 
        oprot.writeFieldEnd();
39480 
      }
 39480 
      }
Line 39840... Line 39840...
39840 
        }
 39840 
        }
39841 
        switch (field.id) {
 39841 
        switch (field.id) {
39842 
          case 0: // SUCCESS
 39842 
          case 0: // SUCCESS
39843 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 39843 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39844 
              {
 39844 
              {
39845 
                org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
 39845 
                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
39846 
                this.success = new ArrayList<Order>(_list112.size);
 39846 
                this.success = new ArrayList<Order>(_list124.size);
39847 
                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
 39847 
                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
39848 
                {
 39848 
                {
39849 
                  Order _elem114; // required
 39849 
                  Order _elem126; // required
39850 
                  _elem114 = new Order();
 39850 
                  _elem126 = new Order();
39851 
                  _elem114.read(iprot);
 39851 
                  _elem126.read(iprot);
39852 
                  this.success.add(_elem114);
 39852 
                  this.success.add(_elem126);
39853 
                }
 39853 
                }
39854 
                iprot.readListEnd();
 39854 
                iprot.readListEnd();
39855 
              }
 39855 
              }
39856 
            } else {
39856 
            } else {
39857 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 39857 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39879... Line 39879...
39879 
 
 39879 
 
39880 
      if (this.isSetSuccess()) {
 39880 
      if (this.isSetSuccess()) {
39881 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 39881 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39882 
        {
 39882 
        {
39883 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 39883 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39884 
          for (Order _iter115 : this.success)
 39884 
          for (Order _iter127 : this.success)
39885 
          {
 39885 
          {
39886 
            _iter115.write(oprot);
 39886 
            _iter127.write(oprot);
39887 
          }
 39887 
          }
39888 
          oprot.writeListEnd();
 39888 
          oprot.writeListEnd();
39889 
        }
 39889 
        }
39890 
        oprot.writeFieldEnd();
 39890 
        oprot.writeFieldEnd();
39891 
      } else if (this.isSetEx()) {
 39891 
      } else if (this.isSetEx()) {
Line 40566... Line 40566...
40566 
        }
 40566 
        }
40567 
        switch (field.id) {
 40567 
        switch (field.id) {
40568 
          case 0: // SUCCESS
 40568 
          case 0: // SUCCESS
40569 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 40569 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
40570 
              {
 40570 
              {
40571 
                org.apache.thrift.protocol.TList _list116 = iprot.readListBegin();
 40571 
                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
40572 
                this.success = new ArrayList<Order>(_list116.size);
 40572 
                this.success = new ArrayList<Order>(_list128.size);
40573 
                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
 40573 
                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
40574 
                {
 40574 
                {
40575 
                  Order _elem118; // required
 40575 
                  Order _elem130; // required
40576 
                  _elem118 = new Order();
 40576 
                  _elem130 = new Order();
40577 
                  _elem118.read(iprot);
 40577 
                  _elem130.read(iprot);
40578 
                  this.success.add(_elem118);
 40578 
                  this.success.add(_elem130);
40579 
                }
 40579 
                }
40580 
                iprot.readListEnd();
 40580 
                iprot.readListEnd();
40581 
              }
 40581 
              }
40582 
            } else {
40582 
            } else {
40583 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 40583 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 40597... Line 40597...
40597 
 
 40597 
 
40598 
      if (this.isSetSuccess()) {
 40598 
      if (this.isSetSuccess()) {
40599 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 40599 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
40600 
        {
 40600 
        {
40601 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 40601 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
40602 
          for (Order _iter119 : this.success)
 40602 
          for (Order _iter131 : this.success)
40603 
          {
 40603 
          {
40604 
            _iter119.write(oprot);
 40604 
            _iter131.write(oprot);
40605 
          }
 40605 
          }
40606 
          oprot.writeListEnd();
 40606 
          oprot.writeListEnd();
40607 
        }
 40607 
        }
40608 
        oprot.writeFieldEnd();
 40608 
        oprot.writeFieldEnd();
40609 
      }
 40609 
      }
Line 41097... Line 41097...
41097 
        }
 41097 
        }
41098 
        switch (field.id) {
 41098 
        switch (field.id) {
41099 
          case 0: // SUCCESS
 41099 
          case 0: // SUCCESS
41100 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 41100 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41101 
              {
 41101 
              {
41102 
                org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
 41102 
                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
41103 
                this.success = new ArrayList<Order>(_list120.size);
 41103 
                this.success = new ArrayList<Order>(_list132.size);
41104 
                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
 41104 
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
41105 
                {
 41105 
                {
41106 
                  Order _elem122; // required
 41106 
                  Order _elem134; // required
41107 
                  _elem122 = new Order();
 41107 
                  _elem134 = new Order();
41108 
                  _elem122.read(iprot);
 41108 
                  _elem134.read(iprot);
41109 
                  this.success.add(_elem122);
 41109 
                  this.success.add(_elem134);
41110 
                }
 41110 
                }
41111 
                iprot.readListEnd();
 41111 
                iprot.readListEnd();
41112 
              }
 41112 
              }
41113 
            } else {
41113 
            } else {
41114 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 41114 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41128... Line 41128...
41128 
 
 41128 
 
41129 
      if (this.isSetSuccess()) {
 41129 
      if (this.isSetSuccess()) {
41130 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 41130 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41131 
        {
 41131 
        {
41132 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 41132 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41133 
          for (Order _iter123 : this.success)
 41133 
          for (Order _iter135 : this.success)
41134 
          {
 41134 
          {
41135 
            _iter123.write(oprot);
 41135 
            _iter135.write(oprot);
41136 
          }
 41136 
          }
41137 
          oprot.writeListEnd();
 41137 
          oprot.writeListEnd();
41138 
        }
 41138 
        }
41139 
        oprot.writeFieldEnd();
 41139 
        oprot.writeFieldEnd();
41140 
      }
 41140 
      }
Line 45837... Line 45837...
45837 
      }
 45837 
      }
45838 
    }
 45838 
    }
45839 
 
 45839 
 
45840 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 45840 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
45841 
      try {
 45841 
      try {
45842 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
45843 
        __isset_bit_vector = new BitSet(1);
 - 
 
45844 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 45842 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
45845 
      } catch (org.apache.thrift.TException te) {
 45843 
      } catch (org.apache.thrift.TException te) {
45846 
        throw new java.io.IOException(te);
 45844 
        throw new java.io.IOException(te);
45847 
      }
 45845 
      }
45848 
    }
 45846 
    }
Line 47406... Line 47404...
47406 
            }
 47404 
            }
47407 
            break;
 47405 
            break;
47408 
          case 2: // PICKUP_DETAILS
 47406 
          case 2: // PICKUP_DETAILS
47409 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 47407 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
47410 
              {
 47408 
              {
47411 
                org.apache.thrift.protocol.TMap _map124 = iprot.readMapBegin();
 47409 
                org.apache.thrift.protocol.TMap _map136 = iprot.readMapBegin();
47412 
                this.pickupDetails = new HashMap<String,String>(2*_map124.size);
 47410 
                this.pickupDetails = new HashMap<String,String>(2*_map136.size);
47413 
                for (int _i125 = 0; _i125 < _map124.size; ++_i125)
 47411 
                for (int _i137 = 0; _i137 < _map136.size; ++_i137)
47414 
                {
 47412 
                {
47415 
                  String _key126; // required
 47413 
                  String _key138; // required
47416 
                  String _val127; // required
 47414 
                  String _val139; // required
47417 
                  _key126 = iprot.readString();
 47415 
                  _key138 = iprot.readString();
47418 
                  _val127 = iprot.readString();
 47416 
                  _val139 = iprot.readString();
47419 
                  this.pickupDetails.put(_key126, _val127);
 47417 
                  this.pickupDetails.put(_key138, _val139);
47420 
                }
 47418 
                }
47421 
                iprot.readMapEnd();
 47419 
                iprot.readMapEnd();
47422 
              }
 47420 
              }
47423 
            } else {
47421 
            } else {
47424 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 47422 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 47442... Line 47440...
47442 
      oprot.writeFieldEnd();
 47440 
      oprot.writeFieldEnd();
47443 
      if (this.pickupDetails != null) {
 47441 
      if (this.pickupDetails != null) {
47444 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
 47442 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
47445 
        {
 47443 
        {
47446 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
 47444 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
47447 
          for (Map.Entry<String, String> _iter128 : this.pickupDetails.entrySet())
 47445 
          for (Map.Entry<String, String> _iter140 : this.pickupDetails.entrySet())
47448 
          {
 47446 
          {
47449 
            oprot.writeString(_iter128.getKey());
 47447 
            oprot.writeString(_iter140.getKey());
47450 
            oprot.writeString(_iter128.getValue());
 47448 
            oprot.writeString(_iter140.getValue());
47451 
          }
 47449 
          }
47452 
          oprot.writeMapEnd();
 47450 
          oprot.writeMapEnd();
47453 
        }
 47451 
        }
47454 
        oprot.writeFieldEnd();
 47452 
        oprot.writeFieldEnd();
47455 
      }
 47453 
      }
Line 47747... Line 47745...
47747 
        }
 47745 
        }
47748 
        switch (field.id) {
 47746 
        switch (field.id) {
47749 
          case 0: // SUCCESS
 47747 
          case 0: // SUCCESS
47750 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 47748 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
47751 
              {
 47749 
              {
47752 
                org.apache.thrift.protocol.TList _list129 = iprot.readListBegin();
 47750 
                org.apache.thrift.protocol.TList _list141 = iprot.readListBegin();
47753 
                this.success = new ArrayList<Order>(_list129.size);
 47751 
                this.success = new ArrayList<Order>(_list141.size);
47754 
                for (int _i130 = 0; _i130 < _list129.size; ++_i130)
 47752 
                for (int _i142 = 0; _i142 < _list141.size; ++_i142)
47755 
                {
 47753 
                {
47756 
                  Order _elem131; // required
 47754 
                  Order _elem143; // required
47757 
                  _elem131 = new Order();
 47755 
                  _elem143 = new Order();
47758 
                  _elem131.read(iprot);
 47756 
                  _elem143.read(iprot);
47759 
                  this.success.add(_elem131);
 47757 
                  this.success.add(_elem143);
47760 
                }
 47758 
                }
47761 
                iprot.readListEnd();
 47759 
                iprot.readListEnd();
47762 
              }
 47760 
              }
47763 
            } else {
47761 
            } else {
47764 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 47762 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 47778... Line 47776...
47778 
 
 47776 
 
47779 
      if (this.isSetSuccess()) {
 47777 
      if (this.isSetSuccess()) {
47780 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 47778 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47781 
        {
 47779 
        {
47782 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 47780 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
47783 
          for (Order _iter132 : this.success)
 47781 
          for (Order _iter144 : this.success)
47784 
          {
 47782 
          {
47785 
            _iter132.write(oprot);
 47783 
            _iter144.write(oprot);
47786 
          }
 47784 
          }
47787 
          oprot.writeListEnd();
 47785 
          oprot.writeListEnd();
47788 
        }
 47786 
        }
47789 
        oprot.writeFieldEnd();
 47787 
        oprot.writeFieldEnd();
47790 
      }
 47788 
      }
Line 48162... Line 48160...
48162 
            }
 48160 
            }
48163 
            break;
 48161 
            break;
48164 
          case 2: // PICKUP_DETAILS
 48162 
          case 2: // PICKUP_DETAILS
48165 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 48163 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
48166 
              {
 48164 
              {
48167 
                org.apache.thrift.protocol.TMap _map133 = iprot.readMapBegin();
 48165 
                org.apache.thrift.protocol.TMap _map145 = iprot.readMapBegin();
48168 
                this.pickupDetails = new HashMap<String,String>(2*_map133.size);
 48166 
                this.pickupDetails = new HashMap<String,String>(2*_map145.size);
48169 
                for (int _i134 = 0; _i134 < _map133.size; ++_i134)
 48167 
                for (int _i146 = 0; _i146 < _map145.size; ++_i146)
48170 
                {
 48168 
                {
48171 
                  String _key135; // required
 48169 
                  String _key147; // required
48172 
                  String _val136; // required
 48170 
                  String _val148; // required
48173 
                  _key135 = iprot.readString();
 48171 
                  _key147 = iprot.readString();
48174 
                  _val136 = iprot.readString();
 48172 
                  _val148 = iprot.readString();
48175 
                  this.pickupDetails.put(_key135, _val136);
 48173 
                  this.pickupDetails.put(_key147, _val148);
48176 
                }
 48174 
                }
48177 
                iprot.readMapEnd();
 48175 
                iprot.readMapEnd();
48178 
              }
 48176 
              }
48179 
            } else {
48177 
            } else {
48180 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 48178 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 48198... Line 48196...
48198 
      oprot.writeFieldEnd();
 48196 
      oprot.writeFieldEnd();
48199 
      if (this.pickupDetails != null) {
 48197 
      if (this.pickupDetails != null) {
48200 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
 48198 
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
48201 
        {
 48199 
        {
48202 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
 48200 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
48203 
          for (Map.Entry<String, String> _iter137 : this.pickupDetails.entrySet())
 48201 
          for (Map.Entry<String, String> _iter149 : this.pickupDetails.entrySet())
48204 
          {
 48202 
          {
48205 
            oprot.writeString(_iter137.getKey());
 48203 
            oprot.writeString(_iter149.getKey());
48206 
            oprot.writeString(_iter137.getValue());
 48204 
            oprot.writeString(_iter149.getValue());
48207 
          }
 48205 
          }
48208 
          oprot.writeMapEnd();
 48206 
          oprot.writeMapEnd();
48209 
        }
 48207 
        }
48210 
        oprot.writeFieldEnd();
 48208 
        oprot.writeFieldEnd();
48211 
      }
 48209 
      }
Line 48503... Line 48501...
48503 
        }
 48501 
        }
48504 
        switch (field.id) {
 48502 
        switch (field.id) {
48505 
          case 0: // SUCCESS
 48503 
          case 0: // SUCCESS
48506 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 48504 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
48507 
              {
 48505 
              {
48508 
                org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
 48506 
                org.apache.thrift.protocol.TList _list150 = iprot.readListBegin();
48509 
                this.success = new ArrayList<Order>(_list138.size);
 48507 
                this.success = new ArrayList<Order>(_list150.size);
48510 
                for (int _i139 = 0; _i139 < _list138.size; ++_i139)
 48508 
                for (int _i151 = 0; _i151 < _list150.size; ++_i151)
48511 
                {
 48509 
                {
48512 
                  Order _elem140; // required
 48510 
                  Order _elem152; // required
48513 
                  _elem140 = new Order();
 48511 
                  _elem152 = new Order();
48514 
                  _elem140.read(iprot);
 48512 
                  _elem152.read(iprot);
48515 
                  this.success.add(_elem140);
 48513 
                  this.success.add(_elem152);
48516 
                }
 48514 
                }
48517 
                iprot.readListEnd();
 48515 
                iprot.readListEnd();
48518 
              }
 48516 
              }
48519 
            } else {
48517 
            } else {
48520 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 48518 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 48534... Line 48532...
48534 
 
 48532 
 
48535 
      if (this.isSetSuccess()) {
 48533 
      if (this.isSetSuccess()) {
48536 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 48534 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
48537 
        {
 48535 
        {
48538 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 48536 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
48539 
          for (Order _iter141 : this.success)
 48537 
          for (Order _iter153 : this.success)
48540 
          {
 48538 
          {
48541 
            _iter141.write(oprot);
 48539 
            _iter153.write(oprot);
48542 
          }
 48540 
          }
48543 
          oprot.writeListEnd();
 48541 
          oprot.writeListEnd();
48544 
        }
 48542 
        }
48545 
        oprot.writeFieldEnd();
 48543 
        oprot.writeFieldEnd();
48546 
      }
 48544 
      }
Line 49707... Line 49705...
49707 
      }
 49705 
      }
49708 
    }
 49706 
    }
49709 
 
 49707 
 
49710 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 49708 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
49711 
      try {
 49709 
      try {
- 
 
 49710 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
- 
 
 49711 
        __isset_bit_vector = new BitSet(1);
49712 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 49712 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
49713 
      } catch (org.apache.thrift.TException te) {
 49713 
      } catch (org.apache.thrift.TException te) {
49714 
        throw new java.io.IOException(te);
 49714 
        throw new java.io.IOException(te);
49715 
      }
 49715 
      }
49716 
    }
 49716 
    }
Line 51138... Line 51138...
51138 
      }
 51138 
      }
51139 
    }
 51139 
    }
51140 
 
 51140 
 
51141 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 51141 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
51142 
      try {
 51142 
      try {
51143 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
51144 
        __isset_bit_vector = new BitSet(1);
 - 
 
51145 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 51143 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
51146 
      } catch (org.apache.thrift.TException te) {
 51144 
      } catch (org.apache.thrift.TException te) {
51147 
        throw new java.io.IOException(te);
 51145 
        throw new java.io.IOException(te);
51148 
      }
 51146 
      }
51149 
    }
 51147 
    }
Line 53086... Line 53084...
53086 
        }
 53084 
        }
53087 
        switch (field.id) {
 53085 
        switch (field.id) {
53088 
          case 0: // SUCCESS
 53086 
          case 0: // SUCCESS
53089 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 53087 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53090 
              {
 53088 
              {
53091 
                org.apache.thrift.protocol.TList _list142 = iprot.readListBegin();
 53089 
                org.apache.thrift.protocol.TList _list154 = iprot.readListBegin();
53092 
                this.success = new ArrayList<ReturnOrder>(_list142.size);
 53090 
                this.success = new ArrayList<ReturnOrder>(_list154.size);
53093 
                for (int _i143 = 0; _i143 < _list142.size; ++_i143)
 53091 
                for (int _i155 = 0; _i155 < _list154.size; ++_i155)
53094 
                {
 53092 
                {
53095 
                  ReturnOrder _elem144; // required
 53093 
                  ReturnOrder _elem156; // required
53096 
                  _elem144 = new ReturnOrder();
 53094 
                  _elem156 = new ReturnOrder();
53097 
                  _elem144.read(iprot);
 53095 
                  _elem156.read(iprot);
53098 
                  this.success.add(_elem144);
 53096 
                  this.success.add(_elem156);
53099 
                }
 53097 
                }
53100 
                iprot.readListEnd();
 53098 
                iprot.readListEnd();
53101 
              }
 53099 
              }
53102 
            } else {
53100 
            } else {
53103 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 53101 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 53117... Line 53115...
53117 
 
 53115 
 
53118 
      if (this.isSetSuccess()) {
 53116 
      if (this.isSetSuccess()) {
53119 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 53117 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53120 
        {
 53118 
        {
53121 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 53119 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53122 
          for (ReturnOrder _iter145 : this.success)
 53120 
          for (ReturnOrder _iter157 : this.success)
53123 
          {
 53121 
          {
53124 
            _iter145.write(oprot);
 53122 
            _iter157.write(oprot);
53125 
          }
 53123 
          }
53126 
          oprot.writeListEnd();
 53124 
          oprot.writeListEnd();
53127 
        }
 53125 
        }
53128 
        oprot.writeFieldEnd();
 53126 
        oprot.writeFieldEnd();
53129 
      }
 53127 
      }
Line 58104... Line 58102...
58104 
        }
 58102 
        }
58105 
        switch (field.id) {
 58103 
        switch (field.id) {
58106 
          case 1: // COLLECTED_AMOUNT_MAP
 58104 
          case 1: // COLLECTED_AMOUNT_MAP
58107 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 58105 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
58108 
              {
 58106 
              {
58109 
                org.apache.thrift.protocol.TMap _map146 = iprot.readMapBegin();
 58107 
                org.apache.thrift.protocol.TMap _map158 = iprot.readMapBegin();
58110 
                this.collectedAmountMap = new HashMap<String,Double>(2*_map146.size);
 58108 
                this.collectedAmountMap = new HashMap<String,Double>(2*_map158.size);
58111 
                for (int _i147 = 0; _i147 < _map146.size; ++_i147)
 58109 
                for (int _i159 = 0; _i159 < _map158.size; ++_i159)
58112 
                {
 58110 
                {
58113 
                  String _key148; // required
 58111 
                  String _key160; // required
58114 
                  double _val149; // required
 58112 
                  double _val161; // required
58115 
                  _key148 = iprot.readString();
 58113 
                  _key160 = iprot.readString();
58116 
                  _val149 = iprot.readDouble();
 58114 
                  _val161 = iprot.readDouble();
58117 
                  this.collectedAmountMap.put(_key148, _val149);
 58115 
                  this.collectedAmountMap.put(_key160, _val161);
58118 
                }
 58116 
                }
58119 
                iprot.readMapEnd();
 58117 
                iprot.readMapEnd();
58120 
              }
 58118 
              }
58121 
            } else {
58119 
            } else {
58122 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 58120 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58159... Line 58157...
58159 
      oprot.writeStructBegin(STRUCT_DESC);
 58157 
      oprot.writeStructBegin(STRUCT_DESC);
58160 
      if (this.collectedAmountMap != null) {
 58158 
      if (this.collectedAmountMap != null) {
58161 
        oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
 58159 
        oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
58162 
        {
 58160 
        {
58163 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
 58161 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
58164 
          for (Map.Entry<String, Double> _iter150 : this.collectedAmountMap.entrySet())
 58162 
          for (Map.Entry<String, Double> _iter162 : this.collectedAmountMap.entrySet())
58165 
          {
 58163 
          {
58166 
            oprot.writeString(_iter150.getKey());
 58164 
            oprot.writeString(_iter162.getKey());
58167 
            oprot.writeDouble(_iter150.getValue());
 58165 
            oprot.writeDouble(_iter162.getValue());
58168 
          }
 58166 
          }
58169 
          oprot.writeMapEnd();
 58167 
          oprot.writeMapEnd();
58170 
        }
 58168 
        }
58171 
        oprot.writeFieldEnd();
 58169 
        oprot.writeFieldEnd();
58172 
      }
 58170 
      }
Line 58566... Line 58564...
58566 
        }
 58564 
        }
58567 
        switch (field.id) {
 58565 
        switch (field.id) {
58568 
          case 0: // SUCCESS
 58566 
          case 0: // SUCCESS
58569 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 58567 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
58570 
              {
 58568 
              {
58571 
                org.apache.thrift.protocol.TMap _map151 = iprot.readMapBegin();
 58569 
                org.apache.thrift.protocol.TMap _map163 = iprot.readMapBegin();
58572 
                this.success = new HashMap<String,String>(2*_map151.size);
 58570 
                this.success = new HashMap<String,String>(2*_map163.size);
58573 
                for (int _i152 = 0; _i152 < _map151.size; ++_i152)
 58571 
                for (int _i164 = 0; _i164 < _map163.size; ++_i164)
58574 
                {
 58572 
                {
58575 
                  String _key153; // required
 58573 
                  String _key165; // required
58576 
                  String _val154; // required
 58574 
                  String _val166; // required
58577 
                  _key153 = iprot.readString();
 58575 
                  _key165 = iprot.readString();
58578 
                  _val154 = iprot.readString();
 58576 
                  _val166 = iprot.readString();
58579 
                  this.success.put(_key153, _val154);
 58577 
                  this.success.put(_key165, _val166);
58580 
                }
 58578 
                }
58581 
                iprot.readMapEnd();
 58579 
                iprot.readMapEnd();
58582 
              }
 58580 
              }
58583 
            } else {
58581 
            } else {
58584 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 58582 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58606... Line 58604...
58606 
 
 58604 
 
58607 
      if (this.isSetSuccess()) {
 58605 
      if (this.isSetSuccess()) {
58608 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 58606 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58609 
        {
 58607 
        {
58610 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
 58608 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
58611 
          for (Map.Entry<String, String> _iter155 : this.success.entrySet())
 58609 
          for (Map.Entry<String, String> _iter167 : this.success.entrySet())
58612 
          {
 58610 
          {
58613 
            oprot.writeString(_iter155.getKey());
 58611 
            oprot.writeString(_iter167.getKey());
58614 
            oprot.writeString(_iter155.getValue());
 58612 
            oprot.writeString(_iter167.getValue());
58615 
          }
 58613 
          }
58616 
          oprot.writeMapEnd();
 58614 
          oprot.writeMapEnd();
58617 
        }
 58615 
        }
58618 
        oprot.writeFieldEnd();
 58616 
        oprot.writeFieldEnd();
58619 
      } else if (this.isSetEx()) {
 58617 
      } else if (this.isSetEx()) {
Line 59225... Line 59223...
59225 
        }
 59223 
        }
59226 
        switch (field.id) {
 59224 
        switch (field.id) {
59227 
          case 0: // SUCCESS
 59225 
          case 0: // SUCCESS
59228 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 59226 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59229 
              {
 59227 
              {
59230 
                org.apache.thrift.protocol.TList _list156 = iprot.readListBegin();
 59228 
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
59231 
                this.success = new ArrayList<Long>(_list156.size);
 59229 
                this.success = new ArrayList<Long>(_list168.size);
59232 
                for (int _i157 = 0; _i157 < _list156.size; ++_i157)
 59230 
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
59233 
                {
 59231 
                {
59234 
                  long _elem158; // required
 59232 
                  long _elem170; // required
59235 
                  _elem158 = iprot.readI64();
 59233 
                  _elem170 = iprot.readI64();
59236 
                  this.success.add(_elem158);
 59234 
                  this.success.add(_elem170);
59237 
                }
 59235 
                }
59238 
                iprot.readListEnd();
 59236 
                iprot.readListEnd();
59239 
              }
 59237 
              }
59240 
            } else {
59238 
            } else {
59241 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 59239 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 59255... Line 59253...
59255 
 
 59253 
 
59256 
      if (this.isSetSuccess()) {
 59254 
      if (this.isSetSuccess()) {
59257 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 59255 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59258 
        {
 59256 
        {
59259 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 59257 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
59260 
          for (long _iter159 : this.success)
 59258 
          for (long _iter171 : this.success)
59261 
          {
 59259 
          {
59262 
            oprot.writeI64(_iter159);
 59260 
            oprot.writeI64(_iter171);
59263 
          }
 59261 
          }
59264 
          oprot.writeListEnd();
 59262 
          oprot.writeListEnd();
59265 
        }
 59263 
        }
59266 
        oprot.writeFieldEnd();
 59264 
        oprot.writeFieldEnd();
59267 
      }
 59265 
      }
Line 60351... Line 60349...
60351 
        }
 60349 
        }
60352 
        switch (field.id) {
 60350 
        switch (field.id) {
60353 
          case 0: // SUCCESS
 60351 
          case 0: // SUCCESS
60354 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 60352 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
60355 
              {
 60353 
              {
60356 
                org.apache.thrift.protocol.TMap _map160 = iprot.readMapBegin();
 60354 
                org.apache.thrift.protocol.TMap _map172 = iprot.readMapBegin();
60357 
                this.success = new HashMap<Long,Long>(2*_map160.size);
 60355 
                this.success = new HashMap<Long,Long>(2*_map172.size);
60358 
                for (int _i161 = 0; _i161 < _map160.size; ++_i161)
 60356 
                for (int _i173 = 0; _i173 < _map172.size; ++_i173)
60359 
                {
 60357 
                {
60360 
                  long _key162; // required
 60358 
                  long _key174; // required
60361 
                  long _val163; // required
 60359 
                  long _val175; // required
60362 
                  _key162 = iprot.readI64();
 60360 
                  _key174 = iprot.readI64();
60363 
                  _val163 = iprot.readI64();
 60361 
                  _val175 = iprot.readI64();
60364 
                  this.success.put(_key162, _val163);
 60362 
                  this.success.put(_key174, _val175);
60365 
                }
 60363 
                }
60366 
                iprot.readMapEnd();
 60364 
                iprot.readMapEnd();
60367 
              }
 60365 
              }
60368 
            } else {
60366 
            } else {
60369 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 60367 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 60383... Line 60381...
60383 
 
 60381 
 
60384 
      if (this.isSetSuccess()) {
 60382 
      if (this.isSetSuccess()) {
60385 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 60383 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
60386 
        {
 60384 
        {
60387 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
 60385 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
60388 
          for (Map.Entry<Long, Long> _iter164 : this.success.entrySet())
 60386 
          for (Map.Entry<Long, Long> _iter176 : this.success.entrySet())
60389 
          {
 60387 
          {
60390 
            oprot.writeI64(_iter164.getKey());
 60388 
            oprot.writeI64(_iter176.getKey());
60391 
            oprot.writeI64(_iter164.getValue());
 60389 
            oprot.writeI64(_iter176.getValue());
60392 
          }
 60390 
          }
60393 
          oprot.writeMapEnd();
 60391 
          oprot.writeMapEnd();
60394 
        }
 60392 
        }
60395 
        oprot.writeFieldEnd();
 60393 
        oprot.writeFieldEnd();
60396 
      }
 60394 
      }
Line 60684... Line 60682...
60684 
        }
 60682 
        }
60685 
        switch (field.id) {
 60683 
        switch (field.id) {
60686 
          case 1: // ITEM_IDS
 60684 
          case 1: // ITEM_IDS
60687 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 60685 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
60688 
              {
 60686 
              {
60689 
                org.apache.thrift.protocol.TList _list165 = iprot.readListBegin();
 60687 
                org.apache.thrift.protocol.TList _list177 = iprot.readListBegin();
60690 
                this.itemIds = new ArrayList<Long>(_list165.size);
 60688 
                this.itemIds = new ArrayList<Long>(_list177.size);
60691 
                for (int _i166 = 0; _i166 < _list165.size; ++_i166)
 60689 
                for (int _i178 = 0; _i178 < _list177.size; ++_i178)
60692 
                {
 60690 
                {
60693 
                  long _elem167; // required
 60691 
                  long _elem179; // required
60694 
                  _elem167 = iprot.readI64();
 60692 
                  _elem179 = iprot.readI64();
60695 
                  this.itemIds.add(_elem167);
 60693 
                  this.itemIds.add(_elem179);
60696 
                }
 60694 
                }
60697 
                iprot.readListEnd();
 60695 
                iprot.readListEnd();
60698 
              }
 60696 
              }
60699 
            } else {
60697 
            } else {
60700 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 60698 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 60715... Line 60713...
60715 
      oprot.writeStructBegin(STRUCT_DESC);
 60713 
      oprot.writeStructBegin(STRUCT_DESC);
60716 
      if (this.itemIds != null) {
 60714 
      if (this.itemIds != null) {
60717 
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
 60715 
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
60718 
        {
 60716 
        {
60719 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
 60717 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
60720 
          for (long _iter168 : this.itemIds)
 60718 
          for (long _iter180 : this.itemIds)
60721 
          {
 60719 
          {
60722 
            oprot.writeI64(_iter168);
 60720 
            oprot.writeI64(_iter180);
60723 
          }
 60721 
          }
60724 
          oprot.writeListEnd();
 60722 
          oprot.writeListEnd();
60725 
        }
 60723 
        }
60726 
        oprot.writeFieldEnd();
 60724 
        oprot.writeFieldEnd();
60727 
      }
 60725 
      }
Line 61015... Line 61013...
61015 
        }
 61013 
        }
61016 
        switch (field.id) {
 61014 
        switch (field.id) {
61017 
          case 0: // SUCCESS
 61015 
          case 0: // SUCCESS
61018 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 61016 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
61019 
              {
 61017 
              {
61020 
                org.apache.thrift.protocol.TList _list169 = iprot.readListBegin();
 61018 
                org.apache.thrift.protocol.TList _list181 = iprot.readListBegin();
61021 
                this.success = new ArrayList<Order>(_list169.size);
 61019 
                this.success = new ArrayList<Order>(_list181.size);
61022 
                for (int _i170 = 0; _i170 < _list169.size; ++_i170)
 61020 
                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
61023 
                {
 61021 
                {
61024 
                  Order _elem171; // required
 61022 
                  Order _elem183; // required
61025 
                  _elem171 = new Order();
 61023 
                  _elem183 = new Order();
61026 
                  _elem171.read(iprot);
 61024 
                  _elem183.read(iprot);
61027 
                  this.success.add(_elem171);
 61025 
                  this.success.add(_elem183);
61028 
                }
 61026 
                }
61029 
                iprot.readListEnd();
 61027 
                iprot.readListEnd();
61030 
              }
 61028 
              }
61031 
            } else {
61029 
            } else {
61032 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 61030 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 61046... Line 61044...
61046 
 
 61044 
 
61047 
      if (this.isSetSuccess()) {
 61045 
      if (this.isSetSuccess()) {
61048 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 61046 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
61049 
        {
 61047 
        {
61050 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 61048 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
61051 
          for (Order _iter172 : this.success)
 61049 
          for (Order _iter184 : this.success)
61052 
          {
 61050 
          {
61053 
            _iter172.write(oprot);
 61051 
            _iter184.write(oprot);
61054 
          }
 61052 
          }
61055 
          oprot.writeListEnd();
 61053 
          oprot.writeListEnd();
61056 
        }
 61054 
        }
61057 
        oprot.writeFieldEnd();
 61055 
        oprot.writeFieldEnd();
61058 
      }
 61056 
      }
Line 69004... Line 69002...
69004 
        }
 69002 
        }
69005 
        switch (field.id) {
 69003 
        switch (field.id) {
69006 
          case 0: // SUCCESS
 69004 
          case 0: // SUCCESS
69007 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 69005 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
69008 
              {
 69006 
              {
69009 
                org.apache.thrift.protocol.TMap _map173 = iprot.readMapBegin();
 69007 
                org.apache.thrift.protocol.TMap _map185 = iprot.readMapBegin();
69010 
                this.success = new HashMap<Integer,TimeoutSummary>(2*_map173.size);
 69008 
                this.success = new HashMap<Integer,TimeoutSummary>(2*_map185.size);
69011 
                for (int _i174 = 0; _i174 < _map173.size; ++_i174)
 69009 
                for (int _i186 = 0; _i186 < _map185.size; ++_i186)
69012 
                {
 69010 
                {
69013 
                  int _key175; // required
 69011 
                  int _key187; // required
69014 
                  TimeoutSummary _val176; // required
 69012 
                  TimeoutSummary _val188; // required
69015 
                  _key175 = iprot.readI32();
 69013 
                  _key187 = iprot.readI32();
69016 
                  _val176 = new TimeoutSummary();
 69014 
                  _val188 = new TimeoutSummary();
69017 
                  _val176.read(iprot);
 69015 
                  _val188.read(iprot);
69018 
                  this.success.put(_key175, _val176);
 69016 
                  this.success.put(_key187, _val188);
69019 
                }
 69017 
                }
69020 
                iprot.readMapEnd();
 69018 
                iprot.readMapEnd();
69021 
              }
 69019 
              }
69022 
            } else {
69020 
            } else {
69023 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 69021 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 69045... Line 69043...
69045 
 
 69043 
 
69046 
      if (this.isSetSuccess()) {
 69044 
      if (this.isSetSuccess()) {
69047 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 69045 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
69048 
        {
 69046 
        {
69049 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 69047 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
69050 
          for (Map.Entry<Integer, TimeoutSummary> _iter177 : this.success.entrySet())
 69048 
          for (Map.Entry<Integer, TimeoutSummary> _iter189 : this.success.entrySet())
69051 
          {
 69049 
          {
69052 
            oprot.writeI32(_iter177.getKey());
 69050 
            oprot.writeI32(_iter189.getKey());
69053 
            _iter177.getValue().write(oprot);
 69051 
            _iter189.getValue().write(oprot);
69054 
          }
 69052 
          }
69055 
          oprot.writeMapEnd();
 69053 
          oprot.writeMapEnd();
69056 
        }
 69054 
        }
69057 
        oprot.writeFieldEnd();
 69055 
        oprot.writeFieldEnd();
69058 
      } else if (this.isSetEx()) {
 69056 
      } else if (this.isSetEx()) {
Line 71171... Line 71169...
71171 
        }
 71169 
        }
71172 
        switch (field.id) {
 71170 
        switch (field.id) {
71173 
          case 0: // SUCCESS
 71171 
          case 0: // SUCCESS
71174 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 71172 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
71175 
              {
 71173 
              {
71176 
                org.apache.thrift.protocol.TList _list178 = iprot.readListBegin();
 71174 
                org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
71177 
                this.success = new ArrayList<Order>(_list178.size);
 71175 
                this.success = new ArrayList<Order>(_list190.size);
71178 
                for (int _i179 = 0; _i179 < _list178.size; ++_i179)
 71176 
                for (int _i191 = 0; _i191 < _list190.size; ++_i191)
71179 
                {
 71177 
                {
71180 
                  Order _elem180; // required
 71178 
                  Order _elem192; // required
71181 
                  _elem180 = new Order();
 71179 
                  _elem192 = new Order();
71182 
                  _elem180.read(iprot);
 71180 
                  _elem192.read(iprot);
71183 
                  this.success.add(_elem180);
 71181 
                  this.success.add(_elem192);
71184 
                }
 71182 
                }
71185 
                iprot.readListEnd();
 71183 
                iprot.readListEnd();
71186 
              }
 71184 
              }
71187 
            } else {
71185 
            } else {
71188 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 71186 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 71210... Line 71208...
71210 
 
 71208 
 
71211 
      if (this.isSetSuccess()) {
 71209 
      if (this.isSetSuccess()) {
71212 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 71210 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
71213 
        {
 71211 
        {
71214 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 71212 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
71215 
          for (Order _iter181 : this.success)
 71213 
          for (Order _iter193 : this.success)
71216 
          {
 71214 
          {
71217 
            _iter181.write(oprot);
 71215 
            _iter193.write(oprot);
71218 
          }
 71216 
          }
71219 
          oprot.writeListEnd();
 71217 
          oprot.writeListEnd();
71220 
        }
 71218 
        }
71221 
        oprot.writeFieldEnd();
 71219 
        oprot.writeFieldEnd();
71222 
      } else if (this.isSetEx()) {
 71220 
      } else if (this.isSetEx()) {
Line 72050... Line 72048...
72050 
        }
 72048 
        }
72051 
        switch (field.id) {
 72049 
        switch (field.id) {
72052 
          case 0: // SUCCESS
 72050 
          case 0: // SUCCESS
72053 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 72051 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72054 
              {
 72052 
              {
72055 
                org.apache.thrift.protocol.TList _list182 = iprot.readListBegin();
 72053 
                org.apache.thrift.protocol.TList _list194 = iprot.readListBegin();
72056 
                this.success = new ArrayList<Order>(_list182.size);
 72054 
                this.success = new ArrayList<Order>(_list194.size);
72057 
                for (int _i183 = 0; _i183 < _list182.size; ++_i183)
 72055 
                for (int _i195 = 0; _i195 < _list194.size; ++_i195)
72058 
                {
 72056 
                {
72059 
                  Order _elem184; // required
 72057 
                  Order _elem196; // required
72060 
                  _elem184 = new Order();
 72058 
                  _elem196 = new Order();
72061 
                  _elem184.read(iprot);
 72059 
                  _elem196.read(iprot);
72062 
                  this.success.add(_elem184);
 72060 
                  this.success.add(_elem196);
72063 
                }
 72061 
                }
72064 
                iprot.readListEnd();
 72062 
                iprot.readListEnd();
72065 
              }
 72063 
              }
72066 
            } else {
72064 
            } else {
72067 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 72065 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 72089... Line 72087...
72089 
 
 72087 
 
72090 
      if (this.isSetSuccess()) {
 72088 
      if (this.isSetSuccess()) {
72091 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 72089 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
72092 
        {
 72090 
        {
72093 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 72091 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
72094 
          for (Order _iter185 : this.success)
 72092 
          for (Order _iter197 : this.success)
72095 
          {
 72093 
          {
72096 
            _iter185.write(oprot);
 72094 
            _iter197.write(oprot);
72097 
          }
 72095 
          }
72098 
          oprot.writeListEnd();
 72096 
          oprot.writeListEnd();
72099 
        }
 72097 
        }
72100 
        oprot.writeFieldEnd();
 72098 
        oprot.writeFieldEnd();
72101 
      } else if (this.isSetEx()) {
 72099 
      } else if (this.isSetEx()) {
Line 72669... Line 72667...
72669 
        }
 72667 
        }
72670 
        switch (field.id) {
 72668 
        switch (field.id) {
72671 
          case 0: // SUCCESS
 72669 
          case 0: // SUCCESS
72672 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 72670 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72673 
              {
 72671 
              {
72674 
                org.apache.thrift.protocol.TList _list186 = iprot.readListBegin();
 72672 
                org.apache.thrift.protocol.TList _list198 = iprot.readListBegin();
72675 
                this.success = new ArrayList<Order>(_list186.size);
 72673 
                this.success = new ArrayList<Order>(_list198.size);
72676 
                for (int _i187 = 0; _i187 < _list186.size; ++_i187)
 72674 
                for (int _i199 = 0; _i199 < _list198.size; ++_i199)
72677 
                {
 72675 
                {
72678 
                  Order _elem188; // required
 72676 
                  Order _elem200; // required
72679 
                  _elem188 = new Order();
 72677 
                  _elem200 = new Order();
72680 
                  _elem188.read(iprot);
 72678 
                  _elem200.read(iprot);
72681 
                  this.success.add(_elem188);
 72679 
                  this.success.add(_elem200);
72682 
                }
 72680 
                }
72683 
                iprot.readListEnd();
 72681 
                iprot.readListEnd();
72684 
              }
 72682 
              }
72685 
            } else {
72683 
            } else {
72686 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 72684 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 72708... Line 72706...
72708 
 
 72706 
 
72709 
      if (this.isSetSuccess()) {
 72707 
      if (this.isSetSuccess()) {
72710 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 72708 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
72711 
        {
 72709 
        {
72712 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 72710 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
72713 
          for (Order _iter189 : this.success)
 72711 
          for (Order _iter201 : this.success)
72714 
          {
 72712 
          {
72715 
            _iter189.write(oprot);
 72713 
            _iter201.write(oprot);
72716 
          }
 72714 
          }
72717 
          oprot.writeListEnd();
 72715 
          oprot.writeListEnd();
72718 
        }
 72716 
        }
72719 
        oprot.writeFieldEnd();
 72717 
        oprot.writeFieldEnd();
72720 
      } else if (this.isSetEx()) {
 72718 
      } else if (this.isSetEx()) {
Line 73465... Line 73463...
73465 
        }
 73463 
        }
73466 
        switch (field.id) {
 73464 
        switch (field.id) {
73467 
          case 0: // SUCCESS
 73465 
          case 0: // SUCCESS
73468 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 73466 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
73469 
              {
 73467 
              {
73470 
                org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
 73468 
                org.apache.thrift.protocol.TList _list202 = iprot.readListBegin();
73471 
                this.success = new ArrayList<Order>(_list190.size);
 73469 
                this.success = new ArrayList<Order>(_list202.size);
73472 
                for (int _i191 = 0; _i191 < _list190.size; ++_i191)
 73470 
                for (int _i203 = 0; _i203 < _list202.size; ++_i203)
73473 
                {
 73471 
                {
73474 
                  Order _elem192; // required
 73472 
                  Order _elem204; // required
73475 
                  _elem192 = new Order();
 73473 
                  _elem204 = new Order();
73476 
                  _elem192.read(iprot);
 73474 
                  _elem204.read(iprot);
73477 
                  this.success.add(_elem192);
 73475 
                  this.success.add(_elem204);
73478 
                }
 73476 
                }
73479 
                iprot.readListEnd();
 73477 
                iprot.readListEnd();
73480 
              }
 73478 
              }
73481 
            } else {
73479 
            } else {
73482 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 73480 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 73504... Line 73502...
73504 
 
 73502 
 
73505 
      if (this.isSetSuccess()) {
 73503 
      if (this.isSetSuccess()) {
73506 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 73504 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
73507 
        {
 73505 
        {
73508 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 73506 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
73509 
          for (Order _iter193 : this.success)
 73507 
          for (Order _iter205 : this.success)
73510 
          {
 73508 
          {
73511 
            _iter193.write(oprot);
 73509 
            _iter205.write(oprot);
73512 
          }
 73510 
          }
73513 
          oprot.writeListEnd();
 73511 
          oprot.writeListEnd();
73514 
        }
 73512 
        }
73515 
        oprot.writeFieldEnd();
 73513 
        oprot.writeFieldEnd();
73516 
      } else if (this.isSetEx()) {
 73514 
      } else if (this.isSetEx()) {
Line 73821... Line 73819...
73821 
        }
 73819 
        }
73822 
        switch (field.id) {
 73820 
        switch (field.id) {
73823 
          case 1: // MAP_AWBAND_AMOUNT
 73821 
          case 1: // MAP_AWBAND_AMOUNT
73824 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 73822 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
73825 
              {
 73823 
              {
73826 
                org.apache.thrift.protocol.TMap _map194 = iprot.readMapBegin();
 73824 
                org.apache.thrift.protocol.TMap _map206 = iprot.readMapBegin();
73827 
                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map194.size);
 73825 
                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map206.size);
73828 
                for (int _i195 = 0; _i195 < _map194.size; ++_i195)
 73826 
                for (int _i207 = 0; _i207 < _map206.size; ++_i207)
73829 
                {
 73827 
                {
73830 
                  long _key196; // required
 73828 
                  long _key208; // required
73831 
                  double _val197; // required
 73829 
                  double _val209; // required
73832 
                  _key196 = iprot.readI64();
 73830 
                  _key208 = iprot.readI64();
73833 
                  _val197 = iprot.readDouble();
 73831 
                  _val209 = iprot.readDouble();
73834 
                  this.mapAWBAndAmount.put(_key196, _val197);
 73832 
                  this.mapAWBAndAmount.put(_key208, _val209);
73835 
                }
 73833 
                }
73836 
                iprot.readMapEnd();
 73834 
                iprot.readMapEnd();
73837 
              }
 73835 
              }
73838 
            } else {
73836 
            } else {
73839 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 73837 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 73854... Line 73852...
73854 
      oprot.writeStructBegin(STRUCT_DESC);
 73852 
      oprot.writeStructBegin(STRUCT_DESC);
73855 
      if (this.mapAWBAndAmount != null) {
 73853 
      if (this.mapAWBAndAmount != null) {
73856 
        oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
 73854 
        oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
73857 
        {
 73855 
        {
73858 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
 73856 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
73859 
          for (Map.Entry<Long, Double> _iter198 : this.mapAWBAndAmount.entrySet())
 73857 
          for (Map.Entry<Long, Double> _iter210 : this.mapAWBAndAmount.entrySet())
73860 
          {
 73858 
          {
73861 
            oprot.writeI64(_iter198.getKey());
 73859 
            oprot.writeI64(_iter210.getKey());
73862 
            oprot.writeDouble(_iter198.getValue());
 73860 
            oprot.writeDouble(_iter210.getValue());
73863 
          }
 73861 
          }
73864 
          oprot.writeMapEnd();
 73862 
          oprot.writeMapEnd();
73865 
        }
 73863 
        }
73866 
        oprot.writeFieldEnd();
 73864 
        oprot.writeFieldEnd();
73867 
      }
 73865 
      }
Line 77321... Line 77319...
77321 
        }
 77319 
        }
77322 
        switch (field.id) {
 77320 
        switch (field.id) {
77323 
          case 0: // SUCCESS
 77321 
          case 0: // SUCCESS
77324 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 77322 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
77325 
              {
 77323 
              {
77326 
                org.apache.thrift.protocol.TMap _map199 = iprot.readMapBegin();
 77324 
                org.apache.thrift.protocol.TMap _map211 = iprot.readMapBegin();
77327 
                this.success = new HashMap<Long,String>(2*_map199.size);
 77325 
                this.success = new HashMap<Long,String>(2*_map211.size);
77328 
                for (int _i200 = 0; _i200 < _map199.size; ++_i200)
 77326 
                for (int _i212 = 0; _i212 < _map211.size; ++_i212)
77329 
                {
 77327 
                {
77330 
                  long _key201; // required
 77328 
                  long _key213; // required
77331 
                  String _val202; // required
 77329 
                  String _val214; // required
77332 
                  _key201 = iprot.readI64();
 77330 
                  _key213 = iprot.readI64();
77333 
                  _val202 = iprot.readString();
 77331 
                  _val214 = iprot.readString();
77334 
                  this.success.put(_key201, _val202);
 77332 
                  this.success.put(_key213, _val214);
77335 
                }
 77333 
                }
77336 
                iprot.readMapEnd();
 77334 
                iprot.readMapEnd();
77337 
              }
 77335 
              }
77338 
            } else {
77336 
            } else {
77339 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 77337 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 77361... Line 77359...
77361 
 
 77359 
 
77362 
      if (this.isSetSuccess()) {
 77360 
      if (this.isSetSuccess()) {
77363 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 77361 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77364 
        {
 77362 
        {
77365 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, this.success.size()));
 77363 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, this.success.size()));
77366 
          for (Map.Entry<Long, String> _iter203 : this.success.entrySet())
 77364 
          for (Map.Entry<Long, String> _iter215 : this.success.entrySet())
77367 
          {
 77365 
          {
77368 
            oprot.writeI64(_iter203.getKey());
 77366 
            oprot.writeI64(_iter215.getKey());
77369 
            oprot.writeString(_iter203.getValue());
 77367 
            oprot.writeString(_iter215.getValue());
77370 
          }
 77368 
          }
77371 
          oprot.writeMapEnd();
 77369 
          oprot.writeMapEnd();
77372 
        }
 77370 
        }
77373 
        oprot.writeFieldEnd();
 77371 
        oprot.writeFieldEnd();
77374 
      } else if (this.isSetEx()) {
 77372 
      } else if (this.isSetEx()) {
Line 79465... Line 79463...
79465 
        }
 79463 
        }
79466 
        switch (field.id) {
 79464 
        switch (field.id) {
79467 
          case 0: // SUCCESS
 79465 
          case 0: // SUCCESS
79468 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 79466 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
79469 
              {
 79467 
              {
79470 
                org.apache.thrift.protocol.TList _list204 = iprot.readListBegin();
 79468 
                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
79471 
                this.success = new ArrayList<PaymentSettlement>(_list204.size);
 79469 
                this.success = new ArrayList<PaymentSettlement>(_list216.size);
79472 
                for (int _i205 = 0; _i205 < _list204.size; ++_i205)
 79470 
                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
79473 
                {
 79471 
                {
79474 
                  PaymentSettlement _elem206; // required
 79472 
                  PaymentSettlement _elem218; // required
79475 
                  _elem206 = new PaymentSettlement();
 79473 
                  _elem218 = new PaymentSettlement();
79476 
                  _elem206.read(iprot);
 79474 
                  _elem218.read(iprot);
79477 
                  this.success.add(_elem206);
 79475 
                  this.success.add(_elem218);
79478 
                }
 79476 
                }
79479 
                iprot.readListEnd();
 79477 
                iprot.readListEnd();
79480 
              }
 79478 
              }
79481 
            } else {
79479 
            } else {
79482 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 79480 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 79504... Line 79502...
79504 
 
 79502 
 
79505 
      if (this.isSetSuccess()) {
 79503 
      if (this.isSetSuccess()) {
79506 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 79504 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
79507 
        {
 79505 
        {
79508 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 79506 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
79509 
          for (PaymentSettlement _iter207 : this.success)
 79507 
          for (PaymentSettlement _iter219 : this.success)
79510 
          {
 79508 
          {
79511 
            _iter207.write(oprot);
 79509 
            _iter219.write(oprot);
79512 
          }
 79510 
          }
79513 
          oprot.writeListEnd();
 79511 
          oprot.writeListEnd();
79514 
        }
 79512 
        }
79515 
        oprot.writeFieldEnd();
 79513 
        oprot.writeFieldEnd();
79516 
      } else if (this.isSetEx()) {
 79514 
      } else if (this.isSetEx()) {
Line 79816... Line 79814...
79816 
        }
 79814 
        }
79817 
        switch (field.id) {
 79815 
        switch (field.id) {
79818 
          case 1: // ORDER_IDS
 79816 
          case 1: // ORDER_IDS
79819 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 79817 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
79820 
              {
 79818 
              {
79821 
                org.apache.thrift.protocol.TList _list208 = iprot.readListBegin();
 79819 
                org.apache.thrift.protocol.TList _list220 = iprot.readListBegin();
79822 
                this.orderIds = new ArrayList<Long>(_list208.size);
 79820 
                this.orderIds = new ArrayList<Long>(_list220.size);
79823 
                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
 79821 
                for (int _i221 = 0; _i221 < _list220.size; ++_i221)
79824 
                {
 79822 
                {
79825 
                  long _elem210; // required
 79823 
                  long _elem222; // required
79826 
                  _elem210 = iprot.readI64();
 79824 
                  _elem222 = iprot.readI64();
79827 
                  this.orderIds.add(_elem210);
 79825 
                  this.orderIds.add(_elem222);
79828 
                }
 79826 
                }
79829 
                iprot.readListEnd();
 79827 
                iprot.readListEnd();
79830 
              }
 79828 
              }
79831 
            } else {
79829 
            } else {
79832 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 79830 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 79847... Line 79845...
79847 
      oprot.writeStructBegin(STRUCT_DESC);
 79845 
      oprot.writeStructBegin(STRUCT_DESC);
79848 
      if (this.orderIds != null) {
 79846 
      if (this.orderIds != null) {
79849 
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
 79847 
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
79850 
        {
 79848 
        {
79851 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
 79849 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
79852 
          for (long _iter211 : this.orderIds)
 79850 
          for (long _iter223 : this.orderIds)
79853 
          {
 79851 
          {
79854 
            oprot.writeI64(_iter211);
 79852 
            oprot.writeI64(_iter223);
79855 
          }
 79853 
          }
79856 
          oprot.writeListEnd();
 79854 
          oprot.writeListEnd();
79857 
        }
 79855 
        }
79858 
        oprot.writeFieldEnd();
 79856 
        oprot.writeFieldEnd();
79859 
      }
 79857 
      }
Line 80215... Line 80213...
80215 
        }
 80213 
        }
80216 
        switch (field.id) {
 80214 
        switch (field.id) {
80217 
          case 0: // SUCCESS
 80215 
          case 0: // SUCCESS
80218 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 80216 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
80219 
              {
 80217 
              {
80220 
                org.apache.thrift.protocol.TList _list212 = iprot.readListBegin();
 80218 
                org.apache.thrift.protocol.TList _list224 = iprot.readListBegin();
80221 
                this.success = new ArrayList<Long>(_list212.size);
 80219 
                this.success = new ArrayList<Long>(_list224.size);
80222 
                for (int _i213 = 0; _i213 < _list212.size; ++_i213)
 80220 
                for (int _i225 = 0; _i225 < _list224.size; ++_i225)
80223 
                {
 80221 
                {
80224 
                  long _elem214; // required
 80222 
                  long _elem226; // required
80225 
                  _elem214 = iprot.readI64();
 80223 
                  _elem226 = iprot.readI64();
80226 
                  this.success.add(_elem214);
 80224 
                  this.success.add(_elem226);
80227 
                }
 80225 
                }
80228 
                iprot.readListEnd();
 80226 
                iprot.readListEnd();
80229 
              }
 80227 
              }
80230 
            } else {
80228 
            } else {
80231 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 80229 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 80253... Line 80251...
80253 
 
 80251 
 
80254 
      if (this.isSetSuccess()) {
 80252 
      if (this.isSetSuccess()) {
80255 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 80253 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
80256 
        {
 80254 
        {
80257 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 80255 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
80258 
          for (long _iter215 : this.success)
 80256 
          for (long _iter227 : this.success)
80259 
          {
 80257 
          {
80260 
            oprot.writeI64(_iter215);
 80258 
            oprot.writeI64(_iter227);
80261 
          }
 80259 
          }
80262 
          oprot.writeListEnd();
 80260 
          oprot.writeListEnd();
80263 
        }
 80261 
        }
80264 
        oprot.writeFieldEnd();
 80262 
        oprot.writeFieldEnd();
80265 
      } else if (this.isSetEx()) {
 80263 
      } else if (this.isSetEx()) {
Line 80709... Line 80707...
80709 
        }
 80707 
        }
80710 
        switch (field.id) {
 80708 
        switch (field.id) {
80711 
          case 1: // ITEM_ID_QUANTITY_MAP
 80709 
          case 1: // ITEM_ID_QUANTITY_MAP
80712 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 80710 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
80713 
              {
 80711 
              {
80714 
                org.apache.thrift.protocol.TMap _map216 = iprot.readMapBegin();
 80712 
                org.apache.thrift.protocol.TMap _map228 = iprot.readMapBegin();
80715 
                this.itemIdQuantityMap = new HashMap<Long,Long>(2*_map216.size);
 80713 
                this.itemIdQuantityMap = new HashMap<Long,Long>(2*_map228.size);
80716 
                for (int _i217 = 0; _i217 < _map216.size; ++_i217)
 80714 
                for (int _i229 = 0; _i229 < _map228.size; ++_i229)
80717 
                {
 80715 
                {
80718 
                  long _key218; // required
 80716 
                  long _key230; // required
80719 
                  long _val219; // required
 80717 
                  long _val231; // required
80720 
                  _key218 = iprot.readI64();
 80718 
                  _key230 = iprot.readI64();
80721 
                  _val219 = iprot.readI64();
 80719 
                  _val231 = iprot.readI64();
80722 
                  this.itemIdQuantityMap.put(_key218, _val219);
 80720 
                  this.itemIdQuantityMap.put(_key230, _val231);
80723 
                }
 80721 
                }
80724 
                iprot.readMapEnd();
 80722 
                iprot.readMapEnd();
80725 
              }
 80723 
              }
80726 
            } else {
80724 
            } else {
80727 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 80725 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 80758... Line 80756...
80758 
      oprot.writeStructBegin(STRUCT_DESC);
 80756 
      oprot.writeStructBegin(STRUCT_DESC);
80759 
      if (this.itemIdQuantityMap != null) {
 80757 
      if (this.itemIdQuantityMap != null) {
80760 
        oprot.writeFieldBegin(ITEM_ID_QUANTITY_MAP_FIELD_DESC);
 80758 
        oprot.writeFieldBegin(ITEM_ID_QUANTITY_MAP_FIELD_DESC);
80761 
        {
 80759 
        {
80762 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemIdQuantityMap.size()));
 80760 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemIdQuantityMap.size()));
80763 
          for (Map.Entry<Long, Long> _iter220 : this.itemIdQuantityMap.entrySet())
 80761 
          for (Map.Entry<Long, Long> _iter232 : this.itemIdQuantityMap.entrySet())
80764 
          {
 80762 
          {
80765 
            oprot.writeI64(_iter220.getKey());
 80763 
            oprot.writeI64(_iter232.getKey());
80766 
            oprot.writeI64(_iter220.getValue());
 80764 
            oprot.writeI64(_iter232.getValue());
80767 
          }
 80765 
          }
80768 
          oprot.writeMapEnd();
 80766 
          oprot.writeMapEnd();
80769 
        }
 80767 
        }
80770 
        oprot.writeFieldEnd();
 80768 
        oprot.writeFieldEnd();
80771 
      }
 80769 
      }