| /* |
| * Copyright © 2015 Cask Data, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| /** |
| * Autogenerated by Thrift Compiler (0.9.0) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| package co.cask.tephra.distributed.thrift; |
| |
| 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 org.apache.thrift.protocol.TProtocolException; |
| import org.apache.thrift.EncodingUtils; |
| import org.apache.thrift.TException; |
| 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 TTransaction implements org.apache.thrift.TBase<TTransaction, TTransaction._Fields>, java.io.Serializable, Cloneable { |
| private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTransaction"); |
| |
| private static final org.apache.thrift.protocol.TField TRANSACTION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("transactionId", org.apache.thrift.protocol.TType.I64, (short)1); |
| private static final org.apache.thrift.protocol.TField READ_POINTER_FIELD_DESC = new org.apache.thrift.protocol.TField("readPointer", org.apache.thrift.protocol.TType.I64, (short)2); |
| private static final org.apache.thrift.protocol.TField INVALIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("invalids", org.apache.thrift.protocol.TType.LIST, (short)3); |
| private static final org.apache.thrift.protocol.TField IN_PROGRESS_FIELD_DESC = new org.apache.thrift.protocol.TField("inProgress", org.apache.thrift.protocol.TType.LIST, (short)4); |
| private static final org.apache.thrift.protocol.TField FIRST_SHORT_FIELD_DESC = new org.apache.thrift.protocol.TField("firstShort", org.apache.thrift.protocol.TType.I64, (short)5); |
| private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)6); |
| private static final org.apache.thrift.protocol.TField WRITE_POINTER_FIELD_DESC = new org.apache.thrift.protocol.TField("writePointer", org.apache.thrift.protocol.TType.I64, (short)7); |
| private static final org.apache.thrift.protocol.TField CHECKPOINT_WRITE_POINTERS_FIELD_DESC = new org.apache.thrift.protocol.TField("checkpointWritePointers", org.apache.thrift.protocol.TType.LIST, (short)8); |
| private static final org.apache.thrift.protocol.TField VISIBILITY_LEVEL_FIELD_DESC = new org.apache.thrift.protocol.TField("visibilityLevel", org.apache.thrift.protocol.TType.I32, (short)9); |
| |
| private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); |
| static { |
| schemes.put(StandardScheme.class, new TTransactionStandardSchemeFactory()); |
| schemes.put(TupleScheme.class, new TTransactionTupleSchemeFactory()); |
| } |
| |
| public long transactionId; // required |
| public long readPointer; // required |
| public List<Long> invalids; // required |
| public List<Long> inProgress; // required |
| public long firstShort; // required |
| /** |
| * |
| * @see TTransactionType |
| */ |
| public TTransactionType type; // required |
| public long writePointer; // required |
| public List<Long> checkpointWritePointers; // required |
| /** |
| * |
| * @see TVisibilityLevel |
| */ |
| public TVisibilityLevel visibilityLevel; // 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 { |
| TRANSACTION_ID((short)1, "transactionId"), |
| READ_POINTER((short)2, "readPointer"), |
| INVALIDS((short)3, "invalids"), |
| IN_PROGRESS((short)4, "inProgress"), |
| FIRST_SHORT((short)5, "firstShort"), |
| /** |
| * |
| * @see TTransactionType |
| */ |
| TYPE((short)6, "type"), |
| WRITE_POINTER((short)7, "writePointer"), |
| CHECKPOINT_WRITE_POINTERS((short)8, "checkpointWritePointers"), |
| /** |
| * |
| * @see TVisibilityLevel |
| */ |
| VISIBILITY_LEVEL((short)9, "visibilityLevel"); |
| |
| 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: // TRANSACTION_ID |
| return TRANSACTION_ID; |
| case 2: // READ_POINTER |
| return READ_POINTER; |
| case 3: // INVALIDS |
| return INVALIDS; |
| case 4: // IN_PROGRESS |
| return IN_PROGRESS; |
| case 5: // FIRST_SHORT |
| return FIRST_SHORT; |
| case 6: // TYPE |
| return TYPE; |
| case 7: // WRITE_POINTER |
| return WRITE_POINTER; |
| case 8: // CHECKPOINT_WRITE_POINTERS |
| return CHECKPOINT_WRITE_POINTERS; |
| case 9: // VISIBILITY_LEVEL |
| return VISIBILITY_LEVEL; |
| 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 __TRANSACTIONID_ISSET_ID = 0; |
| private static final int __READPOINTER_ISSET_ID = 1; |
| private static final int __FIRSTSHORT_ISSET_ID = 2; |
| private static final int __WRITEPOINTER_ISSET_ID = 3; |
| private byte __isset_bitfield = 0; |
| 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.TRANSACTION_ID, new org.apache.thrift.meta_data.FieldMetaData("transactionId", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); |
| tmpMap.put(_Fields.READ_POINTER, new org.apache.thrift.meta_data.FieldMetaData("readPointer", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); |
| tmpMap.put(_Fields.INVALIDS, new org.apache.thrift.meta_data.FieldMetaData("invalids", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)))); |
| tmpMap.put(_Fields.IN_PROGRESS, new org.apache.thrift.meta_data.FieldMetaData("inProgress", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)))); |
| tmpMap.put(_Fields.FIRST_SHORT, new org.apache.thrift.meta_data.FieldMetaData("firstShort", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); |
| tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TTransactionType.class))); |
| tmpMap.put(_Fields.WRITE_POINTER, new org.apache.thrift.meta_data.FieldMetaData("writePointer", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); |
| tmpMap.put(_Fields.CHECKPOINT_WRITE_POINTERS, new org.apache.thrift.meta_data.FieldMetaData("checkpointWritePointers", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, |
| new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)))); |
| tmpMap.put(_Fields.VISIBILITY_LEVEL, new org.apache.thrift.meta_data.FieldMetaData("visibilityLevel", org.apache.thrift.TFieldRequirementType.DEFAULT, |
| new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TVisibilityLevel.class))); |
| metaDataMap = Collections.unmodifiableMap(tmpMap); |
| org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTransaction.class, metaDataMap); |
| } |
| |
| public TTransaction() { |
| } |
| |
| public TTransaction( |
| long transactionId, |
| long readPointer, |
| List<Long> invalids, |
| List<Long> inProgress, |
| long firstShort, |
| TTransactionType type, |
| long writePointer, |
| List<Long> checkpointWritePointers, |
| TVisibilityLevel visibilityLevel) |
| { |
| this(); |
| this.transactionId = transactionId; |
| setTransactionIdIsSet(true); |
| this.readPointer = readPointer; |
| setReadPointerIsSet(true); |
| this.invalids = invalids; |
| this.inProgress = inProgress; |
| this.firstShort = firstShort; |
| setFirstShortIsSet(true); |
| this.type = type; |
| this.writePointer = writePointer; |
| setWritePointerIsSet(true); |
| this.checkpointWritePointers = checkpointWritePointers; |
| this.visibilityLevel = visibilityLevel; |
| } |
| |
| /** |
| * Performs a deep copy on <i>other</i>. |
| */ |
| public TTransaction(TTransaction other) { |
| __isset_bitfield = other.__isset_bitfield; |
| this.transactionId = other.transactionId; |
| this.readPointer = other.readPointer; |
| if (other.isSetInvalids()) { |
| List<Long> __this__invalids = new ArrayList<Long>(); |
| for (Long other_element : other.invalids) { |
| __this__invalids.add(other_element); |
| } |
| this.invalids = __this__invalids; |
| } |
| if (other.isSetInProgress()) { |
| List<Long> __this__inProgress = new ArrayList<Long>(); |
| for (Long other_element : other.inProgress) { |
| __this__inProgress.add(other_element); |
| } |
| this.inProgress = __this__inProgress; |
| } |
| this.firstShort = other.firstShort; |
| if (other.isSetType()) { |
| this.type = other.type; |
| } |
| this.writePointer = other.writePointer; |
| if (other.isSetCheckpointWritePointers()) { |
| List<Long> __this__checkpointWritePointers = new ArrayList<Long>(); |
| for (Long other_element : other.checkpointWritePointers) { |
| __this__checkpointWritePointers.add(other_element); |
| } |
| this.checkpointWritePointers = __this__checkpointWritePointers; |
| } |
| if (other.isSetVisibilityLevel()) { |
| this.visibilityLevel = other.visibilityLevel; |
| } |
| } |
| |
| public TTransaction deepCopy() { |
| return new TTransaction(this); |
| } |
| |
| @Override |
| public void clear() { |
| setTransactionIdIsSet(false); |
| this.transactionId = 0; |
| setReadPointerIsSet(false); |
| this.readPointer = 0; |
| this.invalids = null; |
| this.inProgress = null; |
| setFirstShortIsSet(false); |
| this.firstShort = 0; |
| this.type = null; |
| setWritePointerIsSet(false); |
| this.writePointer = 0; |
| this.checkpointWritePointers = null; |
| this.visibilityLevel = null; |
| } |
| |
| public long getTransactionId() { |
| return this.transactionId; |
| } |
| |
| public TTransaction setTransactionId(long transactionId) { |
| this.transactionId = transactionId; |
| setTransactionIdIsSet(true); |
| return this; |
| } |
| |
| public void unsetTransactionId() { |
| __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TRANSACTIONID_ISSET_ID); |
| } |
| |
| /** Returns true if field transactionId is set (has been assigned a value) and false otherwise */ |
| public boolean isSetTransactionId() { |
| return EncodingUtils.testBit(__isset_bitfield, __TRANSACTIONID_ISSET_ID); |
| } |
| |
| public void setTransactionIdIsSet(boolean value) { |
| __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TRANSACTIONID_ISSET_ID, value); |
| } |
| |
| public long getReadPointer() { |
| return this.readPointer; |
| } |
| |
| public TTransaction setReadPointer(long readPointer) { |
| this.readPointer = readPointer; |
| setReadPointerIsSet(true); |
| return this; |
| } |
| |
| public void unsetReadPointer() { |
| __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __READPOINTER_ISSET_ID); |
| } |
| |
| /** Returns true if field readPointer is set (has been assigned a value) and false otherwise */ |
| public boolean isSetReadPointer() { |
| return EncodingUtils.testBit(__isset_bitfield, __READPOINTER_ISSET_ID); |
| } |
| |
| public void setReadPointerIsSet(boolean value) { |
| __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __READPOINTER_ISSET_ID, value); |
| } |
| |
| public int getInvalidsSize() { |
| return (this.invalids == null) ? 0 : this.invalids.size(); |
| } |
| |
| public java.util.Iterator<Long> getInvalidsIterator() { |
| return (this.invalids == null) ? null : this.invalids.iterator(); |
| } |
| |
| public void addToInvalids(long elem) { |
| if (this.invalids == null) { |
| this.invalids = new ArrayList<Long>(); |
| } |
| this.invalids.add(elem); |
| } |
| |
| public List<Long> getInvalids() { |
| return this.invalids; |
| } |
| |
| public TTransaction setInvalids(List<Long> invalids) { |
| this.invalids = invalids; |
| return this; |
| } |
| |
| public void unsetInvalids() { |
| this.invalids = null; |
| } |
| |
| /** Returns true if field invalids is set (has been assigned a value) and false otherwise */ |
| public boolean isSetInvalids() { |
| return this.invalids != null; |
| } |
| |
| public void setInvalidsIsSet(boolean value) { |
| if (!value) { |
| this.invalids = null; |
| } |
| } |
| |
| public int getInProgressSize() { |
| return (this.inProgress == null) ? 0 : this.inProgress.size(); |
| } |
| |
| public java.util.Iterator<Long> getInProgressIterator() { |
| return (this.inProgress == null) ? null : this.inProgress.iterator(); |
| } |
| |
| public void addToInProgress(long elem) { |
| if (this.inProgress == null) { |
| this.inProgress = new ArrayList<Long>(); |
| } |
| this.inProgress.add(elem); |
| } |
| |
| public List<Long> getInProgress() { |
| return this.inProgress; |
| } |
| |
| public TTransaction setInProgress(List<Long> inProgress) { |
| this.inProgress = inProgress; |
| return this; |
| } |
| |
| public void unsetInProgress() { |
| this.inProgress = null; |
| } |
| |
| /** Returns true if field inProgress is set (has been assigned a value) and false otherwise */ |
| public boolean isSetInProgress() { |
| return this.inProgress != null; |
| } |
| |
| public void setInProgressIsSet(boolean value) { |
| if (!value) { |
| this.inProgress = null; |
| } |
| } |
| |
| public long getFirstShort() { |
| return this.firstShort; |
| } |
| |
| public TTransaction setFirstShort(long firstShort) { |
| this.firstShort = firstShort; |
| setFirstShortIsSet(true); |
| return this; |
| } |
| |
| public void unsetFirstShort() { |
| __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FIRSTSHORT_ISSET_ID); |
| } |
| |
| /** Returns true if field firstShort is set (has been assigned a value) and false otherwise */ |
| public boolean isSetFirstShort() { |
| return EncodingUtils.testBit(__isset_bitfield, __FIRSTSHORT_ISSET_ID); |
| } |
| |
| public void setFirstShortIsSet(boolean value) { |
| __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FIRSTSHORT_ISSET_ID, value); |
| } |
| |
| /** |
| * |
| * @see TTransactionType |
| */ |
| public TTransactionType getType() { |
| return this.type; |
| } |
| |
| /** |
| * |
| * @see TTransactionType |
| */ |
| public TTransaction setType(TTransactionType type) { |
| this.type = type; |
| return this; |
| } |
| |
| public void unsetType() { |
| this.type = null; |
| } |
| |
| /** Returns true if field type is set (has been assigned a value) and false otherwise */ |
| public boolean isSetType() { |
| return this.type != null; |
| } |
| |
| public void setTypeIsSet(boolean value) { |
| if (!value) { |
| this.type = null; |
| } |
| } |
| |
| public long getWritePointer() { |
| return this.writePointer; |
| } |
| |
| public TTransaction setWritePointer(long writePointer) { |
| this.writePointer = writePointer; |
| setWritePointerIsSet(true); |
| return this; |
| } |
| |
| public void unsetWritePointer() { |
| __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __WRITEPOINTER_ISSET_ID); |
| } |
| |
| /** Returns true if field writePointer is set (has been assigned a value) and false otherwise */ |
| public boolean isSetWritePointer() { |
| return EncodingUtils.testBit(__isset_bitfield, __WRITEPOINTER_ISSET_ID); |
| } |
| |
| public void setWritePointerIsSet(boolean value) { |
| __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __WRITEPOINTER_ISSET_ID, value); |
| } |
| |
| public int getCheckpointWritePointersSize() { |
| return (this.checkpointWritePointers == null) ? 0 : this.checkpointWritePointers.size(); |
| } |
| |
| public java.util.Iterator<Long> getCheckpointWritePointersIterator() { |
| return (this.checkpointWritePointers == null) ? null : this.checkpointWritePointers.iterator(); |
| } |
| |
| public void addToCheckpointWritePointers(long elem) { |
| if (this.checkpointWritePointers == null) { |
| this.checkpointWritePointers = new ArrayList<Long>(); |
| } |
| this.checkpointWritePointers.add(elem); |
| } |
| |
| public List<Long> getCheckpointWritePointers() { |
| return this.checkpointWritePointers; |
| } |
| |
| public TTransaction setCheckpointWritePointers(List<Long> checkpointWritePointers) { |
| this.checkpointWritePointers = checkpointWritePointers; |
| return this; |
| } |
| |
| public void unsetCheckpointWritePointers() { |
| this.checkpointWritePointers = null; |
| } |
| |
| /** Returns true if field checkpointWritePointers is set (has been assigned a value) and false otherwise */ |
| public boolean isSetCheckpointWritePointers() { |
| return this.checkpointWritePointers != null; |
| } |
| |
| public void setCheckpointWritePointersIsSet(boolean value) { |
| if (!value) { |
| this.checkpointWritePointers = null; |
| } |
| } |
| |
| /** |
| * |
| * @see TVisibilityLevel |
| */ |
| public TVisibilityLevel getVisibilityLevel() { |
| return this.visibilityLevel; |
| } |
| |
| /** |
| * |
| * @see TVisibilityLevel |
| */ |
| public TTransaction setVisibilityLevel(TVisibilityLevel visibilityLevel) { |
| this.visibilityLevel = visibilityLevel; |
| return this; |
| } |
| |
| public void unsetVisibilityLevel() { |
| this.visibilityLevel = null; |
| } |
| |
| /** Returns true if field visibilityLevel is set (has been assigned a value) and false otherwise */ |
| public boolean isSetVisibilityLevel() { |
| return this.visibilityLevel != null; |
| } |
| |
| public void setVisibilityLevelIsSet(boolean value) { |
| if (!value) { |
| this.visibilityLevel = null; |
| } |
| } |
| |
| public void setFieldValue(_Fields field, Object value) { |
| switch (field) { |
| case TRANSACTION_ID: |
| if (value == null) { |
| unsetTransactionId(); |
| } else { |
| setTransactionId((Long)value); |
| } |
| break; |
| |
| case READ_POINTER: |
| if (value == null) { |
| unsetReadPointer(); |
| } else { |
| setReadPointer((Long)value); |
| } |
| break; |
| |
| case INVALIDS: |
| if (value == null) { |
| unsetInvalids(); |
| } else { |
| setInvalids((List<Long>)value); |
| } |
| break; |
| |
| case IN_PROGRESS: |
| if (value == null) { |
| unsetInProgress(); |
| } else { |
| setInProgress((List<Long>)value); |
| } |
| break; |
| |
| case FIRST_SHORT: |
| if (value == null) { |
| unsetFirstShort(); |
| } else { |
| setFirstShort((Long)value); |
| } |
| break; |
| |
| case TYPE: |
| if (value == null) { |
| unsetType(); |
| } else { |
| setType((TTransactionType)value); |
| } |
| break; |
| |
| case WRITE_POINTER: |
| if (value == null) { |
| unsetWritePointer(); |
| } else { |
| setWritePointer((Long)value); |
| } |
| break; |
| |
| case CHECKPOINT_WRITE_POINTERS: |
| if (value == null) { |
| unsetCheckpointWritePointers(); |
| } else { |
| setCheckpointWritePointers((List<Long>)value); |
| } |
| break; |
| |
| case VISIBILITY_LEVEL: |
| if (value == null) { |
| unsetVisibilityLevel(); |
| } else { |
| setVisibilityLevel((TVisibilityLevel)value); |
| } |
| break; |
| |
| } |
| } |
| |
| public Object getFieldValue(_Fields field) { |
| switch (field) { |
| case TRANSACTION_ID: |
| return Long.valueOf(getTransactionId()); |
| |
| case READ_POINTER: |
| return Long.valueOf(getReadPointer()); |
| |
| case INVALIDS: |
| return getInvalids(); |
| |
| case IN_PROGRESS: |
| return getInProgress(); |
| |
| case FIRST_SHORT: |
| return Long.valueOf(getFirstShort()); |
| |
| case TYPE: |
| return getType(); |
| |
| case WRITE_POINTER: |
| return Long.valueOf(getWritePointer()); |
| |
| case CHECKPOINT_WRITE_POINTERS: |
| return getCheckpointWritePointers(); |
| |
| case VISIBILITY_LEVEL: |
| return getVisibilityLevel(); |
| |
| } |
| 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 TRANSACTION_ID: |
| return isSetTransactionId(); |
| case READ_POINTER: |
| return isSetReadPointer(); |
| case INVALIDS: |
| return isSetInvalids(); |
| case IN_PROGRESS: |
| return isSetInProgress(); |
| case FIRST_SHORT: |
| return isSetFirstShort(); |
| case TYPE: |
| return isSetType(); |
| case WRITE_POINTER: |
| return isSetWritePointer(); |
| case CHECKPOINT_WRITE_POINTERS: |
| return isSetCheckpointWritePointers(); |
| case VISIBILITY_LEVEL: |
| return isSetVisibilityLevel(); |
| } |
| throw new IllegalStateException(); |
| } |
| |
| @Override |
| public boolean equals(Object that) { |
| if (that == null) |
| return false; |
| if (that instanceof TTransaction) |
| return this.equals((TTransaction)that); |
| return false; |
| } |
| |
| public boolean equals(TTransaction that) { |
| if (that == null) |
| return false; |
| |
| boolean this_present_transactionId = true; |
| boolean that_present_transactionId = true; |
| if (this_present_transactionId || that_present_transactionId) { |
| if (!(this_present_transactionId && that_present_transactionId)) |
| return false; |
| if (this.transactionId != that.transactionId) |
| return false; |
| } |
| |
| boolean this_present_readPointer = true; |
| boolean that_present_readPointer = true; |
| if (this_present_readPointer || that_present_readPointer) { |
| if (!(this_present_readPointer && that_present_readPointer)) |
| return false; |
| if (this.readPointer != that.readPointer) |
| return false; |
| } |
| |
| boolean this_present_invalids = true && this.isSetInvalids(); |
| boolean that_present_invalids = true && that.isSetInvalids(); |
| if (this_present_invalids || that_present_invalids) { |
| if (!(this_present_invalids && that_present_invalids)) |
| return false; |
| if (!this.invalids.equals(that.invalids)) |
| return false; |
| } |
| |
| boolean this_present_inProgress = true && this.isSetInProgress(); |
| boolean that_present_inProgress = true && that.isSetInProgress(); |
| if (this_present_inProgress || that_present_inProgress) { |
| if (!(this_present_inProgress && that_present_inProgress)) |
| return false; |
| if (!this.inProgress.equals(that.inProgress)) |
| return false; |
| } |
| |
| boolean this_present_firstShort = true; |
| boolean that_present_firstShort = true; |
| if (this_present_firstShort || that_present_firstShort) { |
| if (!(this_present_firstShort && that_present_firstShort)) |
| return false; |
| if (this.firstShort != that.firstShort) |
| return false; |
| } |
| |
| boolean this_present_type = true && this.isSetType(); |
| boolean that_present_type = true && that.isSetType(); |
| if (this_present_type || that_present_type) { |
| if (!(this_present_type && that_present_type)) |
| return false; |
| if (!this.type.equals(that.type)) |
| return false; |
| } |
| |
| boolean this_present_writePointer = true; |
| boolean that_present_writePointer = true; |
| if (this_present_writePointer || that_present_writePointer) { |
| if (!(this_present_writePointer && that_present_writePointer)) |
| return false; |
| if (this.writePointer != that.writePointer) |
| return false; |
| } |
| |
| boolean this_present_checkpointWritePointers = true && this.isSetCheckpointWritePointers(); |
| boolean that_present_checkpointWritePointers = true && that.isSetCheckpointWritePointers(); |
| if (this_present_checkpointWritePointers || that_present_checkpointWritePointers) { |
| if (!(this_present_checkpointWritePointers && that_present_checkpointWritePointers)) |
| return false; |
| if (!this.checkpointWritePointers.equals(that.checkpointWritePointers)) |
| return false; |
| } |
| |
| boolean this_present_visibilityLevel = true && this.isSetVisibilityLevel(); |
| boolean that_present_visibilityLevel = true && that.isSetVisibilityLevel(); |
| if (this_present_visibilityLevel || that_present_visibilityLevel) { |
| if (!(this_present_visibilityLevel && that_present_visibilityLevel)) |
| return false; |
| if (!this.visibilityLevel.equals(that.visibilityLevel)) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| return 0; |
| } |
| |
| public int compareTo(TTransaction other) { |
| if (!getClass().equals(other.getClass())) { |
| return getClass().getName().compareTo(other.getClass().getName()); |
| } |
| |
| int lastComparison = 0; |
| TTransaction typedOther = (TTransaction)other; |
| |
| lastComparison = Boolean.valueOf(isSetTransactionId()).compareTo(typedOther.isSetTransactionId()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetTransactionId()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.transactionId, typedOther.transactionId); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetReadPointer()).compareTo(typedOther.isSetReadPointer()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetReadPointer()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.readPointer, typedOther.readPointer); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetInvalids()).compareTo(typedOther.isSetInvalids()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetInvalids()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.invalids, typedOther.invalids); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetInProgress()).compareTo(typedOther.isSetInProgress()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetInProgress()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.inProgress, typedOther.inProgress); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetFirstShort()).compareTo(typedOther.isSetFirstShort()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetFirstShort()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.firstShort, typedOther.firstShort); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetType()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetWritePointer()).compareTo(typedOther.isSetWritePointer()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetWritePointer()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.writePointer, typedOther.writePointer); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetCheckpointWritePointers()).compareTo(typedOther.isSetCheckpointWritePointers()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetCheckpointWritePointers()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.checkpointWritePointers, typedOther.checkpointWritePointers); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| } |
| lastComparison = Boolean.valueOf(isSetVisibilityLevel()).compareTo(typedOther.isSetVisibilityLevel()); |
| if (lastComparison != 0) { |
| return lastComparison; |
| } |
| if (isSetVisibilityLevel()) { |
| lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.visibilityLevel, typedOther.visibilityLevel); |
| 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("TTransaction("); |
| boolean first = true; |
| |
| sb.append("transactionId:"); |
| sb.append(this.transactionId); |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("readPointer:"); |
| sb.append(this.readPointer); |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("invalids:"); |
| if (this.invalids == null) { |
| sb.append("null"); |
| } else { |
| sb.append(this.invalids); |
| } |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("inProgress:"); |
| if (this.inProgress == null) { |
| sb.append("null"); |
| } else { |
| sb.append(this.inProgress); |
| } |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("firstShort:"); |
| sb.append(this.firstShort); |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("type:"); |
| if (this.type == null) { |
| sb.append("null"); |
| } else { |
| sb.append(this.type); |
| } |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("writePointer:"); |
| sb.append(this.writePointer); |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("checkpointWritePointers:"); |
| if (this.checkpointWritePointers == null) { |
| sb.append("null"); |
| } else { |
| sb.append(this.checkpointWritePointers); |
| } |
| first = false; |
| if (!first) sb.append(", "); |
| sb.append("visibilityLevel:"); |
| if (this.visibilityLevel == null) { |
| sb.append("null"); |
| } else { |
| sb.append(this.visibilityLevel); |
| } |
| first = false; |
| sb.append(")"); |
| return sb.toString(); |
| } |
| |
| public void validate() throws org.apache.thrift.TException { |
| // check for required fields |
| // check for sub-struct validity |
| } |
| |
| 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_bitfield = 0; |
| 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 TTransactionStandardSchemeFactory implements SchemeFactory { |
| public TTransactionStandardScheme getScheme() { |
| return new TTransactionStandardScheme(); |
| } |
| } |
| |
| private static class TTransactionStandardScheme extends StandardScheme<TTransaction> { |
| |
| public void read(org.apache.thrift.protocol.TProtocol iprot, TTransaction 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: // TRANSACTION_ID |
| if (schemeField.type == org.apache.thrift.protocol.TType.I64) { |
| struct.transactionId = iprot.readI64(); |
| struct.setTransactionIdIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 2: // READ_POINTER |
| if (schemeField.type == org.apache.thrift.protocol.TType.I64) { |
| struct.readPointer = iprot.readI64(); |
| struct.setReadPointerIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 3: // INVALIDS |
| if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { |
| { |
| org.apache.thrift.protocol.TList _list0 = iprot.readListBegin(); |
| struct.invalids = new ArrayList<Long>(_list0.size); |
| for (int _i1 = 0; _i1 < _list0.size; ++_i1) |
| { |
| long _elem2; // required |
| _elem2 = iprot.readI64(); |
| struct.invalids.add(_elem2); |
| } |
| iprot.readListEnd(); |
| } |
| struct.setInvalidsIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 4: // IN_PROGRESS |
| if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { |
| { |
| org.apache.thrift.protocol.TList _list3 = iprot.readListBegin(); |
| struct.inProgress = new ArrayList<Long>(_list3.size); |
| for (int _i4 = 0; _i4 < _list3.size; ++_i4) |
| { |
| long _elem5; // required |
| _elem5 = iprot.readI64(); |
| struct.inProgress.add(_elem5); |
| } |
| iprot.readListEnd(); |
| } |
| struct.setInProgressIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 5: // FIRST_SHORT |
| if (schemeField.type == org.apache.thrift.protocol.TType.I64) { |
| struct.firstShort = iprot.readI64(); |
| struct.setFirstShortIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 6: // TYPE |
| if (schemeField.type == org.apache.thrift.protocol.TType.I32) { |
| struct.type = TTransactionType.findByValue(iprot.readI32()); |
| struct.setTypeIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 7: // WRITE_POINTER |
| if (schemeField.type == org.apache.thrift.protocol.TType.I64) { |
| struct.writePointer = iprot.readI64(); |
| struct.setWritePointerIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 8: // CHECKPOINT_WRITE_POINTERS |
| if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { |
| { |
| org.apache.thrift.protocol.TList _list6 = iprot.readListBegin(); |
| struct.checkpointWritePointers = new ArrayList<Long>(_list6.size); |
| for (int _i7 = 0; _i7 < _list6.size; ++_i7) |
| { |
| long _elem8; // required |
| _elem8 = iprot.readI64(); |
| struct.checkpointWritePointers.add(_elem8); |
| } |
| iprot.readListEnd(); |
| } |
| struct.setCheckpointWritePointersIsSet(true); |
| } else { |
| org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); |
| } |
| break; |
| case 9: // VISIBILITY_LEVEL |
| if (schemeField.type == org.apache.thrift.protocol.TType.I32) { |
| struct.visibilityLevel = TVisibilityLevel.findByValue(iprot.readI32()); |
| struct.setVisibilityLevelIsSet(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(); |
| |
| // check for required fields of primitive type, which can't be checked in the validate method |
| struct.validate(); |
| } |
| |
| public void write(org.apache.thrift.protocol.TProtocol oprot, TTransaction struct) throws org.apache.thrift.TException { |
| struct.validate(); |
| |
| oprot.writeStructBegin(STRUCT_DESC); |
| oprot.writeFieldBegin(TRANSACTION_ID_FIELD_DESC); |
| oprot.writeI64(struct.transactionId); |
| oprot.writeFieldEnd(); |
| oprot.writeFieldBegin(READ_POINTER_FIELD_DESC); |
| oprot.writeI64(struct.readPointer); |
| oprot.writeFieldEnd(); |
| if (struct.invalids != null) { |
| oprot.writeFieldBegin(INVALIDS_FIELD_DESC); |
| { |
| oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.invalids.size())); |
| for (long _iter9 : struct.invalids) |
| { |
| oprot.writeI64(_iter9); |
| } |
| oprot.writeListEnd(); |
| } |
| oprot.writeFieldEnd(); |
| } |
| if (struct.inProgress != null) { |
| oprot.writeFieldBegin(IN_PROGRESS_FIELD_DESC); |
| { |
| oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.inProgress.size())); |
| for (long _iter10 : struct.inProgress) |
| { |
| oprot.writeI64(_iter10); |
| } |
| oprot.writeListEnd(); |
| } |
| oprot.writeFieldEnd(); |
| } |
| oprot.writeFieldBegin(FIRST_SHORT_FIELD_DESC); |
| oprot.writeI64(struct.firstShort); |
| oprot.writeFieldEnd(); |
| if (struct.type != null) { |
| oprot.writeFieldBegin(TYPE_FIELD_DESC); |
| oprot.writeI32(struct.type.getValue()); |
| oprot.writeFieldEnd(); |
| } |
| oprot.writeFieldBegin(WRITE_POINTER_FIELD_DESC); |
| oprot.writeI64(struct.writePointer); |
| oprot.writeFieldEnd(); |
| if (struct.checkpointWritePointers != null) { |
| oprot.writeFieldBegin(CHECKPOINT_WRITE_POINTERS_FIELD_DESC); |
| { |
| oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.checkpointWritePointers.size())); |
| for (long _iter11 : struct.checkpointWritePointers) |
| { |
| oprot.writeI64(_iter11); |
| } |
| oprot.writeListEnd(); |
| } |
| oprot.writeFieldEnd(); |
| } |
| if (struct.visibilityLevel != null) { |
| oprot.writeFieldBegin(VISIBILITY_LEVEL_FIELD_DESC); |
| oprot.writeI32(struct.visibilityLevel.getValue()); |
| oprot.writeFieldEnd(); |
| } |
| oprot.writeFieldStop(); |
| oprot.writeStructEnd(); |
| } |
| |
| } |
| |
| private static class TTransactionTupleSchemeFactory implements SchemeFactory { |
| public TTransactionTupleScheme getScheme() { |
| return new TTransactionTupleScheme(); |
| } |
| } |
| |
| private static class TTransactionTupleScheme extends TupleScheme<TTransaction> { |
| |
| @Override |
| public void write(org.apache.thrift.protocol.TProtocol prot, TTransaction struct) throws org.apache.thrift.TException { |
| TTupleProtocol oprot = (TTupleProtocol) prot; |
| BitSet optionals = new BitSet(); |
| if (struct.isSetTransactionId()) { |
| optionals.set(0); |
| } |
| if (struct.isSetReadPointer()) { |
| optionals.set(1); |
| } |
| if (struct.isSetInvalids()) { |
| optionals.set(2); |
| } |
| if (struct.isSetInProgress()) { |
| optionals.set(3); |
| } |
| if (struct.isSetFirstShort()) { |
| optionals.set(4); |
| } |
| if (struct.isSetType()) { |
| optionals.set(5); |
| } |
| if (struct.isSetWritePointer()) { |
| optionals.set(6); |
| } |
| if (struct.isSetCheckpointWritePointers()) { |
| optionals.set(7); |
| } |
| if (struct.isSetVisibilityLevel()) { |
| optionals.set(8); |
| } |
| oprot.writeBitSet(optionals, 9); |
| if (struct.isSetTransactionId()) { |
| oprot.writeI64(struct.transactionId); |
| } |
| if (struct.isSetReadPointer()) { |
| oprot.writeI64(struct.readPointer); |
| } |
| if (struct.isSetInvalids()) { |
| { |
| oprot.writeI32(struct.invalids.size()); |
| for (long _iter12 : struct.invalids) |
| { |
| oprot.writeI64(_iter12); |
| } |
| } |
| } |
| if (struct.isSetInProgress()) { |
| { |
| oprot.writeI32(struct.inProgress.size()); |
| for (long _iter13 : struct.inProgress) |
| { |
| oprot.writeI64(_iter13); |
| } |
| } |
| } |
| if (struct.isSetFirstShort()) { |
| oprot.writeI64(struct.firstShort); |
| } |
| if (struct.isSetType()) { |
| oprot.writeI32(struct.type.getValue()); |
| } |
| if (struct.isSetWritePointer()) { |
| oprot.writeI64(struct.writePointer); |
| } |
| if (struct.isSetCheckpointWritePointers()) { |
| { |
| oprot.writeI32(struct.checkpointWritePointers.size()); |
| for (long _iter14 : struct.checkpointWritePointers) |
| { |
| oprot.writeI64(_iter14); |
| } |
| } |
| } |
| if (struct.isSetVisibilityLevel()) { |
| oprot.writeI32(struct.visibilityLevel.getValue()); |
| } |
| } |
| |
| @Override |
| public void read(org.apache.thrift.protocol.TProtocol prot, TTransaction struct) throws org.apache.thrift.TException { |
| TTupleProtocol iprot = (TTupleProtocol) prot; |
| BitSet incoming = iprot.readBitSet(9); |
| if (incoming.get(0)) { |
| struct.transactionId = iprot.readI64(); |
| struct.setTransactionIdIsSet(true); |
| } |
| if (incoming.get(1)) { |
| struct.readPointer = iprot.readI64(); |
| struct.setReadPointerIsSet(true); |
| } |
| if (incoming.get(2)) { |
| { |
| org.apache.thrift.protocol.TList _list15 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); |
| struct.invalids = new ArrayList<Long>(_list15.size); |
| for (int _i16 = 0; _i16 < _list15.size; ++_i16) |
| { |
| long _elem17; // required |
| _elem17 = iprot.readI64(); |
| struct.invalids.add(_elem17); |
| } |
| } |
| struct.setInvalidsIsSet(true); |
| } |
| if (incoming.get(3)) { |
| { |
| org.apache.thrift.protocol.TList _list18 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); |
| struct.inProgress = new ArrayList<Long>(_list18.size); |
| for (int _i19 = 0; _i19 < _list18.size; ++_i19) |
| { |
| long _elem20; // required |
| _elem20 = iprot.readI64(); |
| struct.inProgress.add(_elem20); |
| } |
| } |
| struct.setInProgressIsSet(true); |
| } |
| if (incoming.get(4)) { |
| struct.firstShort = iprot.readI64(); |
| struct.setFirstShortIsSet(true); |
| } |
| if (incoming.get(5)) { |
| struct.type = TTransactionType.findByValue(iprot.readI32()); |
| struct.setTypeIsSet(true); |
| } |
| if (incoming.get(6)) { |
| struct.writePointer = iprot.readI64(); |
| struct.setWritePointerIsSet(true); |
| } |
| if (incoming.get(7)) { |
| { |
| org.apache.thrift.protocol.TList _list21 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); |
| struct.checkpointWritePointers = new ArrayList<Long>(_list21.size); |
| for (int _i22 = 0; _i22 < _list21.size; ++_i22) |
| { |
| long _elem23; // required |
| _elem23 = iprot.readI64(); |
| struct.checkpointWritePointers.add(_elem23); |
| } |
| } |
| struct.setCheckpointWritePointersIsSet(true); |
| } |
| if (incoming.get(8)) { |
| struct.visibilityLevel = TVisibilityLevel.findByValue(iprot.readI32()); |
| struct.setVisibilityLevelIsSet(true); |
| } |
| } |
| } |
| |
| } |
| |
