ezbake.publisher.thrift.PublishData.java Source code

Java tutorial

Introduction

Here is the source code for ezbake.publisher.thrift.PublishData.java

Source

/*   Copyright (C) 2013-2014 Computer Sciences Corporation
 *
 * 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.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package ezbake.publisher.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 org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.server.AbstractNonblockingServer.*;
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 PublishData implements org.apache.thrift.TBase<PublishData, PublishData._Fields>, java.io.Serializable,
        Cloneable, Comparable<PublishData> {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct(
            "PublishData");

    private static final org.apache.thrift.protocol.TField FEEDNAME_FIELD_DESC = new org.apache.thrift.protocol.TField(
            "feedname", org.apache.thrift.protocol.TType.STRING, (short) 1);
    private static final org.apache.thrift.protocol.TField ENTRY_FIELD_DESC = new org.apache.thrift.protocol.TField(
            "entry", org.apache.thrift.protocol.TType.STRUCT, (short) 2);
    private static final org.apache.thrift.protocol.TField SSRJSON_FIELD_DESC = new org.apache.thrift.protocol.TField(
            "ssrjson", org.apache.thrift.protocol.TType.STRUCT, (short) 3);
    private static final org.apache.thrift.protocol.TField PROVENANCE_FIELD_DESC = new org.apache.thrift.protocol.TField(
            "provenance", org.apache.thrift.protocol.TType.STRUCT, (short) 4);
    private static final org.apache.thrift.protocol.TField IGNORE_PROVENANCE_DUPLICATE_FIELD_DESC = new org.apache.thrift.protocol.TField(
            "ignoreProvenanceDuplicate", org.apache.thrift.protocol.TType.BOOL, (short) 5);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
        schemes.put(StandardScheme.class, new PublishDataStandardSchemeFactory());
        schemes.put(TupleScheme.class, new PublishDataTupleSchemeFactory());
    }

    public String feedname; // required
    public ezbake.warehaus.UpdateEntry entry; // required
    public ezbake.frack.common.utils.thrift.SSRJSON ssrjson; // optional
    public ezbake.frack.common.utils.thrift.ProvenanceRegistration provenance; // optional
    public boolean ignoreProvenanceDuplicate; // 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 {
        FEEDNAME((short) 1, "feedname"), ENTRY((short) 2, "entry"), SSRJSON((short) 3, "ssrjson"), PROVENANCE(
                (short) 4, "provenance"), IGNORE_PROVENANCE_DUPLICATE((short) 5, "ignoreProvenanceDuplicate");

        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: // FEEDNAME
                return FEEDNAME;
            case 2: // ENTRY
                return ENTRY;
            case 3: // SSRJSON
                return SSRJSON;
            case 4: // PROVENANCE
                return PROVENANCE;
            case 5: // IGNORE_PROVENANCE_DUPLICATE
                return IGNORE_PROVENANCE_DUPLICATE;
            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 __IGNOREPROVENANCEDUPLICATE_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    private _Fields optionals[] = { _Fields.SSRJSON, _Fields.PROVENANCE, _Fields.IGNORE_PROVENANCE_DUPLICATE };
    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.FEEDNAME, new org.apache.thrift.meta_data.FieldMetaData("feedname",
                org.apache.thrift.TFieldRequirementType.DEFAULT,
                new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
        tmpMap.put(_Fields.ENTRY,
                new org.apache.thrift.meta_data.FieldMetaData("entry",
                        org.apache.thrift.TFieldRequirementType.DEFAULT,
                        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT,
                                ezbake.warehaus.UpdateEntry.class)));
        tmpMap.put(_Fields.SSRJSON,
                new org.apache.thrift.meta_data.FieldMetaData("ssrjson",
                        org.apache.thrift.TFieldRequirementType.OPTIONAL,
                        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT,
                                ezbake.frack.common.utils.thrift.SSRJSON.class)));
        tmpMap.put(_Fields.PROVENANCE,
                new org.apache.thrift.meta_data.FieldMetaData("provenance",
                        org.apache.thrift.TFieldRequirementType.OPTIONAL,
                        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT,
                                ezbake.frack.common.utils.thrift.ProvenanceRegistration.class)));
        tmpMap.put(_Fields.IGNORE_PROVENANCE_DUPLICATE,
                new org.apache.thrift.meta_data.FieldMetaData("ignoreProvenanceDuplicate",
                        org.apache.thrift.TFieldRequirementType.OPTIONAL,
                        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
        metaDataMap = Collections.unmodifiableMap(tmpMap);
        org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PublishData.class, metaDataMap);
    }

    public PublishData() {
        this.ignoreProvenanceDuplicate = false;

    }

    public PublishData(String feedname, ezbake.warehaus.UpdateEntry entry) {
        this();
        this.feedname = feedname;
        this.entry = entry;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public PublishData(PublishData other) {
        __isset_bitfield = other.__isset_bitfield;
        if (other.isSetFeedname()) {
            this.feedname = other.feedname;
        }
        if (other.isSetEntry()) {
            this.entry = new ezbake.warehaus.UpdateEntry(other.entry);
        }
        if (other.isSetSsrjson()) {
            this.ssrjson = new ezbake.frack.common.utils.thrift.SSRJSON(other.ssrjson);
        }
        if (other.isSetProvenance()) {
            this.provenance = new ezbake.frack.common.utils.thrift.ProvenanceRegistration(other.provenance);
        }
        this.ignoreProvenanceDuplicate = other.ignoreProvenanceDuplicate;
    }

    public PublishData deepCopy() {
        return new PublishData(this);
    }

    @Override
    public void clear() {
        this.feedname = null;
        this.entry = null;
        this.ssrjson = null;
        this.provenance = null;
        this.ignoreProvenanceDuplicate = false;

    }

    public String getFeedname() {
        return this.feedname;
    }

    public PublishData setFeedname(String feedname) {
        this.feedname = feedname;
        return this;
    }

    public void unsetFeedname() {
        this.feedname = null;
    }

    /** Returns true if field feedname is set (has been assigned a value) and false otherwise */
    public boolean isSetFeedname() {
        return this.feedname != null;
    }

    public void setFeednameIsSet(boolean value) {
        if (!value) {
            this.feedname = null;
        }
    }

    public ezbake.warehaus.UpdateEntry getEntry() {
        return this.entry;
    }

    public PublishData setEntry(ezbake.warehaus.UpdateEntry entry) {
        this.entry = entry;
        return this;
    }

    public void unsetEntry() {
        this.entry = null;
    }

    /** Returns true if field entry is set (has been assigned a value) and false otherwise */
    public boolean isSetEntry() {
        return this.entry != null;
    }

    public void setEntryIsSet(boolean value) {
        if (!value) {
            this.entry = null;
        }
    }

    public ezbake.frack.common.utils.thrift.SSRJSON getSsrjson() {
        return this.ssrjson;
    }

    public PublishData setSsrjson(ezbake.frack.common.utils.thrift.SSRJSON ssrjson) {
        this.ssrjson = ssrjson;
        return this;
    }

    public void unsetSsrjson() {
        this.ssrjson = null;
    }

    /** Returns true if field ssrjson is set (has been assigned a value) and false otherwise */
    public boolean isSetSsrjson() {
        return this.ssrjson != null;
    }

    public void setSsrjsonIsSet(boolean value) {
        if (!value) {
            this.ssrjson = null;
        }
    }

    public ezbake.frack.common.utils.thrift.ProvenanceRegistration getProvenance() {
        return this.provenance;
    }

    public PublishData setProvenance(ezbake.frack.common.utils.thrift.ProvenanceRegistration provenance) {
        this.provenance = provenance;
        return this;
    }

    public void unsetProvenance() {
        this.provenance = null;
    }

    /** Returns true if field provenance is set (has been assigned a value) and false otherwise */
    public boolean isSetProvenance() {
        return this.provenance != null;
    }

    public void setProvenanceIsSet(boolean value) {
        if (!value) {
            this.provenance = null;
        }
    }

    public boolean isIgnoreProvenanceDuplicate() {
        return this.ignoreProvenanceDuplicate;
    }

    public PublishData setIgnoreProvenanceDuplicate(boolean ignoreProvenanceDuplicate) {
        this.ignoreProvenanceDuplicate = ignoreProvenanceDuplicate;
        setIgnoreProvenanceDuplicateIsSet(true);
        return this;
    }

    public void unsetIgnoreProvenanceDuplicate() {
        __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __IGNOREPROVENANCEDUPLICATE_ISSET_ID);
    }

    /** Returns true if field ignoreProvenanceDuplicate is set (has been assigned a value) and false otherwise */
    public boolean isSetIgnoreProvenanceDuplicate() {
        return EncodingUtils.testBit(__isset_bitfield, __IGNOREPROVENANCEDUPLICATE_ISSET_ID);
    }

    public void setIgnoreProvenanceDuplicateIsSet(boolean value) {
        __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __IGNOREPROVENANCEDUPLICATE_ISSET_ID, value);
    }

    public void setFieldValue(_Fields field, Object value) {
        switch (field) {
        case FEEDNAME:
            if (value == null) {
                unsetFeedname();
            } else {
                setFeedname((String) value);
            }
            break;

        case ENTRY:
            if (value == null) {
                unsetEntry();
            } else {
                setEntry((ezbake.warehaus.UpdateEntry) value);
            }
            break;

        case SSRJSON:
            if (value == null) {
                unsetSsrjson();
            } else {
                setSsrjson((ezbake.frack.common.utils.thrift.SSRJSON) value);
            }
            break;

        case PROVENANCE:
            if (value == null) {
                unsetProvenance();
            } else {
                setProvenance((ezbake.frack.common.utils.thrift.ProvenanceRegistration) value);
            }
            break;

        case IGNORE_PROVENANCE_DUPLICATE:
            if (value == null) {
                unsetIgnoreProvenanceDuplicate();
            } else {
                setIgnoreProvenanceDuplicate((Boolean) value);
            }
            break;

        }
    }

    public Object getFieldValue(_Fields field) {
        switch (field) {
        case FEEDNAME:
            return getFeedname();

        case ENTRY:
            return getEntry();

        case SSRJSON:
            return getSsrjson();

        case PROVENANCE:
            return getProvenance();

        case IGNORE_PROVENANCE_DUPLICATE:
            return Boolean.valueOf(isIgnoreProvenanceDuplicate());

        }
        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 FEEDNAME:
            return isSetFeedname();
        case ENTRY:
            return isSetEntry();
        case SSRJSON:
            return isSetSsrjson();
        case PROVENANCE:
            return isSetProvenance();
        case IGNORE_PROVENANCE_DUPLICATE:
            return isSetIgnoreProvenanceDuplicate();
        }
        throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
        if (that == null)
            return false;
        if (that instanceof PublishData)
            return this.equals((PublishData) that);
        return false;
    }

    public boolean equals(PublishData that) {
        if (that == null)
            return false;

        boolean this_present_feedname = true && this.isSetFeedname();
        boolean that_present_feedname = true && that.isSetFeedname();
        if (this_present_feedname || that_present_feedname) {
            if (!(this_present_feedname && that_present_feedname))
                return false;
            if (!this.feedname.equals(that.feedname))
                return false;
        }

        boolean this_present_entry = true && this.isSetEntry();
        boolean that_present_entry = true && that.isSetEntry();
        if (this_present_entry || that_present_entry) {
            if (!(this_present_entry && that_present_entry))
                return false;
            if (!this.entry.equals(that.entry))
                return false;
        }

        boolean this_present_ssrjson = true && this.isSetSsrjson();
        boolean that_present_ssrjson = true && that.isSetSsrjson();
        if (this_present_ssrjson || that_present_ssrjson) {
            if (!(this_present_ssrjson && that_present_ssrjson))
                return false;
            if (!this.ssrjson.equals(that.ssrjson))
                return false;
        }

        boolean this_present_provenance = true && this.isSetProvenance();
        boolean that_present_provenance = true && that.isSetProvenance();
        if (this_present_provenance || that_present_provenance) {
            if (!(this_present_provenance && that_present_provenance))
                return false;
            if (!this.provenance.equals(that.provenance))
                return false;
        }

        boolean this_present_ignoreProvenanceDuplicate = true && this.isSetIgnoreProvenanceDuplicate();
        boolean that_present_ignoreProvenanceDuplicate = true && that.isSetIgnoreProvenanceDuplicate();
        if (this_present_ignoreProvenanceDuplicate || that_present_ignoreProvenanceDuplicate) {
            if (!(this_present_ignoreProvenanceDuplicate && that_present_ignoreProvenanceDuplicate))
                return false;
            if (this.ignoreProvenanceDuplicate != that.ignoreProvenanceDuplicate)
                return false;
        }

        return true;
    }

    @Override
    public int hashCode() {
        return 0;
    }

    @Override
    public int compareTo(PublishData other) {
        if (!getClass().equals(other.getClass())) {
            return getClass().getName().compareTo(other.getClass().getName());
        }

        int lastComparison = 0;

        lastComparison = Boolean.valueOf(isSetFeedname()).compareTo(other.isSetFeedname());
        if (lastComparison != 0) {
            return lastComparison;
        }
        if (isSetFeedname()) {
            lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.feedname, other.feedname);
            if (lastComparison != 0) {
                return lastComparison;
            }
        }
        lastComparison = Boolean.valueOf(isSetEntry()).compareTo(other.isSetEntry());
        if (lastComparison != 0) {
            return lastComparison;
        }
        if (isSetEntry()) {
            lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.entry, other.entry);
            if (lastComparison != 0) {
                return lastComparison;
            }
        }
        lastComparison = Boolean.valueOf(isSetSsrjson()).compareTo(other.isSetSsrjson());
        if (lastComparison != 0) {
            return lastComparison;
        }
        if (isSetSsrjson()) {
            lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ssrjson, other.ssrjson);
            if (lastComparison != 0) {
                return lastComparison;
            }
        }
        lastComparison = Boolean.valueOf(isSetProvenance()).compareTo(other.isSetProvenance());
        if (lastComparison != 0) {
            return lastComparison;
        }
        if (isSetProvenance()) {
            lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.provenance, other.provenance);
            if (lastComparison != 0) {
                return lastComparison;
            }
        }
        lastComparison = Boolean.valueOf(isSetIgnoreProvenanceDuplicate())
                .compareTo(other.isSetIgnoreProvenanceDuplicate());
        if (lastComparison != 0) {
            return lastComparison;
        }
        if (isSetIgnoreProvenanceDuplicate()) {
            lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ignoreProvenanceDuplicate,
                    other.ignoreProvenanceDuplicate);
            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("PublishData(");
        boolean first = true;

        sb.append("feedname:");
        if (this.feedname == null) {
            sb.append("null");
        } else {
            sb.append(this.feedname);
        }
        first = false;
        if (!first)
            sb.append(", ");
        sb.append("entry:");
        if (this.entry == null) {
            sb.append("null");
        } else {
            sb.append(this.entry);
        }
        first = false;
        if (isSetSsrjson()) {
            if (!first)
                sb.append(", ");
            sb.append("ssrjson:");
            if (this.ssrjson == null) {
                sb.append("null");
            } else {
                sb.append(this.ssrjson);
            }
            first = false;
        }
        if (isSetProvenance()) {
            if (!first)
                sb.append(", ");
            sb.append("provenance:");
            if (this.provenance == null) {
                sb.append("null");
            } else {
                sb.append(this.provenance);
            }
            first = false;
        }
        if (isSetIgnoreProvenanceDuplicate()) {
            if (!first)
                sb.append(", ");
            sb.append("ignoreProvenanceDuplicate:");
            sb.append(this.ignoreProvenanceDuplicate);
            first = false;
        }
        sb.append(")");
        return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
        // check for required fields
        // check for sub-struct validity
        if (entry != null) {
            entry.validate();
        }
        if (ssrjson != null) {
            ssrjson.validate();
        }
        if (provenance != null) {
            provenance.validate();
        }
    }

    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 PublishDataStandardSchemeFactory implements SchemeFactory {
        public PublishDataStandardScheme getScheme() {
            return new PublishDataStandardScheme();
        }
    }

    private static class PublishDataStandardScheme extends StandardScheme<PublishData> {

        public void read(org.apache.thrift.protocol.TProtocol iprot, PublishData 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: // FEEDNAME
                    if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                        struct.feedname = iprot.readString();
                        struct.setFeednameIsSet(true);
                    } else {
                        org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
                    }
                    break;
                case 2: // ENTRY
                    if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                        struct.entry = new ezbake.warehaus.UpdateEntry();
                        struct.entry.read(iprot);
                        struct.setEntryIsSet(true);
                    } else {
                        org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
                    }
                    break;
                case 3: // SSRJSON
                    if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                        struct.ssrjson = new ezbake.frack.common.utils.thrift.SSRJSON();
                        struct.ssrjson.read(iprot);
                        struct.setSsrjsonIsSet(true);
                    } else {
                        org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
                    }
                    break;
                case 4: // PROVENANCE
                    if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                        struct.provenance = new ezbake.frack.common.utils.thrift.ProvenanceRegistration();
                        struct.provenance.read(iprot);
                        struct.setProvenanceIsSet(true);
                    } else {
                        org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
                    }
                    break;
                case 5: // IGNORE_PROVENANCE_DUPLICATE
                    if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
                        struct.ignoreProvenanceDuplicate = iprot.readBool();
                        struct.setIgnoreProvenanceDuplicateIsSet(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, PublishData struct)
                throws org.apache.thrift.TException {
            struct.validate();

            oprot.writeStructBegin(STRUCT_DESC);
            if (struct.feedname != null) {
                oprot.writeFieldBegin(FEEDNAME_FIELD_DESC);
                oprot.writeString(struct.feedname);
                oprot.writeFieldEnd();
            }
            if (struct.entry != null) {
                oprot.writeFieldBegin(ENTRY_FIELD_DESC);
                struct.entry.write(oprot);
                oprot.writeFieldEnd();
            }
            if (struct.ssrjson != null) {
                if (struct.isSetSsrjson()) {
                    oprot.writeFieldBegin(SSRJSON_FIELD_DESC);
                    struct.ssrjson.write(oprot);
                    oprot.writeFieldEnd();
                }
            }
            if (struct.provenance != null) {
                if (struct.isSetProvenance()) {
                    oprot.writeFieldBegin(PROVENANCE_FIELD_DESC);
                    struct.provenance.write(oprot);
                    oprot.writeFieldEnd();
                }
            }
            if (struct.isSetIgnoreProvenanceDuplicate()) {
                oprot.writeFieldBegin(IGNORE_PROVENANCE_DUPLICATE_FIELD_DESC);
                oprot.writeBool(struct.ignoreProvenanceDuplicate);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

    }

    private static class PublishDataTupleSchemeFactory implements SchemeFactory {
        public PublishDataTupleScheme getScheme() {
            return new PublishDataTupleScheme();
        }
    }

    private static class PublishDataTupleScheme extends TupleScheme<PublishData> {

        @Override
        public void write(org.apache.thrift.protocol.TProtocol prot, PublishData struct)
                throws org.apache.thrift.TException {
            TTupleProtocol oprot = (TTupleProtocol) prot;
            BitSet optionals = new BitSet();
            if (struct.isSetFeedname()) {
                optionals.set(0);
            }
            if (struct.isSetEntry()) {
                optionals.set(1);
            }
            if (struct.isSetSsrjson()) {
                optionals.set(2);
            }
            if (struct.isSetProvenance()) {
                optionals.set(3);
            }
            if (struct.isSetIgnoreProvenanceDuplicate()) {
                optionals.set(4);
            }
            oprot.writeBitSet(optionals, 5);
            if (struct.isSetFeedname()) {
                oprot.writeString(struct.feedname);
            }
            if (struct.isSetEntry()) {
                struct.entry.write(oprot);
            }
            if (struct.isSetSsrjson()) {
                struct.ssrjson.write(oprot);
            }
            if (struct.isSetProvenance()) {
                struct.provenance.write(oprot);
            }
            if (struct.isSetIgnoreProvenanceDuplicate()) {
                oprot.writeBool(struct.ignoreProvenanceDuplicate);
            }
        }

        @Override
        public void read(org.apache.thrift.protocol.TProtocol prot, PublishData struct)
                throws org.apache.thrift.TException {
            TTupleProtocol iprot = (TTupleProtocol) prot;
            BitSet incoming = iprot.readBitSet(5);
            if (incoming.get(0)) {
                struct.feedname = iprot.readString();
                struct.setFeednameIsSet(true);
            }
            if (incoming.get(1)) {
                struct.entry = new ezbake.warehaus.UpdateEntry();
                struct.entry.read(iprot);
                struct.setEntryIsSet(true);
            }
            if (incoming.get(2)) {
                struct.ssrjson = new ezbake.frack.common.utils.thrift.SSRJSON();
                struct.ssrjson.read(iprot);
                struct.setSsrjsonIsSet(true);
            }
            if (incoming.get(3)) {
                struct.provenance = new ezbake.frack.common.utils.thrift.ProvenanceRegistration();
                struct.provenance.read(iprot);
                struct.setProvenanceIsSet(true);
            }
            if (incoming.get(4)) {
                struct.ignoreProvenanceDuplicate = iprot.readBool();
                struct.setIgnoreProvenanceDuplicateIsSet(true);
            }
        }
    }

}