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: // UID
          if (field.type == TType.I32) {
            this.uid = iprot.readI32();
            setUidIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 2: // ITEM_NUMBER
          if (field.type == TType.STRING) {
            this.itemNumber = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 3: // RESERVE_QUANTITY
          if (field.type == TType.I32) {
            this.reserveQuantity = iprot.readI32();
            setReserveQuantityIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 4: // ORDER_NUMBER
          if (field.type == TType.STRING) {
            this.orderNumber = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 5: // FROM_ID
          if (field.type == TType.STRING) {
            this.fromId = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, field.type);
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }
Esempio n. 2
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 1: // START
          if (field.type == TType.STRING) {
            this.start = iprot.readBinary();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 2: // FINISH
          if (field.type == TType.STRING) {
            this.finish = iprot.readBinary();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 3: // REVERSED
          if (field.type == TType.BOOL) {
            this.reversed = iprot.readBool();
            setReversedIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 4: // COUNT
          if (field.type == TType.I32) {
            this.count = iprot.readI32();
            setCountIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, field.type);
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    if (!isSetReversed()) {
      throw new TProtocolException(
          "Required field 'reversed' was not found in serialized data! Struct: " + toString());
    }
    if (!isSetCount()) {
      throw new TProtocolException(
          "Required field 'count' was not found in serialized data! Struct: " + toString());
    }
    validate();
  }
Esempio n. 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 1: // MYINT
         if (field.type == TType.I32) {
           this.myint = iprot.readI32();
           setMyintIsSet(true);
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 2: // MY_STRING
         if (field.type == TType.STRING) {
           this.myString = iprot.readString();
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 3: // UNDERSCORE_INT
         if (field.type == TType.I32) {
           this.underscore_int = iprot.readI32();
           setUnderscore_intIsSet(true);
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       default:
         TProtocolUtil.skip(iprot, field.type);
     }
     iprot.readFieldEnd();
   }
   iprot.readStructEnd();
   validate();
 }
  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: // TIMESTAMP
          if (field.type == TType.I64) {
            this.timestamp = iprot.readI64();
            setTimestampIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 2: // WHAT
          if (field.type == TType.I32) {
            this.what = iprot.readI32();
            setWhatIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 3: // WHY
          if (field.type == TType.STRING) {
            this.why = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, field.type);
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }
Esempio n. 5
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 1: // RESPONSE_CODE
          if (field.type == TType.I32) {
            this.responseCode = iprot.readI32();
            setResponseCodeIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 2: // TRANSACTION_ID
          if (field.type == TType.I64) {
            this.transactionID = iprot.readI64();
            setTransactionIDIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case 3: // DESCRIPTION
          if (field.type == TType.STRING) {
            this.description = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, field.type);
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }
  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 TASKTRACKERS:
          if (field.type == TType.I32) {
            this.taskTrackers = iprot.readI32();
            this.__isset.taskTrackers = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case MAPTASKS:
          if (field.type == TType.I32) {
            this.mapTasks = iprot.readI32();
            this.__isset.mapTasks = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case REDUCETASKS:
          if (field.type == TType.I32) {
            this.reduceTasks = iprot.readI32();
            this.__isset.reduceTasks = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case MAXMAPTASKS:
          if (field.type == TType.I32) {
            this.maxMapTasks = iprot.readI32();
            this.__isset.maxMapTasks = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case MAXREDUCETASKS:
          if (field.type == TType.I32) {
            this.maxReduceTasks = iprot.readI32();
            this.__isset.maxReduceTasks = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        case STATE:
          if (field.type == TType.I32) {
            this.state = iprot.readI32();
            this.__isset.state = true;
          } else {
            TProtocolUtil.skip(iprot, field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, field.type);
          break;
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();

    validate();
  }
Esempio n. 7
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 1: // OBJECT_TYPE
         if (field.type == TType.I32) {
           this.objectType = HiveObjectType.findByValue(iprot.readI32());
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 2: // DB_NAME
         if (field.type == TType.STRING) {
           this.dbName = iprot.readString();
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 3: // OBJECT_NAME
         if (field.type == TType.STRING) {
           this.objectName = iprot.readString();
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 4: // PART_VALUES
         if (field.type == TType.LIST) {
           {
             TList _list4 = iprot.readListBegin();
             this.partValues = new ArrayList<String>(_list4.size);
             for (int _i5 = 0; _i5 < _list4.size; ++_i5) {
               String _elem6;
               _elem6 = iprot.readString();
               this.partValues.add(_elem6);
             }
             iprot.readListEnd();
           }
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       case 5: // COLUMN_NAME
         if (field.type == TType.STRING) {
           this.columnName = iprot.readString();
         } else {
           TProtocolUtil.skip(iprot, field.type);
         }
         break;
       default:
         TProtocolUtil.skip(iprot, field.type);
     }
     iprot.readFieldEnd();
   }
   iprot.readStructEnd();
   validate();
 }
Esempio n. 8
0
  public void read(TProtocol iprot) throws TException {
    TField field;
    iprot.readStructBegin();
    while (true) {
      field = iprot.readFieldBegin();
      if (field.type == TType.STOP) {
        break;
      }
      _Fields fieldId = _Fields.findByThriftId(field.id);
      if (fieldId == null) {
        TProtocolUtil.skip(iprot, field.type);
      } else {
        switch (fieldId) {
          case BYTES_TOTAL:
            if (field.type == TType.I64) {
              this.bytesTotal = iprot.readI64();
              setBytesTotalIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BYTES_USED:
            if (field.type == TType.I64) {
              this.bytesUsed = iprot.readI64();
              setBytesUsedIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BYTES_REMAINING:
            if (field.type == TType.I64) {
              this.bytesRemaining = iprot.readI64();
              setBytesRemainingIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BYTES_NON_DFS:
            if (field.type == TType.I64) {
              this.bytesNonDfs = iprot.readI64();
              setBytesNonDfsIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case NUM_LIVE_DATA_NODES:
            if (field.type == TType.I32) {
              this.numLiveDataNodes = iprot.readI32();
              setNumLiveDataNodesIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case NUM_DEAD_DATA_NODES:
            if (field.type == TType.I32) {
              this.numDeadDataNodes = iprot.readI32();
              setNumDeadDataNodesIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case UPGRADE_STATUS:
            if (field.type == TType.STRUCT) {
              this.upgradeStatus = new UpgradeStatusReport();
              this.upgradeStatus.read(iprot);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case HTTP_PORT:
            if (field.type == TType.I32) {
              this.httpPort = iprot.readI32();
              setHttpPortIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
        }
        iprot.readFieldEnd();
      }
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }