(split) The cameo server sends the key value events and they are dispatched in the APIs

include/EventListener.h

@@ -30,6 +30,10 @@ public:
 	EventListener();
 	virtual ~EventListener();
 
+	/**
+	 * Sets the name of the listener i.e. the application name.
+	 * It is used to filter the messages in the event thread because when the listener is registered, the application id is not known.
+	 */
 	void setName(const std::string& name);
 	const std::string& getName() const;
 

src/EventStreamSocket.cpp

@@ -22,6 +22,8 @@
 #include "PublisherEvent.h"
 #include "ResultEvent.h"
 #include "StatusEvent.h"
+#include "StoreKeyValueEvent.h"
+#include "RemoveKeyEvent.h"
 #include "impl/StreamSocketImpl.h"
 #include "message/Message.h"
 
@@ -109,6 +111,35 @@ std::unique_ptr<Event> EventStreamSocket::receive(bool blocking) {
 
 		return unique_ptr<Event>(new PortEvent(id, name, portName));
 	}
+	else if (response == message::Event::STOREKEYVALUE) {
+
+		message = m_impl->receive();
+
+		// Get the JSON event.
+		json::Object event;
+		json::parse(event, message.get());
+
+		int id = event[message::StoreKeyValueEvent::ID].GetInt();
+		string name = event[message::StoreKeyValueEvent::NAME].GetString();
+		string key = event[message::StoreKeyValueEvent::KEY].GetString();
+		string value = event[message::StoreKeyValueEvent::VALUE].GetString();
+
+		return unique_ptr<Event>(new StoreKeyValueEvent(id, name, key, value));
+	}
+	else if (response == message::Event::REMOVEKEY) {
+
+		message = m_impl->receive();
+
+		// Get the JSON event.
+		json::Object event;
+		json::parse(event, message.get());
+
+		int id = event[message::RemoveKeyEvent::ID].GetInt();
+		string name = event[message::RemoveKeyEvent::NAME].GetString();
+		string key = event[message::RemoveKeyEvent::KEY].GetString();
+
+		return unique_ptr<Event>(new RemoveKeyEvent(id, name, key));
+	}
 	else if (response == message::Event::CANCEL) {
 
 		message = m_impl->receive();

src/EventThread.cpp

@@ -52,6 +52,7 @@ void EventThread::start() {
 			for (EventListener * listener : eventListeners) {
 
 				// If the application name is null, all the status are pushed, otherwise, filter on the name.
+				// We filter on the name because the id is not known at the registration.
 				if (listener->getName() == ""
 					|| listener->getName() == event->getName()) {
 

src/KeyEvent.cpp

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#include "KeyEvent.h"
+
+#include <iostream>
+
+namespace cameo {
+
+KeyEvent::KeyEvent(int id, const std::string& name, const std::string& key) :
+	Event(id, name),
+	m_key(key) {
+}
+
+KeyEvent::KeyEvent(const KeyEvent& event) :
+	Event(event), m_key(event.m_key) {
+}
+
+const std::string& KeyEvent::getKey() const {
+	return m_key;
+}
+
+}

src/KeyEvent.h

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#ifndef CAMEO_KEYEVENT_H_
+#define CAMEO_KEYEVENT_H_
+
+#include <iostream>
+#include "Event.h"
+
+namespace cameo {
+
+class KeyEvent : public Event {
+
+public:
+	KeyEvent(int id, const std::string& name, const std::string& key);
+	KeyEvent(const KeyEvent& event);
+
+	const std::string& getKey() const;
+
+private:
+	std::string m_key;
+};
+
+}
+
+#endif

src/RemoveKeyEvent.cpp

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#include "RemoveKeyEvent.h"
+
+#include <iostream>
+
+namespace cameo {
+
+RemoveKeyEvent::RemoveKeyEvent(int id, const std::string& name, const std::string& key) :
+	KeyEvent(id, name, key) {
+}
+
+RemoveKeyEvent::RemoveKeyEvent(const RemoveKeyEvent& event) :
+	KeyEvent(event) {
+}
+
+RemoveKeyEvent* RemoveKeyEvent::clone() {
+	return new RemoveKeyEvent(*this);
+}
+
+std::ostream& operator<<(std::ostream& os, const cameo::RemoveKeyEvent& event) {
+	os << "name=" << event.m_name
+		<< "\nid=" << event.m_id
+		<< "\nkey=" << event.m_key;
+
+	return os;
+}
+
+}

src/RemoveKeyEvent.h

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#ifndef CAMEO_REMOVEKEYEVENT_H_
+#define CAMEO_REMOVEKEYEVENT_H_
+
+#include <iostream>
+#include "KeyEvent.h"
+
+namespace cameo {
+
+class RemoveKeyEvent : public KeyEvent {
+
+	friend std::ostream& operator<<(std::ostream&, const RemoveKeyEvent&);
+
+public:
+	RemoveKeyEvent(int id, const std::string& name, const std::string& key);
+	RemoveKeyEvent(const RemoveKeyEvent& event);
+
+	virtual RemoveKeyEvent* clone();
+};
+
+std::ostream& operator<<(std::ostream&, const RemoveKeyEvent&);
+
+}
+
+#endif

src/StoreKeyValueEvent.cpp

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#include "StoreKeyValueEvent.h"
+
+#include <iostream>
+
+namespace cameo {
+
+StoreKeyValueEvent::StoreKeyValueEvent(int id, const std::string& name, const std::string& key, const std::string& value) :
+	KeyEvent(id, name, key),
+	m_value(value) {
+}
+
+StoreKeyValueEvent::StoreKeyValueEvent(const StoreKeyValueEvent& event) :
+	KeyEvent(event), m_value(event.m_value) {
+}
+
+StoreKeyValueEvent* StoreKeyValueEvent::clone() {
+	return new StoreKeyValueEvent(*this);
+}
+
+const std::string& StoreKeyValueEvent::getValue() const {
+	return m_value;
+}
+
+std::ostream& operator<<(std::ostream& os, const cameo::StoreKeyValueEvent& event) {
+	os << "name=" << event.m_name
+		<< "\nid=" << event.m_id
+		<< "\nkey=" << event.m_key
+		<< "\nvalue=" << event.m_value;
+
+	return os;
+}
+
+}

src/StoreKeyValueEvent.h

+/*
+ * Copyright 2015 Institut Laue-Langevin
+ *
+ * Licensed under the EUPL, Version 1.1 only (the "License");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ *
+ * http://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ */
+
+#ifndef CAMEO_STOREKEYVALUEEVENT_H_
+#define CAMEO_STOREKEYVALUEEVENT_H_
+
+#include <iostream>
+#include "KeyEvent.h"
+
+namespace cameo {
+
+class StoreKeyValueEvent : public KeyEvent {
+
+	friend std::ostream& operator<<(std::ostream&, const StoreKeyValueEvent&);
+
+public:
+	StoreKeyValueEvent(int id, const std::string& name, const std::string& key, const std::string& value);
+	StoreKeyValueEvent(const StoreKeyValueEvent& event);
+
+	virtual StoreKeyValueEvent* clone();
+
+	const std::string& getValue() const;
+
+private:
+	std::string m_value;
+};
+
+std::ostream& operator<<(std::ostream&, const StoreKeyValueEvent&);
+
+}
+
+#endif

src/message/Message.h

@@ -69,6 +69,8 @@ namespace message {
 		constexpr const char* RESULT = "RESULT";
 		constexpr const char* PORT = "PORT";
 		constexpr const char* PUBLISHER = "PUBLISHER";
+		constexpr const char* STOREKEYVALUE = "STOREKEYVALUE";
+		constexpr const char* REMOVEKEY = "REMOVEKEY";
 	}
 
 	namespace SyncStreamRequest {
@@ -272,6 +274,18 @@ namespace message {
 		constexpr const char* KEY = "key"; // string
 	}
 
+	namespace StoreKeyValueEvent {
+		constexpr const char* ID = "id"; // int32
+		constexpr const char* NAME = "name"; // string
+		constexpr const char* KEY = "key"; // string
+		constexpr const char* VALUE = "value"; // string
+	}
+
+	namespace RemoveKeyEvent {
+		constexpr const char* ID = "id"; // int32
+		constexpr const char* NAME = "name"; // string
+		constexpr const char* KEY = "key"; // string
+	}
 }
 
 }