Project: Flume-Hive
Code Examples
/**
 * Autogenerated by Thrift 
 * 
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 
 */
package com.cloudera.flume.conf.thrift; 
 
import java.util.List; 
import java.util.ArrayList; 
import java.util.Map; 
import java.util.HashMap; 
import java.util.EnumMap; 
import java.util.Set; 
import java.util.HashSet; 
import java.util.EnumSet; 
import java.util.Collections; 
import java.util.BitSet; 
import java.nio.ByteBuffer; 
import java.util.Arrays; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
 
import org.apache.thrift.*; 
import org.apache.thrift.async.*; 
import org.apache.thrift.meta_data.*; 
import org.apache.thrift.transport.*; 
import org.apache.thrift.protocol.*; 
 
public class FlumeMasterCommandThrift implements TBase<FlumeMasterCommandThrift, FlumeMasterCommandThrift._Fields>, java.io.Serializable, Cloneable { 
  private static final TStruct STRUCT_DESC = new TStruct("FlumeMasterCommandThrift"); 
 
  private static final TField COMMAND_FIELD_DESC = new TField("command", TType.STRING, (short)1); 
  private static final TField ARGUMENTS_FIELD_DESC = new TField("arguments", TType.LIST, (short)2); 
 
  public String command; 
  public List<String> arguments; 
 
  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ 
  public enum _Fields implements TFieldIdEnum { 
    COMMAND((short)1, "command"), 
    ARGUMENTS((short)2, "arguments"); 
 
    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); 
 
    static { 
      for (_Fields field : EnumSet.allOf(_Fields.class)) { 
        byName.put(field.getFieldName(), field); 
      } 
    } 
 
    /**
     * Find the _Fields constant that matches fieldId, or null if its not found. 
     */
 
    public static _Fields findByThriftId(int fieldId) { 
      switch(fieldId) { 
        case 1// COMMAND 
          return COMMAND; 
        case 2// ARGUMENTS 
          return ARGUMENTS; 
        default
          return null
      } 
    } 
 
    /**
     * Find the _Fields constant that matches fieldId, throwing an exception 
     * if it is not found. 
     */
 
    public static _Fields findByThriftIdOrThrow(int fieldId) { 
      _Fields fields = findByThriftId(fieldId); 
      if (fields == nullthrow new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); 
      return fields; 
    } 
 
    /**
     * Find the _Fields constant that matches name, or null if its not found. 
     */
 
    public static _Fields findByName(String name) { 
      return byName.get(name); 
    } 
 
    private final short _thriftId; 
    private final String _fieldName; 
 
    _Fields(short thriftId, String fieldName) { 
      _thriftId = thriftId; 
      _fieldName = fieldName; 
    } 
 
    public short getThriftFieldId() { 
      return _thriftId; 
    } 
 
    public String getFieldName() { 
      return _fieldName; 
    } 
  } 
 
  // isset id assignments 
 
  public static final Map<_Fields, FieldMetaData> metaDataMap; 
  static { 
    Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); 
    tmpMap.put(_Fields.COMMAND, new FieldMetaData("command", TFieldRequirementType.DEFAULT,  
        new FieldValueMetaData(TType.STRING))); 
    tmpMap.put(_Fields.ARGUMENTS, new FieldMetaData("arguments", TFieldRequirementType.DEFAULT,  
        new ListMetaData(TType.LIST,  
            new FieldValueMetaData(TType.STRING)))); 
    metaDataMap = Collections.unmodifiableMap(tmpMap); 
    FieldMetaData.addStructMetaDataMap(FlumeMasterCommandThrift.class, metaDataMap); 
  } 
 
  public FlumeMasterCommandThrift() { 
  } 
 
    String command, 
    List<String> arguments) 
  { 
    this(); 
    this.command = command; 
    this.arguments = arguments; 
  } 
 
  /**
   * Performs a deep copy on <i>other</i>. 
   */
 
  public FlumeMasterCommandThrift(FlumeMasterCommandThrift other) { 
    if (other.isSetCommand()) { 
      this.command = other.command; 
    } 
    if (other.isSetArguments()) { 
      List<String> __this__arguments = new ArrayList<String>(); 
      for (String other_element : other.arguments) { 
        __this__arguments.add(other_element); 
      } 
      this.arguments = __this__arguments; 
    } 
  } 
 
  public FlumeMasterCommandThrift deepCopy() { 
    return new FlumeMasterCommandThrift(this); 
  } 
 
  @Deprecated 
  public FlumeMasterCommandThrift clone() { 
    return new FlumeMasterCommandThrift(this); 
  } 
 
  @Override 
  public void clear() { 
    this.command = null
    this.arguments = null
  } 
 
  public String getCommand() { 
    return this.command; 
  } 
 
  public FlumeMasterCommandThrift setCommand(String command) { 
    this.command = command; 
    return this
  } 
 
  public void unsetCommand() { 
    this.command = null
  } 
 
  /** Returns true if field command is set (has been asigned a value) and false otherwise */ 
  public boolean isSetCommand() { 
    return this.command != null
  } 
 
  public void setCommandIsSet(boolean value) { 
    if (!value) { 
      this.command = null
    } 
  } 
 
  public int getArgumentsSize() { 
    return (this.arguments == null) ? 0 : this.arguments.size(); 
  } 
 
  public java.util.Iterator<String> getArgumentsIterator() { 
    return (this.arguments == null) ? null : this.arguments.iterator(); 
  } 
 
  public void addToArguments(String elem) { 
    if (this.arguments == null) { 
      this.arguments = new ArrayList<String>(); 
    } 
    this.arguments.add(elem); 
  } 
 
  public List<String> getArguments() { 
    return this.arguments; 
  } 
 
  public FlumeMasterCommandThrift setArguments(List<String> arguments) { 
    this.arguments = arguments; 
    return this
  } 
 
  public void unsetArguments() { 
    this.arguments = null
  } 
 
  /** Returns true if field arguments is set (has been asigned a value) and false otherwise */ 
  public boolean isSetArguments() { 
    return this.arguments != null
  } 
 
  public void setArgumentsIsSet(boolean value) { 
    if (!value) { 
      this.arguments = null
    } 
  } 
 
  public void setFieldValue(_Fields field, Object value) { 
    switch (field) { 
    case COMMAND: 
      if (value == null) { 
        unsetCommand(); 
      } else { 
        setCommand((String)value); 
      } 
      break
 
    case ARGUMENTS: 
      if (value == null) { 
        unsetArguments(); 
      } else { 
        setArguments((List<String>)value); 
      } 
      break
 
    } 
  } 
 
  public void setFieldValue(int fieldID, Object value) { 
    setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value); 
  } 
 
  public Object getFieldValue(_Fields field) { 
    switch (field) { 
    case COMMAND: 
      return getCommand(); 
 
    case ARGUMENTS: 
      return getArguments(); 
 
    } 
    throw new IllegalStateException(); 
  } 
 
  public Object getFieldValue(int fieldId) { 
    return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId)); 
  } 
 
  /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ 
  public boolean isSet(_Fields field) { 
    switch (field) { 
    case COMMAND: 
      return isSetCommand(); 
    case ARGUMENTS: 
      return isSetArguments(); 
    } 
    throw new IllegalStateException(); 
  } 
 
  public boolean isSet(int fieldID) { 
    return isSet(_Fields.findByThriftIdOrThrow(fieldID)); 
  } 
 
  @Override 
  public boolean equals(Object that) { 
    if (that == null
      return false
    if (that instanceof FlumeMasterCommandThrift) 
      return this.equals((FlumeMasterCommandThrift)that); 
    return false
  } 
 
  public boolean equals(FlumeMasterCommandThrift that) { 
    if (that == null
      return false
 
    boolean this_present_command = true && this.isSetCommand(); 
    boolean that_present_command = true && that.isSetCommand(); 
    if (this_present_command || that_present_command) { 
      if (!(this_present_command && that_present_command)) 
        return false
      if (!this.command.equals(that.command)) 
        return false
    } 
 
    boolean this_present_arguments = true && this.isSetArguments(); 
    boolean that_present_arguments = true && that.isSetArguments(); 
    if (this_present_arguments || that_present_arguments) { 
      if (!(this_present_arguments && that_present_arguments)) 
        return false
      if (!this.arguments.equals(that.arguments)) 
        return false
    } 
 
    return true
  } 
 
  @Override 
  public int hashCode() { 
    return 0
  } 
 
  public int compareTo(FlumeMasterCommandThrift other) { 
    if (!getClass().equals(other.getClass())) { 
      return getClass().getName().compareTo(other.getClass().getName()); 
    } 
 
    int lastComparison = 0
    FlumeMasterCommandThrift typedOther = (FlumeMasterCommandThrift)other; 
 
    lastComparison = Boolean.valueOf(isSetCommand()).compareTo(typedOther.isSetCommand()); 
    if (lastComparison != 0) { 
      return lastComparison; 
    } 
    if (isSetCommand()) {      lastComparison = TBaseHelper.compareTo(this.command, typedOther.command); 
      if (lastComparison != 0) { 
        return lastComparison; 
      } 
    } 
    lastComparison = Boolean.valueOf(isSetArguments()).compareTo(typedOther.isSetArguments()); 
    if (lastComparison != 0) { 
      return lastComparison; 
    } 
    if (isSetArguments()) {      lastComparison = TBaseHelper.compareTo(this.arguments, typedOther.arguments); 
      if (lastComparison != 0) { 
        return lastComparison; 
      } 
    } 
    return 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// COMMAND 
          if (field.type == TType.STRING) { 
            this.command = iprot.readString(); 
          } else {  
            TProtocolUtil.skip(iprot, field.type); 
          } 
          break
        case 2// ARGUMENTS 
          if (field.type == TType.LIST) { 
            { 
              TList _list0 = iprot.readListBegin(); 
              this.arguments = new ArrayList<String>(_list0.size); 
              for (int _i1 = 0; _i1 < _list0.size; ++_i1) 
              { 
                String _elem2; 
                _elem2 = iprot.readString(); 
                this.arguments.add(_elem2); 
              } 
              iprot.readListEnd(); 
            } 
          } 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 write(TProtocol oprot) throws TException { 
    validate(); 
 
    oprot.writeStructBegin(STRUCT_DESC); 
    if (this.command != null) { 
      oprot.writeFieldBegin(COMMAND_FIELD_DESC); 
      oprot.writeString(this.command); 
      oprot.writeFieldEnd(); 
    } 
    if (this.arguments != null) { 
      oprot.writeFieldBegin(ARGUMENTS_FIELD_DESC); 
      { 
        oprot.writeListBegin(new TList(TType.STRING, this.arguments.size())); 
        for (String _iter3 : this.arguments) 
        { 
          oprot.writeString(_iter3); 
        } 
        oprot.writeListEnd(); 
      } 
      oprot.writeFieldEnd(); 
    } 
    oprot.writeFieldStop(); 
    oprot.writeStructEnd(); 
  } 
 
  @Override 
  public String toString() { 
    StringBuilder sb = new StringBuilder("FlumeMasterCommandThrift("); 
    boolean first = true
 
    sb.append("command:"); 
    if (this.command == null) { 
      sb.append("null"); 
    } else { 
      sb.append(this.command); 
    } 
    first = false
    if (!first) sb.append(", "); 
    sb.append("arguments:"); 
    if (this.arguments == null) { 
      sb.append("null"); 
    } else { 
      sb.append(this.arguments); 
    } 
    first = false
    sb.append(")"); 
    return sb.toString(); 
  } 
 
  public void validate() throws TException { 
    // check for required fields 
  } 
 
}