Beispiel #1
0
 public void write(TProtocol oprot) throws TException {
   TStruct struct = new TStruct("TTestStruct");
   oprot.writeStructBegin(struct);
   TField field = new TField();
   field.name = "booleanField";
   field.type = TType.BOOL;
   field.id = BOOLEANFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeBool(this.booleanField);
   oprot.writeFieldEnd();
   field.name = "byteField";
   field.type = TType.BYTE;
   field.id = BYTEFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeByte(this.byteField);
   oprot.writeFieldEnd();
   field.name = "shortField";
   field.type = TType.I16;
   field.id = SHORTFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeI16(this.shortField);
   oprot.writeFieldEnd();
   field.name = "intField";
   field.type = TType.I32;
   field.id = INTFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeI32(this.intField);
   oprot.writeFieldEnd();
   field.name = "longField";
   field.type = TType.I64;
   field.id = LONGFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeI64(this.longField);
   oprot.writeFieldEnd();
   field.name = "doubleField";
   field.type = TType.DOUBLE;
   field.id = DOUBLEFIELD;
   oprot.writeFieldBegin(field);
   oprot.writeDouble(this.doubleField);
   oprot.writeFieldEnd();
   if (this.stringField != null) {
     field.name = "stringField";
     field.type = TType.STRING;
     field.id = STRINGFIELD;
     oprot.writeFieldBegin(field);
     oprot.writeString(this.stringField);
     oprot.writeFieldEnd();
   }
   if (this.binaryField != null) {
     field.name = "binaryField";
     field.type = TType.STRING;
     field.id = BINARYFIELD;
     oprot.writeFieldBegin(field);
     oprot.writeBinary(this.binaryField);
     oprot.writeFieldEnd();
   }
   if (this.listOfIntsField != null) {
     field.name = "listOfIntsField";
     field.type = TType.LIST;
     field.id = LISTOFINTSFIELD;
     oprot.writeFieldBegin(field);
     {
       oprot.writeListBegin(new TList(TType.I32, this.listOfIntsField.size()));
       for (int _iter20 : this.listOfIntsField) {
         oprot.writeI32(_iter20);
       }
       oprot.writeListEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.setOfIntsField != null) {
     field.name = "setOfIntsField";
     field.type = TType.SET;
     field.id = SETOFINTSFIELD;
     oprot.writeFieldBegin(field);
     {
       oprot.writeSetBegin(new TSet(TType.I32, this.setOfIntsField.size()));
       for (int _iter21 : this.setOfIntsField) {
         oprot.writeI32(_iter21);
       }
       oprot.writeSetEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.mapOfIntsIntsField != null) {
     field.name = "mapOfIntsIntsField";
     field.type = TType.MAP;
     field.id = MAPOFINTSINTSFIELD;
     oprot.writeFieldBegin(field);
     {
       oprot.writeMapBegin(new TMap(TType.I32, TType.I32, this.mapOfIntsIntsField.size()));
       for (int _iter22 : this.mapOfIntsIntsField.keySet()) {
         oprot.writeI32(_iter22);
         oprot.writeI32(this.mapOfIntsIntsField.get(_iter22));
       }
       oprot.writeMapEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.structField != null) {
     field.name = "structField";
     field.type = TType.STRUCT;
     field.id = STRUCTFIELD;
     oprot.writeFieldBegin(field);
     this.structField.write(oprot);
     oprot.writeFieldEnd();
   }
   if (this.nestedListOfIntsField != null) {
     field.name = "nestedListOfIntsField";
     field.type = TType.LIST;
     field.id = NESTEDLISTOFINTSFIELD;
     oprot.writeFieldBegin(field);
     {
       oprot.writeListBegin(new TList(TType.LIST, this.nestedListOfIntsField.size()));
       for (List<Integer> _iter23 : this.nestedListOfIntsField) {
         {
           oprot.writeListBegin(new TList(TType.I32, _iter23.size()));
           for (int _iter24 : _iter23) {
             oprot.writeI32(_iter24);
           }
           oprot.writeListEnd();
         }
       }
       oprot.writeListEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.mapOfIntsStringsField != null) {
     field.name = "mapOfIntsStringsField";
     field.type = TType.MAP;
     field.id = MAPOFINTSSTRINGSFIELD;
     oprot.writeFieldBegin(field);
     {
       oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, this.mapOfIntsStringsField.size()));
       for (int _iter25 : this.mapOfIntsStringsField.keySet()) {
         oprot.writeI32(_iter25);
         oprot.writeString(this.mapOfIntsStringsField.get(_iter25));
       }
       oprot.writeMapEnd();
     }
     oprot.writeFieldEnd();
   }
   oprot.writeFieldStop();
   oprot.writeStructEnd();
 }
 public void write(TProtocol oprot) throws TException {
   TStruct struct = new TStruct("MockMessage");
   oprot.writeStructBegin(struct);
   TField field = new TField();
   if (this.name != null) {
     field.name = "name";
     field.type = TType.STRING;
     field.id = 1;
     oprot.writeFieldBegin(field);
     oprot.writeString(this.name);
     oprot.writeFieldEnd();
   }
   if (this.mappings != null) {
     field.name = "mappings";
     field.type = TType.MAP;
     field.id = 2;
     oprot.writeFieldBegin(field);
     {
       oprot.writeMapBegin(new TMap(TType.I64, TType.MAP, this.mappings.size()));
       for (long _iter14 : this.mappings.keySet()) {
         oprot.writeI64(_iter14);
         {
           oprot.writeMapBegin(
               new TMap(TType.STRING, TType.I32, this.mappings.get(_iter14).size()));
           for (String _iter15 : this.mappings.get(_iter14).keySet()) {
             oprot.writeString(_iter15);
             oprot.writeI32(this.mappings.get(_iter14).get(_iter15));
           }
           oprot.writeMapEnd();
         }
       }
       oprot.writeMapEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.intList != null) {
     field.name = "intList";
     field.type = TType.LIST;
     field.id = 3;
     oprot.writeFieldBegin(field);
     {
       oprot.writeListBegin(new TList(TType.I16, this.intList.size()));
       for (short _iter16 : this.intList) {
         oprot.writeI16(_iter16);
       }
       oprot.writeListEnd();
     }
     oprot.writeFieldEnd();
   }
   if (this.strSet != null) {
     field.name = "strSet";
     field.type = TType.SET;
     field.id = 4;
     oprot.writeFieldBegin(field);
     {
       oprot.writeSetBegin(new TSet(TType.STRING, this.strSet.size()));
       for (String _iter17 : this.strSet) {
         oprot.writeString(_iter17);
       }
       oprot.writeSetEnd();
     }
     oprot.writeFieldEnd();
   }
   oprot.writeFieldStop();
   oprot.writeStructEnd();
 }
Beispiel #3
0
 public void read(TProtocol iprot) throws TException {
   TField field;
   iprot.readStructBegin();
   while (true) {
     field = iprot.readFieldBegin();
     if (field.type == TType.STOP) {
       break;
     }
     switch (field.id) {
       case BOOLEANFIELD:
         if (field.type == TType.BOOL) {
           this.booleanField = iprot.readBool();
           this.__isset.booleanField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case BYTEFIELD:
         if (field.type == TType.BYTE) {
           this.byteField = iprot.readByte();
           this.__isset.byteField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case SHORTFIELD:
         if (field.type == TType.I16) {
           this.shortField = iprot.readI16();
           this.__isset.shortField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case INTFIELD:
         if (field.type == TType.I32) {
           this.intField = iprot.readI32();
           this.__isset.intField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case LONGFIELD:
         if (field.type == TType.I64) {
           this.longField = iprot.readI64();
           this.__isset.longField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case DOUBLEFIELD:
         if (field.type == TType.DOUBLE) {
           this.doubleField = iprot.readDouble();
           this.__isset.doubleField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case STRINGFIELD:
         if (field.type == TType.STRING) {
           this.stringField = iprot.readString();
           this.__isset.stringField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case BINARYFIELD:
         if (field.type == TType.STRING) {
           this.binaryField = iprot.readBinary();
           this.__isset.binaryField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case LISTOFINTSFIELD:
         if (field.type == TType.LIST) {
           {
             TList _list0 = iprot.readListBegin();
             this.listOfIntsField = new ArrayList<Integer>(_list0.size);
             for (int _i1 = 0; _i1 < _list0.size; ++_i1) {
               int _elem2 = 0;
               _elem2 = iprot.readI32();
               this.listOfIntsField.add(_elem2);
             }
             iprot.readListEnd();
           }
           this.__isset.listOfIntsField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case SETOFINTSFIELD:
         if (field.type == TType.SET) {
           {
             TSet _set3 = iprot.readSetBegin();
             this.setOfIntsField = new HashSet<Integer>(2 * _set3.size);
             for (int _i4 = 0; _i4 < _set3.size; ++_i4) {
               int _elem5;
               _elem5 = iprot.readI32();
               this.setOfIntsField.add(_elem5);
             }
             iprot.readSetEnd();
           }
           this.__isset.setOfIntsField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case MAPOFINTSINTSFIELD:
         if (field.type == TType.MAP) {
           {
             TMap _map6 = iprot.readMapBegin();
             this.mapOfIntsIntsField = new HashMap<Integer, Integer>(2 * _map6.size);
             for (int _i7 = 0; _i7 < _map6.size; ++_i7) {
               int _key8;
               int _val9;
               _key8 = iprot.readI32();
               _val9 = iprot.readI32();
               this.mapOfIntsIntsField.put(_key8, _val9);
             }
             iprot.readMapEnd();
           }
           this.__isset.mapOfIntsIntsField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case STRUCTFIELD:
         if (field.type == TType.STRUCT) {
           this.structField = new TNestedStruct();
           this.structField.read(iprot);
           this.__isset.structField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case NESTEDLISTOFINTSFIELD:
         if (field.type == TType.LIST) {
           {
             TList _list10 = iprot.readListBegin();
             this.nestedListOfIntsField = new ArrayList<List<Integer>>(_list10.size);
             for (int _i11 = 0; _i11 < _list10.size; ++_i11) {
               List<Integer> _elem12 = new ArrayList<Integer>();
               {
                 TList _list13 = iprot.readListBegin();
                 _elem12 = new ArrayList<Integer>(_list13.size);
                 for (int _i14 = 0; _i14 < _list13.size; ++_i14) {
                   int _elem15 = 0;
                   _elem15 = iprot.readI32();
                   _elem12.add(_elem15);
                 }
                 iprot.readListEnd();
               }
               this.nestedListOfIntsField.add(_elem12);
             }
             iprot.readListEnd();
           }
           this.__isset.nestedListOfIntsField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case MAPOFINTSSTRINGSFIELD:
         if (field.type == TType.MAP) {
           {
             TMap _map16 = iprot.readMapBegin();
             this.mapOfIntsStringsField = new HashMap<Integer, String>(2 * _map16.size);
             for (int _i17 = 0; _i17 < _map16.size; ++_i17) {
               int _key18;
               String _val19;
               _key18 = iprot.readI32();
               _val19 = iprot.readString();
               this.mapOfIntsStringsField.put(_key18, _val19);
             }
             iprot.readMapEnd();
           }
           this.__isset.mapOfIntsStringsField = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       default:
         TProtocolUtil.skip(iprot, field.type);
         break;
     }
     iprot.readFieldEnd();
   }
   iprot.readStructEnd();
 }
 public void read(TProtocol iprot) throws TException {
   TField field;
   iprot.readStructBegin();
   while (true) {
     field = iprot.readFieldBegin();
     if (field.type == TType.STOP) {
       break;
     }
     switch (field.id) {
       case 1:
         if (field.type == TType.STRING) {
           this.name = iprot.readString();
           this.__isset.name = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 2:
         if (field.type == TType.MAP) {
           {
             TMap _map0 = iprot.readMapBegin();
             this.mappings = new HashMap<Long, Map<String, Integer>>(2 * _map0.size);
             for (int _i1 = 0; _i1 < _map0.size; ++_i1) {
               long _key2;
               Map<String, Integer> _val3;
               _key2 = iprot.readI64();
               {
                 TMap _map4 = iprot.readMapBegin();
                 _val3 = new HashMap<String, Integer>(2 * _map4.size);
                 for (int _i5 = 0; _i5 < _map4.size; ++_i5) {
                   String _key6;
                   int _val7;
                   _key6 = iprot.readString();
                   _val7 = iprot.readI32();
                   _val3.put(_key6, _val7);
                 }
                 iprot.readMapEnd();
               }
               this.mappings.put(_key2, _val3);
             }
             iprot.readMapEnd();
           }
           this.__isset.mappings = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 3:
         if (field.type == TType.LIST) {
           {
             TList _list8 = iprot.readListBegin();
             this.intList = new ArrayList<Short>(_list8.size);
             for (int _i9 = 0; _i9 < _list8.size; ++_i9) {
               short _elem10 = 0;
               _elem10 = iprot.readI16();
               this.intList.add(_elem10);
             }
             iprot.readListEnd();
           }
           this.__isset.intList = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 4:
         if (field.type == TType.SET) {
           {
             TSet _set11 = iprot.readSetBegin();
             this.strSet = new HashSet<String>(2 * _set11.size);
             for (int _i12 = 0; _i12 < _set11.size; ++_i12) {
               String _elem13;
               _elem13 = iprot.readString();
               this.strSet.add(_elem13);
             }
             iprot.readSetEnd();
           }
           this.__isset.strSet = true;
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       default:
         TProtocolUtil.skip(iprot, field.type);
         break;
     }
     iprot.readFieldEnd();
   }
   iprot.readStructEnd();
 }