enum State {

REQUEST_STATE_NEW,

REQUEST_STATE_WRITING,

REQUEST_STATE_READING,

REQUEST_STATE_TIMEOUT,

REQUEST_STATE_TIMEOUT_WRITE_OUTSTANDING,

REQUEST_STATE_READ_BEFORE_WRITE,

REQUEST_STATE_RETRY_WRITE_OUTSTANDING,

REQUEST_STATE_DONE

};

Handler(const Request* request)

: request_(request)

, connection_(NULL)

, stream_(-1)

, state_(REQUEST_STATE_NEW)

, cl_(CASS_CONSISTENCY_UNKNOWN)

, timestamp_(CASS_INT64_MIN) { }

virtual ~Handler() {}

int32_t encode(int version, int flags, BufferVec* bufs);

virtual void on_set(ResponseMessage* response) = 0;

virtual void on_error(CassError code, const std::string& message) = 0;

virtual void on_timeout() = 0;

virtual void retry() { }

const Request* request() const { return request_.get(); }

Connection* connection() const { return connection_; }

void set_connection(Connection* connection) {

connection_ = connection;

}

int stream() const { return stream_; }

void set_stream(int stream) {

stream_ = stream;

}

State state() const { return state_; }

void set_state(State next_state);

void start_timer(uv_loop_t* loop, uint64_t timeout, void* data,

Timer::Callback cb) {

timer_.start(loop, timeout, data, cb);

}

void stop_timer() {

timer_.stop();

}

CassConsistency consistency() const {

return cl_ != CASS_CONSISTENCY_UNKNOWN ? cl_ : request()->consistency();

}

void set_consistency(CassConsistency cl) { cl_ = cl; }

int64_t timestamp() const {

return timestamp_;

}

void set_timestamp(int64_t timestamp) {

timestamp_ = timestamp;

}

uint64_t start_time_ns() const { return start_time_ns_; }

Request::EncodingCache* encoding_cache() { return &encoding_cache_; }

ScopedRefPtr<const Request> request_;

Connection* connection_;

Timer timer_;

int stream_;

State state_;

CassConsistency cl_;

int64_t timestamp_;

uint64_t start_time_ns_;

Request::EncodingCache encoding_cache_;

DISALLOW_COPY_AND_ASSIGN(Handler);