public Map<String, Long> getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_getCounters();
            }
        }

        public void getCounter(String key, AsyncMethodCallback<getCounter_call> resultHandler) throws TException {
            checkReady();
            getCounter_call method_call = new getCounter_call(key, resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class getCounter_call extends TAsyncMethodCall {
            private String key;

            public getCounter_call(String key, AsyncMethodCallback<getCounter_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
                this.key = key;
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("getCounter", TMessageType.CALL, 0));
                getCounter_args args = new getCounter_args();
                args.setKey(key);
                args.write(prot);
                prot.writeMessageEnd();
            }

            public long getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_getCounter();
            }
        }

        public void setOption(String key, String value, AsyncMethodCallback<setOption_call> resultHandler) throws TException {
            checkReady();
            setOption_call method_call = new setOption_call(key, value, resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class setOption_call extends TAsyncMethodCall {
            private String key;
            private String value;

            public setOption_call(String key, String value, AsyncMethodCallback<setOption_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
                this.key = key;
                this.value = value;
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("setOption", TMessageType.CALL, 0));
                setOption_args args = new setOption_args();
                args.setKey(key);
                args.setValue(value);
                args.write(prot);
                prot.writeMessageEnd();
            }

            public void getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                (new Client(prot)).recv_setOption();
            }
        }

        public void getOption(String key, AsyncMethodCallback<getOption_call> resultHandler) throws TException {
            checkReady();
            getOption_call method_call = new getOption_call(key, resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class getOption_call extends TAsyncMethodCall {
            private String key;

            public getOption_call(String key, AsyncMethodCallback<getOption_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
                this.key = key;
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("getOption", TMessageType.CALL, 0));
                getOption_args args = new getOption_args();
                args.setKey(key);
                args.write(prot);
                prot.writeMessageEnd();
            }

            public String getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_getOption();
            }
        }

        public void getOptions(AsyncMethodCallback<getOptions_call> resultHandler) throws TException {
            checkReady();
            getOptions_call method_call = new getOptions_call(resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class getOptions_call extends TAsyncMethodCall {
            public getOptions_call(AsyncMethodCallback<getOptions_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("getOptions", TMessageType.CALL, 0));
                getOptions_args args = new getOptions_args();
                args.write(prot);
                prot.writeMessageEnd();
            }

            public Map<String, String> getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_getOptions();
            }
        }

        public void getCpuProfile(int profileDurationInSec, AsyncMethodCallback<getCpuProfile_call> resultHandler) throws TException {
            checkReady();
            getCpuProfile_call method_call = new getCpuProfile_call(profileDurationInSec, resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class getCpuProfile_call extends TAsyncMethodCall {
            private int profileDurationInSec;

            public getCpuProfile_call(int profileDurationInSec, AsyncMethodCallback<getCpuProfile_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
                this.profileDurationInSec = profileDurationInSec;
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("getCpuProfile", TMessageType.CALL, 0));
                getCpuProfile_args args = new getCpuProfile_args();
                args.setProfileDurationInSec(profileDurationInSec);
                args.write(prot);
                prot.writeMessageEnd();
            }

            public String getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_getCpuProfile();
            }
        }

        public void aliveSince(AsyncMethodCallback<aliveSince_call> resultHandler) throws TException {
            checkReady();
            aliveSince_call method_call = new aliveSince_call(resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class aliveSince_call extends TAsyncMethodCall {
            public aliveSince_call(AsyncMethodCallback<aliveSince_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, false);
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("aliveSince", TMessageType.CALL, 0));
                aliveSince_args args = new aliveSince_args();
                args.write(prot);
                prot.writeMessageEnd();
            }

            public long getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
                return (new Client(prot)).recv_aliveSince();
            }
        }

        public void reinitialize(AsyncMethodCallback<reinitialize_call> resultHandler) throws TException {
            checkReady();
            reinitialize_call method_call = new reinitialize_call(resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class reinitialize_call extends TAsyncMethodCall {
            public reinitialize_call(AsyncMethodCallback<reinitialize_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, true);
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("reinitialize", TMessageType.CALL, 0));
                reinitialize_args args = new reinitialize_args();
                args.write(prot);
                prot.writeMessageEnd();
            }

            public void getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
            }
        }

        public void shutdown(AsyncMethodCallback<shutdown_call> resultHandler) throws TException {
            checkReady();
            shutdown_call method_call = new shutdown_call(resultHandler, this, protocolFactory, transport);
            manager.call(method_call);
        }

        public static class shutdown_call extends TAsyncMethodCall {
            public shutdown_call(AsyncMethodCallback<shutdown_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
                super(client, protocolFactory, transport, resultHandler, true);
            }

            public void write_args(TProtocol prot) throws TException {
                prot.writeMessageBegin(new TMessage("shutdown", TMessageType.CALL, 0));
                shutdown_args args = new shutdown_args();
                args.write(prot);
                prot.writeMessageEnd();
            }

            public void getResult() throws TException {
                if (getState() != State.RESPONSE_READ) {
                    throw new IllegalStateException("Method call not finished!");
                }
                TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
                TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
            }
        }

    }

    public static class Processor implements TProcessor {
        private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());

        public Processor(Iface iface) {
            iface_ = iface;
            processMap_.put("getName", new getName());
            processMap_.put("getVersion", new getVersion());
            processMap_.put("getStatus", new getStatus());
            processMap_.put("getStatusDetails", new getStatusDetails());
            processMap_.put("getCounters", new getCounters());
            processMap_.put("getCounter", new getCounter());
            processMap_.put("setOption", new setOption());
            processMap_.put("getOption", new getOption());
            processMap_.put("getOptions", new getOptions());
            processMap_.put("getCpuProfile", new getCpuProfile());
            processMap_.put("aliveSince", new aliveSince());
            processMap_.put("reinitialize", new reinitialize());
            processMap_.put("shutdown", new shutdown());
        }

        protected static interface ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
        }

        private Iface iface_;
        protected final HashMap<String, ProcessFunction> processMap_ = new HashMap<String, ProcessFunction>();

        public boolean process(TProtocol iprot, TProtocol oprot) throws TException {
            TMessage msg = iprot.readMessageBegin();
            ProcessFunction fn = processMap_.get(msg.name);
            if (fn == null) {
                TProtocolUtil.skip(iprot, TType.STRUCT);
                iprot.readMessageEnd();
                TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '" + msg.name + "'");
                oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
                x.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
                return true;
            }
            fn.process(msg.seqid, iprot, oprot);
            return true;
        }

        private class getName implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getName_args args = new getName_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getName", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getName_result result = new getName_result();
                result.success = iface_.getName();
                oprot.writeMessageBegin(new TMessage("getName", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getVersion implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getVersion_args args = new getVersion_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getVersion", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getVersion_result result = new getVersion_result();
                result.success = iface_.getVersion();
                oprot.writeMessageBegin(new TMessage("getVersion", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getStatus implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getStatus_args args = new getStatus_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getStatus", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getStatus_result result = new getStatus_result();
                result.success = iface_.getStatus();
                oprot.writeMessageBegin(new TMessage("getStatus", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getStatusDetails implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getStatusDetails_args args = new getStatusDetails_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getStatusDetails", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getStatusDetails_result result = new getStatusDetails_result();
                result.success = iface_.getStatusDetails();
                oprot.writeMessageBegin(new TMessage("getStatusDetails", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getCounters implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getCounters_args args = new getCounters_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getCounters", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getCounters_result result = new getCounters_result();
                result.success = iface_.getCounters();
                oprot.writeMessageBegin(new TMessage("getCounters", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getCounter implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getCounter_args args = new getCounter_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getCounter", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getCounter_result result = new getCounter_result();
                result.success = iface_.getCounter(args.key);
                result.setSuccessIsSet(true);
                oprot.writeMessageBegin(new TMessage("getCounter", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class setOption implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                setOption_args args = new setOption_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("setOption", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                setOption_result result = new setOption_result();
                iface_.setOption(args.key, args.value);
                oprot.writeMessageBegin(new TMessage("setOption", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getOption implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getOption_args args = new getOption_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getOption", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getOption_result result = new getOption_result();
                result.success = iface_.getOption(args.key);
                oprot.writeMessageBegin(new TMessage("getOption", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getOptions implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getOptions_args args = new getOptions_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getOptions", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getOptions_result result = new getOptions_result();
                result.success = iface_.getOptions();
                oprot.writeMessageBegin(new TMessage("getOptions", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class getCpuProfile implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                getCpuProfile_args args = new getCpuProfile_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("getCpuProfile", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                getCpuProfile_result result = new getCpuProfile_result();
                result.success = iface_.getCpuProfile(args.profileDurationInSec);
                oprot.writeMessageBegin(new TMessage("getCpuProfile", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class aliveSince implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                aliveSince_args args = new aliveSince_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("aliveSince", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                aliveSince_result result = new aliveSince_result();
                result.success = iface_.aliveSince();
                result.setSuccessIsSet(true);
                oprot.writeMessageBegin(new TMessage("aliveSince", TMessageType.REPLY, seqid));
                result.write(oprot);
                oprot.writeMessageEnd();
                oprot.getTransport().flush();
            }

        }

        private class reinitialize implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                reinitialize_args args = new reinitialize_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("reinitialize", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                iface_.reinitialize();
                return;
            }
        }

        private class shutdown implements ProcessFunction {
            public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException {
                shutdown_args args = new shutdown_args();
                try {
                    args.read(iprot);
                } catch (TProtocolException e) {
                    iprot.readMessageEnd();
                    TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
                    oprot.writeMessageBegin(new TMessage("shutdown", TMessageType.EXCEPTION, seqid));
                    x.write(oprot);
                    oprot.writeMessageEnd();
                    oprot.getTransport().flush();
                    return;
                }
                iprot.readMessageEnd();
                iface_.shutdown();
                return;
            }
        }

    }

    public static class getName_args implements TBase<getName_args, getName_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getName_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getName_args.class, metaDataMap);
        }

        public getName_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getName_args(getName_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getName_args typedOther = (getName_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getName_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getName_result implements TBase<getName_result, getName_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getName_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short) 0);

        public String success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getName_result.class, metaDataMap);
        }

        public getName_result() {
        }

        public getName_result(
                String success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getName_result(getName_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public String getSuccess() {
            return this.success;
        }

        public getName_result setSuccess(String success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getName_result typedOther = (getName_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.STRING) {
                            this.success = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeString(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getName_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getVersion_args implements TBase<getVersion_args, getVersion_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getVersion_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getVersion_args.class, metaDataMap);
        }

        public getVersion_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getVersion_args(getVersion_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getVersion_args typedOther = (getVersion_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getVersion_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getVersion_result implements TBase<getVersion_result, getVersion_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getVersion_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short) 0);

        public String success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getVersion_result.class, metaDataMap);
        }

        public getVersion_result() {
        }

        public getVersion_result(
                String success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getVersion_result(getVersion_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public String getSuccess() {
            return this.success;
        }

        public getVersion_result setSuccess(String success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getVersion_result typedOther = (getVersion_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.STRING) {
                            this.success = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeString(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getVersion_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getStatus_args implements TBase<getStatus_args, getStatus_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getStatus_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getStatus_args.class, metaDataMap);
        }

        public getStatus_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getStatus_args(getStatus_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getStatus_args typedOther = (getStatus_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getStatus_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getStatus_result implements TBase<getStatus_result, getStatus_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getStatus_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short) 0);

        /**
         * @see fb_status
         */
        public fb_status success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            /**
             * @see fb_status
             */
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new EnumMetaData(TType.ENUM, fb_status.class)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getStatus_result.class, metaDataMap);
        }

        public getStatus_result() {
        }

        public getStatus_result(
                fb_status success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getStatus_result(getStatus_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        /**
         * @see fb_status
         */
        public fb_status getSuccess() {
            return this.success;
        }

        /**
         * @see fb_status
         */
        public getStatus_result setSuccess(fb_status success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((fb_status) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getStatus_result typedOther = (getStatus_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.I32) {
                            this.success = fb_status.findByValue(iprot.readI32());
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeI32(this.success.getValue());
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getStatus_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getStatusDetails_args implements TBase<getStatusDetails_args, getStatusDetails_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getStatusDetails_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getStatusDetails_args.class, metaDataMap);
        }

        public getStatusDetails_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getStatusDetails_args(getStatusDetails_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getStatusDetails_args typedOther = (getStatusDetails_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getStatusDetails_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getStatusDetails_result implements TBase<getStatusDetails_result, getStatusDetails_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getStatusDetails_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short) 0);

        public String success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getStatusDetails_result.class, metaDataMap);
        }

        public getStatusDetails_result() {
        }

        public getStatusDetails_result(
                String success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getStatusDetails_result(getStatusDetails_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public String getSuccess() {
            return this.success;
        }

        public getStatusDetails_result setSuccess(String success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getStatusDetails_result typedOther = (getStatusDetails_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.STRING) {
                            this.success = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeString(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getStatusDetails_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCounters_args implements TBase<getCounters_args, getCounters_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCounters_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCounters_args.class, metaDataMap);
        }

        public getCounters_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCounters_args(getCounters_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getCounters_args typedOther = (getCounters_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCounters_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCounters_result implements TBase<getCounters_result, getCounters_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCounters_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short) 0);

        public Map<String, Long> success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new MapMetaData(TType.MAP,
                            new FieldValueMetaData(TType.STRING),
                            new FieldValueMetaData(TType.I64))));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCounters_result.class, metaDataMap);
        }

        public getCounters_result() {
        }

        public getCounters_result(
                Map<String, Long> success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCounters_result(getCounters_result other) {
            if (other.isSetSuccess()) {
                Map<String, Long> __this__success = new HashMap<String, Long>();
                for (Map.Entry<String, Long> other_element : other.success.entrySet()) {

                    String other_element_key = other_element.getKey();
                    Long other_element_value = other_element.getValue();

                    String __this__success_copy_key = other_element_key;

                    Long __this__success_copy_value = other_element_value;

                    __this__success.put(__this__success_copy_key, __this__success_copy_value);
                }
                this.success = __this__success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public int getSuccessSize() {
            return (this.success == null) ? 0 : this.success.size();
        }

        public void putToSuccess(String key, long val) {
            if (this.success == null) {
                this.success = new HashMap<String, Long>();
            }
            this.success.put(key, val);
        }

        public Map<String, Long> getSuccess() {
            return this.success;
        }

        public getCounters_result setSuccess(Map<String, Long> success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((Map<String, Long>) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getCounters_result typedOther = (getCounters_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.MAP) {
                            {
                                TMap _map0 = iprot.readMapBegin();
                                this.success = new HashMap<String, Long>(2 * _map0.size);
                                for (int _i1 = 0; _i1 < _map0.size; ++_i1) {
                                    String _key2;
                                    long _val3;
                                    _key2 = iprot.readString();
                                    _val3 = iprot.readI64();
                                    this.success.put(_key2, _val3);
                                }
                                iprot.readMapEnd();
                            }
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                {
                    oprot.writeMapBegin(new TMap(TType.STRING, TType.I64, this.success.size()));
                    for (Map.Entry<String, Long> _iter4 : this.success.entrySet()) {
                        oprot.writeString(_iter4.getKey());
                        oprot.writeI64(_iter4.getValue());
                    }
                    oprot.writeMapEnd();
                }
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCounters_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCounter_args implements TBase<getCounter_args, getCounter_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCounter_args");

        private static final TField KEY_FIELD_DESC = new TField("key", TType.STRING, (short) 1);

        public String key;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            KEY((short) 1, "key");

            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: // KEY
                        return KEY;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.KEY, new FieldMetaData("key", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCounter_args.class, metaDataMap);
        }

        public getCounter_args() {
        }

        public getCounter_args(
                String key) {
            this();
            this.key = key;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCounter_args(getCounter_args other) {
            if (other.isSetKey()) {
                this.key = other.key;
            }
        }

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

        @Override
        public void clear() {
            this.key = null;
        }

        public String getKey() {
            return this.key;
        }

        public getCounter_args setKey(String key) {
            this.key = key;
            return this;
        }

        public void unsetKey() {
            this.key = null;
        }

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

        public void setKeyIsSet(boolean value) {
            if (!value) {
                this.key = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case KEY:
                    if (value == null) {
                        unsetKey();
                    } else {
                        setKey((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case KEY:
                    return getKey();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case KEY:
                    return isSetKey();
            }
            throw new IllegalStateException();
        }

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

        public boolean equals(getCounter_args that) {
            if (that == null)
                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;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getCounter_args typedOther = (getCounter_args) other;

            lastComparison = Boolean.valueOf(isSetKey()).compareTo(typedOther.isSetKey());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetKey()) {
                lastComparison = TBaseHelper.compareTo(this.key, typedOther.key);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 1: // KEY
                        if (field.type == TType.STRING) {
                            this.key = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            if (this.key != null) {
                oprot.writeFieldBegin(KEY_FIELD_DESC);
                oprot.writeString(this.key);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCounter_args(");
            boolean first = true;

            sb.append("key:");
            if (this.key == null) {
                sb.append("null");
            } else {
                sb.append(this.key);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCounter_result implements TBase<getCounter_result, getCounter_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCounter_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short) 0);

        public long success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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 __SUCCESS_ISSET_ID = 0;
        private BitSet __isset_bit_vector = new BitSet(1);

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.I64)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCounter_result.class, metaDataMap);
        }

        public getCounter_result() {
        }

        public getCounter_result(
                long success) {
            this();
            this.success = success;
            setSuccessIsSet(true);
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCounter_result(getCounter_result other) {
            __isset_bit_vector.clear();
            __isset_bit_vector.or(other.__isset_bit_vector);
            this.success = other.success;
        }

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

        @Override
        public void clear() {
            setSuccessIsSet(false);
            this.success = 0;
        }

        public long getSuccess() {
            return this.success;
        }

        public getCounter_result setSuccess(long success) {
            this.success = success;
            setSuccessIsSet(true);
            return this;
        }

        public void unsetSuccess() {
            __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
        }

        /**
         * Returns true if field success is set (has been asigned a value) and false otherwise
         */
        public boolean isSetSuccess() {
            return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
        }

        public void setSuccessIsSet(boolean value) {
            __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((Long) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return new Long(getSuccess());

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true;
            boolean that_present_success = true;
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (this.success != that.success)
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getCounter_result typedOther = (getCounter_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.I64) {
                            this.success = iprot.readI64();
                            setSuccessIsSet(true);
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeI64(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCounter_result(");
            boolean first = true;

            sb.append("success:");
            sb.append(this.success);
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class setOption_args implements TBase<setOption_args, setOption_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("setOption_args");

        private static final TField KEY_FIELD_DESC = new TField("key", TType.STRING, (short) 1);
        private static final TField VALUE_FIELD_DESC = new TField("value", TType.STRING, (short) 2);

        public String key;
        public String value;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            KEY((short) 1, "key"),
            VALUE((short) 2, "value");

            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: // KEY
                        return KEY;
                    case 2: // VALUE
                        return VALUE;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.KEY, new FieldMetaData("key", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            tmpMap.put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(setOption_args.class, metaDataMap);
        }

        public setOption_args() {
        }

        public setOption_args(
                String key,
                String value) {
            this();
            this.key = key;
            this.value = value;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public setOption_args(setOption_args other) {
            if (other.isSetKey()) {
                this.key = other.key;
            }
            if (other.isSetValue()) {
                this.value = other.value;
            }
        }

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

        @Override
        public void clear() {
            this.key = null;
            this.value = null;
        }

        public String getKey() {
            return this.key;
        }

        public setOption_args setKey(String key) {
            this.key = key;
            return this;
        }

        public void unsetKey() {
            this.key = null;
        }

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

        public void setKeyIsSet(boolean value) {
            if (!value) {
                this.key = null;
            }
        }

        public String getValue() {
            return this.value;
        }

        public setOption_args setValue(String value) {
            this.value = value;
            return this;
        }

        public void unsetValue() {
            this.value = null;
        }

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

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

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case KEY:
                    if (value == null) {
                        unsetKey();
                    } else {
                        setKey((String) value);
                    }
                    break;

                case VALUE:
                    if (value == null) {
                        unsetValue();
                    } else {
                        setValue((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case KEY:
                    return getKey();

                case VALUE:
                    return getValue();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case KEY:
                    return isSetKey();
                case VALUE:
                    return isSetValue();
            }
            throw new IllegalStateException();
        }

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

        public boolean equals(setOption_args that) {
            if (that == null)
                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;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            setOption_args typedOther = (setOption_args) other;

            lastComparison = Boolean.valueOf(isSetKey()).compareTo(typedOther.isSetKey());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetKey()) {
                lastComparison = 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 = TBaseHelper.compareTo(this.value, typedOther.value);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 1: // KEY
                        if (field.type == TType.STRING) {
                            this.key = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    case 2: // VALUE
                        if (field.type == TType.STRING) {
                            this.value = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            if (this.key != null) {
                oprot.writeFieldBegin(KEY_FIELD_DESC);
                oprot.writeString(this.key);
                oprot.writeFieldEnd();
            }
            if (this.value != null) {
                oprot.writeFieldBegin(VALUE_FIELD_DESC);
                oprot.writeString(this.value);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("setOption_args(");
            boolean first = true;

            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 {
                sb.append(this.value);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class setOption_result implements TBase<setOption_result, setOption_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("setOption_result");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(setOption_result.class, metaDataMap);
        }

        public setOption_result() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public setOption_result(setOption_result other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            setOption_result typedOther = (setOption_result) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("setOption_result(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getOption_args implements TBase<getOption_args, getOption_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getOption_args");

        private static final TField KEY_FIELD_DESC = new TField("key", TType.STRING, (short) 1);

        public String key;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            KEY((short) 1, "key");

            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: // KEY
                        return KEY;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.KEY, new FieldMetaData("key", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getOption_args.class, metaDataMap);
        }

        public getOption_args() {
        }

        public getOption_args(
                String key) {
            this();
            this.key = key;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getOption_args(getOption_args other) {
            if (other.isSetKey()) {
                this.key = other.key;
            }
        }

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

        @Override
        public void clear() {
            this.key = null;
        }

        public String getKey() {
            return this.key;
        }

        public getOption_args setKey(String key) {
            this.key = key;
            return this;
        }

        public void unsetKey() {
            this.key = null;
        }

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

        public void setKeyIsSet(boolean value) {
            if (!value) {
                this.key = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case KEY:
                    if (value == null) {
                        unsetKey();
                    } else {
                        setKey((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case KEY:
                    return getKey();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case KEY:
                    return isSetKey();
            }
            throw new IllegalStateException();
        }

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

        public boolean equals(getOption_args that) {
            if (that == null)
                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;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getOption_args typedOther = (getOption_args) other;

            lastComparison = Boolean.valueOf(isSetKey()).compareTo(typedOther.isSetKey());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetKey()) {
                lastComparison = TBaseHelper.compareTo(this.key, typedOther.key);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 1: // KEY
                        if (field.type == TType.STRING) {
                            this.key = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            if (this.key != null) {
                oprot.writeFieldBegin(KEY_FIELD_DESC);
                oprot.writeString(this.key);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getOption_args(");
            boolean first = true;

            sb.append("key:");
            if (this.key == null) {
                sb.append("null");
            } else {
                sb.append(this.key);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getOption_result implements TBase<getOption_result, getOption_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getOption_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short) 0);

        public String success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getOption_result.class, metaDataMap);
        }

        public getOption_result() {
        }

        public getOption_result(
                String success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getOption_result(getOption_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public String getSuccess() {
            return this.success;
        }

        public getOption_result setSuccess(String success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getOption_result typedOther = (getOption_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.STRING) {
                            this.success = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeString(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getOption_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getOptions_args implements TBase<getOptions_args, getOptions_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getOptions_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getOptions_args.class, metaDataMap);
        }

        public getOptions_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getOptions_args(getOptions_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            getOptions_args typedOther = (getOptions_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getOptions_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getOptions_result implements TBase<getOptions_result, getOptions_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getOptions_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short) 0);

        public Map<String, String> success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new MapMetaData(TType.MAP,
                            new FieldValueMetaData(TType.STRING),
                            new FieldValueMetaData(TType.STRING))));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getOptions_result.class, metaDataMap);
        }

        public getOptions_result() {
        }

        public getOptions_result(
                Map<String, String> success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getOptions_result(getOptions_result other) {
            if (other.isSetSuccess()) {
                Map<String, String> __this__success = new HashMap<String, String>();
                for (Map.Entry<String, String> other_element : other.success.entrySet()) {

                    String other_element_key = other_element.getKey();
                    String other_element_value = other_element.getValue();

                    String __this__success_copy_key = other_element_key;

                    String __this__success_copy_value = other_element_value;

                    __this__success.put(__this__success_copy_key, __this__success_copy_value);
                }
                this.success = __this__success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public int getSuccessSize() {
            return (this.success == null) ? 0 : this.success.size();
        }

        public void putToSuccess(String key, String val) {
            if (this.success == null) {
                this.success = new HashMap<String, String>();
            }
            this.success.put(key, val);
        }

        public Map<String, String> getSuccess() {
            return this.success;
        }

        public getOptions_result setSuccess(Map<String, String> success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((Map<String, String>) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getOptions_result typedOther = (getOptions_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.MAP) {
                            {
                                TMap _map5 = iprot.readMapBegin();
                                this.success = new HashMap<String, String>(2 * _map5.size);
                                for (int _i6 = 0; _i6 < _map5.size; ++_i6) {
                                    String _key7;
                                    String _val8;
                                    _key7 = iprot.readString();
                                    _val8 = iprot.readString();
                                    this.success.put(_key7, _val8);
                                }
                                iprot.readMapEnd();
                            }
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                {
                    oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
                    for (Map.Entry<String, String> _iter9 : this.success.entrySet()) {
                        oprot.writeString(_iter9.getKey());
                        oprot.writeString(_iter9.getValue());
                    }
                    oprot.writeMapEnd();
                }
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getOptions_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCpuProfile_args implements TBase<getCpuProfile_args, getCpuProfile_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCpuProfile_args");

        private static final TField PROFILE_DURATION_IN_SEC_FIELD_DESC = new TField("profileDurationInSec", TType.I32, (short) 1);

        public int profileDurationInSec;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            PROFILE_DURATION_IN_SEC((short) 1, "profileDurationInSec");

            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: // PROFILE_DURATION_IN_SEC
                        return PROFILE_DURATION_IN_SEC;
                    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 __PROFILEDURATIONINSEC_ISSET_ID = 0;
        private BitSet __isset_bit_vector = new BitSet(1);

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.PROFILE_DURATION_IN_SEC, new FieldMetaData("profileDurationInSec", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.I32)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCpuProfile_args.class, metaDataMap);
        }

        public getCpuProfile_args() {
        }

        public getCpuProfile_args(
                int profileDurationInSec) {
            this();
            this.profileDurationInSec = profileDurationInSec;
            setProfileDurationInSecIsSet(true);
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCpuProfile_args(getCpuProfile_args other) {
            __isset_bit_vector.clear();
            __isset_bit_vector.or(other.__isset_bit_vector);
            this.profileDurationInSec = other.profileDurationInSec;
        }

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

        @Override
        public void clear() {
            setProfileDurationInSecIsSet(false);
            this.profileDurationInSec = 0;
        }

        public int getProfileDurationInSec() {
            return this.profileDurationInSec;
        }

        public getCpuProfile_args setProfileDurationInSec(int profileDurationInSec) {
            this.profileDurationInSec = profileDurationInSec;
            setProfileDurationInSecIsSet(true);
            return this;
        }

        public void unsetProfileDurationInSec() {
            __isset_bit_vector.clear(__PROFILEDURATIONINSEC_ISSET_ID);
        }

        /**
         * Returns true if field profileDurationInSec is set (has been asigned a value) and false otherwise
         */
        public boolean isSetProfileDurationInSec() {
            return __isset_bit_vector.get(__PROFILEDURATIONINSEC_ISSET_ID);
        }

        public void setProfileDurationInSecIsSet(boolean value) {
            __isset_bit_vector.set(__PROFILEDURATIONINSEC_ISSET_ID, value);
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case PROFILE_DURATION_IN_SEC:
                    if (value == null) {
                        unsetProfileDurationInSec();
                    } else {
                        setProfileDurationInSec((Integer) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case PROFILE_DURATION_IN_SEC:
                    return new Integer(getProfileDurationInSec());

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case PROFILE_DURATION_IN_SEC:
                    return isSetProfileDurationInSec();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_profileDurationInSec = true;
            boolean that_present_profileDurationInSec = true;
            if (this_present_profileDurationInSec || that_present_profileDurationInSec) {
                if (!(this_present_profileDurationInSec && that_present_profileDurationInSec))
                    return false;
                if (this.profileDurationInSec != that.profileDurationInSec)
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getCpuProfile_args typedOther = (getCpuProfile_args) other;

            lastComparison = Boolean.valueOf(isSetProfileDurationInSec()).compareTo(typedOther.isSetProfileDurationInSec());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetProfileDurationInSec()) {
                lastComparison = TBaseHelper.compareTo(this.profileDurationInSec, typedOther.profileDurationInSec);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 1: // PROFILE_DURATION_IN_SEC
                        if (field.type == TType.I32) {
                            this.profileDurationInSec = iprot.readI32();
                            setProfileDurationInSecIsSet(true);
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldBegin(PROFILE_DURATION_IN_SEC_FIELD_DESC);
            oprot.writeI32(this.profileDurationInSec);
            oprot.writeFieldEnd();
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCpuProfile_args(");
            boolean first = true;

            sb.append("profileDurationInSec:");
            sb.append(this.profileDurationInSec);
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class getCpuProfile_result implements TBase<getCpuProfile_result, getCpuProfile_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("getCpuProfile_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short) 0);

        public String success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.STRING)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(getCpuProfile_result.class, metaDataMap);
        }

        public getCpuProfile_result() {
        }

        public getCpuProfile_result(
                String success) {
            this();
            this.success = success;
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public getCpuProfile_result(getCpuProfile_result other) {
            if (other.isSetSuccess()) {
                this.success = other.success;
            }
        }

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

        @Override
        public void clear() {
            this.success = null;
        }

        public String getSuccess() {
            return this.success;
        }

        public getCpuProfile_result setSuccess(String success) {
            this.success = success;
            return this;
        }

        public void unsetSuccess() {
            this.success = null;
        }

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

        public void setSuccessIsSet(boolean value) {
            if (!value) {
                this.success = null;
            }
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((String) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return getSuccess();

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true && this.isSetSuccess();
            boolean that_present_success = true && that.isSetSuccess();
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (!this.success.equals(that.success))
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            getCpuProfile_result typedOther = (getCpuProfile_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.STRING) {
                            this.success = iprot.readString();
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeString(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("getCpuProfile_result(");
            boolean first = true;

            sb.append("success:");
            if (this.success == null) {
                sb.append("null");
            } else {
                sb.append(this.success);
            }
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class aliveSince_args implements TBase<aliveSince_args, aliveSince_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("aliveSince_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(aliveSince_args.class, metaDataMap);
        }

        public aliveSince_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public aliveSince_args(aliveSince_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            aliveSince_args typedOther = (aliveSince_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("aliveSince_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class aliveSince_result implements TBase<aliveSince_result, aliveSince_result._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("aliveSince_result");

        private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short) 0);

        public long success;

        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            SUCCESS((short) 0, "success");

            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 0: // SUCCESS
                        return SUCCESS;
                    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 __SUCCESS_ISSET_ID = 0;
        private BitSet __isset_bit_vector = new BitSet(1);

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
                    new FieldValueMetaData(TType.I64)));
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(aliveSince_result.class, metaDataMap);
        }

        public aliveSince_result() {
        }

        public aliveSince_result(
                long success) {
            this();
            this.success = success;
            setSuccessIsSet(true);
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public aliveSince_result(aliveSince_result other) {
            __isset_bit_vector.clear();
            __isset_bit_vector.or(other.__isset_bit_vector);
            this.success = other.success;
        }

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

        @Override
        public void clear() {
            setSuccessIsSet(false);
            this.success = 0;
        }

        public long getSuccess() {
            return this.success;
        }

        public aliveSince_result setSuccess(long success) {
            this.success = success;
            setSuccessIsSet(true);
            return this;
        }

        public void unsetSuccess() {
            __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
        }

        /**
         * Returns true if field success is set (has been asigned a value) and false otherwise
         */
        public boolean isSetSuccess() {
            return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
        }

        public void setSuccessIsSet(boolean value) {
            __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
                case SUCCESS:
                    if (value == null) {
                        unsetSuccess();
                    } else {
                        setSuccess((Long) value);
                    }
                    break;

            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
                case SUCCESS:
                    return new Long(getSuccess());

            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
                case SUCCESS:
                    return isSetSuccess();
            }
            throw new IllegalStateException();
        }

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

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

            boolean this_present_success = true;
            boolean that_present_success = true;
            if (this_present_success || that_present_success) {
                if (!(this_present_success && that_present_success))
                    return false;
                if (this.success != that.success)
                    return false;
            }

            return true;
        }

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

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

            int lastComparison = 0;
            aliveSince_result typedOther = (aliveSince_result) other;

            lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
            if (lastComparison != 0) {
                return lastComparison;
            }
            if (isSetSuccess()) {
                lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
                if (lastComparison != 0) {
                    return lastComparison;
                }
            }
            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    case 0: // SUCCESS
                        if (field.type == TType.I64) {
                            this.success = iprot.readI64();
                            setSuccessIsSet(true);
                        } else {
                            TProtocolUtil.skip(iprot, field.type);
                        }
                        break;
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            oprot.writeStructBegin(STRUCT_DESC);

            if (this.isSetSuccess()) {
                oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
                oprot.writeI64(this.success);
                oprot.writeFieldEnd();
            }
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("aliveSince_result(");
            boolean first = true;

            sb.append("success:");
            sb.append(this.success);
            first = false;
            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class reinitialize_args implements TBase<reinitialize_args, reinitialize_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("reinitialize_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(reinitialize_args.class, metaDataMap);
        }

        public reinitialize_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public reinitialize_args(reinitialize_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            reinitialize_args typedOther = (reinitialize_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("reinitialize_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }

        public void validate() throws TException {
            // check for required fields
        }

    }

    public static class shutdown_args implements TBase<shutdown_args, shutdown_args._Fields>, java.io.Serializable, Cloneable {
        private static final TStruct STRUCT_DESC = new TStruct("shutdown_args");


        /**
         * The set of fields this struct contains, along with convenience methods for finding and manipulating them.
         */
        public enum _Fields implements TFieldIdEnum {
            ;

            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) {
                    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;
            }
        }

        public static final Map<_Fields, FieldMetaData> metaDataMap;

        static {
            Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
            metaDataMap = Collections.unmodifiableMap(tmpMap);
            FieldMetaData.addStructMetaDataMap(shutdown_args.class, metaDataMap);
        }

        public shutdown_args() {
        }

        /**
         * Performs a deep copy on <i>other</i>.
         */
        public shutdown_args(shutdown_args other) {
        }

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

        @Override
        public void clear() {
        }

        public void setFieldValue(_Fields field, Object value) {
            switch (field) {
            }
        }

        public Object getFieldValue(_Fields field) {
            switch (field) {
            }
            throw new IllegalStateException();
        }

        /**
         * Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise
         */
        public boolean isSet(_Fields field) {
            if (field == null) {
                throw new IllegalArgumentException();
            }

            switch (field) {
            }
            throw new IllegalStateException();
        }

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

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

            return true;
        }

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

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

            int lastComparison = 0;
            shutdown_args typedOther = (shutdown_args) other;

            return 0;
        }

        public _Fields fieldForId(int fieldId) {
            return _Fields.findByThriftId(fieldId);
        }

        public void read(TProtocol iprot) throws TException {
            TField field;
            iprot.readStructBegin();
            while (true) {
                field = iprot.readFieldBegin();
                if (field.type == TType.STOP) {
                    break;
                }
                switch (field.id) {
                    default:
                        TProtocolUtil.skip(iprot, field.type);
                }
                iprot.readFieldEnd();
            }
            iprot.readStructEnd();

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

        public void write(TProtocol oprot) throws TException {
            validate();

            oprot.writeStructBegin(STRUCT_DESC);
            oprot.writeFieldStop();
            oprot.writeStructEnd();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("shutdown_args(");
            boolean first = true;

            sb.append(")");
            return sb.toString();
        }