Subversion Repositories SmartDukaan

Rev

Rev 5296 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5296 Rev 5305
Line 8009... Line 8009...
8009 
      }
 8009 
      }
8010 
    }
 8010 
    }
8011 
 
 8011 
 
8012 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 8012 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8013 
      try {
 8013 
      try {
8014 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
8015 
        __isset_bit_vector = new BitSet(1);
 - 
 
8016 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 8014 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8017 
      } catch (org.apache.thrift.TException te) {
 8015 
      } catch (org.apache.thrift.TException te) {
8018 
        throw new java.io.IOException(te);
 8016 
        throw new java.io.IOException(te);
8019 
      }
 8017 
      }
8020 
    }
 8018 
    }
Line 8687... Line 8685...
8687 
      }
 8685 
      }
8688 
    }
 8686 
    }
8689 
 
 8687 
 
8690 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 8688 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8691 
      try {
 8689 
      try {
8692 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
8693 
        __isset_bit_vector = new BitSet(1);
 - 
 
8694 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 8690 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8695 
      } catch (org.apache.thrift.TException te) {
 8691 
      } catch (org.apache.thrift.TException te) {
8696 
        throw new java.io.IOException(te);
 8692 
        throw new java.io.IOException(te);
8697 
      }
 8693 
      }
8698 
    }
 8694 
    }
Line 9365... Line 9361...
9365 
      }
 9361 
      }
9366 
    }
 9362 
    }
9367 
 
 9363 
 
9368 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 9364 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9369 
      try {
 9365 
      try {
9370 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
9371 
        __isset_bit_vector = new BitSet(1);
 - 
 
9372 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 9366 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9373 
      } catch (org.apache.thrift.TException te) {
 9367 
      } catch (org.apache.thrift.TException te) {
9374 
        throw new java.io.IOException(te);
 9368 
        throw new java.io.IOException(te);
9375 
      }
 9369 
      }
9376 
    }
 9370 
    }
Line 10043... Line 10037...
10043 
      }
 10037 
      }
10044 
    }
 10038 
    }
10045 
 
 10039 
 
10046 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 10040 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10047 
      try {
 10041 
      try {
10048 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
10049 
        __isset_bit_vector = new BitSet(1);
 - 
 
10050 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 10042 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10051 
      } catch (org.apache.thrift.TException te) {
 10043 
      } catch (org.apache.thrift.TException te) {
10052 
        throw new java.io.IOException(te);
 10044 
        throw new java.io.IOException(te);
10053 
      }
 10045 
      }
10054 
    }
 10046 
    }
Line 11811... Line 11803...
11811 
            }
 11803 
            }
11812 
            break;
 11804 
            break;
11813 
          case 3: // AVAILABILITY
 11805 
          case 3: // AVAILABILITY
11814 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 11806 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
11815 
              {
 11807 
              {
11816 
                org.apache.thrift.protocol.TMap _map19 = iprot.readMapBegin();
 11808 
                org.apache.thrift.protocol.TMap _map14 = iprot.readMapBegin();
11817 
                this.availability = new HashMap<String,Long>(2*_map19.size);
 11809 
                this.availability = new HashMap<String,Long>(2*_map14.size);
11818 
                for (int _i20 = 0; _i20 < _map19.size; ++_i20)
 11810 
                for (int _i15 = 0; _i15 < _map14.size; ++_i15)
11819 
                {
 11811 
                {
11820 
                  String _key21; // required
 11812 
                  String _key16; // required
11821 
                  long _val22; // required
 11813 
                  long _val17; // required
11822 
                  _key21 = iprot.readString();
 11814 
                  _key16 = iprot.readString();
11823 
                  _val22 = iprot.readI64();
 11815 
                  _val17 = iprot.readI64();
11824 
                  this.availability.put(_key21, _val22);
 11816 
                  this.availability.put(_key16, _val17);
11825 
                }
 11817 
                }
11826 
                iprot.readMapEnd();
 11818 
                iprot.readMapEnd();
11827 
              }
 11819 
              }
11828 
            } else {
11820 
            } else {
11829 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 11821 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11852... Line 11844...
11852 
      }
 11844 
      }
11853 
      if (this.availability != null) {
 11845 
      if (this.availability != null) {
11854 
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
 11846 
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
11855 
        {
 11847 
        {
11856 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
 11848 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
11857 
          for (Map.Entry<String, Long> _iter23 : this.availability.entrySet())
 11849 
          for (Map.Entry<String, Long> _iter18 : this.availability.entrySet())
11858 
          {
 11850 
          {
11859 
            oprot.writeString(_iter23.getKey());
 11851 
            oprot.writeString(_iter18.getKey());
11860 
            oprot.writeI64(_iter23.getValue());
 11852 
            oprot.writeI64(_iter18.getValue());
11861 
          }
 11853 
          }
11862 
          oprot.writeMapEnd();
 11854 
          oprot.writeMapEnd();
11863 
        }
 11855 
        }
11864 
        oprot.writeFieldEnd();
 11856 
        oprot.writeFieldEnd();
11865 
      }
 11857 
      }
Line 12620... Line 12612...
12620 
            }
 12612 
            }
12621 
            break;
 12613 
            break;
12622 
          case 3: // AVAILABILITY
 12614 
          case 3: // AVAILABILITY
12623 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 12615 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
12624 
              {
 12616 
              {
12625 
                org.apache.thrift.protocol.TMap _map24 = iprot.readMapBegin();
 12617 
                org.apache.thrift.protocol.TMap _map19 = iprot.readMapBegin();
12626 
                this.availability = new HashMap<String,Long>(2*_map24.size);
 12618 
                this.availability = new HashMap<String,Long>(2*_map19.size);
12627 
                for (int _i25 = 0; _i25 < _map24.size; ++_i25)
 12619 
                for (int _i20 = 0; _i20 < _map19.size; ++_i20)
12628 
                {
 12620 
                {
12629 
                  String _key26; // required
 12621 
                  String _key21; // required
12630 
                  long _val27; // required
 12622 
                  long _val22; // required
12631 
                  _key26 = iprot.readString();
 12623 
                  _key21 = iprot.readString();
12632 
                  _val27 = iprot.readI64();
 12624 
                  _val22 = iprot.readI64();
12633 
                  this.availability.put(_key26, _val27);
 12625 
                  this.availability.put(_key21, _val22);
12634 
                }
 12626 
                }
12635 
                iprot.readMapEnd();
 12627 
                iprot.readMapEnd();
12636 
              }
 12628 
              }
12637 
            } else {
12629 
            } else {
12638 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 12630 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 12661... Line 12653...
12661 
      }
 12653 
      }
12662 
      if (this.availability != null) {
 12654 
      if (this.availability != null) {
12663 
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
 12655 
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
12664 
        {
 12656 
        {
12665 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
 12657 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
12666 
          for (Map.Entry<String, Long> _iter28 : this.availability.entrySet())
 12658 
          for (Map.Entry<String, Long> _iter23 : this.availability.entrySet())
12667 
          {
 12659 
          {
12668 
            oprot.writeString(_iter28.getKey());
 12660 
            oprot.writeString(_iter23.getKey());
12669 
            oprot.writeI64(_iter28.getValue());
 12661 
            oprot.writeI64(_iter23.getValue());
12670 
          }
 12662 
          }
12671 
          oprot.writeMapEnd();
 12663 
          oprot.writeMapEnd();
12672 
        }
 12664 
        }
12673 
        oprot.writeFieldEnd();
 12665 
        oprot.writeFieldEnd();
12674 
      }
 12666 
      }
Line 17763... Line 17755...
17763 
        }
 17755 
        }
17764 
        switch (field.id) {
 17756 
        switch (field.id) {
17765 
          case 0: // SUCCESS
 17757 
          case 0: // SUCCESS
17766 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 17758 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17767 
              {
 17759 
              {
17768 
                org.apache.thrift.protocol.TList _list29 = iprot.readListBegin();
 17760 
                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
17769 
                this.success = new ArrayList<Item>(_list29.size);
 17761 
                this.success = new ArrayList<Item>(_list24.size);
17770 
                for (int _i30 = 0; _i30 < _list29.size; ++_i30)
 17762 
                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
17771 
                {
 17763 
                {
17772 
                  Item _elem31; // required
 17764 
                  Item _elem26; // required
17773 
                  _elem31 = new Item();
 17765 
                  _elem26 = new Item();
17774 
                  _elem31.read(iprot);
 17766 
                  _elem26.read(iprot);
17775 
                  this.success.add(_elem31);
 17767 
                  this.success.add(_elem26);
17776 
                }
 17768 
                }
17777 
                iprot.readListEnd();
 17769 
                iprot.readListEnd();
17778 
              }
 17770 
              }
17779 
            } else {
17771 
            } else {
17780 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 17772 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17802... Line 17794...
17802 
 
 17794 
 
17803 
      if (this.isSetSuccess()) {
 17795 
      if (this.isSetSuccess()) {
17804 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 17796 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17805 
        {
 17797 
        {
17806 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 17798 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17807 
          for (Item _iter32 : this.success)
 17799 
          for (Item _iter27 : this.success)
17808 
          {
 17800 
          {
17809 
            _iter32.write(oprot);
 17801 
            _iter27.write(oprot);
17810 
          }
 17802 
          }
17811 
          oprot.writeListEnd();
 17803 
          oprot.writeListEnd();
17812 
        }
 17804 
        }
17813 
        oprot.writeFieldEnd();
 17805 
        oprot.writeFieldEnd();
17814 
      } else if (this.isSetCex()) {
 17806 
      } else if (this.isSetCex()) {
Line 18476... Line 18468...
18476 
        }
 18468 
        }
18477 
        switch (field.id) {
 18469 
        switch (field.id) {
18478 
          case 0: // SUCCESS
 18470 
          case 0: // SUCCESS
18479 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 18471 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18480 
              {
 18472 
              {
18481 
                org.apache.thrift.protocol.TList _list33 = iprot.readListBegin();
 18473 
                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
18482 
                this.success = new ArrayList<Item>(_list33.size);
 18474 
                this.success = new ArrayList<Item>(_list28.size);
18483 
                for (int _i34 = 0; _i34 < _list33.size; ++_i34)
 18475 
                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
18484 
                {
 18476 
                {
18485 
                  Item _elem35; // required
 18477 
                  Item _elem30; // required
18486 
                  _elem35 = new Item();
 18478 
                  _elem30 = new Item();
18487 
                  _elem35.read(iprot);
 18479 
                  _elem30.read(iprot);
18488 
                  this.success.add(_elem35);
 18480 
                  this.success.add(_elem30);
18489 
                }
 18481 
                }
18490 
                iprot.readListEnd();
 18482 
                iprot.readListEnd();
18491 
              }
 18483 
              }
18492 
            } else {
18484 
            } else {
18493 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 18485 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 18515... Line 18507...
18515 
 
 18507 
 
18516 
      if (this.isSetSuccess()) {
 18508 
      if (this.isSetSuccess()) {
18517 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 18509 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18518 
        {
 18510 
        {
18519 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 18511 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18520 
          for (Item _iter36 : this.success)
 18512 
          for (Item _iter31 : this.success)
18521 
          {
 18513 
          {
18522 
            _iter36.write(oprot);
 18514 
            _iter31.write(oprot);
18523 
          }
 18515 
          }
18524 
          oprot.writeListEnd();
 18516 
          oprot.writeListEnd();
18525 
        }
 18517 
        }
18526 
        oprot.writeFieldEnd();
 18518 
        oprot.writeFieldEnd();
18527 
      } else if (this.isSetCex()) {
 18519 
      } else if (this.isSetCex()) {
Line 19189... Line 19181...
19189 
        }
 19181 
        }
19190 
        switch (field.id) {
 19182 
        switch (field.id) {
19191 
          case 0: // SUCCESS
 19183 
          case 0: // SUCCESS
19192 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 19184 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19193 
              {
 19185 
              {
19194 
                org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
 19186 
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
19195 
                this.success = new ArrayList<Item>(_list37.size);
 19187 
                this.success = new ArrayList<Item>(_list32.size);
19196 
                for (int _i38 = 0; _i38 < _list37.size; ++_i38)
 19188 
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
19197 
                {
 19189 
                {
19198 
                  Item _elem39; // required
 19190 
                  Item _elem34; // required
19199 
                  _elem39 = new Item();
 19191 
                  _elem34 = new Item();
19200 
                  _elem39.read(iprot);
 19192 
                  _elem34.read(iprot);
19201 
                  this.success.add(_elem39);
 19193 
                  this.success.add(_elem34);
19202 
                }
 19194 
                }
19203 
                iprot.readListEnd();
 19195 
                iprot.readListEnd();
19204 
              }
 19196 
              }
19205 
            } else {
19197 
            } else {
19206 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 19198 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 19228... Line 19220...
19228 
 
 19220 
 
19229 
      if (this.isSetSuccess()) {
 19221 
      if (this.isSetSuccess()) {
19230 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 19222 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19231 
        {
 19223 
        {
19232 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 19224 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19233 
          for (Item _iter40 : this.success)
 19225 
          for (Item _iter35 : this.success)
19234 
          {
 19226 
          {
19235 
            _iter40.write(oprot);
 19227 
            _iter35.write(oprot);
19236 
          }
 19228 
          }
19237 
          oprot.writeListEnd();
 19229 
          oprot.writeListEnd();
19238 
        }
 19230 
        }
19239 
        oprot.writeFieldEnd();
 19231 
        oprot.writeFieldEnd();
19240 
      } else if (this.isSetCex()) {
 19232 
      } else if (this.isSetCex()) {
Line 19914... Line 19906...
19914 
        }
 19906 
        }
19915 
        switch (field.id) {
 19907 
        switch (field.id) {
19916 
          case 0: // SUCCESS
 19908 
          case 0: // SUCCESS
19917 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 19909 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19918 
              {
 19910 
              {
19919 
                org.apache.thrift.protocol.TList _list41 = iprot.readListBegin();
 19911 
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
19920 
                this.success = new ArrayList<Item>(_list41.size);
 19912 
                this.success = new ArrayList<Item>(_list36.size);
19921 
                for (int _i42 = 0; _i42 < _list41.size; ++_i42)
 19913 
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
19922 
                {
 19914 
                {
19923 
                  Item _elem43; // required
 19915 
                  Item _elem38; // required
19924 
                  _elem43 = new Item();
 19916 
                  _elem38 = new Item();
19925 
                  _elem43.read(iprot);
 19917 
                  _elem38.read(iprot);
19926 
                  this.success.add(_elem43);
 19918 
                  this.success.add(_elem38);
19927 
                }
 19919 
                }
19928 
                iprot.readListEnd();
 19920 
                iprot.readListEnd();
19929 
              }
 19921 
              }
19930 
            } else {
19922 
            } else {
19931 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 19923 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 19953... Line 19945...
19953 
 
 19945 
 
19954 
      if (this.isSetSuccess()) {
 19946 
      if (this.isSetSuccess()) {
19955 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 19947 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19956 
        {
 19948 
        {
19957 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 19949 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19958 
          for (Item _iter44 : this.success)
 19950 
          for (Item _iter39 : this.success)
19959 
          {
 19951 
          {
19960 
            _iter44.write(oprot);
 19952 
            _iter39.write(oprot);
19961 
          }
 19953 
          }
19962 
          oprot.writeListEnd();
 19954 
          oprot.writeListEnd();
19963 
        }
 19955 
        }
19964 
        oprot.writeFieldEnd();
 19956 
        oprot.writeFieldEnd();
19965 
      } else if (this.isSetCex()) {
 19957 
      } else if (this.isSetCex()) {
Line 21441... Line 21433...
21441 
      }
 21433 
      }
21442 
    }
 21434 
    }
21443 
 
 21435 
 
21444 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 21436 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
21445 
      try {
 21437 
      try {
21446 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
21447 
        __isset_bit_vector = new BitSet(1);
 - 
 
21448 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 21438 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
21449 
      } catch (org.apache.thrift.TException te) {
 21439 
      } catch (org.apache.thrift.TException te) {
21450 
        throw new java.io.IOException(te);
 21440 
        throw new java.io.IOException(te);
21451 
      }
 21441 
      }
21452 
    }
 21442 
    }
Line 22465... Line 22455...
22465 
      }
 22455 
      }
22466 
    }
 22456 
    }
22467 
 
 22457 
 
22468 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 22458 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
22469 
      try {
 22459 
      try {
22470 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
22471 
        __isset_bit_vector = new BitSet(1);
 - 
 
22472 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 22460 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
22473 
      } catch (org.apache.thrift.TException te) {
 22461 
      } catch (org.apache.thrift.TException te) {
22474 
        throw new java.io.IOException(te);
 22462 
        throw new java.io.IOException(te);
22475 
      }
 22463 
      }
22476 
    }
 22464 
    }
Line 23168... Line 23156...
23168 
        }
 23156 
        }
23169 
        switch (field.id) {
 23157 
        switch (field.id) {
23170 
          case 0: // SUCCESS
 23158 
          case 0: // SUCCESS
23171 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 23159 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23172 
              {
 23160 
              {
23173 
                org.apache.thrift.protocol.TList _list45 = iprot.readListBegin();
 23161 
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
23174 
                this.success = new ArrayList<Item>(_list45.size);
 23162 
                this.success = new ArrayList<Item>(_list40.size);
23175 
                for (int _i46 = 0; _i46 < _list45.size; ++_i46)
 23163 
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
23176 
                {
 23164 
                {
23177 
                  Item _elem47; // required
 23165 
                  Item _elem42; // required
23178 
                  _elem47 = new Item();
 23166 
                  _elem42 = new Item();
23179 
                  _elem47.read(iprot);
 23167 
                  _elem42.read(iprot);
23180 
                  this.success.add(_elem47);
 23168 
                  this.success.add(_elem42);
23181 
                }
 23169 
                }
23182 
                iprot.readListEnd();
 23170 
                iprot.readListEnd();
23183 
              }
 23171 
              }
23184 
            } else {
23172 
            } else {
23185 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 23173 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23207... Line 23195...
23207 
 
 23195 
 
23208 
      if (this.isSetSuccess()) {
 23196 
      if (this.isSetSuccess()) {
23209 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 23197 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23210 
        {
 23198 
        {
23211 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 23199 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23212 
          for (Item _iter48 : this.success)
 23200 
          for (Item _iter43 : this.success)
23213 
          {
 23201 
          {
23214 
            _iter48.write(oprot);
 23202 
            _iter43.write(oprot);
23215 
          }
 23203 
          }
23216 
          oprot.writeListEnd();
 23204 
          oprot.writeListEnd();
23217 
        }
 23205 
        }
23218 
        oprot.writeFieldEnd();
 23206 
        oprot.writeFieldEnd();
23219 
      } else if (this.isSetCex()) {
 23207 
      } else if (this.isSetCex()) {
Line 24062... Line 24050...
24062 
        }
 24050 
        }
24063 
        switch (field.id) {
 24051 
        switch (field.id) {
24064 
          case 0: // SUCCESS
 24052 
          case 0: // SUCCESS
24065 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 24053 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
24066 
              {
 24054 
              {
24067 
                org.apache.thrift.protocol.TList _list49 = iprot.readListBegin();
 24055 
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
24068 
                this.success = new ArrayList<Item>(_list49.size);
 24056 
                this.success = new ArrayList<Item>(_list44.size);
24069 
                for (int _i50 = 0; _i50 < _list49.size; ++_i50)
 24057 
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
24070 
                {
 24058 
                {
24071 
                  Item _elem51; // required
 24059 
                  Item _elem46; // required
24072 
                  _elem51 = new Item();
 24060 
                  _elem46 = new Item();
24073 
                  _elem51.read(iprot);
 24061 
                  _elem46.read(iprot);
24074 
                  this.success.add(_elem51);
 24062 
                  this.success.add(_elem46);
24075 
                }
 24063 
                }
24076 
                iprot.readListEnd();
 24064 
                iprot.readListEnd();
24077 
              }
 24065 
              }
24078 
            } else {
24066 
            } else {
24079 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 24067 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 24101... Line 24089...
24101 
 
 24089 
 
24102 
      if (this.isSetSuccess()) {
 24090 
      if (this.isSetSuccess()) {
24103 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 24091 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24104 
        {
 24092 
        {
24105 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 24093 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
24106 
          for (Item _iter52 : this.success)
 24094 
          for (Item _iter47 : this.success)
24107 
          {
 24095 
          {
24108 
            _iter52.write(oprot);
 24096 
            _iter47.write(oprot);
24109 
          }
 24097 
          }
24110 
          oprot.writeListEnd();
 24098 
          oprot.writeListEnd();
24111 
        }
 24099 
        }
24112 
        oprot.writeFieldEnd();
 24100 
        oprot.writeFieldEnd();
24113 
      } else if (this.isSetCex()) {
 24101 
      } else if (this.isSetCex()) {
Line 24842... Line 24830...
24842 
      }
 24830 
      }
24843 
    }
 24831 
    }
24844 
 
 24832 
 
24845 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 24833 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
24846 
      try {
 24834 
      try {
24847 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
24848 
        __isset_bit_vector = new BitSet(1);
 - 
 
24849 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 24835 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
24850 
      } catch (org.apache.thrift.TException te) {
 24836 
      } catch (org.apache.thrift.TException te) {
24851 
        throw new java.io.IOException(te);
 24837 
        throw new java.io.IOException(te);
24852 
      }
 24838 
      }
24853 
    }
 24839 
    }
Line 25462... Line 25448...
25462 
        }
 25448 
        }
25463 
        switch (field.id) {
 25449 
        switch (field.id) {
25464 
          case 0: // SUCCESS
 25450 
          case 0: // SUCCESS
25465 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 25451 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25466 
              {
 25452 
              {
25467 
                org.apache.thrift.protocol.TList _list53 = iprot.readListBegin();
 25453 
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
25468 
                this.success = new ArrayList<Long>(_list53.size);
 25454 
                this.success = new ArrayList<Long>(_list48.size);
25469 
                for (int _i54 = 0; _i54 < _list53.size; ++_i54)
 25455 
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
25470 
                {
 25456 
                {
25471 
                  long _elem55; // required
 25457 
                  long _elem50; // required
25472 
                  _elem55 = iprot.readI64();
 25458 
                  _elem50 = iprot.readI64();
25473 
                  this.success.add(_elem55);
 25459 
                  this.success.add(_elem50);
25474 
                }
 25460 
                }
25475 
                iprot.readListEnd();
 25461 
                iprot.readListEnd();
25476 
              }
 25462 
              }
25477 
            } else {
25463 
            } else {
25478 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 25464 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25500... Line 25486...
25500 
 
 25486 
 
25501 
      if (this.isSetSuccess()) {
 25487 
      if (this.isSetSuccess()) {
25502 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 25488 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25503 
        {
 25489 
        {
25504 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 25490 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
25505 
          for (long _iter56 : this.success)
 25491 
          for (long _iter51 : this.success)
25506 
          {
 25492 
          {
25507 
            oprot.writeI64(_iter56);
 25493 
            oprot.writeI64(_iter51);
25508 
          }
 25494 
          }
25509 
          oprot.writeListEnd();
 25495 
          oprot.writeListEnd();
25510 
        }
 25496 
        }
25511 
        oprot.writeFieldEnd();
 25497 
        oprot.writeFieldEnd();
25512 
      } else if (this.isSetIsex()) {
 25498 
      } else if (this.isSetIsex()) {
Line 26172... Line 26158...
26172 
        }
 26158 
        }
26173 
        switch (field.id) {
 26159 
        switch (field.id) {
26174 
          case 0: // SUCCESS
 26160 
          case 0: // SUCCESS
26175 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 26161 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
26176 
              {
 26162 
              {
26177 
                org.apache.thrift.protocol.TList _list57 = iprot.readListBegin();
 26163 
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
26178 
                this.success = new ArrayList<Warehouse>(_list57.size);
 26164 
                this.success = new ArrayList<Warehouse>(_list52.size);
26179 
                for (int _i58 = 0; _i58 < _list57.size; ++_i58)
 26165 
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
26180 
                {
 26166 
                {
26181 
                  Warehouse _elem59; // required
 26167 
                  Warehouse _elem54; // required
26182 
                  _elem59 = new Warehouse();
 26168 
                  _elem54 = new Warehouse();
26183 
                  _elem59.read(iprot);
 26169 
                  _elem54.read(iprot);
26184 
                  this.success.add(_elem59);
 26170 
                  this.success.add(_elem54);
26185 
                }
 26171 
                }
26186 
                iprot.readListEnd();
 26172 
                iprot.readListEnd();
26187 
              }
 26173 
              }
26188 
            } else {
26174 
            } else {
26189 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 26175 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 26211... Line 26197...
26211 
 
 26197 
 
26212 
      if (this.isSetSuccess()) {
 26198 
      if (this.isSetSuccess()) {
26213 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 26199 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26214 
        {
 26200 
        {
26215 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 26201 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
26216 
          for (Warehouse _iter60 : this.success)
 26202 
          for (Warehouse _iter55 : this.success)
26217 
          {
 26203 
          {
26218 
            _iter60.write(oprot);
 26204 
            _iter55.write(oprot);
26219 
          }
 26205 
          }
26220 
          oprot.writeListEnd();
 26206 
          oprot.writeListEnd();
26221 
        }
 26207 
        }
26222 
        oprot.writeFieldEnd();
 26208 
        oprot.writeFieldEnd();
26223 
      } else if (this.isSetCex()) {
 26209 
      } else if (this.isSetCex()) {
Line 27561... Line 27547...
27561 
        }
 27547 
        }
27562 
        switch (field.id) {
 27548 
        switch (field.id) {
27563 
          case 0: // SUCCESS
 27549 
          case 0: // SUCCESS
27564 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 27550 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
27565 
              {
 27551 
              {
27566 
                org.apache.thrift.protocol.TList _list61 = iprot.readListBegin();
 27552 
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
27567 
                this.success = new ArrayList<Warehouse>(_list61.size);
 27553 
                this.success = new ArrayList<Warehouse>(_list56.size);
27568 
                for (int _i62 = 0; _i62 < _list61.size; ++_i62)
 27554 
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
27569 
                {
 27555 
                {
27570 
                  Warehouse _elem63; // required
 27556 
                  Warehouse _elem58; // required
27571 
                  _elem63 = new Warehouse();
 27557 
                  _elem58 = new Warehouse();
27572 
                  _elem63.read(iprot);
 27558 
                  _elem58.read(iprot);
27573 
                  this.success.add(_elem63);
 27559 
                  this.success.add(_elem58);
27574 
                }
 27560 
                }
27575 
                iprot.readListEnd();
 27561 
                iprot.readListEnd();
27576 
              }
 27562 
              }
27577 
            } else {
27563 
            } else {
27578 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 27564 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 27600... Line 27586...
27600 
 
 27586 
 
27601 
      if (this.isSetSuccess()) {
 27587 
      if (this.isSetSuccess()) {
27602 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 27588 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27603 
        {
 27589 
        {
27604 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 27590 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
27605 
          for (Warehouse _iter64 : this.success)
 27591 
          for (Warehouse _iter59 : this.success)
27606 
          {
 27592 
          {
27607 
            _iter64.write(oprot);
 27593 
            _iter59.write(oprot);
27608 
          }
 27594 
          }
27609 
          oprot.writeListEnd();
 27595 
          oprot.writeListEnd();
27610 
        }
 27596 
        }
27611 
        oprot.writeFieldEnd();
 27597 
        oprot.writeFieldEnd();
27612 
      } else if (this.isSetCex()) {
 27598 
      } else if (this.isSetCex()) {
Line 28274... Line 28260...
28274 
        }
 28260 
        }
28275 
        switch (field.id) {
 28261 
        switch (field.id) {
28276 
          case 0: // SUCCESS
 28262 
          case 0: // SUCCESS
28277 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 28263 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28278 
              {
 28264 
              {
28279 
                org.apache.thrift.protocol.TList _list65 = iprot.readListBegin();
 28265 
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
28280 
                this.success = new ArrayList<Item>(_list65.size);
 28266 
                this.success = new ArrayList<Item>(_list60.size);
28281 
                for (int _i66 = 0; _i66 < _list65.size; ++_i66)
 28267 
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
28282 
                {
 28268 
                {
28283 
                  Item _elem67; // required
 28269 
                  Item _elem62; // required
28284 
                  _elem67 = new Item();
 28270 
                  _elem62 = new Item();
28285 
                  _elem67.read(iprot);
 28271 
                  _elem62.read(iprot);
28286 
                  this.success.add(_elem67);
 28272 
                  this.success.add(_elem62);
28287 
                }
 28273 
                }
28288 
                iprot.readListEnd();
 28274 
                iprot.readListEnd();
28289 
              }
 28275 
              }
28290 
            } else {
28276 
            } else {
28291 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 28277 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 28313... Line 28299...
28313 
 
 28299 
 
28314 
      if (this.isSetSuccess()) {
 28300 
      if (this.isSetSuccess()) {
28315 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 28301 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28316 
        {
 28302 
        {
28317 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 28303 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28318 
          for (Item _iter68 : this.success)
 28304 
          for (Item _iter63 : this.success)
28319 
          {
 28305 
          {
28320 
            _iter68.write(oprot);
 28306 
            _iter63.write(oprot);
28321 
          }
 28307 
          }
28322 
          oprot.writeListEnd();
 28308 
          oprot.writeListEnd();
28323 
        }
 28309 
        }
28324 
        oprot.writeFieldEnd();
 28310 
        oprot.writeFieldEnd();
28325 
      } else if (this.isSetCex()) {
 28311 
      } else if (this.isSetCex()) {
Line 29206... Line 29192...
29206 
      }
 29192 
      }
29207 
    }
 29193 
    }
29208 
 
 29194 
 
29209 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 29195 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
29210 
      try {
 29196 
      try {
29211 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
29212 
        __isset_bit_vector = new BitSet(1);
 - 
 
29213 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 29197 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
29214 
      } catch (org.apache.thrift.TException te) {
 29198 
      } catch (org.apache.thrift.TException te) {
29215 
        throw new java.io.IOException(te);
 29199 
        throw new java.io.IOException(te);
29216 
      }
 29200 
      }
29217 
    }
 29201 
    }
Line 30047... Line 30031...
30047 
      }
 30031 
      }
30048 
    }
 30032 
    }
30049 
 
 30033 
 
30050 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 30034 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
30051 
      try {
 30035 
      try {
30052 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
30053 
        __isset_bit_vector = new BitSet(1);
 - 
 
30054 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 30036 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
30055 
      } catch (org.apache.thrift.TException te) {
 30037 
      } catch (org.apache.thrift.TException te) {
30056 
        throw new java.io.IOException(te);
 30038 
        throw new java.io.IOException(te);
30057 
      }
 30039 
      }
30058 
    }
 30040 
    }
Line 30575... Line 30557...
30575 
        }
 30557 
        }
30576 
        switch (field.id) {
 30558 
        switch (field.id) {
30577 
          case 0: // SUCCESS
 30559 
          case 0: // SUCCESS
30578 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 30560 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30579 
              {
 30561 
              {
30580 
                org.apache.thrift.protocol.TList _list69 = iprot.readListBegin();
 30562 
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
30581 
                this.success = new ArrayList<Item>(_list69.size);
 30563 
                this.success = new ArrayList<Item>(_list64.size);
30582 
                for (int _i70 = 0; _i70 < _list69.size; ++_i70)
 30564 
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
30583 
                {
 30565 
                {
30584 
                  Item _elem71; // required
 30566 
                  Item _elem66; // required
30585 
                  _elem71 = new Item();
 30567 
                  _elem66 = new Item();
30586 
                  _elem71.read(iprot);
 30568 
                  _elem66.read(iprot);
30587 
                  this.success.add(_elem71);
 30569 
                  this.success.add(_elem66);
30588 
                }
 30570 
                }
30589 
                iprot.readListEnd();
 30571 
                iprot.readListEnd();
30590 
              }
 30572 
              }
30591 
            } else {
30573 
            } else {
30592 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 30574 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30614... Line 30596...
30614 
 
 30596 
 
30615 
      if (this.isSetSuccess()) {
 30597 
      if (this.isSetSuccess()) {
30616 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 30598 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30617 
        {
 30599 
        {
30618 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 30600 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30619 
          for (Item _iter72 : this.success)
 30601 
          for (Item _iter67 : this.success)
30620 
          {
 30602 
          {
30621 
            _iter72.write(oprot);
 30603 
            _iter67.write(oprot);
30622 
          }
 30604 
          }
30623 
          oprot.writeListEnd();
 30605 
          oprot.writeListEnd();
30624 
        }
 30606 
        }
30625 
        oprot.writeFieldEnd();
 30607 
        oprot.writeFieldEnd();
30626 
      } else if (this.isSetIsex()) {
 30608 
      } else if (this.isSetIsex()) {
Line 31542... Line 31524...
31542 
        }
 31524 
        }
31543 
        switch (field.id) {
 31525 
        switch (field.id) {
31544 
          case 0: // SUCCESS
 31526 
          case 0: // SUCCESS
31545 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 31527 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31546 
              {
 31528 
              {
31547 
                org.apache.thrift.protocol.TList _list73 = iprot.readListBegin();
 31529 
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
31548 
                this.success = new ArrayList<Long>(_list73.size);
 31530 
                this.success = new ArrayList<Long>(_list68.size);
31549 
                for (int _i74 = 0; _i74 < _list73.size; ++_i74)
 31531 
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
31550 
                {
 31532 
                {
31551 
                  long _elem75; // required
 31533 
                  long _elem70; // required
31552 
                  _elem75 = iprot.readI64();
 31534 
                  _elem70 = iprot.readI64();
31553 
                  this.success.add(_elem75);
 31535 
                  this.success.add(_elem70);
31554 
                }
 31536 
                }
31555 
                iprot.readListEnd();
 31537 
                iprot.readListEnd();
31556 
              }
 31538 
              }
31557 
            } else {
31539 
            } else {
31558 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 31540 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 31580... Line 31562...
31580 
 
 31562 
 
31581 
      if (this.isSetSuccess()) {
 31563 
      if (this.isSetSuccess()) {
31582 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 31564 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31583 
        {
 31565 
        {
31584 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 31566 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
31585 
          for (long _iter76 : this.success)
 31567 
          for (long _iter71 : this.success)
31586 
          {
 31568 
          {
31587 
            oprot.writeI64(_iter76);
 31569 
            oprot.writeI64(_iter71);
31588 
          }
 31570 
          }
31589 
          oprot.writeListEnd();
 31571 
          oprot.writeListEnd();
31590 
        }
 31572 
        }
31591 
        oprot.writeFieldEnd();
 31573 
        oprot.writeFieldEnd();
31592 
      } else if (this.isSetCex()) {
 31574 
      } else if (this.isSetCex()) {
Line 32215... Line 32197...
32215 
      }
 32197 
      }
32216 
    }
 32198 
    }
32217 
 
 32199 
 
32218 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 32200 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
32219 
      try {
 32201 
      try {
32220 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
32221 
        __isset_bit_vector = new BitSet(1);
 - 
 
32222 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 32202 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
32223 
      } catch (org.apache.thrift.TException te) {
 32203 
      } catch (org.apache.thrift.TException te) {
32224 
        throw new java.io.IOException(te);
 32204 
        throw new java.io.IOException(te);
32225 
      }
 32205 
      }
32226 
    }
 32206 
    }
Line 32743... Line 32723...
32743 
        }
 32723 
        }
32744 
        switch (field.id) {
 32724 
        switch (field.id) {
32745 
          case 0: // SUCCESS
 32725 
          case 0: // SUCCESS
32746 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 32726 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32747 
              {
 32727 
              {
32748 
                org.apache.thrift.protocol.TList _list77 = iprot.readListBegin();
 32728 
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
32749 
                this.success = new ArrayList<Item>(_list77.size);
 32729 
                this.success = new ArrayList<Item>(_list72.size);
32750 
                for (int _i78 = 0; _i78 < _list77.size; ++_i78)
 32730 
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
32751 
                {
 32731 
                {
32752 
                  Item _elem79; // required
 32732 
                  Item _elem74; // required
32753 
                  _elem79 = new Item();
 32733 
                  _elem74 = new Item();
32754 
                  _elem79.read(iprot);
 32734 
                  _elem74.read(iprot);
32755 
                  this.success.add(_elem79);
 32735 
                  this.success.add(_elem74);
32756 
                }
 32736 
                }
32757 
                iprot.readListEnd();
 32737 
                iprot.readListEnd();
32758 
              }
 32738 
              }
32759 
            } else {
32739 
            } else {
32760 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 32740 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32782... Line 32762...
32782 
 
 32762 
 
32783 
      if (this.isSetSuccess()) {
 32763 
      if (this.isSetSuccess()) {
32784 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 32764 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32785 
        {
 32765 
        {
32786 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 32766 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
32787 
          for (Item _iter80 : this.success)
 32767 
          for (Item _iter75 : this.success)
32788 
          {
 32768 
          {
32789 
            _iter80.write(oprot);
 32769 
            _iter75.write(oprot);
32790 
          }
 32770 
          }
32791 
          oprot.writeListEnd();
 32771 
          oprot.writeListEnd();
32792 
        }
 32772 
        }
32793 
        oprot.writeFieldEnd();
 32773 
        oprot.writeFieldEnd();
32794 
      } else if (this.isSetIsex()) {
 32774 
      } else if (this.isSetIsex()) {
Line 33710... Line 33690...
33710 
        }
 33690 
        }
33711 
        switch (field.id) {
 33691 
        switch (field.id) {
33712 
          case 0: // SUCCESS
 33692 
          case 0: // SUCCESS
33713 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 33693 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33714 
              {
 33694 
              {
33715 
                org.apache.thrift.protocol.TList _list81 = iprot.readListBegin();
 33695 
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
33716 
                this.success = new ArrayList<Long>(_list81.size);
 33696 
                this.success = new ArrayList<Long>(_list76.size);
33717 
                for (int _i82 = 0; _i82 < _list81.size; ++_i82)
 33697 
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
33718 
                {
 33698 
                {
33719 
                  long _elem83; // required
 33699 
                  long _elem78; // required
33720 
                  _elem83 = iprot.readI64();
 33700 
                  _elem78 = iprot.readI64();
33721 
                  this.success.add(_elem83);
 33701 
                  this.success.add(_elem78);
33722 
                }
 33702 
                }
33723 
                iprot.readListEnd();
 33703 
                iprot.readListEnd();
33724 
              }
 33704 
              }
33725 
            } else {
33705 
            } else {
33726 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 33706 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 33748... Line 33728...
33748 
 
 33728 
 
33749 
      if (this.isSetSuccess()) {
 33729 
      if (this.isSetSuccess()) {
33750 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 33730 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33751 
        {
 33731 
        {
33752 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 33732 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
33753 
          for (long _iter84 : this.success)
 33733 
          for (long _iter79 : this.success)
33754 
          {
 33734 
          {
33755 
            oprot.writeI64(_iter84);
 33735 
            oprot.writeI64(_iter79);
33756 
          }
 33736 
          }
33757 
          oprot.writeListEnd();
 33737 
          oprot.writeListEnd();
33758 
        }
 33738 
        }
33759 
        oprot.writeFieldEnd();
 33739 
        oprot.writeFieldEnd();
33760 
      } else if (this.isSetCex()) {
 33740 
      } else if (this.isSetCex()) {
Line 34383... Line 34363...
34383 
      }
 34363 
      }
34384 
    }
 34364 
    }
34385 
 
 34365 
 
34386 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 34366 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
34387 
      try {
 34367 
      try {
34388 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
34389 
        __isset_bit_vector = new BitSet(1);
 - 
 
34390 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 34368 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
34391 
      } catch (org.apache.thrift.TException te) {
 34369 
      } catch (org.apache.thrift.TException te) {
34392 
        throw new java.io.IOException(te);
 34370 
        throw new java.io.IOException(te);
34393 
      }
 34371 
      }
34394 
    }
 34372 
    }
Line 34911... Line 34889...
34911 
        }
 34889 
        }
34912 
        switch (field.id) {
 34890 
        switch (field.id) {
34913 
          case 0: // SUCCESS
 34891 
          case 0: // SUCCESS
34914 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 34892 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
34915 
              {
 34893 
              {
34916 
                org.apache.thrift.protocol.TList _list85 = iprot.readListBegin();
 34894 
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
34917 
                this.success = new ArrayList<Item>(_list85.size);
 34895 
                this.success = new ArrayList<Item>(_list80.size);
34918 
                for (int _i86 = 0; _i86 < _list85.size; ++_i86)
 34896 
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
34919 
                {
 34897 
                {
34920 
                  Item _elem87; // required
 34898 
                  Item _elem82; // required
34921 
                  _elem87 = new Item();
 34899 
                  _elem82 = new Item();
34922 
                  _elem87.read(iprot);
 34900 
                  _elem82.read(iprot);
34923 
                  this.success.add(_elem87);
 34901 
                  this.success.add(_elem82);
34924 
                }
 34902 
                }
34925 
                iprot.readListEnd();
 34903 
                iprot.readListEnd();
34926 
              }
 34904 
              }
34927 
            } else {
34905 
            } else {
34928 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 34906 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 34950... Line 34928...
34950 
 
 34928 
 
34951 
      if (this.isSetSuccess()) {
 34929 
      if (this.isSetSuccess()) {
34952 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 34930 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
34953 
        {
 34931 
        {
34954 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 34932 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
34955 
          for (Item _iter88 : this.success)
 34933 
          for (Item _iter83 : this.success)
34956 
          {
 34934 
          {
34957 
            _iter88.write(oprot);
 34935 
            _iter83.write(oprot);
34958 
          }
 34936 
          }
34959 
          oprot.writeListEnd();
 34937 
          oprot.writeListEnd();
34960 
        }
 34938 
        }
34961 
        oprot.writeFieldEnd();
 34939 
        oprot.writeFieldEnd();
34962 
      } else if (this.isSetIsex()) {
 34940 
      } else if (this.isSetIsex()) {
Line 35878... Line 35856...
35878 
        }
 35856 
        }
35879 
        switch (field.id) {
 35857 
        switch (field.id) {
35880 
          case 0: // SUCCESS
 35858 
          case 0: // SUCCESS
35881 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 35859 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
35882 
              {
 35860 
              {
35883 
                org.apache.thrift.protocol.TList _list89 = iprot.readListBegin();
 35861 
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
35884 
                this.success = new ArrayList<Long>(_list89.size);
 35862 
                this.success = new ArrayList<Long>(_list84.size);
35885 
                for (int _i90 = 0; _i90 < _list89.size; ++_i90)
 35863 
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
35886 
                {
 35864 
                {
35887 
                  long _elem91; // required
 35865 
                  long _elem86; // required
35888 
                  _elem91 = iprot.readI64();
 35866 
                  _elem86 = iprot.readI64();
35889 
                  this.success.add(_elem91);
 35867 
                  this.success.add(_elem86);
35890 
                }
 35868 
                }
35891 
                iprot.readListEnd();
 35869 
                iprot.readListEnd();
35892 
              }
 35870 
              }
35893 
            } else {
35871 
            } else {
35894 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 35872 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 35916... Line 35894...
35916 
 
 35894 
 
35917 
      if (this.isSetSuccess()) {
 35895 
      if (this.isSetSuccess()) {
35918 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 35896 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
35919 
        {
 35897 
        {
35920 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 35898 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
35921 
          for (long _iter92 : this.success)
 35899 
          for (long _iter87 : this.success)
35922 
          {
 35900 
          {
35923 
            oprot.writeI64(_iter92);
 35901 
            oprot.writeI64(_iter87);
35924 
          }
 35902 
          }
35925 
          oprot.writeListEnd();
 35903 
          oprot.writeListEnd();
35926 
        }
 35904 
        }
35927 
        oprot.writeFieldEnd();
 35905 
        oprot.writeFieldEnd();
35928 
      } else if (this.isSetCex()) {
 35906 
      } else if (this.isSetCex()) {
Line 36551... Line 36529...
36551 
      }
 36529 
      }
36552 
    }
 36530 
    }
36553 
 
 36531 
 
36554 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 36532 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
36555 
      try {
 36533 
      try {
36556 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
36557 
        __isset_bit_vector = new BitSet(1);
 - 
 
36558 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 36534 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
36559 
      } catch (org.apache.thrift.TException te) {
 36535 
      } catch (org.apache.thrift.TException te) {
36560 
        throw new java.io.IOException(te);
 36536 
        throw new java.io.IOException(te);
36561 
      }
 36537 
      }
36562 
    }
 36538 
    }
Line 37079... Line 37055...
37079 
        }
 37055 
        }
37080 
        switch (field.id) {
 37056 
        switch (field.id) {
37081 
          case 0: // SUCCESS
 37057 
          case 0: // SUCCESS
37082 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 37058 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37083 
              {
 37059 
              {
37084 
                org.apache.thrift.protocol.TList _list93 = iprot.readListBegin();
 37060 
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
37085 
                this.success = new ArrayList<Item>(_list93.size);
 37061 
                this.success = new ArrayList<Item>(_list88.size);
37086 
                for (int _i94 = 0; _i94 < _list93.size; ++_i94)
 37062 
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
37087 
                {
 37063 
                {
37088 
                  Item _elem95; // required
 37064 
                  Item _elem90; // required
37089 
                  _elem95 = new Item();
 37065 
                  _elem90 = new Item();
37090 
                  _elem95.read(iprot);
 37066 
                  _elem90.read(iprot);
37091 
                  this.success.add(_elem95);
 37067 
                  this.success.add(_elem90);
37092 
                }
 37068 
                }
37093 
                iprot.readListEnd();
 37069 
                iprot.readListEnd();
37094 
              }
 37070 
              }
37095 
            } else {
37071 
            } else {
37096 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 37072 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37118... Line 37094...
37118 
 
 37094 
 
37119 
      if (this.isSetSuccess()) {
 37095 
      if (this.isSetSuccess()) {
37120 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 37096 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37121 
        {
 37097 
        {
37122 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 37098 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
37123 
          for (Item _iter96 : this.success)
 37099 
          for (Item _iter91 : this.success)
37124 
          {
 37100 
          {
37125 
            _iter96.write(oprot);
 37101 
            _iter91.write(oprot);
37126 
          }
 37102 
          }
37127 
          oprot.writeListEnd();
 37103 
          oprot.writeListEnd();
37128 
        }
 37104 
        }
37129 
        oprot.writeFieldEnd();
 37105 
        oprot.writeFieldEnd();
37130 
      } else if (this.isSetIsex()) {
 37106 
      } else if (this.isSetIsex()) {
Line 37660... Line 37636...
37660 
            }
 37636 
            }
37661 
            break;
 37637 
            break;
37662 
          case 4: // CATEGORIES
 37638 
          case 4: // CATEGORIES
37663 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 37639 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37664 
              {
 37640 
              {
37665 
                org.apache.thrift.protocol.TList _list97 = iprot.readListBegin();
 37641 
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
37666 
                this.categories = new ArrayList<Long>(_list97.size);
 37642 
                this.categories = new ArrayList<Long>(_list92.size);
37667 
                for (int _i98 = 0; _i98 < _list97.size; ++_i98)
 37643 
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
37668 
                {
 37644 
                {
37669 
                  long _elem99; // required
 37645 
                  long _elem94; // required
37670 
                  _elem99 = iprot.readI64();
 37646 
                  _elem94 = iprot.readI64();
37671 
                  this.categories.add(_elem99);
 37647 
                  this.categories.add(_elem94);
37672 
                }
 37648 
                }
37673 
                iprot.readListEnd();
 37649 
                iprot.readListEnd();
37674 
              }
 37650 
              }
37675 
            } else {
37651 
            } else {
37676 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 37652 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37702... Line 37678...
37702 
      }
 37678 
      }
37703 
      if (this.categories != null) {
 37679 
      if (this.categories != null) {
37704 
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
 37680 
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
37705 
        {
 37681 
        {
37706 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
 37682 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
37707 
          for (long _iter100 : this.categories)
 37683 
          for (long _iter95 : this.categories)
37708 
          {
 37684 
          {
37709 
            oprot.writeI64(_iter100);
 37685 
            oprot.writeI64(_iter95);
37710 
          }
 37686 
          }
37711 
          oprot.writeListEnd();
 37687 
          oprot.writeListEnd();
37712 
        }
 37688 
        }
37713 
        oprot.writeFieldEnd();
 37689 
        oprot.writeFieldEnd();
37714 
      }
 37690 
      }
Line 38086... Line 38062...
38086 
        }
 38062 
        }
38087 
        switch (field.id) {
 38063 
        switch (field.id) {
38088 
          case 0: // SUCCESS
 38064 
          case 0: // SUCCESS
38089 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 38065 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
38090 
              {
 38066 
              {
38091 
                org.apache.thrift.protocol.TList _list101 = iprot.readListBegin();
 38067 
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
38092 
                this.success = new ArrayList<Long>(_list101.size);
 38068 
                this.success = new ArrayList<Long>(_list96.size);
38093 
                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
 38069 
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
38094 
                {
 38070 
                {
38095 
                  long _elem103; // required
 38071 
                  long _elem98; // required
38096 
                  _elem103 = iprot.readI64();
 38072 
                  _elem98 = iprot.readI64();
38097 
                  this.success.add(_elem103);
 38073 
                  this.success.add(_elem98);
38098 
                }
 38074 
                }
38099 
                iprot.readListEnd();
 38075 
                iprot.readListEnd();
38100 
              }
 38076 
              }
38101 
            } else {
38077 
            } else {
38102 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 38078 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 38124... Line 38100...
38124 
 
 38100 
 
38125 
      if (this.isSetSuccess()) {
 38101 
      if (this.isSetSuccess()) {
38126 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 38102 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
38127 
        {
 38103 
        {
38128 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 38104 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
38129 
          for (long _iter104 : this.success)
 38105 
          for (long _iter99 : this.success)
38130 
          {
 38106 
          {
38131 
            oprot.writeI64(_iter104);
 38107 
            oprot.writeI64(_iter99);
38132 
          }
 38108 
          }
38133 
          oprot.writeListEnd();
 38109 
          oprot.writeListEnd();
38134 
        }
 38110 
        }
38135 
        oprot.writeFieldEnd();
 38111 
        oprot.writeFieldEnd();
38136 
      } else if (this.isSetCex()) {
 38112 
      } else if (this.isSetCex()) {
Line 38759... Line 38735...
38759 
      }
 38735 
      }
38760 
    }
 38736 
    }
38761 
 
 38737 
 
38762 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 38738 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
38763 
      try {
 38739 
      try {
38764 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
38765 
        __isset_bit_vector = new BitSet(1);
 - 
 
38766 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 38740 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
38767 
      } catch (org.apache.thrift.TException te) {
 38741 
      } catch (org.apache.thrift.TException te) {
38768 
        throw new java.io.IOException(te);
 38742 
        throw new java.io.IOException(te);
38769 
      }
 38743 
      }
38770 
    }
 38744 
    }
Line 39254... Line 39228...
39254 
      }
 39228 
      }
39255 
    }
 39229 
    }
39256 
 
 39230 
 
39257 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 39231 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
39258 
      try {
 39232 
      try {
39259 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
39260 
        __isset_bit_vector = new BitSet(1);
 - 
 
39261 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 39233 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
39262 
      } catch (org.apache.thrift.TException te) {
 39234 
      } catch (org.apache.thrift.TException te) {
39263 
        throw new java.io.IOException(te);
 39235 
        throw new java.io.IOException(te);
39264 
      }
 39236 
      }
39265 
    }
 39237 
    }
Line 40601... Line 40573...
40601 
      }
 40573 
      }
40602 
    }
 40574 
    }
40603 
 
 40575 
 
40604 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 40576 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
40605 
      try {
 40577 
      try {
40606 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
40607 
        __isset_bit_vector = new BitSet(1);
 - 
 
40608 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 40578 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
40609 
      } catch (org.apache.thrift.TException te) {
 40579 
      } catch (org.apache.thrift.TException te) {
40610 
        throw new java.io.IOException(te);
 40580 
        throw new java.io.IOException(te);
40611 
      }
 40581 
      }
40612 
    }
 40582 
    }
Line 41649... Line 41619...
41649 
        }
 41619 
        }
41650 
        switch (field.id) {
 41620 
        switch (field.id) {
41651 
          case 0: // SUCCESS
 41621 
          case 0: // SUCCESS
41652 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 41622 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41653 
              {
 41623 
              {
41654 
                org.apache.thrift.protocol.TList _list105 = iprot.readListBegin();
 41624 
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
41655 
                this.success = new ArrayList<Category>(_list105.size);
 41625 
                this.success = new ArrayList<Category>(_list100.size);
41656 
                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
 41626 
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
41657 
                {
 41627 
                {
41658 
                  Category _elem107; // required
 41628 
                  Category _elem102; // required
41659 
                  _elem107 = new Category();
 41629 
                  _elem102 = new Category();
41660 
                  _elem107.read(iprot);
 41630 
                  _elem102.read(iprot);
41661 
                  this.success.add(_elem107);
 41631 
                  this.success.add(_elem102);
41662 
                }
 41632 
                }
41663 
                iprot.readListEnd();
 41633 
                iprot.readListEnd();
41664 
              }
 41634 
              }
41665 
            } else {
41635 
            } else {
41666 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 41636 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41680... Line 41650...
41680 
 
 41650 
 
41681 
      if (this.isSetSuccess()) {
 41651 
      if (this.isSetSuccess()) {
41682 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 41652 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41683 
        {
 41653 
        {
41684 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 41654 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41685 
          for (Category _iter108 : this.success)
 41655 
          for (Category _iter103 : this.success)
41686 
          {
 41656 
          {
41687 
            _iter108.write(oprot);
 41657 
            _iter103.write(oprot);
41688 
          }
 41658 
          }
41689 
          oprot.writeListEnd();
 41659 
          oprot.writeListEnd();
41690 
        }
 41660 
        }
41691 
        oprot.writeFieldEnd();
 41661 
        oprot.writeFieldEnd();
41692 
      }
 41662 
      }
Line 42340... Line 42310...
42340 
        }
 42310 
        }
42341 
        switch (field.id) {
 42311 
        switch (field.id) {
42342 
          case 0: // SUCCESS
 42312 
          case 0: // SUCCESS
42343 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 42313 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
42344 
              {
 42314 
              {
42345 
                org.apache.thrift.protocol.TList _list109 = iprot.readListBegin();
 42315 
                org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
42346 
                this.success = new ArrayList<VendorItemPricing>(_list109.size);
 42316 
                this.success = new ArrayList<VendorItemPricing>(_list104.size);
42347 
                for (int _i110 = 0; _i110 < _list109.size; ++_i110)
 42317 
                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
42348 
                {
 42318 
                {
42349 
                  VendorItemPricing _elem111; // required
 42319 
                  VendorItemPricing _elem106; // required
42350 
                  _elem111 = new VendorItemPricing();
 42320 
                  _elem106 = new VendorItemPricing();
42351 
                  _elem111.read(iprot);
 42321 
                  _elem106.read(iprot);
42352 
                  this.success.add(_elem111);
 42322 
                  this.success.add(_elem106);
42353 
                }
 42323 
                }
42354 
                iprot.readListEnd();
 42324 
                iprot.readListEnd();
42355 
              }
 42325 
              }
42356 
            } else {
42326 
            } else {
42357 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 42327 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 42379... Line 42349...
42379 
 
 42349 
 
42380 
      if (this.isSetSuccess()) {
 42350 
      if (this.isSetSuccess()) {
42381 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 42351 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
42382 
        {
 42352 
        {
42383 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 42353 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
42384 
          for (VendorItemPricing _iter112 : this.success)
 42354 
          for (VendorItemPricing _iter107 : this.success)
42385 
          {
 42355 
          {
42386 
            _iter112.write(oprot);
 42356 
            _iter107.write(oprot);
42387 
          }
 42357 
          }
42388 
          oprot.writeListEnd();
 42358 
          oprot.writeListEnd();
42389 
        }
 42359 
        }
42390 
        oprot.writeFieldEnd();
 42360 
        oprot.writeFieldEnd();
42391 
      } else if (this.isSetCex()) {
 42361 
      } else if (this.isSetCex()) {
Line 43480... Line 43450...
43480 
        }
 43450 
        }
43481 
        switch (field.id) {
 43451 
        switch (field.id) {
43482 
          case 0: // SUCCESS
 43452 
          case 0: // SUCCESS
43483 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 43453 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
43484 
              {
 43454 
              {
43485 
                org.apache.thrift.protocol.TList _list113 = iprot.readListBegin();
 43455 
                org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();
43486 
                this.success = new ArrayList<Vendor>(_list113.size);
 43456 
                this.success = new ArrayList<Vendor>(_list108.size);
43487 
                for (int _i114 = 0; _i114 < _list113.size; ++_i114)
 43457 
                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
43488 
                {
 43458 
                {
43489 
                  Vendor _elem115; // required
 43459 
                  Vendor _elem110; // required
43490 
                  _elem115 = new Vendor();
 43460 
                  _elem110 = new Vendor();
43491 
                  _elem115.read(iprot);
 43461 
                  _elem110.read(iprot);
43492 
                  this.success.add(_elem115);
 43462 
                  this.success.add(_elem110);
43493 
                }
 43463 
                }
43494 
                iprot.readListEnd();
 43464 
                iprot.readListEnd();
43495 
              }
 43465 
              }
43496 
            } else {
43466 
            } else {
43497 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 43467 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 43511... Line 43481...
43511 
 
 43481 
 
43512 
      if (this.isSetSuccess()) {
 43482 
      if (this.isSetSuccess()) {
43513 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 43483 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
43514 
        {
 43484 
        {
43515 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 43485 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
43516 
          for (Vendor _iter116 : this.success)
 43486 
          for (Vendor _iter111 : this.success)
43517 
          {
 43487 
          {
43518 
            _iter116.write(oprot);
 43488 
            _iter111.write(oprot);
43519 
          }
 43489 
          }
43520 
          oprot.writeListEnd();
 43490 
          oprot.writeListEnd();
43521 
        }
 43491 
        }
43522 
        oprot.writeFieldEnd();
 43492 
        oprot.writeFieldEnd();
43523 
      }
 43493 
      }
Line 44105... Line 44075...
44105 
        }
 44075 
        }
44106 
        switch (field.id) {
 44076 
        switch (field.id) {
44107 
          case 0: // SUCCESS
 44077 
          case 0: // SUCCESS
44108 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 44078 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44109 
              {
 44079 
              {
44110 
                org.apache.thrift.protocol.TList _list117 = iprot.readListBegin();
 44080 
                org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
44111 
                this.success = new ArrayList<Item>(_list117.size);
 44081 
                this.success = new ArrayList<Item>(_list112.size);
44112 
                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
 44082 
                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
44113 
                {
 44083 
                {
44114 
                  Item _elem119; // required
 44084 
                  Item _elem114; // required
44115 
                  _elem119 = new Item();
 44085 
                  _elem114 = new Item();
44116 
                  _elem119.read(iprot);
 44086 
                  _elem114.read(iprot);
44117 
                  this.success.add(_elem119);
 44087 
                  this.success.add(_elem114);
44118 
                }
 44088 
                }
44119 
                iprot.readListEnd();
 44089 
                iprot.readListEnd();
44120 
              }
 44090 
              }
44121 
            } else {
44091 
            } else {
44122 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 44092 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 44136... Line 44106...
44136 
 
 44106 
 
44137 
      if (this.isSetSuccess()) {
 44107 
      if (this.isSetSuccess()) {
44138 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 44108 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44139 
        {
 44109 
        {
44140 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 44110 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
44141 
          for (Item _iter120 : this.success)
 44111 
          for (Item _iter115 : this.success)
44142 
          {
 44112 
          {
44143 
            _iter120.write(oprot);
 44113 
            _iter115.write(oprot);
44144 
          }
 44114 
          }
44145 
          oprot.writeListEnd();
 44115 
          oprot.writeListEnd();
44146 
        }
 44116 
        }
44147 
        oprot.writeFieldEnd();
 44117 
        oprot.writeFieldEnd();
44148 
      }
 44118 
      }
Line 45695... Line 45665...
45695 
      }
 45665 
      }
45696 
    }
 45666 
    }
45697 
 
 45667 
 
45698 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 45668 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
45699 
      try {
 45669 
      try {
45700 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
45701 
        __isset_bit_vector = new BitSet(1);
 - 
 
45702 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 45670 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
45703 
      } catch (org.apache.thrift.TException te) {
 45671 
      } catch (org.apache.thrift.TException te) {
45704 
        throw new java.io.IOException(te);
 45672 
        throw new java.io.IOException(te);
45705 
      }
 45673 
      }
45706 
    }
 45674 
    }
Line 46992... Line 46960...
46992 
        }
 46960 
        }
46993 
        switch (field.id) {
 46961 
        switch (field.id) {
46994 
          case 0: // SUCCESS
 46962 
          case 0: // SUCCESS
46995 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 46963 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
46996 
              {
 46964 
              {
46997 
                org.apache.thrift.protocol.TList _list121 = iprot.readListBegin();
 46965 
                org.apache.thrift.protocol.TList _list116 = iprot.readListBegin();
46998 
                this.success = new ArrayList<VendorItemMapping>(_list121.size);
 46966 
                this.success = new ArrayList<VendorItemMapping>(_list116.size);
46999 
                for (int _i122 = 0; _i122 < _list121.size; ++_i122)
 46967 
                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
47000 
                {
 46968 
                {
47001 
                  VendorItemMapping _elem123; // required
 46969 
                  VendorItemMapping _elem118; // required
47002 
                  _elem123 = new VendorItemMapping();
 46970 
                  _elem118 = new VendorItemMapping();
47003 
                  _elem123.read(iprot);
 46971 
                  _elem118.read(iprot);
47004 
                  this.success.add(_elem123);
 46972 
                  this.success.add(_elem118);
47005 
                }
 46973 
                }
47006 
                iprot.readListEnd();
 46974 
                iprot.readListEnd();
47007 
              }
 46975 
              }
47008 
            } else {
46976 
            } else {
47009 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 46977 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 47031... Line 46999...
47031 
 
 46999 
 
47032 
      if (this.isSetSuccess()) {
 47000 
      if (this.isSetSuccess()) {
47033 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 47001 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47034 
        {
 47002 
        {
47035 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 47003 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
47036 
          for (VendorItemMapping _iter124 : this.success)
 47004 
          for (VendorItemMapping _iter119 : this.success)
47037 
          {
 47005 
          {
47038 
            _iter124.write(oprot);
 47006 
            _iter119.write(oprot);
47039 
          }
 47007 
          }
47040 
          oprot.writeListEnd();
 47008 
          oprot.writeListEnd();
47041 
        }
 47009 
        }
47042 
        oprot.writeFieldEnd();
 47010 
        oprot.writeFieldEnd();
47043 
      } else if (this.isSetCex()) {
 47011 
      } else if (this.isSetCex()) {
Line 47936... Line 47904...
47936 
      }
 47904 
      }
47937 
    }
 47905 
    }
47938 
 
 47906 
 
47939 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 47907 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
47940 
      try {
 47908 
      try {
47941 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
47942 
        __isset_bit_vector = new BitSet(1);
 - 
 
47943 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 47909 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
47944 
      } catch (org.apache.thrift.TException te) {
 47910 
      } catch (org.apache.thrift.TException te) {
47945 
        throw new java.io.IOException(te);
 47911 
        throw new java.io.IOException(te);
47946 
      }
 47912 
      }
47947 
    }
 47913 
    }
Line 48970... Line 48936...
48970 
        }
 48936 
        }
48971 
        switch (field.id) {
 48937 
        switch (field.id) {
48972 
          case 0: // SUCCESS
 48938 
          case 0: // SUCCESS
48973 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 48939 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
48974 
              {
 48940 
              {
48975 
                org.apache.thrift.protocol.TList _list125 = iprot.readListBegin();
 48941 
                org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
48976 
                this.success = new ArrayList<Item>(_list125.size);
 48942 
                this.success = new ArrayList<Item>(_list120.size);
48977 
                for (int _i126 = 0; _i126 < _list125.size; ++_i126)
 48943 
                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
48978 
                {
 48944 
                {
48979 
                  Item _elem127; // required
 48945 
                  Item _elem122; // required
48980 
                  _elem127 = new Item();
 48946 
                  _elem122 = new Item();
48981 
                  _elem127.read(iprot);
 48947 
                  _elem122.read(iprot);
48982 
                  this.success.add(_elem127);
 48948 
                  this.success.add(_elem122);
48983 
                }
 48949 
                }
48984 
                iprot.readListEnd();
 48950 
                iprot.readListEnd();
48985 
              }
 48951 
              }
48986 
            } else {
48952 
            } else {
48987 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 48953 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 49001... Line 48967...
49001 
 
 48967 
 
49002 
      if (this.isSetSuccess()) {
 48968 
      if (this.isSetSuccess()) {
49003 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 48969 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
49004 
        {
 48970 
        {
49005 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 48971 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
49006 
          for (Item _iter128 : this.success)
 48972 
          for (Item _iter123 : this.success)
49007 
          {
 48973 
          {
49008 
            _iter128.write(oprot);
 48974 
            _iter123.write(oprot);
49009 
          }
 48975 
          }
49010 
          oprot.writeListEnd();
 48976 
          oprot.writeListEnd();
49011 
        }
 48977 
        }
49012 
        oprot.writeFieldEnd();
 48978 
        oprot.writeFieldEnd();
49013 
      }
 48979 
      }
Line 49683... Line 49649...
49683 
        }
 49649 
        }
49684 
        switch (field.id) {
 49650 
        switch (field.id) {
49685 
          case 0: // SUCCESS
 49651 
          case 0: // SUCCESS
49686 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 49652 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
49687 
              {
 49653 
              {
49688 
                org.apache.thrift.protocol.TList _list129 = iprot.readListBegin();
 49654 
                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
49689 
                this.success = new ArrayList<Item>(_list129.size);
 49655 
                this.success = new ArrayList<Item>(_list124.size);
49690 
                for (int _i130 = 0; _i130 < _list129.size; ++_i130)
 49656 
                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
49691 
                {
 49657 
                {
49692 
                  Item _elem131; // required
 49658 
                  Item _elem126; // required
49693 
                  _elem131 = new Item();
 49659 
                  _elem126 = new Item();
49694 
                  _elem131.read(iprot);
 49660 
                  _elem126.read(iprot);
49695 
                  this.success.add(_elem131);
 49661 
                  this.success.add(_elem126);
49696 
                }
 49662 
                }
49697 
                iprot.readListEnd();
 49663 
                iprot.readListEnd();
49698 
              }
 49664 
              }
49699 
            } else {
49665 
            } else {
49700 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 49666 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 49714... Line 49680...
49714 
 
 49680 
 
49715 
      if (this.isSetSuccess()) {
 49681 
      if (this.isSetSuccess()) {
49716 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 49682 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
49717 
        {
 49683 
        {
49718 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 49684 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
49719 
          for (Item _iter132 : this.success)
 49685 
          for (Item _iter127 : this.success)
49720 
          {
 49686 
          {
49721 
            _iter132.write(oprot);
 49687 
            _iter127.write(oprot);
49722 
          }
 49688 
          }
49723 
          oprot.writeListEnd();
 49689 
          oprot.writeListEnd();
49724 
        }
 49690 
        }
49725 
        oprot.writeFieldEnd();
 49691 
        oprot.writeFieldEnd();
49726 
      }
 49692 
      }
Line 50472... Line 50438...
50472 
        }
 50438 
        }
50473 
        switch (field.id) {
 50439 
        switch (field.id) {
50474 
          case 0: // SUCCESS
 50440 
          case 0: // SUCCESS
50475 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 50441 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
50476 
              {
 50442 
              {
50477 
                org.apache.thrift.protocol.TList _list133 = iprot.readListBegin();
 50443 
                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
50478 
                this.success = new ArrayList<Long>(_list133.size);
 50444 
                this.success = new ArrayList<Long>(_list128.size);
50479 
                for (int _i134 = 0; _i134 < _list133.size; ++_i134)
 50445 
                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
50480 
                {
 50446 
                {
50481 
                  long _elem135; // required
 50447 
                  long _elem130; // required
50482 
                  _elem135 = iprot.readI64();
 50448 
                  _elem130 = iprot.readI64();
50483 
                  this.success.add(_elem135);
 50449 
                  this.success.add(_elem130);
50484 
                }
 50450 
                }
50485 
                iprot.readListEnd();
 50451 
                iprot.readListEnd();
50486 
              }
 50452 
              }
50487 
            } else {
50453 
            } else {
50488 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 50454 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 50502... Line 50468...
50502 
 
 50468 
 
50503 
      if (this.isSetSuccess()) {
 50469 
      if (this.isSetSuccess()) {
50504 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 50470 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
50505 
        {
 50471 
        {
50506 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
 50472 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
50507 
          for (long _iter136 : this.success)
 50473 
          for (long _iter131 : this.success)
50508 
          {
 50474 
          {
50509 
            oprot.writeI64(_iter136);
 50475 
            oprot.writeI64(_iter131);
50510 
          }
 50476 
          }
50511 
          oprot.writeListEnd();
 50477 
          oprot.writeListEnd();
50512 
        }
 50478 
        }
50513 
        oprot.writeFieldEnd();
 50479 
        oprot.writeFieldEnd();
50514 
      }
 50480 
      }
Line 51219... Line 51185...
51219 
      }
 51185 
      }
51220 
    }
 51186 
    }
51221 
 
 51187 
 
51222 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 51188 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
51223 
      try {
 51189 
      try {
51224 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
51225 
        __isset_bit_vector = new BitSet(1);
 - 
 
51226 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 51190 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
51227 
      } catch (org.apache.thrift.TException te) {
 51191 
      } catch (org.apache.thrift.TException te) {
51228 
        throw new java.io.IOException(te);
 51192 
        throw new java.io.IOException(te);
51229 
      }
 51193 
      }
51230 
    }
 51194 
    }
Line 51714... Line 51678...
51714 
      }
 51678 
      }
51715 
    }
 51679 
    }
51716 
 
 51680 
 
51717 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 51681 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
51718 
      try {
 51682 
      try {
51719 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
51720 
        __isset_bit_vector = new BitSet(1);
 - 
 
51721 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 51683 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
51722 
      } catch (org.apache.thrift.TException te) {
 51684 
      } catch (org.apache.thrift.TException te) {
51723 
        throw new java.io.IOException(te);
 51685 
        throw new java.io.IOException(te);
51724 
      }
 51686 
      }
51725 
    }
 51687 
    }
Line 52268... Line 52230...
52268 
        }
 52230 
        }
52269 
        switch (field.id) {
 52231 
        switch (field.id) {
52270 
          case 0: // SUCCESS
 52232 
          case 0: // SUCCESS
52271 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 52233 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52272 
              {
 52234 
              {
52273 
                org.apache.thrift.protocol.TList _list137 = iprot.readListBegin();
 52235 
                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
52274 
                this.success = new ArrayList<String>(_list137.size);
 52236 
                this.success = new ArrayList<String>(_list132.size);
52275 
                for (int _i138 = 0; _i138 < _list137.size; ++_i138)
 52237 
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
52276 
                {
 52238 
                {
52277 
                  String _elem139; // required
 52239 
                  String _elem134; // required
52278 
                  _elem139 = iprot.readString();
 52240 
                  _elem134 = iprot.readString();
52279 
                  this.success.add(_elem139);
 52241 
                  this.success.add(_elem134);
52280 
                }
 52242 
                }
52281 
                iprot.readListEnd();
 52243 
                iprot.readListEnd();
52282 
              }
 52244 
              }
52283 
            } else {
52245 
            } else {
52284 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 52246 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 52298... Line 52260...
52298 
 
 52260 
 
52299 
      if (this.isSetSuccess()) {
 52261 
      if (this.isSetSuccess()) {
52300 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 52262 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
52301 
        {
 52263 
        {
52302 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
 52264 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
52303 
          for (String _iter140 : this.success)
 52265 
          for (String _iter135 : this.success)
52304 
          {
 52266 
          {
52305 
            oprot.writeString(_iter140);
 52267 
            oprot.writeString(_iter135);
52306 
          }
 52268 
          }
52307 
          oprot.writeListEnd();
 52269 
          oprot.writeListEnd();
52308 
        }
 52270 
        }
52309 
        oprot.writeFieldEnd();
 52271 
        oprot.writeFieldEnd();
52310 
      }
 52272 
      }
Line 52798... Line 52760...
52798 
        }
 52760 
        }
52799 
        switch (field.id) {
 52761 
        switch (field.id) {
52800 
          case 0: // SUCCESS
 52762 
          case 0: // SUCCESS
52801 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 52763 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52802 
              {
 52764 
              {
52803 
                org.apache.thrift.protocol.TList _list141 = iprot.readListBegin();
 52765 
                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
52804 
                this.success = new ArrayList<String>(_list141.size);
 52766 
                this.success = new ArrayList<String>(_list136.size);
52805 
                for (int _i142 = 0; _i142 < _list141.size; ++_i142)
 52767 
                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
52806 
                {
 52768 
                {
52807 
                  String _elem143; // required
 52769 
                  String _elem138; // required
52808 
                  _elem143 = iprot.readString();
 52770 
                  _elem138 = iprot.readString();
52809 
                  this.success.add(_elem143);
 52771 
                  this.success.add(_elem138);
52810 
                }
 52772 
                }
52811 
                iprot.readListEnd();
 52773 
                iprot.readListEnd();
52812 
              }
 52774 
              }
52813 
            } else {
52775 
            } else {
52814 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 52776 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 52828... Line 52790...
52828 
 
 52790 
 
52829 
      if (this.isSetSuccess()) {
 52791 
      if (this.isSetSuccess()) {
52830 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 52792 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
52831 
        {
 52793 
        {
52832 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
 52794 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
52833 
          for (String _iter144 : this.success)
 52795 
          for (String _iter139 : this.success)
52834 
          {
 52796 
          {
52835 
            oprot.writeString(_iter144);
 52797 
            oprot.writeString(_iter139);
52836 
          }
 52798 
          }
52837 
          oprot.writeListEnd();
 52799 
          oprot.writeListEnd();
52838 
        }
 52800 
        }
52839 
        oprot.writeFieldEnd();
 52801 
        oprot.writeFieldEnd();
52840 
      }
 52802 
      }
Line 53328... Line 53290...
53328 
        }
 53290 
        }
53329 
        switch (field.id) {
 53291 
        switch (field.id) {
53330 
          case 0: // SUCCESS
 53292 
          case 0: // SUCCESS
53331 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 53293 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53332 
              {
 53294 
              {
53333 
                org.apache.thrift.protocol.TList _list145 = iprot.readListBegin();
 53295 
                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
53334 
                this.success = new ArrayList<Source>(_list145.size);
 53296 
                this.success = new ArrayList<Source>(_list140.size);
53335 
                for (int _i146 = 0; _i146 < _list145.size; ++_i146)
 53297 
                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
53336 
                {
 53298 
                {
53337 
                  Source _elem147; // required
 53299 
                  Source _elem142; // required
53338 
                  _elem147 = new Source();
 53300 
                  _elem142 = new Source();
53339 
                  _elem147.read(iprot);
 53301 
                  _elem142.read(iprot);
53340 
                  this.success.add(_elem147);
 53302 
                  this.success.add(_elem142);
53341 
                }
 53303 
                }
53342 
                iprot.readListEnd();
 53304 
                iprot.readListEnd();
53343 
              }
 53305 
              }
53344 
            } else {
53306 
            } else {
53345 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 53307 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 53359... Line 53321...
53359 
 
 53321 
 
53360 
      if (this.isSetSuccess()) {
 53322 
      if (this.isSetSuccess()) {
53361 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 53323 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53362 
        {
 53324 
        {
53363 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 53325 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53364 
          for (Source _iter148 : this.success)
 53326 
          for (Source _iter143 : this.success)
53365 
          {
 53327 
          {
53366 
            _iter148.write(oprot);
 53328 
            _iter143.write(oprot);
53367 
          }
 53329 
          }
53368 
          oprot.writeListEnd();
 53330 
          oprot.writeListEnd();
53369 
        }
 53331 
        }
53370 
        oprot.writeFieldEnd();
 53332 
        oprot.writeFieldEnd();
53371 
      }
 53333 
      }
Line 55365... Line 55327...
55365 
        }
 55327 
        }
55366 
        switch (field.id) {
 55328 
        switch (field.id) {
55367 
          case 0: // SUCCESS
 55329 
          case 0: // SUCCESS
55368 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 55330 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
55369 
              {
 55331 
              {
55370 
                org.apache.thrift.protocol.TList _list149 = iprot.readListBegin();
 55332 
                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
55371 
                this.success = new ArrayList<SourceItemPricing>(_list149.size);
 55333 
                this.success = new ArrayList<SourceItemPricing>(_list144.size);
55372 
                for (int _i150 = 0; _i150 < _list149.size; ++_i150)
 55334 
                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
55373 
                {
 55335 
                {
55374 
                  SourceItemPricing _elem151; // required
 55336 
                  SourceItemPricing _elem146; // required
55375 
                  _elem151 = new SourceItemPricing();
 55337 
                  _elem146 = new SourceItemPricing();
55376 
                  _elem151.read(iprot);
 55338 
                  _elem146.read(iprot);
55377 
                  this.success.add(_elem151);
 55339 
                  this.success.add(_elem146);
55378 
                }
 55340 
                }
55379 
                iprot.readListEnd();
 55341 
                iprot.readListEnd();
55380 
              }
 55342 
              }
55381 
            } else {
55343 
            } else {
55382 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 55344 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 55404... Line 55366...
55404 
 
 55366 
 
55405 
      if (this.isSetSuccess()) {
 55367 
      if (this.isSetSuccess()) {
55406 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 55368 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
55407 
        {
 55369 
        {
55408 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 55370 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
55409 
          for (SourceItemPricing _iter152 : this.success)
 55371 
          for (SourceItemPricing _iter147 : this.success)
55410 
          {
 55372 
          {
55411 
            _iter152.write(oprot);
 55373 
            _iter147.write(oprot);
55412 
          }
 55374 
          }
55413 
          oprot.writeListEnd();
 55375 
          oprot.writeListEnd();
55414 
        }
 55376 
        }
55415 
        oprot.writeFieldEnd();
 55377 
        oprot.writeFieldEnd();
55416 
      } else if (this.isSetCex()) {
 55378 
      } else if (this.isSetCex()) {
Line 56612... Line 56574...
56612 
        }
 56574 
        }
56613 
        switch (field.id) {
 56575 
        switch (field.id) {
56614 
          case 1: // SEARCH_TERMS
 56576 
          case 1: // SEARCH_TERMS
56615 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 56577 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
56616 
              {
 56578 
              {
56617 
                org.apache.thrift.protocol.TList _list153 = iprot.readListBegin();
 56579 
                org.apache.thrift.protocol.TList _list148 = iprot.readListBegin();
56618 
                this.searchTerms = new ArrayList<String>(_list153.size);
 56580 
                this.searchTerms = new ArrayList<String>(_list148.size);
56619 
                for (int _i154 = 0; _i154 < _list153.size; ++_i154)
 56581 
                for (int _i149 = 0; _i149 < _list148.size; ++_i149)
56620 
                {
 56582 
                {
56621 
                  String _elem155; // required
 56583 
                  String _elem150; // required
56622 
                  _elem155 = iprot.readString();
 56584 
                  _elem150 = iprot.readString();
56623 
                  this.searchTerms.add(_elem155);
 56585 
                  this.searchTerms.add(_elem150);
56624 
                }
 56586 
                }
56625 
                iprot.readListEnd();
 56587 
                iprot.readListEnd();
56626 
              }
 56588 
              }
56627 
            } else {
56589 
            } else {
56628 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 56590 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 56659... Line 56621...
56659 
      oprot.writeStructBegin(STRUCT_DESC);
 56621 
      oprot.writeStructBegin(STRUCT_DESC);
56660 
      if (this.searchTerms != null) {
 56622 
      if (this.searchTerms != null) {
56661 
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
 56623 
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
56662 
        {
 56624 
        {
56663 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
 56625 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
56664 
          for (String _iter156 : this.searchTerms)
 56626 
          for (String _iter151 : this.searchTerms)
56665 
          {
 56627 
          {
56666 
            oprot.writeString(_iter156);
 56628 
            oprot.writeString(_iter151);
56667 
          }
 56629 
          }
56668 
          oprot.writeListEnd();
 56630 
          oprot.writeListEnd();
56669 
        }
 56631 
        }
56670 
        oprot.writeFieldEnd();
 56632 
        oprot.writeFieldEnd();
56671 
      }
 56633 
      }
Line 56973... Line 56935...
56973 
        }
 56935 
        }
56974 
        switch (field.id) {
 56936 
        switch (field.id) {
56975 
          case 0: // SUCCESS
 56937 
          case 0: // SUCCESS
56976 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 56938 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
56977 
              {
 56939 
              {
56978 
                org.apache.thrift.protocol.TList _list157 = iprot.readListBegin();
 56940 
                org.apache.thrift.protocol.TList _list152 = iprot.readListBegin();
56979 
                this.success = new ArrayList<Item>(_list157.size);
 56941 
                this.success = new ArrayList<Item>(_list152.size);
56980 
                for (int _i158 = 0; _i158 < _list157.size; ++_i158)
 56942 
                for (int _i153 = 0; _i153 < _list152.size; ++_i153)
56981 
                {
 56943 
                {
56982 
                  Item _elem159; // required
 56944 
                  Item _elem154; // required
56983 
                  _elem159 = new Item();
 56945 
                  _elem154 = new Item();
56984 
                  _elem159.read(iprot);
 56946 
                  _elem154.read(iprot);
56985 
                  this.success.add(_elem159);
 56947 
                  this.success.add(_elem154);
56986 
                }
 56948 
                }
56987 
                iprot.readListEnd();
 56949 
                iprot.readListEnd();
56988 
              }
 56950 
              }
56989 
            } else {
56951 
            } else {
56990 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 56952 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 57004... Line 56966...
57004 
 
 56966 
 
57005 
      if (this.isSetSuccess()) {
 56967 
      if (this.isSetSuccess()) {
57006 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 56968 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
57007 
        {
 56969 
        {
57008 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 56970 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
57009 
          for (Item _iter160 : this.success)
 56971 
          for (Item _iter155 : this.success)
57010 
          {
 56972 
          {
57011 
            _iter160.write(oprot);
 56973 
            _iter155.write(oprot);
57012 
          }
 56974 
          }
57013 
          oprot.writeListEnd();
 56975 
          oprot.writeListEnd();
57014 
        }
 56976 
        }
57015 
        oprot.writeFieldEnd();
 56977 
        oprot.writeFieldEnd();
57016 
      }
 56978 
      }
Line 57304... Line 57266...
57304 
        }
 57266 
        }
57305 
        switch (field.id) {
 57267 
        switch (field.id) {
57306 
          case 1: // SEARCH_TERMS
 57268 
          case 1: // SEARCH_TERMS
57307 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 57269 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
57308 
              {
 57270 
              {
57309 
                org.apache.thrift.protocol.TList _list161 = iprot.readListBegin();
 57271 
                org.apache.thrift.protocol.TList _list156 = iprot.readListBegin();
57310 
                this.searchTerms = new ArrayList<String>(_list161.size);
 57272 
                this.searchTerms = new ArrayList<String>(_list156.size);
57311 
                for (int _i162 = 0; _i162 < _list161.size; ++_i162)
 57273 
                for (int _i157 = 0; _i157 < _list156.size; ++_i157)
57312 
                {
 57274 
                {
57313 
                  String _elem163; // required
 57275 
                  String _elem158; // required
57314 
                  _elem163 = iprot.readString();
 57276 
                  _elem158 = iprot.readString();
57315 
                  this.searchTerms.add(_elem163);
 57277 
                  this.searchTerms.add(_elem158);
57316 
                }
 57278 
                }
57317 
                iprot.readListEnd();
 57279 
                iprot.readListEnd();
57318 
              }
 57280 
              }
57319 
            } else {
57281 
            } else {
57320 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 57282 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 57335... Line 57297...
57335 
      oprot.writeStructBegin(STRUCT_DESC);
 57297 
      oprot.writeStructBegin(STRUCT_DESC);
57336 
      if (this.searchTerms != null) {
 57298 
      if (this.searchTerms != null) {
57337 
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
 57299 
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
57338 
        {
 57300 
        {
57339 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
 57301 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
57340 
          for (String _iter164 : this.searchTerms)
 57302 
          for (String _iter159 : this.searchTerms)
57341 
          {
 57303 
          {
57342 
            oprot.writeString(_iter164);
 57304 
            oprot.writeString(_iter159);
57343 
          }
 57305 
          }
57344 
          oprot.writeListEnd();
 57306 
          oprot.writeListEnd();
57345 
        }
 57307 
        }
57346 
        oprot.writeFieldEnd();
 57308 
        oprot.writeFieldEnd();
57347 
      }
 57309 
      }
Line 57670... Line 57632...
57670 
      }
 57632 
      }
57671 
    }
 57633 
    }
57672 
 
 57634 
 
57673 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 57635 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
57674 
      try {
 57636 
      try {
57675 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
57676 
        __isset_bit_vector = new BitSet(1);
 - 
 
57677 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 57637 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
57678 
      } catch (org.apache.thrift.TException te) {
 57638 
      } catch (org.apache.thrift.TException te) {
57679 
        throw new java.io.IOException(te);
 57639 
        throw new java.io.IOException(te);
57680 
      }
 57640 
      }
57681 
    }
 57641 
    }
Line 58224... Line 58184...
58224 
        }
 58184 
        }
58225 
        switch (field.id) {
 58185 
        switch (field.id) {
58226 
          case 0: // SUCCESS
 58186 
          case 0: // SUCCESS
58227 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 58187 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58228 
              {
 58188 
              {
58229 
                org.apache.thrift.protocol.TList _list165 = iprot.readListBegin();
 58189 
                org.apache.thrift.protocol.TList _list160 = iprot.readListBegin();
58230 
                this.success = new ArrayList<AvailableAndReservedStock>(_list165.size);
 58190 
                this.success = new ArrayList<AvailableAndReservedStock>(_list160.size);
58231 
                for (int _i166 = 0; _i166 < _list165.size; ++_i166)
 58191 
                for (int _i161 = 0; _i161 < _list160.size; ++_i161)
58232 
                {
 58192 
                {
58233 
                  AvailableAndReservedStock _elem167; // required
 58193 
                  AvailableAndReservedStock _elem162; // required
58234 
                  _elem167 = new AvailableAndReservedStock();
 58194 
                  _elem162 = new AvailableAndReservedStock();
58235 
                  _elem167.read(iprot);
 58195 
                  _elem162.read(iprot);
58236 
                  this.success.add(_elem167);
 58196 
                  this.success.add(_elem162);
58237 
                }
 58197 
                }
58238 
                iprot.readListEnd();
 58198 
                iprot.readListEnd();
58239 
              }
 58199 
              }
58240 
            } else {
58200 
            } else {
58241 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 58201 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58255... Line 58215...
58255 
 
 58215 
 
58256 
      if (this.isSetSuccess()) {
 58216 
      if (this.isSetSuccess()) {
58257 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 58217 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58258 
        {
 58218 
        {
58259 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 58219 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58260 
          for (AvailableAndReservedStock _iter168 : this.success)
 58220 
          for (AvailableAndReservedStock _iter163 : this.success)
58261 
          {
 58221 
          {
58262 
            _iter168.write(oprot);
 58222 
            _iter163.write(oprot);
58263 
          }
 58223 
          }
58264 
          oprot.writeListEnd();
 58224 
          oprot.writeListEnd();
58265 
        }
 58225 
        }
58266 
        oprot.writeFieldEnd();
 58226 
        oprot.writeFieldEnd();
58267 
      }
 58227 
      }
Line 58849... Line 58809...
58849 
        }
 58809 
        }
58850 
        switch (field.id) {
 58810 
        switch (field.id) {
58851 
          case 0: // SUCCESS
 58811 
          case 0: // SUCCESS
58852 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 58812 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58853 
              {
 58813 
              {
58854 
                org.apache.thrift.protocol.TList _list169 = iprot.readListBegin();
 58814 
                org.apache.thrift.protocol.TList _list164 = iprot.readListBegin();
58855 
                this.success = new ArrayList<ProductNotificationRequest>(_list169.size);
 58815 
                this.success = new ArrayList<ProductNotificationRequest>(_list164.size);
58856 
                for (int _i170 = 0; _i170 < _list169.size; ++_i170)
 58816 
                for (int _i165 = 0; _i165 < _list164.size; ++_i165)
58857 
                {
 58817 
                {
58858 
                  ProductNotificationRequest _elem171; // required
 58818 
                  ProductNotificationRequest _elem166; // required
58859 
                  _elem171 = new ProductNotificationRequest();
 58819 
                  _elem166 = new ProductNotificationRequest();
58860 
                  _elem171.read(iprot);
 58820 
                  _elem166.read(iprot);
58861 
                  this.success.add(_elem171);
 58821 
                  this.success.add(_elem166);
58862 
                }
 58822 
                }
58863 
                iprot.readListEnd();
 58823 
                iprot.readListEnd();
58864 
              }
 58824 
              }
58865 
            } else {
58825 
            } else {
58866 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 58826 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58880... Line 58840...
58880 
 
 58840 
 
58881 
      if (this.isSetSuccess()) {
 58841 
      if (this.isSetSuccess()) {
58882 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 58842 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58883 
        {
 58843 
        {
58884 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 58844 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58885 
          for (ProductNotificationRequest _iter172 : this.success)
 58845 
          for (ProductNotificationRequest _iter167 : this.success)
58886 
          {
 58846 
          {
58887 
            _iter172.write(oprot);
 58847 
            _iter167.write(oprot);
58888 
          }
 58848 
          }
58889 
          oprot.writeListEnd();
 58849 
          oprot.writeListEnd();
58890 
        }
 58850 
        }
58891 
        oprot.writeFieldEnd();
 58851 
        oprot.writeFieldEnd();
58892 
      }
 58852 
      }
Line 59474... Line 59434...
59474 
        }
 59434 
        }
59475 
        switch (field.id) {
 59435 
        switch (field.id) {
59476 
          case 0: // SUCCESS
 59436 
          case 0: // SUCCESS
59477 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 59437 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59478 
              {
 59438 
              {
59479 
                org.apache.thrift.protocol.TList _list173 = iprot.readListBegin();
 59439 
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
59480 
                this.success = new ArrayList<ProductNotificationRequestCount>(_list173.size);
 59440 
                this.success = new ArrayList<ProductNotificationRequestCount>(_list168.size);
59481 
                for (int _i174 = 0; _i174 < _list173.size; ++_i174)
 59441 
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
59482 
                {
 59442 
                {
59483 
                  ProductNotificationRequestCount _elem175; // required
 59443 
                  ProductNotificationRequestCount _elem170; // required
59484 
                  _elem175 = new ProductNotificationRequestCount();
 59444 
                  _elem170 = new ProductNotificationRequestCount();
59485 
                  _elem175.read(iprot);
 59445 
                  _elem170.read(iprot);
59486 
                  this.success.add(_elem175);
 59446 
                  this.success.add(_elem170);
59487 
                }
 59447 
                }
59488 
                iprot.readListEnd();
 59448 
                iprot.readListEnd();
59489 
              }
 59449 
              }
59490 
            } else {
59450 
            } else {
59491 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 59451 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 59505... Line 59465...
59505 
 
 59465 
 
59506 
      if (this.isSetSuccess()) {
 59466 
      if (this.isSetSuccess()) {
59507 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 59467 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59508 
        {
 59468 
        {
59509 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 59469 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
59510 
          for (ProductNotificationRequestCount _iter176 : this.success)
 59470 
          for (ProductNotificationRequestCount _iter171 : this.success)
59511 
          {
 59471 
          {
59512 
            _iter176.write(oprot);
 59472 
            _iter171.write(oprot);
59513 
          }
 59473 
          }
59514 
          oprot.writeListEnd();
 59474 
          oprot.writeListEnd();
59515 
        }
 59475 
        }
59516 
        oprot.writeFieldEnd();
 59476 
        oprot.writeFieldEnd();
59517 
      }
 59477 
      }
Line 60398... Line 60358...
60398 
      }
 60358 
      }
60399 
    }
 60359 
    }
60400 
 
 60360 
 
60401 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
 60361 
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
60402 
      try {
 60362 
      try {
60403 
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
 - 
 
60404 
        __isset_bit_vector = new BitSet(1);
 - 
 
60405 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
 60363 
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
60406 
      } catch (org.apache.thrift.TException te) {
 60364 
      } catch (org.apache.thrift.TException te) {
60407 
        throw new java.io.IOException(te);
 60365 
        throw new java.io.IOException(te);
60408 
      }
 60366 
      }
60409 
    }
 60367 
    }
Line 61318... Line 61276...
61318 
        }
 61276 
        }
61319 
        switch (field.id) {
 61277 
        switch (field.id) {
61320 
          case 0: // SUCCESS
 61278 
          case 0: // SUCCESS
61321 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 61279 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
61322 
              {
 61280 
              {
61323 
                org.apache.thrift.protocol.TList _list177 = iprot.readListBegin();
 61281 
                org.apache.thrift.protocol.TList _list172 = iprot.readListBegin();
61324 
                this.success = new ArrayList<Warehouse>(_list177.size);
 61282 
                this.success = new ArrayList<Warehouse>(_list172.size);
61325 
                for (int _i178 = 0; _i178 < _list177.size; ++_i178)
 61283 
                for (int _i173 = 0; _i173 < _list172.size; ++_i173)
61326 
                {
 61284 
                {
61327 
                  Warehouse _elem179; // required
 61285 
                  Warehouse _elem174; // required
61328 
                  _elem179 = new Warehouse();
 61286 
                  _elem174 = new Warehouse();
61329 
                  _elem179.read(iprot);
 61287 
                  _elem174.read(iprot);
61330 
                  this.success.add(_elem179);
 61288 
                  this.success.add(_elem174);
61331 
                }
 61289 
                }
61332 
                iprot.readListEnd();
 61290 
                iprot.readListEnd();
61333 
              }
 61291 
              }
61334 
            } else {
61292 
            } else {
61335 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 61293 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 61349... Line 61307...
61349 
 
 61307 
 
61350 
      if (this.isSetSuccess()) {
 61308 
      if (this.isSetSuccess()) {
61351 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 61309 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
61352 
        {
 61310 
        {
61353 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 61311 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
61354 
          for (Warehouse _iter180 : this.success)
 61312 
          for (Warehouse _iter175 : this.success)
61355 
          {
 61313 
          {
61356 
            _iter180.write(oprot);
 61314 
            _iter175.write(oprot);
61357 
          }
 61315 
          }
61358 
          oprot.writeListEnd();
 61316 
          oprot.writeListEnd();
61359 
        }
 61317 
        }
61360 
        oprot.writeFieldEnd();
 61318 
        oprot.writeFieldEnd();
61361 
      }
 61319 
      }
Line 62783... Line 62741...
62783 
        }
 62741 
        }
62784 
        switch (field.id) {
 62742 
        switch (field.id) {
62785 
          case 0: // SUCCESS
 62743 
          case 0: // SUCCESS
62786 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 62744 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
62787 
              {
 62745 
              {
62788 
                org.apache.thrift.protocol.TList _list181 = iprot.readListBegin();
 62746 
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
62789 
                this.success = new ArrayList<String>(_list181.size);
 62747 
                this.success = new ArrayList<String>(_list176.size);
62790 
                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
 62748 
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
62791 
                {
 62749 
                {
62792 
                  String _elem183; // required
 62750 
                  String _elem178; // required
62793 
                  _elem183 = iprot.readString();
 62751 
                  _elem178 = iprot.readString();
62794 
                  this.success.add(_elem183);
 62752 
                  this.success.add(_elem178);
62795 
                }
 62753 
                }
62796 
                iprot.readListEnd();
 62754 
                iprot.readListEnd();
62797 
              }
 62755 
              }
62798 
            } else {
62756 
            } else {
62799 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 62757 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 62813... Line 62771...
62813 
 
 62771 
 
62814 
      if (this.isSetSuccess()) {
 62772 
      if (this.isSetSuccess()) {
62815 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 62773 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
62816 
        {
 62774 
        {
62817 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
 62775 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
62818 
          for (String _iter184 : this.success)
 62776 
          for (String _iter179 : this.success)
62819 
          {
 62777 
          {
62820 
            oprot.writeString(_iter184);
 62778 
            oprot.writeString(_iter179);
62821 
          }
 62779 
          }
62822 
          oprot.writeListEnd();
 62780 
          oprot.writeListEnd();
62823 
        }
 62781 
        }
62824 
        oprot.writeFieldEnd();
 62782 
        oprot.writeFieldEnd();
62825 
      }
 62783 
      }
Line 63910... Line 63868...
63910 
        }
 63868 
        }
63911 
        switch (field.id) {
 63869 
        switch (field.id) {
63912 
          case 0: // SUCCESS
 63870 
          case 0: // SUCCESS
63913 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
 63871 
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
63914 
              {
 63872 
              {
63915 
                org.apache.thrift.protocol.TMap _map185 = iprot.readMapBegin();
 63873 
                org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin();
63916 
                this.success = new HashMap<String,Map<Long,Long>>(2*_map185.size);
 63874 
                this.success = new HashMap<String,Map<Long,Long>>(2*_map180.size);
63917 
                for (int _i186 = 0; _i186 < _map185.size; ++_i186)
 63875 
                for (int _i181 = 0; _i181 < _map180.size; ++_i181)
63918 
                {
 63876 
                {
63919 
                  String _key187; // required
 63877 
                  String _key182; // required
63920 
                  Map<Long,Long> _val188; // required
 63878 
                  Map<Long,Long> _val183; // required
63921 
                  _key187 = iprot.readString();
 63879 
                  _key182 = iprot.readString();
63922 
                  {
 63880 
                  {
63923 
                    org.apache.thrift.protocol.TMap _map189 = iprot.readMapBegin();
 63881 
                    org.apache.thrift.protocol.TMap _map184 = iprot.readMapBegin();
63924 
                    _val188 = new HashMap<Long,Long>(2*_map189.size);
 63882 
                    _val183 = new HashMap<Long,Long>(2*_map184.size);
63925 
                    for (int _i190 = 0; _i190 < _map189.size; ++_i190)
 63883 
                    for (int _i185 = 0; _i185 < _map184.size; ++_i185)
63926 
                    {
 63884 
                    {
63927 
                      long _key191; // required
 63885 
                      long _key186; // required
63928 
                      long _val192; // required
 63886 
                      long _val187; // required
63929 
                      _key191 = iprot.readI64();
 63887 
                      _key186 = iprot.readI64();
63930 
                      _val192 = iprot.readI64();
 63888 
                      _val187 = iprot.readI64();
63931 
                      _val188.put(_key191, _val192);
 63889 
                      _val183.put(_key186, _val187);
63932 
                    }
 63890 
                    }
63933 
                    iprot.readMapEnd();
 63891 
                    iprot.readMapEnd();
63934 
                  }
 63892 
                  }
63935 
                  this.success.put(_key187, _val188);
 63893 
                  this.success.put(_key182, _val183);
63936 
                }
 63894 
                }
63937 
                iprot.readMapEnd();
 63895 
                iprot.readMapEnd();
63938 
              }
 63896 
              }
63939 
            } else {
63897 
            } else {
63940 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 63898 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 63954... Line 63912...
63954 
 
 63912 
 
63955 
      if (this.isSetSuccess()) {
 63913 
      if (this.isSetSuccess()) {
63956 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 63914 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63957 
        {
 63915 
        {
63958 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.success.size()));
 63916 
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.success.size()));
63959 
          for (Map.Entry<String, Map<Long,Long>> _iter193 : this.success.entrySet())
 63917 
          for (Map.Entry<String, Map<Long,Long>> _iter188 : this.success.entrySet())
63960 
          {
 63918 
          {
63961 
            oprot.writeString(_iter193.getKey());
 63919 
            oprot.writeString(_iter188.getKey());
63962 
            {
 63920 
            {
63963 
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter193.getValue().size()));
 63921 
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter188.getValue().size()));
63964 
              for (Map.Entry<Long, Long> _iter194 : _iter193.getValue().entrySet())
 63922 
              for (Map.Entry<Long, Long> _iter189 : _iter188.getValue().entrySet())
63965 
              {
 63923 
              {
63966 
                oprot.writeI64(_iter194.getKey());
 63924 
                oprot.writeI64(_iter189.getKey());
63967 
                oprot.writeI64(_iter194.getValue());
 63925 
                oprot.writeI64(_iter189.getValue());
63968 
              }
 63926 
              }
63969 
              oprot.writeMapEnd();
 63927 
              oprot.writeMapEnd();
63970 
            }
 63928 
            }
63971 
          }
 63929 
          }
63972 
          oprot.writeMapEnd();
 63930 
          oprot.writeMapEnd();
Line 65217... Line 65175...
65217 
        }
 65175 
        }
65218 
        switch (field.id) {
 65176 
        switch (field.id) {
65219 
          case 0: // SUCCESS
 65177 
          case 0: // SUCCESS
65220 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 65178 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65221 
              {
 65179 
              {
65222 
                org.apache.thrift.protocol.TList _list195 = iprot.readListBegin();
 65180 
                org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
65223 
                this.success = new ArrayList<Warehouse>(_list195.size);
 65181 
                this.success = new ArrayList<Warehouse>(_list190.size);
65224 
                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
 65182 
                for (int _i191 = 0; _i191 < _list190.size; ++_i191)
65225 
                {
 65183 
                {
65226 
                  Warehouse _elem197; // required
 65184 
                  Warehouse _elem192; // required
65227 
                  _elem197 = new Warehouse();
 65185 
                  _elem192 = new Warehouse();
65228 
                  _elem197.read(iprot);
 65186 
                  _elem192.read(iprot);
65229 
                  this.success.add(_elem197);
 65187 
                  this.success.add(_elem192);
65230 
                }
 65188 
                }
65231 
                iprot.readListEnd();
 65189 
                iprot.readListEnd();
65232 
              }
 65190 
              }
65233 
            } else {
65191 
            } else {
65234 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 65192 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 65248... Line 65206...
65248 
 
 65206 
 
65249 
      if (this.isSetSuccess()) {
 65207 
      if (this.isSetSuccess()) {
65250 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 65208 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65251 
        {
 65209 
        {
65252 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 65210 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
65253 
          for (Warehouse _iter198 : this.success)
 65211 
          for (Warehouse _iter193 : this.success)
65254 
          {
 65212 
          {
65255 
            _iter198.write(oprot);
 65213 
            _iter193.write(oprot);
65256 
          }
 65214 
          }
65257 
          oprot.writeListEnd();
 65215 
          oprot.writeListEnd();
65258 
        }
 65216 
        }
65259 
        oprot.writeFieldEnd();
 65217 
        oprot.writeFieldEnd();
65260 
      }
 65218 
      }
Line 65748... Line 65706...
65748 
        }
 65706 
        }
65749 
        switch (field.id) {
 65707 
        switch (field.id) {
65750 
          case 0: // SUCCESS
 65708 
          case 0: // SUCCESS
65751 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
 65709 
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65752 
              {
 65710 
              {
65753 
                org.apache.thrift.protocol.TList _list199 = iprot.readListBegin();
 65711 
                org.apache.thrift.protocol.TList _list194 = iprot.readListBegin();
65754 
                this.success = new ArrayList<VendorItemMapping>(_list199.size);
 65712 
                this.success = new ArrayList<VendorItemMapping>(_list194.size);
65755 
                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
 65713 
                for (int _i195 = 0; _i195 < _list194.size; ++_i195)
65756 
                {
 65714 
                {
65757 
                  VendorItemMapping _elem201; // required
 65715 
                  VendorItemMapping _elem196; // required
65758 
                  _elem201 = new VendorItemMapping();
 65716 
                  _elem196 = new VendorItemMapping();
65759 
                  _elem201.read(iprot);
 65717 
                  _elem196.read(iprot);
65760 
                  this.success.add(_elem201);
 65718 
                  this.success.add(_elem196);
65761 
                }
 65719 
                }
65762 
                iprot.readListEnd();
 65720 
                iprot.readListEnd();
65763 
              }
 65721 
              }
65764 
            } else {
65722 
            } else {
65765 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
 65723 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 65779... Line 65737...
65779 
 
 65737 
 
65780 
      if (this.isSetSuccess()) {
 65738 
      if (this.isSetSuccess()) {
65781 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
 65739 
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65782 
        {
 65740 
        {
65783 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
 65741 
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
65784 
          for (VendorItemMapping _iter202 : this.success)
 65742 
          for (VendorItemMapping _iter197 : this.success)
65785 
          {
 65743 
          {
65786 
            _iter202.write(oprot);
 65744 
            _iter197.write(oprot);
65787 
          }
 65745 
          }
65788 
          oprot.writeListEnd();
 65746 
          oprot.writeListEnd();
65789 
        }
 65747 
        }
65790 
        oprot.writeFieldEnd();
 65748 
        oprot.writeFieldEnd();
65791 
      }
 65749 
      }