typedef std::map<std::string, SharedRefPtr<Response> > ResponseMap;

MultipleRequestHandler(Connection* connection)

: connection_(connection)

, has_errors_or_timeouts_(false)

, remaining_(0) { }

virtual ~MultipleRequestHandler() { }

static bool get_result_response(const ResponseMap& responses,

const std::string& index,

ResultResponse** response);

void execute_query(const std::string& index, const std::string& query);

virtual void on_set(const ResponseMap& responses) = 0;

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

virtual void on_timeout() = 0;

Connection* connection() {

return connection_;

}

class InternalHandler : public Handler {

public:

InternalHandler(MultipleRequestHandler* parent, const Request* request, const std::string& index)

: Handler(request)

, parent_(parent)

, index_(index) { }

virtual void on_set(ResponseMessage* response);

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

virtual void on_timeout();

private:

ScopedRefPtr<MultipleRequestHandler> parent_;

std::string index_;

};

Connection* connection_;

bool has_errors_or_timeouts_;

int remaining_;

ResponseMap responses_;