Use simple handler and callback instead of defining new NoOp copies (2ba37c93) · Commits · kinetic-archive / kinetic-cpp-client

include/kinetic/nonblocking_kinetic_connection.h

+1 −18

Original line number	Diff line number	Diff line
		@@ -70,23 +70,6 @@ class SimpleHandler : public HandlerInterface {
		DISALLOW_COPY_AND_ASSIGN(SimpleHandler);
		};

		class NoOpCallbackInterface {
		public:
		virtual ~NoOpCallbackInterface() {}
		virtual void Success() = 0;
		virtual void Failure(KineticStatus error) = 0;
		};

		class NoOpHandler : public HandlerInterface {
		public:
		explicit NoOpHandler(const shared_ptr<NoOpCallbackInterface> callback);
		void Handle(const Message &response, unique_ptr<const string> value);
		void Error(KineticStatus error);

		private:
		const shared_ptr<NoOpCallbackInterface> callback_;
		DISALLOW_COPY_AND_ASSIGN(NoOpHandler);
		};

		class GetCallbackInterface {
		public:
		@@ -241,7 +224,7 @@ class NonblockingKineticConnection {
		virtual bool Run(fd_set read_fds, fd_set write_fds, int *nfds);
		virtual void SetClientClusterVersion(int64_t cluster_version);

		virtual HandlerKey NoOp(const shared_ptr<NoOpCallbackInterface> callback);
		virtual HandlerKey NoOp(const shared_ptr<SimpleCallbackInterface> callback);
		virtual HandlerKey Get(const string key, const shared_ptr<GetCallbackInterface> callback);
		virtual HandlerKey Get(const shared_ptr<const string> key,
		const shared_ptr<GetCallbackInterface> callback);

+4 −17

Original line number	Diff line number	Diff line
		@@ -67,7 +67,7 @@ class BlockingCallbackState {
		}
		};

		class BlockingNoOpCallback : public NoOpCallbackInterface, public BlockingCallbackState {
		class SimpleCallback : public SimpleCallbackInterface, public BlockingCallbackState {
		public:
		virtual void Success() {
		OnSuccess();
		@@ -81,7 +81,7 @@ class BlockingNoOpCallback : public NoOpCallbackInterface, public BlockingCallba
		};

		KineticStatus BlockingKineticConnection::NoOp() {
		auto handler = make_shared<BlockingNoOpCallback>();
		auto handler = make_shared<SimpleCallback>();
		return RunOperation(handler, nonblocking_connection_->NoOp(handler));
		}

		@@ -205,19 +205,6 @@ KineticStatus BlockingKineticConnection::Put(const string& key,
		make_shared<KineticRecord>(record));
		}

		class SimpleCallback : public SimpleCallbackInterface, public BlockingCallbackState {
		public:
		virtual void Success() {
		OnSuccess();
		}

		virtual void Failure(KineticStatus error) {
		OnError(error);
		}

		private:
		};

		KineticStatus BlockingKineticConnection::Delete(const shared_ptr<const string> key,
		const shared_ptr<const string> version, WriteMode mode) {
		auto callback = make_shared<SimpleCallback>();

+2 −14

Original line number	Diff line number	Diff line
		@@ -60,18 +60,6 @@ using std::unique_ptr;
		using std::iterator;
		using std::move;

		NoOpHandler::NoOpHandler(const shared_ptr<NoOpCallbackInterface> callback)
		: callback_(callback) {}

		void NoOpHandler::Handle(const Message &response, unique_ptr<const string> value) {
		callback_->Success();
		}

		void NoOpHandler::Error(KineticStatus error) {
		callback_->Failure(error);
		}


		GetHandler::GetHandler(const shared_ptr<GetCallbackInterface> callback)
		: callback_(callback) {}

		@@ -245,8 +233,8 @@ unique_ptr<Message> NonblockingKineticConnection::NewMessage(Message_MessageType
		return move(msg);
		}

		HandlerKey NonblockingKineticConnection::NoOp(const shared_ptr<NoOpCallbackInterface> callback){
		unique_ptr<NoOpHandler> handler(new NoOpHandler(callback));
		HandlerKey NonblockingKineticConnection::NoOp(const shared_ptr<SimpleCallbackInterface> callback){
		unique_ptr<SimpleHandler> handler(new SimpleHandler(callback));
		unique_ptr<Message> request = NewMessage(Message_MessageType_NOOP);
		return service_->Submit(move(request), empty_str_, move(handler));
		}

+1 −1

Original line number	Diff line number	Diff line
		@@ -91,7 +91,7 @@ TEST_F(NonblockingKineticConnectionTest, NoOpWorks) {
		Message message;
		EXPECT_CALL(*packet_service_, Submit_(_, StringSharedPtrEq(""), _))
		.WillOnce(DoAll(SaveArg<0>(&message), Return(0)));
		shared_ptr<NoOpCallbackInterface> callback;
		shared_ptr<SimpleCallbackInterface> callback;
		connection_.NoOp(callback);

		ASSERT_EQ(Message_MessageType_NOOP, message.command().header().messagetype());