diff --git a/src/main/java/com/profiler/context/gen/Annotation.java b/src/main/java/com/profiler/context/gen/Annotation.java new file mode 100644 index 000000000..317d367f3 --- /dev/null +++ b/src/main/java/com/profiler/context/gen/Annotation.java @@ -0,0 +1,572 @@ +/** + * Autogenerated by Thrift Compiler (0.8.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package com.profiler.context.gen; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +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; + +public class Annotation implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Annotation"); + + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)1); + private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField DURATION_FIELD_DESC = new org.apache.thrift.protocol.TField("duration", org.apache.thrift.protocol.TType.I64, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new AnnotationStandardSchemeFactory()); + schemes.put(TupleScheme.class, new AnnotationTupleSchemeFactory()); + } + + private long timestamp; // required + private String value; // required + private long duration; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TIMESTAMP((short)1, "timestamp"), + VALUE((short)2, "value"), + DURATION((short)3, "duration"); + + private static final Map byName = new HashMap(); + + 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: // TIMESTAMP + return TIMESTAMP; + case 2: // VALUE + return VALUE; + case 3: // DURATION + return DURATION; + 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 == null) throw 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 + private static final int __TIMESTAMP_ISSET_ID = 0; + private static final int __DURATION_ISSET_ID = 1; + private BitSet __isset_bit_vector = new BitSet(2); + private _Fields optionals[] = {_Fields.DURATION}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DURATION, new org.apache.thrift.meta_data.FieldMetaData("duration", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Annotation.class, metaDataMap); + } + + public Annotation() { + } + + public Annotation( + long timestamp, + String value) + { + this(); + this.timestamp = timestamp; + setTimestampIsSet(true); + this.value = value; + } + + /** + * Performs a deep copy on other. + */ + public Annotation(Annotation other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.timestamp = other.timestamp; + if (other.isSetValue()) { + this.value = other.value; + } + this.duration = other.duration; + } + + public Annotation deepCopy() { + return new Annotation(this); + } + + @Override + public void clear() { + setTimestampIsSet(false); + this.timestamp = 0; + this.value = null; + setDurationIsSet(false); + this.duration = 0; + } + + public long getTimestamp() { + return this.timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + + public String getValue() { + return this.value; + } + + public void setValue(String value) { + this.value = value; + } + + public void unsetValue() { + this.value = null; + } + + /** Returns true if field value is set (has been assigned a value) and false otherwise */ + public boolean isSetValue() { + return this.value != null; + } + + public void setValueIsSet(boolean value) { + if (!value) { + this.value = null; + } + } + + public long getDuration() { + return this.duration; + } + + public void setDuration(long duration) { + this.duration = duration; + setDurationIsSet(true); + } + + public void unsetDuration() { + __isset_bit_vector.clear(__DURATION_ISSET_ID); + } + + /** Returns true if field duration is set (has been assigned a value) and false otherwise */ + public boolean isSetDuration() { + return __isset_bit_vector.get(__DURATION_ISSET_ID); + } + + public void setDurationIsSet(boolean value) { + __isset_bit_vector.set(__DURATION_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + + case VALUE: + if (value == null) { + unsetValue(); + } else { + setValue((String)value); + } + break; + + case DURATION: + if (value == null) { + unsetDuration(); + } else { + setDuration((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TIMESTAMP: + return Long.valueOf(getTimestamp()); + + case VALUE: + return getValue(); + + case DURATION: + return Long.valueOf(getDuration()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TIMESTAMP: + return isSetTimestamp(); + case VALUE: + return isSetValue(); + case DURATION: + return isSetDuration(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof Annotation) + return this.equals((Annotation)that); + return false; + } + + public boolean equals(Annotation that) { + if (that == null) + return false; + + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + + boolean this_present_value = true && this.isSetValue(); + boolean that_present_value = true && that.isSetValue(); + if (this_present_value || that_present_value) { + if (!(this_present_value && that_present_value)) + return false; + if (!this.value.equals(that.value)) + return false; + } + + boolean this_present_duration = true && this.isSetDuration(); + boolean that_present_duration = true && that.isSetDuration(); + if (this_present_duration || that_present_duration) { + if (!(this_present_duration && that_present_duration)) + return false; + if (this.duration != that.duration) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(Annotation other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + Annotation typedOther = (Annotation)other; + + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValue()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDuration()).compareTo(typedOther.isSetDuration()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDuration()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.duration, typedOther.duration); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("Annotation("); + boolean first = true; + + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; + if (!first) sb.append(", "); + sb.append("value:"); + if (this.value == null) { + sb.append("null"); + } else { + sb.append(this.value); + } + first = false; + if (isSetDuration()) { + if (!first) sb.append(", "); + sb.append("duration:"); + sb.append(this.duration); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class AnnotationStandardSchemeFactory implements SchemeFactory { + public AnnotationStandardScheme getScheme() { + return new AnnotationStandardScheme(); + } + } + + private static class AnnotationStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, Annotation struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TIMESTAMP + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // VALUE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.value = iprot.readString(); + struct.setValueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DURATION + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.duration = iprot.readI64(); + struct.setDurationIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, Annotation struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(struct.timestamp); + oprot.writeFieldEnd(); + if (struct.value != null) { + oprot.writeFieldBegin(VALUE_FIELD_DESC); + oprot.writeString(struct.value); + oprot.writeFieldEnd(); + } + if (struct.isSetDuration()) { + oprot.writeFieldBegin(DURATION_FIELD_DESC); + oprot.writeI64(struct.duration); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class AnnotationTupleSchemeFactory implements SchemeFactory { + public AnnotationTupleScheme getScheme() { + return new AnnotationTupleScheme(); + } + } + + private static class AnnotationTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, Annotation struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTimestamp()) { + optionals.set(0); + } + if (struct.isSetValue()) { + optionals.set(1); + } + if (struct.isSetDuration()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetTimestamp()) { + oprot.writeI64(struct.timestamp); + } + if (struct.isSetValue()) { + oprot.writeString(struct.value); + } + if (struct.isSetDuration()) { + oprot.writeI64(struct.duration); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, Annotation struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } + if (incoming.get(1)) { + struct.value = iprot.readString(); + struct.setValueIsSet(true); + } + if (incoming.get(2)) { + struct.duration = iprot.readI64(); + struct.setDurationIsSet(true); + } + } + } + +} + diff --git a/src/main/java/com/profiler/context/gen/BinaryAnnotation.java b/src/main/java/com/profiler/context/gen/BinaryAnnotation.java new file mode 100644 index 000000000..2276e716d --- /dev/null +++ b/src/main/java/com/profiler/context/gen/BinaryAnnotation.java @@ -0,0 +1,685 @@ +/** + * Autogenerated by Thrift Compiler (0.8.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package com.profiler.context.gen; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +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; + +public class BinaryAnnotation implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("BinaryAnnotation"); + + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)1); + private static final org.apache.thrift.protocol.TField KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("key", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField VALUE_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("valueType", org.apache.thrift.protocol.TType.STRING, (short)4); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new BinaryAnnotationStandardSchemeFactory()); + schemes.put(TupleScheme.class, new BinaryAnnotationTupleSchemeFactory()); + } + + private long timestamp; // required + private String key; // required + private ByteBuffer value; // required + private String valueType; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TIMESTAMP((short)1, "timestamp"), + KEY((short)2, "key"), + VALUE((short)3, "value"), + VALUE_TYPE((short)4, "valueType"); + + private static final Map byName = new HashMap(); + + 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: // TIMESTAMP + return TIMESTAMP; + case 2: // KEY + return KEY; + case 3: // VALUE + return VALUE; + case 4: // VALUE_TYPE + return VALUE_TYPE; + 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 == null) throw 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 + private static final int __TIMESTAMP_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.KEY, new org.apache.thrift.meta_data.FieldMetaData("key", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); + tmpMap.put(_Fields.VALUE_TYPE, new org.apache.thrift.meta_data.FieldMetaData("valueType", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(BinaryAnnotation.class, metaDataMap); + } + + public BinaryAnnotation() { + } + + public BinaryAnnotation( + long timestamp, + String key, + ByteBuffer value, + String valueType) + { + this(); + this.timestamp = timestamp; + setTimestampIsSet(true); + this.key = key; + this.value = value; + this.valueType = valueType; + } + + /** + * Performs a deep copy on other. + */ + public BinaryAnnotation(BinaryAnnotation other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.timestamp = other.timestamp; + if (other.isSetKey()) { + this.key = other.key; + } + if (other.isSetValue()) { + this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value); +; + } + if (other.isSetValueType()) { + this.valueType = other.valueType; + } + } + + public BinaryAnnotation deepCopy() { + return new BinaryAnnotation(this); + } + + @Override + public void clear() { + setTimestampIsSet(false); + this.timestamp = 0; + this.key = null; + this.value = null; + this.valueType = null; + } + + public long getTimestamp() { + return this.timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + + public String getKey() { + return this.key; + } + + public void setKey(String key) { + this.key = key; + } + + public void unsetKey() { + this.key = null; + } + + /** Returns true if field key is set (has been assigned a value) and false otherwise */ + public boolean isSetKey() { + return this.key != null; + } + + public void setKeyIsSet(boolean value) { + if (!value) { + this.key = null; + } + } + + public byte[] getValue() { + setValue(org.apache.thrift.TBaseHelper.rightSize(value)); + return value == null ? null : value.array(); + } + + public ByteBuffer bufferForValue() { + return value; + } + + public void setValue(byte[] value) { + setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value)); + } + + public void setValue(ByteBuffer value) { + this.value = value; + } + + public void unsetValue() { + this.value = null; + } + + /** Returns true if field value is set (has been assigned a value) and false otherwise */ + public boolean isSetValue() { + return this.value != null; + } + + public void setValueIsSet(boolean value) { + if (!value) { + this.value = null; + } + } + + public String getValueType() { + return this.valueType; + } + + public void setValueType(String valueType) { + this.valueType = valueType; + } + + public void unsetValueType() { + this.valueType = null; + } + + /** Returns true if field valueType is set (has been assigned a value) and false otherwise */ + public boolean isSetValueType() { + return this.valueType != null; + } + + public void setValueTypeIsSet(boolean value) { + if (!value) { + this.valueType = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + + case KEY: + if (value == null) { + unsetKey(); + } else { + setKey((String)value); + } + break; + + case VALUE: + if (value == null) { + unsetValue(); + } else { + setValue((ByteBuffer)value); + } + break; + + case VALUE_TYPE: + if (value == null) { + unsetValueType(); + } else { + setValueType((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TIMESTAMP: + return Long.valueOf(getTimestamp()); + + case KEY: + return getKey(); + + case VALUE: + return getValue(); + + case VALUE_TYPE: + return getValueType(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TIMESTAMP: + return isSetTimestamp(); + case KEY: + return isSetKey(); + case VALUE: + return isSetValue(); + case VALUE_TYPE: + return isSetValueType(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof BinaryAnnotation) + return this.equals((BinaryAnnotation)that); + return false; + } + + public boolean equals(BinaryAnnotation that) { + if (that == null) + return false; + + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + + boolean this_present_key = true && this.isSetKey(); + boolean that_present_key = true && that.isSetKey(); + if (this_present_key || that_present_key) { + if (!(this_present_key && that_present_key)) + return false; + if (!this.key.equals(that.key)) + return false; + } + + boolean this_present_value = true && this.isSetValue(); + boolean that_present_value = true && that.isSetValue(); + if (this_present_value || that_present_value) { + if (!(this_present_value && that_present_value)) + return false; + if (!this.value.equals(that.value)) + return false; + } + + boolean this_present_valueType = true && this.isSetValueType(); + boolean that_present_valueType = true && that.isSetValueType(); + if (this_present_valueType || that_present_valueType) { + if (!(this_present_valueType && that_present_valueType)) + return false; + if (!this.valueType.equals(that.valueType)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(BinaryAnnotation other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + BinaryAnnotation typedOther = (BinaryAnnotation)other; + + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetKey()).compareTo(typedOther.isSetKey()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetKey()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.key, typedOther.key); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValue()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetValueType()).compareTo(typedOther.isSetValueType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValueType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.valueType, typedOther.valueType); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("BinaryAnnotation("); + boolean first = true; + + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; + if (!first) sb.append(", "); + sb.append("key:"); + if (this.key == null) { + sb.append("null"); + } else { + sb.append(this.key); + } + first = false; + if (!first) sb.append(", "); + sb.append("value:"); + if (this.value == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.value, sb); + } + first = false; + if (!first) sb.append(", "); + sb.append("valueType:"); + if (this.valueType == null) { + sb.append("null"); + } else { + sb.append(this.valueType); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class BinaryAnnotationStandardSchemeFactory implements SchemeFactory { + public BinaryAnnotationStandardScheme getScheme() { + return new BinaryAnnotationStandardScheme(); + } + } + + private static class BinaryAnnotationStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, BinaryAnnotation struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TIMESTAMP + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // KEY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.key = iprot.readString(); + struct.setKeyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // VALUE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.value = iprot.readBinary(); + struct.setValueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // VALUE_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.valueType = iprot.readString(); + struct.setValueTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, BinaryAnnotation struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(struct.timestamp); + oprot.writeFieldEnd(); + if (struct.key != null) { + oprot.writeFieldBegin(KEY_FIELD_DESC); + oprot.writeString(struct.key); + oprot.writeFieldEnd(); + } + if (struct.value != null) { + oprot.writeFieldBegin(VALUE_FIELD_DESC); + oprot.writeBinary(struct.value); + oprot.writeFieldEnd(); + } + if (struct.valueType != null) { + oprot.writeFieldBegin(VALUE_TYPE_FIELD_DESC); + oprot.writeString(struct.valueType); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class BinaryAnnotationTupleSchemeFactory implements SchemeFactory { + public BinaryAnnotationTupleScheme getScheme() { + return new BinaryAnnotationTupleScheme(); + } + } + + private static class BinaryAnnotationTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, BinaryAnnotation struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTimestamp()) { + optionals.set(0); + } + if (struct.isSetKey()) { + optionals.set(1); + } + if (struct.isSetValue()) { + optionals.set(2); + } + if (struct.isSetValueType()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetTimestamp()) { + oprot.writeI64(struct.timestamp); + } + if (struct.isSetKey()) { + oprot.writeString(struct.key); + } + if (struct.isSetValue()) { + oprot.writeBinary(struct.value); + } + if (struct.isSetValueType()) { + oprot.writeString(struct.valueType); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, BinaryAnnotation struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } + if (incoming.get(1)) { + struct.key = iprot.readString(); + struct.setKeyIsSet(true); + } + if (incoming.get(2)) { + struct.value = iprot.readBinary(); + struct.setValueIsSet(true); + } + if (incoming.get(3)) { + struct.valueType = iprot.readString(); + struct.setValueTypeIsSet(true); + } + } + } + +} + diff --git a/src/main/java/com/profiler/context/gen/Constants.java b/src/main/java/com/profiler/context/gen/Constants.java new file mode 100644 index 000000000..8e676b0fa --- /dev/null +++ b/src/main/java/com/profiler/context/gen/Constants.java @@ -0,0 +1,40 @@ +/** + * Autogenerated by Thrift Compiler (0.8.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package com.profiler.context.gen; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +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; + +public class Constants { + + public static final String CLIENT_SEND = "CS"; + + public static final String CLIENT_RECV = "CR"; + + public static final String SERVER_SEND = "SS"; + + public static final String SERVER_RECV = "SR"; + +} diff --git a/src/main/java/com/profiler/context/gen/Endpoint.java b/src/main/java/com/profiler/context/gen/Endpoint.java new file mode 100644 index 000000000..e39307e14 --- /dev/null +++ b/src/main/java/com/profiler/context/gen/Endpoint.java @@ -0,0 +1,477 @@ +/** + * Autogenerated by Thrift Compiler (0.8.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package com.profiler.context.gen; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +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; + +public class Endpoint implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Endpoint"); + + private static final org.apache.thrift.protocol.TField IP_FIELD_DESC = new org.apache.thrift.protocol.TField("ip", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField PORT_FIELD_DESC = new org.apache.thrift.protocol.TField("port", org.apache.thrift.protocol.TType.I16, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new EndpointStandardSchemeFactory()); + schemes.put(TupleScheme.class, new EndpointTupleSchemeFactory()); + } + + private String ip; // required + private short port; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + IP((short)1, "ip"), + PORT((short)2, "port"); + + private static final Map byName = new HashMap(); + + 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: // IP + return IP; + case 2: // PORT + return PORT; + 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 == null) throw 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 + private static final int __PORT_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IP, new org.apache.thrift.meta_data.FieldMetaData("ip", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PORT, new org.apache.thrift.meta_data.FieldMetaData("port", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Endpoint.class, metaDataMap); + } + + public Endpoint() { + } + + public Endpoint( + String ip, + short port) + { + this(); + this.ip = ip; + this.port = port; + setPortIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public Endpoint(Endpoint other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + if (other.isSetIp()) { + this.ip = other.ip; + } + this.port = other.port; + } + + public Endpoint deepCopy() { + return new Endpoint(this); + } + + @Override + public void clear() { + this.ip = null; + setPortIsSet(false); + this.port = 0; + } + + public String getIp() { + return this.ip; + } + + public void setIp(String ip) { + this.ip = ip; + } + + public void unsetIp() { + this.ip = null; + } + + /** Returns true if field ip is set (has been assigned a value) and false otherwise */ + public boolean isSetIp() { + return this.ip != null; + } + + public void setIpIsSet(boolean value) { + if (!value) { + this.ip = null; + } + } + + public short getPort() { + return this.port; + } + + public void setPort(short port) { + this.port = port; + setPortIsSet(true); + } + + public void unsetPort() { + __isset_bit_vector.clear(__PORT_ISSET_ID); + } + + /** Returns true if field port is set (has been assigned a value) and false otherwise */ + public boolean isSetPort() { + return __isset_bit_vector.get(__PORT_ISSET_ID); + } + + public void setPortIsSet(boolean value) { + __isset_bit_vector.set(__PORT_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case IP: + if (value == null) { + unsetIp(); + } else { + setIp((String)value); + } + break; + + case PORT: + if (value == null) { + unsetPort(); + } else { + setPort((Short)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case IP: + return getIp(); + + case PORT: + return Short.valueOf(getPort()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case IP: + return isSetIp(); + case PORT: + return isSetPort(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof Endpoint) + return this.equals((Endpoint)that); + return false; + } + + public boolean equals(Endpoint that) { + if (that == null) + return false; + + boolean this_present_ip = true && this.isSetIp(); + boolean that_present_ip = true && that.isSetIp(); + if (this_present_ip || that_present_ip) { + if (!(this_present_ip && that_present_ip)) + return false; + if (!this.ip.equals(that.ip)) + return false; + } + + boolean this_present_port = true; + boolean that_present_port = true; + if (this_present_port || that_present_port) { + if (!(this_present_port && that_present_port)) + return false; + if (this.port != that.port) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(Endpoint other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + Endpoint typedOther = (Endpoint)other; + + lastComparison = Boolean.valueOf(isSetIp()).compareTo(typedOther.isSetIp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ip, typedOther.ip); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPort()).compareTo(typedOther.isSetPort()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPort()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.port, typedOther.port); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("Endpoint("); + boolean first = true; + + sb.append("ip:"); + if (this.ip == null) { + sb.append("null"); + } else { + sb.append(this.ip); + } + first = false; + if (!first) sb.append(", "); + sb.append("port:"); + sb.append(this.port); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class EndpointStandardSchemeFactory implements SchemeFactory { + public EndpointStandardScheme getScheme() { + return new EndpointStandardScheme(); + } + } + + private static class EndpointStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, Endpoint struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // IP + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.ip = iprot.readString(); + struct.setIpIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PORT + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.port = iprot.readI16(); + struct.setPortIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, Endpoint struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.ip != null) { + oprot.writeFieldBegin(IP_FIELD_DESC); + oprot.writeString(struct.ip); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PORT_FIELD_DESC); + oprot.writeI16(struct.port); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class EndpointTupleSchemeFactory implements SchemeFactory { + public EndpointTupleScheme getScheme() { + return new EndpointTupleScheme(); + } + } + + private static class EndpointTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, Endpoint struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetIp()) { + optionals.set(0); + } + if (struct.isSetPort()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetIp()) { + oprot.writeString(struct.ip); + } + if (struct.isSetPort()) { + oprot.writeI16(struct.port); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, Endpoint struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.ip = iprot.readString(); + struct.setIpIsSet(true); + } + if (incoming.get(1)) { + struct.port = iprot.readI16(); + struct.setPortIsSet(true); + } + } + } + +} + diff --git a/src/main/java/com/profiler/context/gen/Span.java b/src/main/java/com/profiler/context/gen/Span.java new file mode 100644 index 000000000..b9c72ecf9 --- /dev/null +++ b/src/main/java/com/profiler/context/gen/Span.java @@ -0,0 +1,1253 @@ +/** + * Autogenerated by Thrift Compiler (0.8.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package com.profiler.context.gen; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +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; + +public class Span implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Span"); + + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)1); + private static final org.apache.thrift.protocol.TField MOST_TRACE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("mostTraceID", org.apache.thrift.protocol.TType.I64, (short)2); + private static final org.apache.thrift.protocol.TField LEAST_TRACE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("leastTraceID", org.apache.thrift.protocol.TType.I64, (short)3); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField SPAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("spanID", org.apache.thrift.protocol.TType.I64, (short)5); + private static final org.apache.thrift.protocol.TField PARENT_SPAN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("parentSpanId", org.apache.thrift.protocol.TType.I64, (short)6); + private static final org.apache.thrift.protocol.TField ANNOTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("annotations", org.apache.thrift.protocol.TType.LIST, (short)7); + private static final org.apache.thrift.protocol.TField BINARY_ANNOTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("binaryAnnotations", org.apache.thrift.protocol.TType.LIST, (short)8); + private static final org.apache.thrift.protocol.TField FLAG_FIELD_DESC = new org.apache.thrift.protocol.TField("flag", org.apache.thrift.protocol.TType.I32, (short)9); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new SpanStandardSchemeFactory()); + schemes.put(TupleScheme.class, new SpanTupleSchemeFactory()); + } + + private long timestamp; // required + private long mostTraceID; // required + private long leastTraceID; // required + private String name; // required + private long spanID; // required + private long parentSpanId; // optional + private List annotations; // required + private List binaryAnnotations; // required + private int flag; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TIMESTAMP((short)1, "timestamp"), + MOST_TRACE_ID((short)2, "mostTraceID"), + LEAST_TRACE_ID((short)3, "leastTraceID"), + NAME((short)4, "name"), + SPAN_ID((short)5, "spanID"), + PARENT_SPAN_ID((short)6, "parentSpanId"), + ANNOTATIONS((short)7, "annotations"), + BINARY_ANNOTATIONS((short)8, "binaryAnnotations"), + FLAG((short)9, "flag"); + + private static final Map byName = new HashMap(); + + 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: // TIMESTAMP + return TIMESTAMP; + case 2: // MOST_TRACE_ID + return MOST_TRACE_ID; + case 3: // LEAST_TRACE_ID + return LEAST_TRACE_ID; + case 4: // NAME + return NAME; + case 5: // SPAN_ID + return SPAN_ID; + case 6: // PARENT_SPAN_ID + return PARENT_SPAN_ID; + case 7: // ANNOTATIONS + return ANNOTATIONS; + case 8: // BINARY_ANNOTATIONS + return BINARY_ANNOTATIONS; + case 9: // FLAG + return FLAG; + 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 == null) throw 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 + private static final int __TIMESTAMP_ISSET_ID = 0; + private static final int __MOSTTRACEID_ISSET_ID = 1; + private static final int __LEASTTRACEID_ISSET_ID = 2; + private static final int __SPANID_ISSET_ID = 3; + private static final int __PARENTSPANID_ISSET_ID = 4; + private static final int __FLAG_ISSET_ID = 5; + private BitSet __isset_bit_vector = new BitSet(6); + private _Fields optionals[] = {_Fields.PARENT_SPAN_ID,_Fields.FLAG}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.MOST_TRACE_ID, new org.apache.thrift.meta_data.FieldMetaData("mostTraceID", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.LEAST_TRACE_ID, new org.apache.thrift.meta_data.FieldMetaData("leastTraceID", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.SPAN_ID, new org.apache.thrift.meta_data.FieldMetaData("spanID", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.PARENT_SPAN_ID, new org.apache.thrift.meta_data.FieldMetaData("parentSpanId", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.ANNOTATIONS, new org.apache.thrift.meta_data.FieldMetaData("annotations", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Annotation.class)))); + tmpMap.put(_Fields.BINARY_ANNOTATIONS, new org.apache.thrift.meta_data.FieldMetaData("binaryAnnotations", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, BinaryAnnotation.class)))); + tmpMap.put(_Fields.FLAG, new org.apache.thrift.meta_data.FieldMetaData("flag", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Span.class, metaDataMap); + } + + public Span() { + this.flag = 0; + + } + + public Span( + long timestamp, + long mostTraceID, + long leastTraceID, + String name, + long spanID, + List annotations, + List binaryAnnotations) + { + this(); + this.timestamp = timestamp; + setTimestampIsSet(true); + this.mostTraceID = mostTraceID; + setMostTraceIDIsSet(true); + this.leastTraceID = leastTraceID; + setLeastTraceIDIsSet(true); + this.name = name; + this.spanID = spanID; + setSpanIDIsSet(true); + this.annotations = annotations; + this.binaryAnnotations = binaryAnnotations; + } + + /** + * Performs a deep copy on other. + */ + public Span(Span other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.timestamp = other.timestamp; + this.mostTraceID = other.mostTraceID; + this.leastTraceID = other.leastTraceID; + if (other.isSetName()) { + this.name = other.name; + } + this.spanID = other.spanID; + this.parentSpanId = other.parentSpanId; + if (other.isSetAnnotations()) { + List __this__annotations = new ArrayList(); + for (Annotation other_element : other.annotations) { + __this__annotations.add(new Annotation(other_element)); + } + this.annotations = __this__annotations; + } + if (other.isSetBinaryAnnotations()) { + List __this__binaryAnnotations = new ArrayList(); + for (BinaryAnnotation other_element : other.binaryAnnotations) { + __this__binaryAnnotations.add(new BinaryAnnotation(other_element)); + } + this.binaryAnnotations = __this__binaryAnnotations; + } + this.flag = other.flag; + } + + public Span deepCopy() { + return new Span(this); + } + + @Override + public void clear() { + setTimestampIsSet(false); + this.timestamp = 0; + setMostTraceIDIsSet(false); + this.mostTraceID = 0; + setLeastTraceIDIsSet(false); + this.leastTraceID = 0; + this.name = null; + setSpanIDIsSet(false); + this.spanID = 0; + setParentSpanIdIsSet(false); + this.parentSpanId = 0; + this.annotations = null; + this.binaryAnnotations = null; + this.flag = 0; + + } + + public long getTimestamp() { + return this.timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + + public long getMostTraceID() { + return this.mostTraceID; + } + + public void setMostTraceID(long mostTraceID) { + this.mostTraceID = mostTraceID; + setMostTraceIDIsSet(true); + } + + public void unsetMostTraceID() { + __isset_bit_vector.clear(__MOSTTRACEID_ISSET_ID); + } + + /** Returns true if field mostTraceID is set (has been assigned a value) and false otherwise */ + public boolean isSetMostTraceID() { + return __isset_bit_vector.get(__MOSTTRACEID_ISSET_ID); + } + + public void setMostTraceIDIsSet(boolean value) { + __isset_bit_vector.set(__MOSTTRACEID_ISSET_ID, value); + } + + public long getLeastTraceID() { + return this.leastTraceID; + } + + public void setLeastTraceID(long leastTraceID) { + this.leastTraceID = leastTraceID; + setLeastTraceIDIsSet(true); + } + + public void unsetLeastTraceID() { + __isset_bit_vector.clear(__LEASTTRACEID_ISSET_ID); + } + + /** Returns true if field leastTraceID is set (has been assigned a value) and false otherwise */ + public boolean isSetLeastTraceID() { + return __isset_bit_vector.get(__LEASTTRACEID_ISSET_ID); + } + + public void setLeastTraceIDIsSet(boolean value) { + __isset_bit_vector.set(__LEASTTRACEID_ISSET_ID, value); + } + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.name = name; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public long getSpanID() { + return this.spanID; + } + + public void setSpanID(long spanID) { + this.spanID = spanID; + setSpanIDIsSet(true); + } + + public void unsetSpanID() { + __isset_bit_vector.clear(__SPANID_ISSET_ID); + } + + /** Returns true if field spanID is set (has been assigned a value) and false otherwise */ + public boolean isSetSpanID() { + return __isset_bit_vector.get(__SPANID_ISSET_ID); + } + + public void setSpanIDIsSet(boolean value) { + __isset_bit_vector.set(__SPANID_ISSET_ID, value); + } + + public long getParentSpanId() { + return this.parentSpanId; + } + + public void setParentSpanId(long parentSpanId) { + this.parentSpanId = parentSpanId; + setParentSpanIdIsSet(true); + } + + public void unsetParentSpanId() { + __isset_bit_vector.clear(__PARENTSPANID_ISSET_ID); + } + + /** Returns true if field parentSpanId is set (has been assigned a value) and false otherwise */ + public boolean isSetParentSpanId() { + return __isset_bit_vector.get(__PARENTSPANID_ISSET_ID); + } + + public void setParentSpanIdIsSet(boolean value) { + __isset_bit_vector.set(__PARENTSPANID_ISSET_ID, value); + } + + public int getAnnotationsSize() { + return (this.annotations == null) ? 0 : this.annotations.size(); + } + + public java.util.Iterator getAnnotationsIterator() { + return (this.annotations == null) ? null : this.annotations.iterator(); + } + + public void addToAnnotations(Annotation elem) { + if (this.annotations == null) { + this.annotations = new ArrayList(); + } + this.annotations.add(elem); + } + + public List getAnnotations() { + return this.annotations; + } + + public void setAnnotations(List annotations) { + this.annotations = annotations; + } + + public void unsetAnnotations() { + this.annotations = null; + } + + /** Returns true if field annotations is set (has been assigned a value) and false otherwise */ + public boolean isSetAnnotations() { + return this.annotations != null; + } + + public void setAnnotationsIsSet(boolean value) { + if (!value) { + this.annotations = null; + } + } + + public int getBinaryAnnotationsSize() { + return (this.binaryAnnotations == null) ? 0 : this.binaryAnnotations.size(); + } + + public java.util.Iterator getBinaryAnnotationsIterator() { + return (this.binaryAnnotations == null) ? null : this.binaryAnnotations.iterator(); + } + + public void addToBinaryAnnotations(BinaryAnnotation elem) { + if (this.binaryAnnotations == null) { + this.binaryAnnotations = new ArrayList(); + } + this.binaryAnnotations.add(elem); + } + + public List getBinaryAnnotations() { + return this.binaryAnnotations; + } + + public void setBinaryAnnotations(List binaryAnnotations) { + this.binaryAnnotations = binaryAnnotations; + } + + public void unsetBinaryAnnotations() { + this.binaryAnnotations = null; + } + + /** Returns true if field binaryAnnotations is set (has been assigned a value) and false otherwise */ + public boolean isSetBinaryAnnotations() { + return this.binaryAnnotations != null; + } + + public void setBinaryAnnotationsIsSet(boolean value) { + if (!value) { + this.binaryAnnotations = null; + } + } + + public int getFlag() { + return this.flag; + } + + public void setFlag(int flag) { + this.flag = flag; + setFlagIsSet(true); + } + + public void unsetFlag() { + __isset_bit_vector.clear(__FLAG_ISSET_ID); + } + + /** Returns true if field flag is set (has been assigned a value) and false otherwise */ + public boolean isSetFlag() { + return __isset_bit_vector.get(__FLAG_ISSET_ID); + } + + public void setFlagIsSet(boolean value) { + __isset_bit_vector.set(__FLAG_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + + case MOST_TRACE_ID: + if (value == null) { + unsetMostTraceID(); + } else { + setMostTraceID((Long)value); + } + break; + + case LEAST_TRACE_ID: + if (value == null) { + unsetLeastTraceID(); + } else { + setLeastTraceID((Long)value); + } + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String)value); + } + break; + + case SPAN_ID: + if (value == null) { + unsetSpanID(); + } else { + setSpanID((Long)value); + } + break; + + case PARENT_SPAN_ID: + if (value == null) { + unsetParentSpanId(); + } else { + setParentSpanId((Long)value); + } + break; + + case ANNOTATIONS: + if (value == null) { + unsetAnnotations(); + } else { + setAnnotations((List)value); + } + break; + + case BINARY_ANNOTATIONS: + if (value == null) { + unsetBinaryAnnotations(); + } else { + setBinaryAnnotations((List)value); + } + break; + + case FLAG: + if (value == null) { + unsetFlag(); + } else { + setFlag((Integer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TIMESTAMP: + return Long.valueOf(getTimestamp()); + + case MOST_TRACE_ID: + return Long.valueOf(getMostTraceID()); + + case LEAST_TRACE_ID: + return Long.valueOf(getLeastTraceID()); + + case NAME: + return getName(); + + case SPAN_ID: + return Long.valueOf(getSpanID()); + + case PARENT_SPAN_ID: + return Long.valueOf(getParentSpanId()); + + case ANNOTATIONS: + return getAnnotations(); + + case BINARY_ANNOTATIONS: + return getBinaryAnnotations(); + + case FLAG: + return Integer.valueOf(getFlag()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TIMESTAMP: + return isSetTimestamp(); + case MOST_TRACE_ID: + return isSetMostTraceID(); + case LEAST_TRACE_ID: + return isSetLeastTraceID(); + case NAME: + return isSetName(); + case SPAN_ID: + return isSetSpanID(); + case PARENT_SPAN_ID: + return isSetParentSpanId(); + case ANNOTATIONS: + return isSetAnnotations(); + case BINARY_ANNOTATIONS: + return isSetBinaryAnnotations(); + case FLAG: + return isSetFlag(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof Span) + return this.equals((Span)that); + return false; + } + + public boolean equals(Span that) { + if (that == null) + return false; + + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + + boolean this_present_mostTraceID = true; + boolean that_present_mostTraceID = true; + if (this_present_mostTraceID || that_present_mostTraceID) { + if (!(this_present_mostTraceID && that_present_mostTraceID)) + return false; + if (this.mostTraceID != that.mostTraceID) + return false; + } + + boolean this_present_leastTraceID = true; + boolean that_present_leastTraceID = true; + if (this_present_leastTraceID || that_present_leastTraceID) { + if (!(this_present_leastTraceID && that_present_leastTraceID)) + return false; + if (this.leastTraceID != that.leastTraceID) + return false; + } + + boolean this_present_name = true && this.isSetName(); + boolean that_present_name = true && that.isSetName(); + if (this_present_name || that_present_name) { + if (!(this_present_name && that_present_name)) + return false; + if (!this.name.equals(that.name)) + return false; + } + + boolean this_present_spanID = true; + boolean that_present_spanID = true; + if (this_present_spanID || that_present_spanID) { + if (!(this_present_spanID && that_present_spanID)) + return false; + if (this.spanID != that.spanID) + return false; + } + + boolean this_present_parentSpanId = true && this.isSetParentSpanId(); + boolean that_present_parentSpanId = true && that.isSetParentSpanId(); + if (this_present_parentSpanId || that_present_parentSpanId) { + if (!(this_present_parentSpanId && that_present_parentSpanId)) + return false; + if (this.parentSpanId != that.parentSpanId) + return false; + } + + boolean this_present_annotations = true && this.isSetAnnotations(); + boolean that_present_annotations = true && that.isSetAnnotations(); + if (this_present_annotations || that_present_annotations) { + if (!(this_present_annotations && that_present_annotations)) + return false; + if (!this.annotations.equals(that.annotations)) + return false; + } + + boolean this_present_binaryAnnotations = true && this.isSetBinaryAnnotations(); + boolean that_present_binaryAnnotations = true && that.isSetBinaryAnnotations(); + if (this_present_binaryAnnotations || that_present_binaryAnnotations) { + if (!(this_present_binaryAnnotations && that_present_binaryAnnotations)) + return false; + if (!this.binaryAnnotations.equals(that.binaryAnnotations)) + return false; + } + + boolean this_present_flag = true && this.isSetFlag(); + boolean that_present_flag = true && that.isSetFlag(); + if (this_present_flag || that_present_flag) { + if (!(this_present_flag && that_present_flag)) + return false; + if (this.flag != that.flag) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(Span other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + Span typedOther = (Span)other; + + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMostTraceID()).compareTo(typedOther.isSetMostTraceID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMostTraceID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mostTraceID, typedOther.mostTraceID); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLeastTraceID()).compareTo(typedOther.isSetLeastTraceID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLeastTraceID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.leastTraceID, typedOther.leastTraceID); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSpanID()).compareTo(typedOther.isSetSpanID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSpanID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.spanID, typedOther.spanID); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetParentSpanId()).compareTo(typedOther.isSetParentSpanId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParentSpanId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.parentSpanId, typedOther.parentSpanId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetAnnotations()).compareTo(typedOther.isSetAnnotations()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAnnotations()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.annotations, typedOther.annotations); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetBinaryAnnotations()).compareTo(typedOther.isSetBinaryAnnotations()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetBinaryAnnotations()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.binaryAnnotations, typedOther.binaryAnnotations); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFlag()).compareTo(typedOther.isSetFlag()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFlag()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.flag, typedOther.flag); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("Span("); + boolean first = true; + + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; + if (!first) sb.append(", "); + sb.append("mostTraceID:"); + sb.append(this.mostTraceID); + first = false; + if (!first) sb.append(", "); + sb.append("leastTraceID:"); + sb.append(this.leastTraceID); + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("spanID:"); + sb.append(this.spanID); + first = false; + if (isSetParentSpanId()) { + if (!first) sb.append(", "); + sb.append("parentSpanId:"); + sb.append(this.parentSpanId); + first = false; + } + if (!first) sb.append(", "); + sb.append("annotations:"); + if (this.annotations == null) { + sb.append("null"); + } else { + sb.append(this.annotations); + } + first = false; + if (!first) sb.append(", "); + sb.append("binaryAnnotations:"); + if (this.binaryAnnotations == null) { + sb.append("null"); + } else { + sb.append(this.binaryAnnotations); + } + first = false; + if (isSetFlag()) { + if (!first) sb.append(", "); + sb.append("flag:"); + sb.append(this.flag); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class SpanStandardSchemeFactory implements SchemeFactory { + public SpanStandardScheme getScheme() { + return new SpanStandardScheme(); + } + } + + private static class SpanStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, Span struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TIMESTAMP + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // MOST_TRACE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.mostTraceID = iprot.readI64(); + struct.setMostTraceIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // LEAST_TRACE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.leastTraceID = iprot.readI64(); + struct.setLeastTraceIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // SPAN_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.spanID = iprot.readI64(); + struct.setSpanIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // PARENT_SPAN_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.parentSpanId = iprot.readI64(); + struct.setParentSpanIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // ANNOTATIONS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list0 = iprot.readListBegin(); + struct.annotations = new ArrayList(_list0.size); + for (int _i1 = 0; _i1 < _list0.size; ++_i1) + { + Annotation _elem2; // required + _elem2 = new Annotation(); + _elem2.read(iprot); + struct.annotations.add(_elem2); + } + iprot.readListEnd(); + } + struct.setAnnotationsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // BINARY_ANNOTATIONS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list3 = iprot.readListBegin(); + struct.binaryAnnotations = new ArrayList(_list3.size); + for (int _i4 = 0; _i4 < _list3.size; ++_i4) + { + BinaryAnnotation _elem5; // required + _elem5 = new BinaryAnnotation(); + _elem5.read(iprot); + struct.binaryAnnotations.add(_elem5); + } + iprot.readListEnd(); + } + struct.setBinaryAnnotationsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // FLAG + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.flag = iprot.readI32(); + struct.setFlagIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, Span struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(struct.timestamp); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(MOST_TRACE_ID_FIELD_DESC); + oprot.writeI64(struct.mostTraceID); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(LEAST_TRACE_ID_FIELD_DESC); + oprot.writeI64(struct.leastTraceID); + oprot.writeFieldEnd(); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(SPAN_ID_FIELD_DESC); + oprot.writeI64(struct.spanID); + oprot.writeFieldEnd(); + if (struct.isSetParentSpanId()) { + oprot.writeFieldBegin(PARENT_SPAN_ID_FIELD_DESC); + oprot.writeI64(struct.parentSpanId); + oprot.writeFieldEnd(); + } + if (struct.annotations != null) { + oprot.writeFieldBegin(ANNOTATIONS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.annotations.size())); + for (Annotation _iter6 : struct.annotations) + { + _iter6.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.binaryAnnotations != null) { + oprot.writeFieldBegin(BINARY_ANNOTATIONS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.binaryAnnotations.size())); + for (BinaryAnnotation _iter7 : struct.binaryAnnotations) + { + _iter7.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.isSetFlag()) { + oprot.writeFieldBegin(FLAG_FIELD_DESC); + oprot.writeI32(struct.flag); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class SpanTupleSchemeFactory implements SchemeFactory { + public SpanTupleScheme getScheme() { + return new SpanTupleScheme(); + } + } + + private static class SpanTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, Span struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTimestamp()) { + optionals.set(0); + } + if (struct.isSetMostTraceID()) { + optionals.set(1); + } + if (struct.isSetLeastTraceID()) { + optionals.set(2); + } + if (struct.isSetName()) { + optionals.set(3); + } + if (struct.isSetSpanID()) { + optionals.set(4); + } + if (struct.isSetParentSpanId()) { + optionals.set(5); + } + if (struct.isSetAnnotations()) { + optionals.set(6); + } + if (struct.isSetBinaryAnnotations()) { + optionals.set(7); + } + if (struct.isSetFlag()) { + optionals.set(8); + } + oprot.writeBitSet(optionals, 9); + if (struct.isSetTimestamp()) { + oprot.writeI64(struct.timestamp); + } + if (struct.isSetMostTraceID()) { + oprot.writeI64(struct.mostTraceID); + } + if (struct.isSetLeastTraceID()) { + oprot.writeI64(struct.leastTraceID); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetSpanID()) { + oprot.writeI64(struct.spanID); + } + if (struct.isSetParentSpanId()) { + oprot.writeI64(struct.parentSpanId); + } + if (struct.isSetAnnotations()) { + { + oprot.writeI32(struct.annotations.size()); + for (Annotation _iter8 : struct.annotations) + { + _iter8.write(oprot); + } + } + } + if (struct.isSetBinaryAnnotations()) { + { + oprot.writeI32(struct.binaryAnnotations.size()); + for (BinaryAnnotation _iter9 : struct.binaryAnnotations) + { + _iter9.write(oprot); + } + } + } + if (struct.isSetFlag()) { + oprot.writeI32(struct.flag); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, Span struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(9); + if (incoming.get(0)) { + struct.timestamp = iprot.readI64(); + struct.setTimestampIsSet(true); + } + if (incoming.get(1)) { + struct.mostTraceID = iprot.readI64(); + struct.setMostTraceIDIsSet(true); + } + if (incoming.get(2)) { + struct.leastTraceID = iprot.readI64(); + struct.setLeastTraceIDIsSet(true); + } + if (incoming.get(3)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(4)) { + struct.spanID = iprot.readI64(); + struct.setSpanIDIsSet(true); + } + if (incoming.get(5)) { + struct.parentSpanId = iprot.readI64(); + struct.setParentSpanIdIsSet(true); + } + if (incoming.get(6)) { + { + org.apache.thrift.protocol.TList _list10 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.annotations = new ArrayList(_list10.size); + for (int _i11 = 0; _i11 < _list10.size; ++_i11) + { + Annotation _elem12; // required + _elem12 = new Annotation(); + _elem12.read(iprot); + struct.annotations.add(_elem12); + } + } + struct.setAnnotationsIsSet(true); + } + if (incoming.get(7)) { + { + org.apache.thrift.protocol.TList _list13 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.binaryAnnotations = new ArrayList(_list13.size); + for (int _i14 = 0; _i14 < _list13.size; ++_i14) + { + BinaryAnnotation _elem15; // required + _elem15 = new BinaryAnnotation(); + _elem15.read(iprot); + struct.binaryAnnotations.add(_elem15); + } + } + struct.setBinaryAnnotationsIsSet(true); + } + if (incoming.get(8)) { + struct.flag = iprot.readI32(); + struct.setFlagIsSet(true); + } + } + } + +} +