ipaacalib/cpp/src/ipaaca-converters.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+namespace converters {
+
+// Wrap a serialized inner object and a wire type in a protobuf::TransportLevelWrapper
+std::string cooked_message(const std::string& raw_message, ipaaca::protobuf::TransportMessageType msg_type)
+{
+    std::string cooked_msg;
+    std::shared_ptr<protobuf::TransportLevelWrapper> pbo(new protobuf::TransportLevelWrapper());
+    pbo->set_raw_message(raw_message);
+    pbo->set_transport_message_type(msg_type);
+    pbo->SerializeToString(&cooked_msg);
+    return cooked_msg;
+};
+
+// protobuf serialization for all supported types (replaces converter repository)
+std::string internal_serialize(ipaaca::IU::ptr iu) {
+    std::string raw_message = IUConverter::serialize(iu);
+    return cooked_message(raw_message,
+            (iu->access_mode()==IU_ACCESS_MESSAGE) ? protobuf::TransportMessageType::WireTypeMessageIU
+                                                   : protobuf::TransportMessageType::WireTypeIU);
+};
+/*
+std::string internal_serialize(ipaaca::Message::ptr msg) {
+    std::string raw_message = MessageConverter::serialize(msg);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeMessageIU);
+};
+*/
+std::string internal_serialize(ipaaca::IUPayloadUpdate::ptr pup) {
+    std::string raw_message = IUPayloadUpdateConverter::serialize(pup);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIUPayloadUpdate);
+};
+std::string internal_serialize(ipaaca::IULinkUpdate::ptr lup) {
+    std::string raw_message = IULinkUpdateConverter::serialize(lup);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIULinkUpdate);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::RemoteRequestResult> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeRemoteRequestResult);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IURetraction> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIURetraction);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IUCommission> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIUCommission);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IUResendRequest> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIUResendRequest);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IUPayloadUpdateRequest> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIUPayloadUpdateRequest);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IULinkUpdateRequest> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIULinkUpdateRequest);
+};
+std::string internal_serialize(std::shared_ptr<protobuf::IUCommissionRequest> pb) {
+    std::string raw_message;
+    pb->SerializeToString(&raw_message);
+    return cooked_message(raw_message, protobuf::TransportMessageType::WireTypeIUCommissionRequest);
+};
+
+// deserialization (just switching here instead of the converter registry business)
+ipaaca::backend::Event::ptr internal_deserialize(const std::string& wire)
+{
+    std::shared_ptr<protobuf::TransportLevelWrapper> pbo(new protobuf::TransportLevelWrapper());
+    pbo->ParseFromString(wire);
+    std::shared_ptr<ipaaca::backend::Event> event;
+    //std::cout << "internal_deserialize of TransportMessageType " << pbo->transport_message_type() << std::endl;
+    switch (pbo->transport_message_type()) {
+        case protobuf::TransportMessageType::WireTypeIU:
+            { event = std::make_shared<ipaaca::backend::Event>("ipaaca::RemotePushIU", std::static_pointer_cast<RemotePushIU>(IUConverter::deserialize(pbo->raw_message()))); }
+            break;
+        case protobuf::TransportMessageType::WireTypeMessageIU:
+            { event = std::make_shared<ipaaca::backend::Event>("ipaaca::RemoteMessage", std::static_pointer_cast<RemoteMessage>(IUConverter::deserialize(pbo->raw_message()))); }
+            break;
+        case protobuf::TransportMessageType::WireTypeIUPayloadUpdate:
+            { event = std::make_shared<ipaaca::backend::Event>("ipaaca::IUPayloadUpdate", IUPayloadUpdateConverter::deserialize(pbo->raw_message())); }
+            break;
+        case protobuf::TransportMessageType::WireTypeIULinkUpdate:
+            { event = std::make_shared<ipaaca::backend::Event>("ipaaca::IULinkUpdate", IULinkUpdateConverter::deserialize(pbo->raw_message())); }
+            break;
+        case protobuf::TransportMessageType::WireTypeIURetraction:
+            { 
+                std::shared_ptr<protobuf::IURetraction> inner(new protobuf::IURetraction());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IURetraction", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeIUCommission:
+            {
+                std::shared_ptr<protobuf::IUCommission> inner(new protobuf::IUCommission());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IUCommission", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeRemoteRequestResult:
+            {
+                std::shared_ptr<protobuf::RemoteRequestResult> inner(new protobuf::RemoteRequestResult());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::RemoteRequestResult", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeIUResendRequest:
+            {
+                std::shared_ptr<protobuf::IUResendRequest> inner(new protobuf::IUResendRequest());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IUResendRequest", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeIUPayloadUpdateRequest:
+            {
+                std::shared_ptr<protobuf::IUPayloadUpdateRequest> inner(new protobuf::IUPayloadUpdateRequest());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IUPayloadUpdateRequest", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeIULinkUpdateRequest:
+            {
+                std::shared_ptr<protobuf::IULinkUpdateRequest> inner(new protobuf::IULinkUpdateRequest());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IULinkUpdateRequest", inner);
+            }
+            break;
+        case protobuf::TransportMessageType::WireTypeIUCommissionRequest:
+            {
+                std::shared_ptr<protobuf::IUCommissionRequest> inner(new protobuf::IUCommissionRequest());
+                inner->ParseFromString(pbo->raw_message());
+                event = std::make_shared<ipaaca::backend::Event>("ipaaca::protobuf::IUCommissionRequest", inner);
+            }
+            break;
+        default:
+            throw ipaaca::UnhandledWireTypeError(pbo->transport_message_type());
+    };
+    return event;
+}
+
+// RSB backend Converters
+// IUConverter//{{{
+
+IPAACA_EXPORT std::string IUConverter::serialize(ipaaca::IU::ptr obj)
+{
+        std::string wire;
+	std::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
+	// transfer obj data to pbo
+	pbo->set_uid(obj->uid());
+	pbo->set_revision(obj->revision());
+	pbo->set_category(obj->category());
+	pbo->set_payload_type(obj->payload_type());
+	pbo->set_owner_name(obj->owner_name());
+	pbo->set_committed(obj->committed());
+	ipaaca::protobuf::IU_AccessMode a_m;
+	switch(obj->access_mode()) {
+		case IU_ACCESS_PUSH:
+			a_m = ipaaca::protobuf::IU_AccessMode_PUSH;
+			break;
+		case IU_ACCESS_REMOTE:
+			a_m = ipaaca::protobuf::IU_AccessMode_REMOTE;
+			break;
+		case IU_ACCESS_MESSAGE:
+			a_m = ipaaca::protobuf::IU_AccessMode_MESSAGE;
+			break;
+	}
+	pbo->set_access_mode(a_m);
+	pbo->set_read_only(obj->read_only());
+	for (auto& kv: obj->_payload._document_store) {
+		protobuf::PayloadItem* item = pbo->add_payload();
+		item->set_key(kv.first);
+		IPAACA_DEBUG("Payload type: " << obj->_payload_type)
+		if (obj->_payload_type=="JSON") {
+			item->set_value( kv.second->to_json_string_representation() );
+			item->set_type("JSON");
+		} else if ((obj->_payload_type=="MAP") || (obj->_payload_type=="STR")) {
+			// legacy mode
+			item->set_value( json_value_cast<std::string>(kv.second->document));
+			item->set_type("STR");
+		}
+	}
+	for (LinkMap::const_iterator it=obj->_links._links.begin(); it!=obj->_links._links.end(); ++it) {
+		protobuf::LinkSet* links = pbo->add_links();
+		links->set_type(it->first);
+		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			links->add_targets(*it2);
+		}
+	}
+	pbo->SerializeToString(&wire);
+        return wire;
+}
+
+IPAACA_EXPORT ipaaca::IUInterface::ptr IUConverter::deserialize(const std::string& wire) {
+	//assert(wireSchema == getWireSchema()); // "ipaaca-iu"
+	std::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
+	pbo->ParseFromString(wire);
+	IUAccessMode mode = static_cast<IUAccessMode>(pbo->access_mode());
+        ipaaca::IUInterface::ptr obj;
+        switch(mode) {
+		case IU_ACCESS_PUSH:
+			{
+                            // Create a "remote push IU"
+                            auto inst = RemotePushIU::create();
+                            inst->_access_mode = IU_ACCESS_PUSH;
+                            obj = inst;
+                            for (int i=0; i<pbo->payload_size(); i++) {
+                                    const protobuf::PayloadItem& it = pbo->payload(i);
+                                    PayloadDocumentEntry::ptr entry;
+                                    if (it.type() == "JSON") {
+                                            // fully parse json text
+                                            entry = PayloadDocumentEntry::from_json_string_representation( it.value() );
+                                    } else {
+                                            // assuming legacy "str" -> just copy value to raw string in document
+                                            entry = std::make_shared<PayloadDocumentEntry>();
+                                            entry->document.SetString(it.value(), entry->document.GetAllocator());
+                                    }
+                                    inst->_payload._document_store[it.key()] = entry;
+                            }
+                        }
+                        break;
+		case IU_ACCESS_MESSAGE:
+                        {
+                            auto inst = RemoteMessage::create();
+                            inst->_access_mode = IU_ACCESS_MESSAGE;
+                            obj = inst;
+                            for (int i=0; i<pbo->payload_size(); i++) {
+                                    const protobuf::PayloadItem& it = pbo->payload(i);
+                                    PayloadDocumentEntry::ptr entry;
+                                    if (it.type() == "JSON") {
+                                            // fully parse json text
+                                            entry = PayloadDocumentEntry::from_json_string_representation( it.value() );
+                                    } else {
+                                            // assuming legacy "str" -> just copy value to raw string in document
+                                            entry = std::make_shared<PayloadDocumentEntry>();
+                                            entry->document.SetString(it.value(), entry->document.GetAllocator());
+                                    }
+                                    inst->_payload._document_store[it.key()] = entry;
+                            }
+                        }
+			break;
+                default:
+                        throw NotImplementedError();
+        }
+        // transfer pbo data to obj
+        obj->_uid = pbo->uid();
+        obj->_revision = pbo->revision();
+        obj->_category = pbo->category();
+        obj->_payload_type = pbo->payload_type();
+        obj->_owner_name = pbo->owner_name();
+        obj->_committed = pbo->committed();
+        obj->_read_only = pbo->read_only();
+        for (int i=0; i<pbo->links_size(); i++) {
+                const protobuf::LinkSet& pls = pbo->links(i);
+                LinkSet& ls = obj->_links._links[pls.type()];
+                for (int j=0; j<pls.targets_size(); j++) {
+                        ls.insert(pls.targets(j));
+                }
+        }
+        return obj;
+}
+
+//}}}
+
+// IUPayloadUpdateConverter//{{{
+
+IPAACA_EXPORT std::string IUPayloadUpdateConverter::serialize(ipaaca::IUPayloadUpdate::ptr obj)
+{
+        std::string wire;
+	//assert(data.first == getDataType()); // "ipaaca::IUPayloadUpdate"
+	std::shared_ptr<protobuf::IUPayloadUpdate> pbo(new protobuf::IUPayloadUpdate());
+	// transfer obj data to pbo
+	pbo->set_uid(obj->uid);
+	pbo->set_revision(obj->revision);
+	pbo->set_writer_name(obj->writer_name);
+	pbo->set_is_delta(obj->is_delta);
+        pbo->set_request_uid(obj->request_uid);
+        pbo->set_request_endpoint(obj->request_endpoint);
+	for (auto& kv: obj->new_items) {
+		protobuf::PayloadItem* item = pbo->add_new_items();
+		item->set_key(kv.first);
+		if (obj->payload_type=="JSON") {
+			item->set_value( kv.second->to_json_string_representation() );
+			item->set_type("JSON");
+		} else if ((obj->payload_type=="MAP") || (obj->payload_type=="STR")) {
+			// legacy mode
+			item->set_value( json_value_cast<std::string>(kv.second->document));
+			item->set_type("STR");
+		} else {
+			IPAACA_ERROR("Uninitialized payload update type!")
+			throw NotImplementedError();
+		}
+		IPAACA_DEBUG("Adding updated item (type " << item->type() << "): " << item->key() << " -> " << item->value() )
+	}
+	for (auto& key: obj->keys_to_remove) {
+		pbo->add_keys_to_remove(key);
+		IPAACA_DEBUG("Adding removed key: " << key)
+	}
+	pbo->SerializeToString(&wire);
+        return wire;
+}
+
+ipaaca::IUPayloadUpdate::ptr IUPayloadUpdateConverter::deserialize(const std::string& wire) {
+	//assert(wireSchema == getWireSchema()); // "ipaaca-iu-payload-update"
+	std::shared_ptr<protobuf::IUPayloadUpdate> pbo(new protobuf::IUPayloadUpdate());
+	pbo->ParseFromString(wire);
+	std::shared_ptr<IUPayloadUpdate> obj(new IUPayloadUpdate());
+	// transfer pbo data to obj
+	obj->uid = pbo->uid();
+	obj->revision = pbo->revision();
+	obj->writer_name = pbo->writer_name();
+	obj->is_delta = pbo->is_delta();
+        obj->request_uid = pbo->request_uid();
+        obj->request_endpoint = pbo->request_endpoint();
+	for (int i=0; i<pbo->new_items_size(); i++) {
+		const protobuf::PayloadItem& it = pbo->new_items(i);
+		PayloadDocumentEntry::ptr entry;
+		if (it.type() == "JSON") {
+			// fully parse json text
+			entry = PayloadDocumentEntry::from_json_string_representation( it.value() );
+			IPAACA_DEBUG("New/updated payload entry: " << it.key() << " -> " << it.value() )
+		} else {
+			// assuming legacy "str" -> just copy value to raw string in document
+			entry = std::make_shared<PayloadDocumentEntry>();
+			entry->document.SetString(it.value(), entry->document.GetAllocator());
+		}
+		obj->new_items[it.key()] = entry;
+	}
+	for (int i=0; i<pbo->keys_to_remove_size(); i++) {
+		obj->keys_to_remove.push_back(pbo->keys_to_remove(i));
+	}
+	return obj;
+}
+
+//}}}
+// IULinkUpdateConverter//{{{
+
+IPAACA_EXPORT std::string IULinkUpdateConverter::serialize(ipaaca::IULinkUpdate::ptr obj)
+{
+        std::string wire;
+	//assert(data.first == getDataType());
+	std::shared_ptr<protobuf::IULinkUpdate> pbo(new protobuf::IULinkUpdate());
+	// transfer obj data to pbo
+	pbo->set_uid(obj->uid);
+	pbo->set_revision(obj->revision);
+	pbo->set_writer_name(obj->writer_name);
+	pbo->set_is_delta(obj->is_delta);
+        pbo->set_request_uid(obj->request_uid);
+        pbo->set_request_endpoint(obj->request_endpoint);
+	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj->new_links.begin(); it!=obj->new_links.end(); ++it) {
+		protobuf::LinkSet* links = pbo->add_new_links();
+		links->set_type(it->first);
+		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			links->add_targets(*it2);
+		}
+	}
+	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj->links_to_remove.begin(); it!=obj->links_to_remove.end(); ++it) {
+		protobuf::LinkSet* links = pbo->add_links_to_remove();
+		links->set_type(it->first);
+		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			links->add_targets(*it2);
+		}
+	}
+	pbo->SerializeToString(&wire);
+        return wire;
+}
+
+ipaaca::IULinkUpdate::ptr IULinkUpdateConverter::deserialize(const std::string& wire) {
+	//assert(wireSchema == getWireSchema()); // "ipaaca-iu-link-update"
+	std::shared_ptr<protobuf::IULinkUpdate> pbo(new protobuf::IULinkUpdate());
+	pbo->ParseFromString(wire);
+	std::shared_ptr<IULinkUpdate> obj(new IULinkUpdate());
+	// transfer pbo data to obj
+	obj->uid = pbo->uid();
+	obj->revision = pbo->revision();
+	obj->writer_name = pbo->writer_name();
+	obj->is_delta = pbo->is_delta();
+        obj->request_uid = pbo->request_uid();
+        obj->request_endpoint = pbo->request_endpoint();
+	for (int i=0; i<pbo->new_links_size(); ++i) {
+		const protobuf::LinkSet& it = pbo->new_links(i);
+		for (int j=0; j<it.targets_size(); ++j) {
+			obj->new_links[it.type()].insert(it.targets(j)); // = vec;
+		}
+	}
+	for (int i=0; i<pbo->links_to_remove_size(); ++i) {
+		const protobuf::LinkSet& it = pbo->links_to_remove(i);
+		for (int j=0; j<it.targets_size(); ++j) {
+			obj->links_to_remove[it.type()].insert(it.targets(j));
+		}
+	}
+	return obj;
+}
+
+//}}}
+
+
+} // namespace converters
+} // namespace ipaaca
+

ipaacalib/cpp/src/ipaaca-fake.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#ifdef IPAACA_BUILD_MOCK_OBJECTS
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+IPAACA_EXPORT inline FakeIU::FakeIU() {
+	IPAACA_INFO("")
+}
+IPAACA_EXPORT std::shared_ptr<FakeIU> FakeIU::create()
+{
+	IPAACA_INFO("");
+	auto iu = std::shared_ptr<FakeIU>(new FakeIU());
+	iu->_payload.initialize(iu);
+	return iu;
+}
+IPAACA_EXPORT void FakeIU::add_fake_payload_item(const std::string& key, PayloadDocumentEntry::ptr entry)
+{
+	_payload._remotely_enforced_setitem(key, entry);
+}
+IPAACA_EXPORT inline FakeIU::~FakeIU() { }
+IPAACA_EXPORT inline Payload& FakeIU::payload() { return _payload; }
+IPAACA_EXPORT inline const Payload& FakeIU::const_payload() const { return _payload; }
+IPAACA_EXPORT inline void FakeIU::commit() { }
+IPAACA_EXPORT inline void FakeIU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name) { }
+IPAACA_EXPORT inline void FakeIU::_modify_payload(bool is_delta, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name) { }
+IPAACA_EXPORT inline void FakeIU::_apply_update(IUPayloadUpdate::ptr update) { }
+IPAACA_EXPORT inline void FakeIU::_apply_link_update(IULinkUpdate::ptr update) { }
+IPAACA_EXPORT inline void FakeIU::_apply_commission() { }
+IPAACA_EXPORT inline void FakeIU::_apply_retraction() { }
+
+} // of namespace ipaaca
+
+#endif
+

ipaacalib/cpp/src/ipaaca-initializer.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+// static library Initializer
+IPAACA_EXPORT bool Initializer::_initialized = false;
+IPAACA_EXPORT bool Initializer::initialized() { return _initialized; }
+IPAACA_EXPORT void Initializer::initialize_ipaaca_rsb_if_needed()
+{
+	initialize_backend();
+}
+IPAACA_EXPORT void Initializer::initialize_backend()//{{{
+{
+	if (_initialized) return;
+
+	override_env_with_cmdline_set_variables();
+
+	_initialized = true;
+}//}}}
+IPAACA_EXPORT void Initializer::dump_current_default_config()//{{{
+{
+    IPAACA_INFO("--- Dumping current global configuration ---")
+    auto cfg = ipaaca::get_global_config();
+    for (auto it = cfg->data_cbegin(); it != cfg->data_cend(); ++it) {
+        IPAACA_INFO("--- " << it->first << " = \"" << it->second << "\"")
+    }
+    IPAACA_INFO("-------------- End of config ---------------")
+}//}}}
+IPAACA_EXPORT void Initializer::override_env_with_cmdline_set_variables()//{{{
+{
+	// set RSB host and port iff provided using cmdline arguments
+	if (__ipaaca_static_option_rsb_host!="") {
+		IPAACA_INFO("Overriding RSB host with " << __ipaaca_static_option_rsb_host)
+		IPAACA_SETENV("RSB_TRANSPORT_SPREAD_HOST", __ipaaca_static_option_rsb_host.c_str())
+		IPAACA_SETENV("RSB_TRANSPORT_SOCKET_HOST", __ipaaca_static_option_rsb_host.c_str());
+	}
+	if (__ipaaca_static_option_rsb_port!="") {
+		IPAACA_INFO("Overriding RSB port with " << __ipaaca_static_option_rsb_port)
+		IPAACA_SETENV("RSB_TRANSPORT_SPREAD_PORT", __ipaaca_static_option_rsb_port.c_str());
+		IPAACA_SETENV("RSB_TRANSPORT_SOCKET_PORT", __ipaaca_static_option_rsb_port.c_str());
+	}
+	if (__ipaaca_static_option_rsb_transport!="") {
+		if (__ipaaca_static_option_rsb_transport == "spread") {
+			IPAACA_INFO("Overriding RSB transport mode - using 'spread' ")
+			IPAACA_SETENV("RSB_TRANSPORT_SPREAD_ENABLED", "1");
+			IPAACA_SETENV("RSB_TRANSPORT_SOCKET_ENABLED", "0");
+		} else if (__ipaaca_static_option_rsb_transport == "socket") {
+			IPAACA_INFO("Overriding RSB transport mode - using 'socket' ")
+			IPAACA_SETENV("RSB_TRANSPORT_SPREAD_ENABLED", "0");
+			IPAACA_SETENV("RSB_TRANSPORT_SOCKET_ENABLED", "1");
+			if (__ipaaca_static_option_rsb_socketserver!="") {
+				const std::string& srv = __ipaaca_static_option_rsb_socketserver;
+				if ((srv=="1")||(srv=="0")||(srv=="auto")) {
+					IPAACA_INFO("Overriding RSB transport.socket.server with " << srv)
+					IPAACA_SETENV("RSB_TRANSPORT_SOCKET_SERVER", srv.c_str());
+				} else {
+					IPAACA_INFO("Unknown RSB transport.socket.server mode " << srv << " - using config default ")
+				}
+			}
+		} else {
+			IPAACA_INFO("Unknown RSB transport mode " <<  __ipaaca_static_option_rsb_transport << " - using config default ")
+		}
+	}
+}//}}}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-iuinterface.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IUInterface& obj)//{{{
+{
+	os << "IUInterface(uid='" << obj.uid() << "'";
+	os << ", category='" << obj.category() << "'";
+	os << ", revision=" << obj.revision();
+	os << ", committed=" << (obj.committed()?"True":"False");
+	os << ", owner_name='" << obj.owner_name() << "'";
+	os << ", payload=";
+	os << obj.const_payload();
+	os << ", links=";
+	os << obj._links;
+	os << ")";
+	return os;
+}
+//}}}
+
+// IUInterface//{{{
+
+IPAACA_EXPORT IUInterface::IUInterface()
+: _buffer(NULL), _committed(false), _retracted(false)
+{
+}
+
+IPAACA_EXPORT void IUInterface::_set_uid(const std::string& uid) {
+	if (_uid != "") {
+		throw IUAlreadyHasAnUIDError();
+	}
+	_uid = uid;
+}
+
+IPAACA_EXPORT void IUInterface::_set_buffer(Buffer* buffer) {
+	if (_buffer) {
+		throw IUAlreadyInABufferError();
+	}
+	_buffer = buffer;
+
+}
+
+IPAACA_EXPORT void IUInterface::_set_owner_name(const std::string& owner_name) {
+	if (_owner_name != "") {
+		throw IUAlreadyHasAnOwnerNameError();
+	}
+	_owner_name = owner_name;
+}
+
+/// set the buffer pointer and the owner names of IU and Payload
+IPAACA_EXPORT void IUInterface::_associate_with_buffer(Buffer* buffer) {
+	_set_buffer(buffer); // will throw if already set
+	_set_owner_name(buffer->unique_name());
+	payload()._set_owner_name(buffer->unique_name());
+}
+
+/// C++-specific convenience function to add one single link
+IPAACA_EXPORT void IUInterface::add_link(const std::string& type, const std::string& target, const std::string& writer_name)
+{
+	LinkMap none;
+	LinkMap add;
+	add[type].insert(target);
+	_modify_links(true, add, none, writer_name);
+	_add_and_remove_links(add, none);
+}
+/// C++-specific convenience function to remove one single link
+IPAACA_EXPORT void IUInterface::remove_link(const std::string& type, const std::string& target, const std::string& writer_name)
+{
+	LinkMap none;
+	LinkMap remove;
+	remove[type].insert(target);
+	_modify_links(true, none, remove, writer_name);
+	_add_and_remove_links(none, remove);
+}
+
+IPAACA_EXPORT void IUInterface::add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
+{
+	LinkMap none;
+	LinkMap add;
+	add[type] = targets;
+	_modify_links(true, add, none, writer_name);
+	_add_and_remove_links(add, none);
+}
+
+IPAACA_EXPORT void IUInterface::remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
+{
+	LinkMap none;
+	LinkMap remove;
+	remove[type] = targets;
+	_modify_links(true, none, remove, writer_name);
+	_add_and_remove_links(none, remove);
+}
+
+IPAACA_EXPORT void IUInterface::modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name)
+{
+	_modify_links(true, add, remove, writer_name);
+	_add_and_remove_links(add, remove);
+}
+
+IPAACA_EXPORT void IUInterface::set_links(const LinkMap& links, const std::string& writer_name)
+{
+	LinkMap none;
+	_modify_links(false, links, none, writer_name);
+	_replace_links(links);
+}
+
+IPAACA_EXPORT const std::string& IUInterface::channel()
+{
+	if (_buffer == NULL)
+		throw IUUnpublishedError();
+	else
+		return _buffer->channel();
+
+}
+
+//}}}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-ius.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+// IU//{{{
+IPAACA_EXPORT IU::ptr IU::create(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+{
+	return IU::create(category, payload_type, read_only);
+}
+IPAACA_EXPORT IU::ptr IU::create(const std::string& category, const std::string& payload_type, bool read_only)
+{
+	IU::ptr iu = IU::ptr(new IU(category, IU_ACCESS_PUSH, read_only, (payload_type=="")?__ipaaca_static_option_default_payload_type:payload_type)); /* params */ //));
+	iu->_payload.initialize(iu);
+	return iu;
+}
+
+IPAACA_EXPORT IU::IU(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+{
+	_revision = 1;
+	_uid = ipaaca::generate_uuid_string();
+	_category = category;
+	_payload_type = (payload_type=="")?__ipaaca_static_option_default_payload_type:payload_type;
+	// payload initialization deferred to IU::create(), above
+	_read_only = read_only;
+	_access_mode = access_mode;
+	_committed = false;
+	_retracted = false;
+}
+
+IPAACA_EXPORT void IU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+{
+	_revision_lock.lock();
+	if (_committed) {
+		_revision_lock.unlock();
+		throw IUCommittedError();
+	} else if (_retracted) {
+		_revision_lock.unlock();
+		throw IURetractedError();
+	}
+	_increase_revision_number();
+	if (is_published()) {
+		_buffer->_send_iu_link_update(this, is_delta, _revision, new_links, links_to_remove, writer_name);
+	}
+	_revision_lock.unlock();
+}
+
+IPAACA_EXPORT void IU::_modify_payload(bool is_delta, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	//IPAACA_INFO("")
+	_revision_lock.lock();
+	if (_committed) {
+		_revision_lock.unlock();
+		throw IUCommittedError();
+	} else if (_retracted) {
+		_revision_lock.unlock();
+		throw IURetractedError();
+	}
+	_increase_revision_number();
+	if (is_published()) {
+		IPAACA_DEBUG("Sending a payload update, new entries:")
+		for (auto& kv: new_items) {
+			IPAACA_DEBUG("  " << kv.first << " -> " << kv.second)
+		}
+		IPAACA_DEBUG("and with removed keys:")
+		for (auto& k: keys_to_remove) {
+			IPAACA_DEBUG("  " << k)
+		}
+		_buffer->_send_iu_payload_update(this, is_delta, _revision, new_items, keys_to_remove, writer_name);
+		IPAACA_DEBUG("... sent.")
+	}
+	_revision_lock.unlock();
+}
+
+IPAACA_EXPORT void IU::commit()
+{
+	_internal_commit();
+}
+
+IPAACA_EXPORT void IU::_internal_commit(const std::string& writer_name)
+{
+	_revision_lock.lock();
+	if (_committed) {
+		_revision_lock.unlock();
+		throw IUCommittedError();
+	} else if (_retracted) {
+		_revision_lock.unlock();
+		throw IURetractedError();
+	}
+	_increase_revision_number();
+	_committed = true;
+	if (is_published()) {
+		_buffer->_send_iu_commission(this, _revision, writer_name);
+	}
+	_revision_lock.unlock();
+}
+//}}}
+// Message//{{{
+Message::ptr Message::create(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+{
+	return Message::create(category, (payload_type=="")?__ipaaca_static_option_default_payload_type:payload_type);
+}
+Message::ptr Message::create(const std::string& category, const std::string& payload_type)
+{
+	Message::ptr iu = Message::ptr(new Message(category, IU_ACCESS_MESSAGE, true, (payload_type=="")?__ipaaca_static_option_default_payload_type:payload_type)); /* params */ //));
+	iu->_payload.initialize(iu);
+	return iu;
+}
+
+Message::Message(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+: IU(category, access_mode, read_only, payload_type)
+{
+}
+
+void Message::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+{
+	if (is_published()) {
+		IPAACA_INFO("Info: modifying a Message after sending has no global effects")
+	}
+}
+void Message::_modify_payload(bool is_delta, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	if (is_published()) {
+		IPAACA_INFO("Info: modifying a Message after sending has no global effects")
+	}
+}
+
+void Message::_internal_commit(const std::string& writer_name)
+{
+	if (is_published()) {
+		IPAACA_INFO("Info: committing to a Message after sending has no global effects")
+	}
+
+}
+//}}}
+
+// RemotePushIU//{{{
+
+IPAACA_EXPORT RemotePushIU::ptr RemotePushIU::create()
+{
+	RemotePushIU::ptr iu = RemotePushIU::ptr(new RemotePushIU());
+	iu->_payload.initialize(iu);
+	return iu;
+}
+IPAACA_EXPORT RemotePushIU::RemotePushIU()
+{
+}
+IPAACA_EXPORT void RemotePushIU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+{
+	if (_committed) {
+		throw IUCommittedError();
+	} else if (_retracted) {
+		throw IURetractedError();
+	} else if (_read_only) {
+		throw IUReadOnlyError();
+	}
+	auto server = ((InputBuffer*)_buffer)->_get_remote_server(_owner_name);
+	IULinkUpdate::ptr update = IULinkUpdate::ptr(new IULinkUpdate());
+	update->uid = _uid;
+	update->revision = _revision;
+	update->is_delta = is_delta;
+	update->writer_name = _buffer->unique_name();
+	update->new_links = new_links;
+	update->links_to_remove = links_to_remove;
+	int result = server->request_remote_link_update(update); // TODO
+	if (result == 0) {
+		throw IUUpdateFailedError();
+	} else {
+		_revision = result;
+	}
+}
+IPAACA_EXPORT void RemotePushIU::_modify_payload(bool is_delta, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	IPAACA_DEBUG("Sending a modify_payload with " << new_items.size() << " keys to merge.")
+	if (_committed) {
+		throw IUCommittedError();
+	} else if (_retracted) {
+		throw IURetractedError();
+	} else if (_read_only) {
+		throw IUReadOnlyError();
+	}
+	auto server = ((InputBuffer*)_buffer)->_get_remote_server(_owner_name);
+	IUPayloadUpdate::ptr update = IUPayloadUpdate::ptr(new IUPayloadUpdate());
+	update->uid = _uid;
+	update->revision = _revision;
+	update->is_delta = is_delta;
+	update->writer_name = _buffer->unique_name();
+	update->new_items = new_items;
+	update->keys_to_remove = keys_to_remove;
+	update->payload_type = _payload_type;
+	int result = server->request_remote_payload_update(update);
+	if (result == 0) {
+		throw IUUpdateFailedError();
+	} else {
+		_revision = result;
+	}
+}
+
+IPAACA_EXPORT void RemotePushIU::commit()
+{
+	if (_read_only) {
+		throw IUReadOnlyError();
+	} else if (_retracted) {
+		throw IURetractedError();
+	}
+	if (_committed) {
+		// Following python version: ignoring multiple commit
+		return;
+	}
+	auto server = ((InputBuffer*)_buffer)->_get_remote_server(_owner_name);
+	std::shared_ptr<protobuf::IUCommission> update = std::shared_ptr<protobuf::IUCommission>(new protobuf::IUCommission());
+	update->set_uid(_uid);
+	update->set_revision(_revision);
+	update->set_writer_name(_buffer->unique_name());
+	int result = server->request_remote_commission(update);
+	if (result == 0) {
+		throw IUUpdateFailedError();
+	} else {
+		_revision = result;
+	}
+}
+
+IPAACA_EXPORT void RemotePushIU::_apply_link_update(IULinkUpdate::ptr update)
+{
+	_revision = update->revision;
+	if (update->is_delta) {
+		_add_and_remove_links(update->new_links, update->links_to_remove);
+	} else {
+		_replace_links(update->new_links);
+	}
+}
+IPAACA_EXPORT void RemotePushIU::_apply_update(IUPayloadUpdate::ptr update)
+{
+	_revision = update->revision;
+	if (update->is_delta) {
+		for (std::vector<std::string>::const_iterator it=update->keys_to_remove.begin(); it!=update->keys_to_remove.end(); ++it) {
+			_payload._remotely_enforced_delitem(*it);
+		}
+		for (std::map<std::string, PayloadDocumentEntry::ptr>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
+			_payload._remotely_enforced_setitem(it->first, it->second);
+		}
+	} else {
+		_payload._remotely_enforced_wipe();
+		for (std::map<std::string, PayloadDocumentEntry::ptr>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
+			_payload._remotely_enforced_setitem(it->first, it->second);
+		}
+	}
+}
+IPAACA_EXPORT void RemotePushIU::_apply_commission()
+{
+	_committed = true;
+}
+IPAACA_EXPORT void RemotePushIU::_apply_retraction()
+{
+	_retracted = true;
+}
+//}}}
+
+// RemoteMessage//{{{
+
+IPAACA_EXPORT RemoteMessage::ptr RemoteMessage::create()
+{
+	RemoteMessage::ptr iu = RemoteMessage::ptr(new RemoteMessage());
+	iu->_payload.initialize(iu);
+	return iu;
+}
+IPAACA_EXPORT RemoteMessage::RemoteMessage()
+{
+}
+IPAACA_EXPORT void RemoteMessage::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+{
+	IPAACA_INFO("Info: modifying a RemoteMessage only has local effects")
+}
+IPAACA_EXPORT void RemoteMessage::_modify_payload(bool is_delta, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	IPAACA_INFO("Info: modifying a RemoteMessage only has local effects")
+}
+IPAACA_EXPORT void RemoteMessage::commit()
+{
+	IPAACA_INFO("Info: committing to a RemoteMessage only has local effects")
+}
+
+IPAACA_EXPORT void RemoteMessage::_apply_link_update(IULinkUpdate::ptr update)
+{
+	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_link_update")
+	_revision = update->revision;
+	if (update->is_delta) {
+		_add_and_remove_links(update->new_links, update->links_to_remove);
+	} else {
+		_replace_links(update->new_links);
+	}
+}
+IPAACA_EXPORT void RemoteMessage::_apply_update(IUPayloadUpdate::ptr update)
+{
+	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_update")
+	_revision = update->revision;
+	if (update->is_delta) {
+		for (std::vector<std::string>::const_iterator it=update->keys_to_remove.begin(); it!=update->keys_to_remove.end(); ++it) {
+			_payload._remotely_enforced_delitem(*it);
+		}
+		for (std::map<std::string, PayloadDocumentEntry::ptr>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
+			_payload._remotely_enforced_setitem(it->first, it->second);
+		}
+	} else {
+		_payload._remotely_enforced_wipe();
+		for (std::map<std::string, PayloadDocumentEntry::ptr>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
+			_payload._remotely_enforced_setitem(it->first, it->second);
+		}
+	}
+}
+IPAACA_EXPORT void RemoteMessage::_apply_commission()
+{
+	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_commission")
+	_committed = true;
+}
+IPAACA_EXPORT void RemoteMessage::_apply_retraction()
+{
+	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_retraction")
+	_retracted = true;
+}
+
+//}}}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-json.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+/**
+ * \file   ipaaca-json.cc
+ *
+ * \brief Testbed for ipaaca / JSON functionality
+ *
+ * This file is not used in the ipaaca library, but produces
+ * a separate program, if enabled in CMakeLists.txt
+ *
+ * \author Ramin Yaghoubzadeh (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   March, 2015
+ */
+
+#include <ipaaca/ipaaca.h>
+
+#include "rapidjson/document.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/filestream.h"
+
+#include <cstdio>
+#include <iomanip>
+
+// Notes:
+//  - From http://stackoverflow.com/questions/10426924/json-root-element
+//    Actually there are two different JSON specifications. RFC 4627 requires a JSON text to be
+//    an object or an array. ECMA-262, 5th edition, section 15.12 does not impose this restriction.
+
+
+
+using namespace rapidjson;
+using namespace std;
+
+int batch_update_main(int argc, char** argv)//{{{
+{
+	ipaaca::OutputBuffer::ptr ob = ipaaca::OutputBuffer::create("myprog");
+	std::cout << std::endl << "Setting up an IU with initial contents" << std::endl;
+	ipaaca::IU::ptr iu = ipaaca::IU::create("testcategory");
+	iu->payload()["a"] = "OLD: initial contents of payload";
+	iu->payload()["b"] = "OLD: initial value for b";
+	std::cout << std::endl << "Initial contents of payload:" << std::endl;
+	for (auto it: iu->payload()) {
+		std::cout << "  " << it.first << " -> " << it.second << std::endl;
+	}
+	
+	std::cout << std::endl << "Publishing IU (sniffer should receive one ADDED)" << std::endl;
+	ob->add(iu);
+	
+	std::cout << "Waiting 5 sec" << std::endl;
+	sleep(5);
+	
+	std::cout << std::endl << "Batch-writing some stuff (sniffer should receive a single UPDATED)" << std::endl;
+	{
+		ipaaca::Locker locker(iu->payload());
+		iu->payload().set(std::map<std::string, std::string>{{"b", "VALUE"}, {"bPrime", "VALUE"}});
+		iu->payload()["a"] = std::map<std::string, long>{{"a", 1},{"b", 2},{"c", 3}};
+		iu->payload()["remove_me"] = "WARNING: this should not be in the payload where an update is received!";
+		iu->payload()["c"] = "WARNING: this should read abc123, not this warning message!";
+		iu->payload()["d"] = 100;
+		iu->payload().remove("d");
+		iu->payload()["d"] = 200;
+		iu->payload()["d"] = 300;
+		iu->payload().remove("d");
+		iu->payload()["d"] = 400;
+		iu->payload()["e"] = "Note: a key 'd' should exist with value 400, and 'b' and 'bPrime' should be equal";
+		iu->payload()["f"] = "12.5000";
+		iu->payload()["g"] = std::vector<std::string>{"g1", "g2"};
+		iu->payload().remove("remove_me");
+		iu->payload()["c"] = "abc123";
+		iu->payload()["testlist"] = std::vector<long> {0, 1, 2, 3, 4, 5};
+	}
+	
+	std::cout << std::endl << "Adding another key 'XYZ' and changing testlist to start with 2 1000s (sniffer -> 1x UPDATED)" << std::endl;
+	{
+		ipaaca::Locker locker(iu->payload());
+		iu->payload()["XYZ"] = "testlist should now start with two 1000s";
+		iu->payload()["testlist"][0] = 500;
+		iu->payload()["testlist"][0] = 1000;
+		iu->payload()["testlist"][1] = 1000;
+	}
+	std::cout << std::endl << "Final batch update, wiping most (sniffer should receive a third UPDATED, with 3 keys remaining in the payload)" << std::endl;
+	{
+		ipaaca::Locker locker(iu->payload());
+		iu->payload()["SHOULD_NOT_EXIST"] = "WARNING: this key should never be visible";
+		iu->payload().set(std::map<std::string, std::string>{{"A", "Final contents (3 entries)"}, {"B", "Final stuff (3 entries)"}});
+		iu->payload()["C"] = std::vector<std::string>{"payload ", "should ", "have ", "three ", "entries, ", "A ", "B ", "and ", "C"};
+	}
+	
+	std::cout << std::endl << "Final contents of payload:" << std::endl;
+	for (auto it: iu->payload()) {
+		std::cout << "  " << it.first << " -> " << it.second << std::endl;
+	}
+	
+	std::cout << "Waiting 2 sec" << std::endl;
+	sleep(2);
+	return 0;
+}
+//}}}
+
+#ifdef IPAACA_BUILD_MOCK_OBJECTS
+int iterators_main(int argc, char** argv)//{{{
+{
+	std::string json_source("[\n\
+	\"old\",\n\
+	[\n\
+		\"str\",\n\
+		null\n\
+	],\n\
+	3,\n\
+	{\n\
+		\"key1\": \"value1\",\n\
+		\"key2\": \"value2\"\n\
+	}\n\
+]");
+	
+	std::cout << "Using this JSON document as initial payload entry 'a':" << std::endl << json_source << std::endl;
+	ipaaca::PayloadDocumentEntry::ptr entry = ipaaca::PayloadDocumentEntry::from_json_string_representation(json_source);
+	
+	std::cout << std::endl << "Setting up payload by adding some additional values" << std::endl;
+	ipaaca::FakeIU::ptr iu = ipaaca::FakeIU::create();
+	iu->add_fake_payload_item("a", entry);
+	iu->payload()["b"] = "simpleString";
+	iu->payload()["bPrime"] = "simpleString";
+	iu->payload()["c"] = "anotherSimpleString";
+	iu->payload()["d"] = 100;
+	iu->payload()["e"] = 3l;
+	iu->payload()["f"] = "12.5000";
+	iu->payload()["g"] = std::vector<std::string>{"g1", "g2"};
+	
+	std::cout << std::endl << "Iterate over payload" << std::endl;
+	for (auto it = iu->payload().begin(); it != iu->payload().end(); ++it) {
+		std::cout << "  " << it->first << " -> " << it->second << std::endl;
+	}
+	std::cout << std::endl << "Iterate over payload, range-based" << std::endl;
+	for (auto it: iu->payload()) {
+		std::cout << "  " << it.first << " -> " << it.second << std::endl;
+	}
+	
+	std::cout << std::endl << "Comparisons" << std::endl;
+	bool eq;
+	eq = iu->payload()["a"] == iu->payload()["b"];
+	std::cout << "  a==b ? : " << (eq?"true":"false") << std::endl;
+	eq = iu->payload()["b"] == iu->payload()["bPrime"];
+	std::cout << "  b==bPrime ? : " << (eq?"true":"false") << std::endl;
+	eq = iu->payload()["b"] == "simpleString";
+	std::cout << "  b==\"simpleString\" ? : " << (eq?"true":"false") << std::endl;
+	eq = iu->payload()["b"] == 100;
+	std::cout << "  b==100 ? : " << (eq?"true":"false") << std::endl;
+	eq = iu->payload()["d"] == 100;
+	std::cout << "  d==100 ? : " << (eq?"true":"false") << std::endl;
+	eq = iu->payload()["a"][2] == iu->payload()["e"];
+	std::cout << "  a[2]==e ? : " << (eq?"true":"false") << std::endl;
+	
+	std::cout << std::endl << "Type checks" << std::endl;
+	std::cout << "  a[3] is_null() ? : " << ((iu->payload()["a"][3].is_null())?"true":"false") << std::endl;
+	std::cout << "  a[3] is_string() ? : " << ((iu->payload()["a"][3].is_string())?"true":"false") << std::endl;
+	std::cout << "  a[3] is_number() ? : " << ((iu->payload()["a"][3].is_number())?"true":"false") << std::endl;
+	std::cout << "  a[3] is_list() ? : " << ((iu->payload()["a"][3].is_list())?"true":"false") << std::endl;
+	std::cout << "  a[3] is_map() ? : " << ((iu->payload()["a"][3].is_map())?"true":"false") << std::endl;
+	std::cout << std::endl;
+	std::cout << "  f is_null() ? : " << ((iu->payload()["f"].is_null())?"true":"false") << std::endl;
+	std::cout << "  f is_string() ? : " << ((iu->payload()["f"].is_string())?"true":"false") << std::endl;
+	std::cout << "  f is_number() ? : " << ((iu->payload()["f"].is_number())?"true":"false") << std::endl;
+	std::cout << "  f is_list() ? : " << ((iu->payload()["f"].is_list())?"true":"false") << std::endl;
+	std::cout << "  f is_map() ? : " << ((iu->payload()["f"].is_map())?"true":"false") << std::endl;
+	
+	std::cout << std::endl << "Inner iterators, map (printing values as strings)" << std::endl;
+	try {
+		auto inner = iu->payload()["a"][3];
+		std::cout << "Map iteration over payload['a'][3], which equals " << inner << std::endl;
+		std::cout << "Reported size is " << inner.size() << std::endl;
+		for (auto kv: inner.as_map()) {
+			std::cout << "  \"" << kv.first << "\" -> \"" << kv.second << "\"" << std::endl;
+		}
+	} catch (ipaaca::Exception& ex) {
+		std::cout << "  Unexpected exception: " << ex.what() << std::endl;
+	}
+	try {
+		auto inner = iu->payload()["a"][2];
+		std::cout << "Map iteration over payload['a'][2], which equals " << inner << std::endl;
+		std::cout << "Reported size is " << inner.size() << std::endl;
+		for (auto kv: inner.as_map()) {
+			std::cout << "  \"" << kv.first << "\" -> \"" << kv.second << "\"" << std::endl;
+		}
+	} catch (ipaaca::PayloadTypeConversionError& ex) {
+		std::cout << "  Failed as expected with " << ex.what() << std::endl;
+	} catch (ipaaca::Exception& ex) {
+		std::cout << "  Unexpected exception: " << ex.what() << std::endl;
+	}
+	
+	std::cout << std::endl << "Inner iterators, list (printing values as strings)" << std::endl;
+	try {
+		auto inner = iu->payload()["a"][1];
+		std::cout << "List iteration over payload['a'][1], which equals " << inner << std::endl;
+		std::cout << "Reported size is " << inner.size() << std::endl;
+		for (auto proxy: inner.as_list()) {
+			std::cout << "  \"" << proxy << "\"" << std::endl;
+		}
+	} catch (ipaaca::Exception& ex) {
+		std::cout << "  Unexpected exception: " << ex.what() << std::endl;
+	}
+	try {
+		auto inner = iu->payload()["a"][1][1];
+		std::cout << "List iteration over payload['a'][1][1], which equals " << inner << std::endl;
+		std::cout << "Reported size is " << inner.size() << std::endl;
+		for (auto proxy: inner.as_list()) {
+			std::cout << "  \"" << proxy << "\"" << std::endl;
+		}
+	} catch (ipaaca::PayloadTypeConversionError& ex) {
+		std::cout << "  Failed as expected with " << ex.what() << std::endl;
+	} catch (ipaaca::Exception& ex) {
+		std::cout << "  Unexpected exception: " << ex.what() << std::endl;
+	}
+	
+	std::cout << std::endl << "Appending a string item to the end of payload['a']" << std::endl;
+	iu->payload()["a"].push_back("appended string entry");
+	std::cout << "Resulting entries in payload['a']:" << std::endl;
+	for (auto v: iu->payload()["a"].as_list()) {
+		std::cout << "  " << v << std::endl;
+	}
+	
+	std::cout << std::endl << "Extending payload['a'] by a list of three bools" << std::endl;
+	iu->payload()["a"].extend(std::list<bool>{false, false, true});
+	std::cout << "Resulting entries in payload['a']:" << std::endl;
+	for (auto v: iu->payload()["a"].as_list()) {
+		std::cout << "  " << v << std::endl;
+	}
+	
+	std::cout << std::endl << "Extending payload['a'] by payload['g'] and appending payload['f']" << std::endl;
+	iu->payload()["a"].extend(iu->payload()["g"]);
+	iu->payload()["a"].push_back(iu->payload()["f"]);
+	std::cout << "Resulting entries in payload['a']:" << std::endl;
+	for (auto v: iu->payload()["a"].as_list()) {
+		std::cout << "  " << v << std::endl;
+	}
+	
+	return 0;
+}
+//}}}
+
+int json_testbed_main(int argc, char** argv)//{{{
+{
+	std::string json_source("[\"old\",2,3,4]");
+	ipaaca::PayloadDocumentEntry::ptr entry = ipaaca::PayloadDocumentEntry::from_json_string_representation(json_source);
+	
+	std::string newinner("{\"K\":\"V\"}");
+	ipaaca::PayloadDocumentEntry::ptr entrynew = ipaaca::PayloadDocumentEntry::from_json_string_representation(newinner);
+	
+	ipaaca::FakeIU::ptr iu = ipaaca::FakeIU::create();
+	iu->add_fake_payload_item("a", entry);
+	iu->add_fake_payload_item("b", entrynew);
+	iu->payload()["c"] = "simpleString";
+	
+	auto proxy = iu->payload()["a"][3];
+	
+	std::cout << "IU payload before: " << iu->payload() << std::endl;
+	std::cout << "Entry before:      " << entry << std::endl;
+	std::cout << "EntryNew before:   " << entrynew << std::endl;
+	
+	/*
+	proxy.json_value->CopyFrom(entrynew->document, proxy.document_entry->document.GetAllocator());
+	proxy.document_entry->update_json_source();
+	*/
+	proxy = iu->payload()["b"];
+	
+	std::cout << "Newly written part: " << iu->payload()["a"][3] << std::endl;
+	iu->payload()["a"][3]["addkey"] = "addvalue";
+	
+	std::cout << "IU payload after: " << iu->payload() << std::endl;
+	std::cout << "Entry after:      " << entry << std::endl;
+	std::cout << "EntryNew after:   " << entrynew << std::endl;
+	
+	return 0;
+}
+//}}}
+
+int fakeiu_main(int argc, char** argv)//{{{
+{
+	//if (argc<2) {
+	//	std::cout << "Please provide json content as the first argument." << std::endl;
+	//	return 0;
+	//}
+	//
+	std::string json_source("[\"old\",2,3,4]");
+	ipaaca::PayloadDocumentEntry::ptr entry = ipaaca::PayloadDocumentEntry::from_json_string_representation(json_source);
+	
+	ipaaca::FakeIU::ptr iu = ipaaca::FakeIU::create();
+	iu->add_fake_payload_item("a", entry);
+	iu->payload()["b"] = "anotherValue";
+	iu->payload()["c"] = "yetAnotherValue";
+
+	auto a = iu->payload()["a"];
+	//auto a0 = a[0];
+	std::cout << "entry as string:       " << (std::string) a << std::endl;
+	std::cout << "entry as long:         " << (long) a << std::endl;
+	std::cout << "entry as double:       " << (double) a << std::endl;
+	std::cout << "entry as bool:         " << ((bool) a?"true":"false") << std::endl;
+	// std::vector
+	std::cout << "entry as vector<string>: ";
+	try {
+		std::vector<std::string> v = a;
+		std::for_each(v.begin(), v.end(), [](std::string& s) {
+				std::cout << s << " ";
+		});
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	std::cout << "entry as vector<long>:   ";
+	try {
+		std::vector<long> v = a;
+		std::for_each(v.begin(), v.end(), [](long& s) {
+				std::cout << s << " ";
+		});
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	std::cout << "entry as vector<bool>:   ";
+	try {
+		std::vector<bool> v = a;
+		std::for_each(v.begin(), v.end(), [](bool s) {
+				std::cout << (s?"true":"false") << " ";
+		});
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	// std::map
+	std::cout << "entry as map<string, string>: ";
+	try {
+		std::map<std::string, std::string> m = a;
+		for (auto it = m.begin(); it != m.end(); ++it) {
+			std::cout << it->first << ":" << it->second << "  ";
+		}
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	std::cout << "entry as map<string, long>: ";
+	try {
+		std::map<std::string, long> m = a;
+		for (auto it = m.begin(); it != m.end(); ++it) {
+			std::cout << it->first << ":" << it->second << "  ";
+		}
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	std::cout << "entry as map<string, double>: ";
+	try {
+		std::map<std::string, double> m = a;
+		for (auto it = m.begin(); it != m.end(); ++it) {
+			std::cout << it->first << ":" << it->second << "  ";
+		}
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	std::cout << "entry as map<string, bool>: ";
+	try {
+		std::map<std::string, bool> m = a;
+		for (auto it = m.begin(); it != m.end(); ++it) {
+			std::cout << it->first << ":" << (it->second?"true":"false") << "  ";
+		}
+		std::cout << std::endl;
+	} catch (...) {
+		std::cout << "(n/a)" << std::endl;
+	}
+	
+	std::cout << "Setting value [0] in the object:" << std::endl;
+	try {
+		iu->payload()["a"][0] = "CHANGED_BY_USER";
+	} catch (ipaaca::PayloadAddressingError& e) {
+		std::cout << "  Error - the provided object was not a suitable array" << std::endl;
+	}
+	//iu->payload()["a"]["A"] = "set by pep::op=";
+	
+	
+	std::cout << "Appending two words to key 'b' the currently wrong way:" << std::endl;
+	auto proxy = iu->payload()["b"];
+	proxy = (std::string) proxy + " WORD1";
+	proxy = (std::string) proxy + " WORD2";
+	
+	std::cout << "Appending two words to key 'c' the compatible way:" << std::endl;
+	iu->payload()["c"] = (std::string) iu->payload()["c"] + " WORD1";
+	iu->payload()["c"] = (std::string) iu->payload()["c"] + " WORD2";
+	
+	std::cout << "Printing final payload using PayloadIterator:" << std::endl;
+	for (auto it = iu->payload().begin(); it != iu->payload().end(); ++it) {
+		std::cout << "  " << std::left << std::setw(15) << ((*it).first+": ") << (*it).second << std::endl;
+	}
+	
+	std::cout << "Final payload (cast to map, printed as strings):" << std::endl;
+	std::map<std::string, std::string> pl_flat = iu->payload();
+	for (auto& kv: pl_flat) {
+		std::cout << "  " << std::left << std::setw(15) << (kv.first+": ") << kv.second << std::endl;
+	}
+	return 0;
+}
+//}}}
+#endif
+
+int legacy_iu_main(int argc, char** argv)//{{{
+{
+	// produce and fill a new and a legacy IU with identical contents
+	
+	ipaaca::OutputBuffer::ptr ob = ipaaca::OutputBuffer::create("jsonTestSenderLegacy");
+	ob->register_handler([](ipaaca::IUInterface::ptr iu, ipaaca::IUEventType event_type, bool local) {
+		std::cout << "Received remote update, new payload: " << iu->payload() << std::endl;
+	});
+	std::cout << "--- Create IUs with category jsonTest" << std::endl;
+	ipaaca::IU::ptr iu1 = ipaaca::IU::create("jsonTest");
+	ipaaca::IU::ptr iu2 = ipaaca::IU::create("jsonTest", "STR"); // explicity request old payload
+	std::map<std::string, long> newmap = { {"fifty", 50}, {"ninety-nine", 99} };
+	std::cout << "--- Set map" << std::endl;
+	iu1->payload()["map"] = newmap;
+	iu1->payload()["array"] = std::vector<std::string>{"aaa", "bbb", "ccc"};
+	iu2->payload()["map"] = newmap;
+	iu2->payload()["array"] = std::vector<std::string>{"aaa", "bbb", "ccc"};
+	std::cout << "--- Publishing IUs with this payload:" << std::endl;
+	std::cout << iu1->payload() << std::endl;
+	ob->add(iu1);
+	ob->add(iu2);
+	std::cout << "--- Waiting for changes for 5s " << std::endl;
+	sleep(5);
+	return 0;
+}
+//}}}
+
+int iu_main(int argc, char** argv)//{{{
+{
+	ipaaca::InputBuffer::ptr ib = ipaaca::InputBuffer::create("jsonTestReceiver", "jsonTest");
+	ib->register_handler([](ipaaca::IUInterface::ptr iu, ipaaca::IUEventType event_type, bool local) {
+		if (event_type==IU_ADDED) {
+			std::cout << "Received a new IU, payload: " << iu->payload() << std::endl;
+			std::cout << "Will write something." << std::endl;
+			//iu->commit();
+			try {
+				iu->payload()["list"][0] = "Overridden from C++";
+			} catch (ipaaca::PayloadAddressingError& e) {
+				iu->payload()["newKey"] = std::vector<long>{2,4,6,8};
+				std::cout << "  (item ['list'][0] could not be addressed, wrote new key)" << std::endl;
+			}
+		}
+	});
+	std::cout << "--- Waiting for IUs for 10s " << std::endl;
+	sleep(10);
+	return 0;
+	
+	ipaaca::OutputBuffer::ptr ob = ipaaca::OutputBuffer::create("jsonTestSender");
+	ob->register_handler([](ipaaca::IUInterface::ptr iu, ipaaca::IUEventType event_type, bool local) {
+		std::cout << "Received remote update, new payload: " << iu->payload() << std::endl;
+	});
+	std::cout << "--- Create IU with category jsonTest" << std::endl;
+	ipaaca::IU::ptr iu = ipaaca::IU::create("jsonTest");
+	std::map<std::string, long> newmap = { {"fifty", 50}, {"ninety-nine", 99} };
+	std::cout << "--- Set map" << std::endl;
+	iu->payload()["map"] = newmap;
+	std::cout << "--- Publishing IU with this payload:" << std::endl;
+	std::cout << iu->payload() << std::endl;
+	ob->add(iu);
+	std::cout << "--- Waiting for changes for 5s before next write" << std::endl;
+	sleep(5);
+	std::cout << "--- Contents of map after 5s" << std::endl;
+	std::cout << iu->payload()["map"] << std::endl;
+	//
+	std::cout << "--- Creating a list" << std::endl;
+	iu->payload()["list"] = std::vector<long>{1, 0} ;
+	std::cout << "--- Waiting for changes for 5s " << std::endl;
+	sleep(5);
+	std::cout << "--- Final map " << std::endl;
+	std::cout << iu->payload()["map"] << std::endl;
+	std::cout << "--- Final list " << std::endl;
+	std::cout << iu->payload()["list"] << std::endl;
+	std::cout << "--- Terminating " << std::endl;
+	return 0;
+}
+//}}}
+
+int main(int argc, char** argv)
+{
+	ipaaca::CommandLineParser::ptr parser = ipaaca::CommandLineParser::create();
+	ipaaca::CommandLineOptions::ptr options = parser->parse(argc, argv);
+
+	return batch_update_main(argc, argv);
+	//return iterators_main(argc, argv);
+	//return json_testbed_main(argc, argv);
+	//return legacy_iu_main(argc, argv);
+	//return fakeiu_main(argc, argv);
+	//return iu_main(argc, argv);
+}

ipaacalib/cpp/src/ipaaca-links.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj)//{{{
+{
+	os << "{";
+	bool first = true;
+	for (LinkMap::const_iterator it=obj._links.begin(); it!=obj._links.end(); ++it) {
+		if (first) { first=false; } else { os << ", "; }
+		os << "'" << it->first << "': [";
+		bool firstinner = true;
+		for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			if (firstinner) { firstinner=false; } else { os << ", "; }
+			os << "'" << *it2 << "'";
+		}
+		os << "]";
+	}
+	os << "}";
+	return os;
+}
+//}}}
+
+// SmartLinkMap//{{{
+
+IPAACA_EXPORT LinkSet SmartLinkMap::empty_link_set;
+IPAACA_EXPORT void SmartLinkMap::_add_and_remove_links(const LinkMap& add, const LinkMap& remove)
+{
+	// remove specified links
+	for (LinkMap::const_iterator it = remove.begin(); it != remove.end(); ++it ) {
+		// if link type exists
+		if (_links.count(it->first) > 0) {
+			// remove one by one
+			for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+				_links[it->first].erase(*it2);
+			}
+			// wipe the type key if no more links are left
+			if (_links[it->first].size() == 0) {
+				_links.erase(it->first);
+			}
+		}
+	}
+	// add specified links
+	for (LinkMap::const_iterator it = add.begin(); it != add.end(); ++it ) {
+		for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			_links[it->first].insert(*it2);
+		}
+	}
+}
+IPAACA_EXPORT void SmartLinkMap::_replace_links(const LinkMap& links)
+{
+	_links=links;
+}
+IPAACA_EXPORT const LinkSet& SmartLinkMap::get_links(const std::string& key)
+{
+	LinkMap::const_iterator it = _links.find(key);
+	if (it==_links.end()) return empty_link_set;
+	return it->second;
+}
+IPAACA_EXPORT const LinkMap& SmartLinkMap::get_all_links()
+{
+	return _links;
+}
+//}}}
+
+} // of namespace ipaaca
+

ipaacalib/cpp/src/ipaaca-locking.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+
+Lock& logger_lock() {
+	static Lock lock;
+	return lock;
+}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-payload.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+
+#include <sstream>
+
+namespace ipaaca {
+
+using namespace rapidjson;
+
+// temporary helper to show rapidjson internal type
+std::string value_diagnosis(rapidjson::Value* val)
+{
+	if (!val) return "nullptr";
+	if (val->IsNull()) return "null";
+	if (val->IsString()) return "string";
+	if (val->IsNumber()) return "number";
+	if (val->IsBool()) return "bool";
+	if (val->IsArray()) return "array";
+	if (val->IsObject()) return "object";
+	return "other";
+}
+
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const rapidjson::Value& val)//{{{
+{
+	os << json_value_cast<std::string>(val);
+	return os;
+}
+//}}}
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const PayloadEntryProxy& proxy)//{{{
+{
+	if (proxy.json_value) os << *(proxy.json_value);
+	else os << "null";
+	return os;
+}
+//}}}
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, PayloadDocumentEntry::ptr entry)//{{{
+{
+	os << json_value_cast<std::string>(entry->document);
+	return os;
+}
+//}}}
+
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const Payload& obj)//{{{
+{
+	os << "{";
+	bool first = true;
+	for (auto& kv: obj._document_store) {
+		if (first) { first=false; } else { os << ", "; }
+		os << "\"" << kv.first << "\":" << kv.second->to_json_string_representation() << "";
+	}
+	os << "}";
+	return os;
+}
+//}}}
+
+double strict_numerical_interpretation(const std::string& str)
+{
+	char* endptr;
+	auto s = str_trim(str);
+	const char* startptr = s.c_str();
+	double d = strtod(startptr, &endptr);
+	if ((*endptr)=='\0') {
+		// everything could be parsed
+		return d;
+	} else {
+		throw PayloadTypeConversionError();
+	}
+}
+
+// json_value_cast//{{{
+IPAACA_EXPORT template<> std::string json_value_cast(const rapidjson::Value& v)
+{
+	if (v.IsString()) return v.GetString();
+	if (v.IsNull()) return "";
+	rapidjson::StringBuffer buffer;
+	rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+	v.Accept(writer);
+	return buffer.GetString();
+}
+IPAACA_EXPORT template<> long json_value_cast(const rapidjson::Value& v)
+{
+	if (v.IsString()) return (long) strict_numerical_interpretation(v.GetString());
+	if (v.IsInt()) return v.GetInt();
+	if (v.IsUint()) return v.GetUint();
+	if (v.IsInt64()) return v.GetInt64();
+	if (v.IsUint64()) return v.GetUint64();
+	if (v.IsDouble()) return (long) v.GetDouble();
+	if (v.IsBool()) return v.GetBool() ? 1l : 0l;
+	if (v.IsNull()) return 0l;
+	// default: return parse of string version (should always be 0 though?)
+	throw PayloadTypeConversionError();
+}
+IPAACA_EXPORT template<> int json_value_cast(const rapidjson::Value& v)
+{
+	if (v.IsString()) return (int) strict_numerical_interpretation(v.GetString());
+	if (v.IsInt()) return v.GetInt();
+	if (v.IsUint()) return v.GetUint();
+	if (v.IsInt64()) return v.GetInt64();
+	if (v.IsUint64()) return v.GetUint64();
+	if (v.IsDouble()) return (long) v.GetDouble();
+	if (v.IsBool()) return v.GetBool() ? 1l : 0l;
+	if (v.IsNull()) return 0l;
+	throw PayloadTypeConversionError();
+}
+IPAACA_EXPORT template<> double json_value_cast(const rapidjson::Value& v)
+{
+	if (v.IsString()) return strict_numerical_interpretation(v.GetString());
+	if (v.IsDouble()) return v.GetDouble();
+	if (v.IsInt()) return (double) v.GetInt();
+	if (v.IsUint()) return (double) v.GetUint();
+	if (v.IsInt64()) return (double) v.GetInt64();
+	if (v.IsUint64()) return (double) v.GetUint64();
+	if (v.IsBool()) return v.GetBool() ? 1.0 : 0.0;
+	if (v.IsNull()) return 0.0;
+	throw PayloadTypeConversionError();
+}
+IPAACA_EXPORT template<> bool json_value_cast(const rapidjson::Value& v)
+{
+	if (v.IsString()) {
+		std::string s = v.GetString();
+		return !(s==""); // NEW: only empty string maps to false
+	}
+	if (v.IsBool()) return v.GetBool();
+	if (v.IsNull()) return false;
+	if (v.IsInt()) return v.GetInt() != 0;
+	if (v.IsUint()) return v.GetUint() != 0;
+	if (v.IsInt64()) return v.GetInt64() != 0;
+	if (v.IsUint64()) return v.GetUint64() != 0;
+	if (v.IsDouble()) return v.GetDouble() != 0.0;
+	// NEW: empty structures map to false ('Pythonesque' semantics!)
+	if (v.IsArray()) return v.Size() > 0;
+	if (v.IsObject()) return v.MemberCount() > 0;
+	throw NotImplementedError(); // should never be reached anyway
+}
+//}}}
+
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, int newvalue)
+{
+	valueobject.SetInt(newvalue);
+}
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, long newvalue)
+{
+	valueobject.SetInt(newvalue);
+}
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, double newvalue)
+{
+	valueobject.SetDouble(newvalue);
+}
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, bool newvalue)
+{
+	valueobject.SetBool(newvalue);
+}
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, const std::string& newvalue)
+{
+	valueobject.SetString(newvalue.c_str(), allocator);
+}
+IPAACA_EXPORT void pack_into_json_value(rapidjson::Value& valueobject, rapidjson::Document::AllocatorType& allocator, const char* newvalue)
+{
+	valueobject.SetString(newvalue, allocator);
+}
+
+// PayloadDocumentEntry//{{{
+IPAACA_EXPORT std::string PayloadDocumentEntry::to_json_string_representation()
+{
+	rapidjson::StringBuffer buffer;
+	rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+	document.Accept(writer);
+	return buffer.GetString();
+}
+IPAACA_EXPORT PayloadDocumentEntry::ptr PayloadDocumentEntry::from_json_string_representation(const std::string& json_str)
+{
+	PayloadDocumentEntry::ptr entry = std::make_shared<ipaaca::PayloadDocumentEntry>();
+	if (entry->document.Parse(json_str.c_str()).HasParseError()) {
+		throw JsonParsingError();
+	}
+	return entry;
+}
+IPAACA_EXPORT PayloadDocumentEntry::ptr PayloadDocumentEntry::from_unquoted_string_value(const std::string& str)
+{
+	PayloadDocumentEntry::ptr entry = std::make_shared<ipaaca::PayloadDocumentEntry>();
+	entry->document.SetString(str.c_str(), entry->document.GetAllocator());
+	return entry;
+}
+
+IPAACA_EXPORT PayloadDocumentEntry::ptr PayloadDocumentEntry::create_null()
+{
+	PayloadDocumentEntry::ptr entry = std::make_shared<ipaaca::PayloadDocumentEntry>();
+	return entry;
+}
+IPAACA_EXPORT PayloadDocumentEntry::ptr PayloadDocumentEntry::clone()
+{
+	auto entry = PayloadDocumentEntry::create_null();
+	entry->document.CopyFrom(this->document, entry->document.GetAllocator());
+	IPAACA_DEBUG("PayloadDocumentEntry cloned for copy-on-write, contents: " << entry)
+	return entry;
+}
+IPAACA_EXPORT rapidjson::Value& PayloadDocumentEntry::get_or_create_nested_value_from_proxy_path(PayloadEntryProxy* pep)
+{
+	if (!(pep->parent)) {
+		return document;
+	}
+	rapidjson::Value& parent_value = get_or_create_nested_value_from_proxy_path(pep->parent);
+	if (pep->addressed_as_array) {
+		IPAACA_DEBUG("Addressed as array with index " << pep->addressed_index)
+		if (! parent_value.IsArray()) {
+			IPAACA_INFO("parent value is not of type Array")
+			throw PayloadAddressingError();
+		} else {
+			long idx = pep->addressed_index;
+			long s = parent_value.Size();
+			if (idx<s) {
+				return parent_value[idx];
+			} else {
+				throw PayloadAddressingError();
+			}
+		}
+	} else {
+		IPAACA_DEBUG("Addressed as dict with key " << pep->addressed_key)
+		if (! parent_value.IsObject()) {
+			IPAACA_INFO("parent value is not of type Object")
+			throw PayloadAddressingError();
+		} else {
+			rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
+			rapidjson::Value key;
+			key.SetString(pep->addressed_key, allocator);
+			auto it = parent_value.FindMember(key);
+			if (it != parent_value.MemberEnd()) {
+				return parent_value[key];
+			} else {
+				rapidjson::Value val;
+				parent_value.AddMember(key, val, allocator);
+				rapidjson::Value rkey;
+				rkey.SetString(pep->addressed_key, allocator);
+				return parent_value[rkey];
+			}
+		}
+	}
+}
+//}}}
+
+// PayloadEntryProxy//{{{
+
+IPAACA_EXPORT PayloadEntryProxy::PayloadEntryProxy(Payload* payload, const std::string& key)
+: _payload(payload), _key(key), parent(nullptr)
+{
+	document_entry = _payload->get_entry(key);
+	set_json_value(&(document_entry->document), "construction");
+}
+IPAACA_EXPORT PayloadEntryProxy::PayloadEntryProxy(PayloadEntryProxy* parent_, const std::string& addr_key_)
+: parent(parent_), addressed_key(addr_key_), addressed_as_array(false)
+{
+	_payload = parent->_payload;
+	_key = parent->_key;
+	document_entry = parent->document_entry;
+	auto it = parent->json_value->FindMember(addr_key_.c_str());
+	if (it != parent->json_value->MemberEnd()) {
+		set_json_value(&(parent->json_value->operator[](addr_key_.c_str())), std::string("construction from str addressing with ")+addr_key_);
+		existent = true;
+	} else {
+		set_json_value(nullptr, std::string("null-construction from failed str addressing with ")+addr_key_); // avoid heap construction here
+		existent = false;
+	}
+}
+IPAACA_EXPORT PayloadEntryProxy::PayloadEntryProxy(PayloadEntryProxy* parent_, size_t addr_idx_)
+: parent(parent_), addressed_index(addr_idx_), addressed_as_array(true)
+{
+	_payload = parent->_payload;
+	_key = parent->_key;
+	document_entry = parent->document_entry;
+	set_json_value(&(parent->json_value->operator[](addr_idx_)), std::string("construction from int addressing with ")+std::to_string(addr_idx_));
+	existent = true;
+}
+
+IPAACA_EXPORT PayloadEntryProxy PayloadEntryProxy::operator[](const char* addr_key_)
+{
+	return operator[](std::string(addr_key_));
+}
+IPAACA_EXPORT PayloadEntryProxy PayloadEntryProxy::operator[](const std::string& addr_key_)
+{
+	if (!json_value) {
+		IPAACA_INFO("Invalid json_value")
+		throw PayloadAddressingError();
+	}
+        //IPAACA_DEBUG("string addressing with '" << addr_key_ << "' of json object " << (off_t) json_value )
+	if (! json_value->IsObject()) {
+		IPAACA_INFO("Expected Object for operator[](string)")
+		//IPAACA_DEBUG("  But type is: " << value_diagnosis(json_value) )
+		throw PayloadAddressingError();
+	}
+	return PayloadEntryProxy(this, addr_key_);
+}
+IPAACA_EXPORT PayloadEntryProxy PayloadEntryProxy::operator[](size_t addr_idx_)
+{
+	if (!json_value) {
+		IPAACA_INFO("Invalid json_value")
+		throw PayloadAddressingError();
+	}
+	if (! json_value->IsArray()) {
+		IPAACA_INFO("Expected Array for operator[](size_t)")
+		throw PayloadAddressingError();
+	}
+	long s = json_value->Size();
+	if (addr_idx_>=s) {
+		IPAACA_INFO("Array out of bounds")
+		throw PayloadAddressingError();
+	}
+	return PayloadEntryProxy(this, addr_idx_);
+}
+IPAACA_EXPORT PayloadEntryProxy PayloadEntryProxy::operator[](int addr_idx_)
+{
+	if (addr_idx_ < 0) {
+		IPAACA_INFO("Negative array index")
+		throw PayloadAddressingError();
+	}
+	return operator[]((size_t) addr_idx_);
+}
+
+IPAACA_EXPORT PayloadEntryProxy& PayloadEntryProxy::operator=(const PayloadEntryProxy& otherproxy)
+{
+	PayloadDocumentEntry::ptr new_entry = document_entry->clone(); // copy-on-write, no lock required
+	rapidjson::Value& newval = new_entry->get_or_create_nested_value_from_proxy_path(this);
+	auto valueptr = otherproxy.json_value;
+	if (valueptr) { // only set if value is valid, keep default null value otherwise
+		newval.CopyFrom(*valueptr, new_entry->document.GetAllocator());
+	}
+	_payload->set(_key, new_entry);
+	return *this;
+}
+
+IPAACA_EXPORT PayloadEntryProxy::operator std::string()
+{
+	return json_value_cast<std::string>(json_value);
+}
+IPAACA_EXPORT PayloadEntryProxy::operator int()
+{
+	return json_value_cast<int>(json_value);
+}
+IPAACA_EXPORT PayloadEntryProxy::operator long()
+{
+	return json_value_cast<long>(json_value);
+}
+IPAACA_EXPORT PayloadEntryProxy::operator double()
+{
+	return json_value_cast<double>(json_value);
+}
+IPAACA_EXPORT PayloadEntryProxy::operator bool()
+{
+	return json_value_cast<bool>(json_value);
+}
+IPAACA_EXPORT std::string PayloadEntryProxy::to_str()
+{
+	return json_value_cast<std::string>(json_value);
+}
+IPAACA_EXPORT int PayloadEntryProxy::to_int()
+{
+	return json_value_cast<int>(json_value);
+}
+IPAACA_EXPORT long PayloadEntryProxy::to_long()
+{
+	return json_value_cast<long>(json_value);
+}
+IPAACA_EXPORT double PayloadEntryProxy::to_float()
+{
+	return json_value_cast<double>(json_value);
+}
+IPAACA_EXPORT double PayloadEntryProxy::to_double()
+{
+	return json_value_cast<double>(json_value);
+}
+IPAACA_EXPORT bool PayloadEntryProxy::to_bool()
+{
+	return json_value_cast<bool>(json_value);
+}
+
+IPAACA_EXPORT PayloadEntryProxyMapDecorator PayloadEntryProxy::as_map()
+{
+	if (json_value && json_value->IsObject()) return PayloadEntryProxyMapDecorator(this);
+	throw PayloadTypeConversionError();
+}
+
+IPAACA_EXPORT PayloadEntryProxyListDecorator PayloadEntryProxy::as_list()
+{
+	if (json_value && json_value->IsArray()) return PayloadEntryProxyListDecorator(this);
+	throw PayloadTypeConversionError();
+}
+
+IPAACA_EXPORT size_t PayloadEntryProxy::size()
+{
+	if (!json_value) return 0;
+	if (json_value->IsArray()) return json_value->Size();
+	if (json_value->IsObject()) return json_value->MemberCount();
+	return 0;
+}
+IPAACA_EXPORT bool PayloadEntryProxy::is_null()
+{
+	return (!json_value) || json_value->IsNull();
+}
+IPAACA_EXPORT bool PayloadEntryProxy::is_string()
+{
+	return json_value && json_value->IsString();
+}
+
+/// is_number => whether it is *interpretable* as a numerical value (i.e. including conversions)
+IPAACA_EXPORT bool PayloadEntryProxy::is_number()
+{
+	if (!json_value) return false;
+	try {
+		double dummy = json_value_cast<double>(*json_value);
+		return true;
+	} catch (PayloadTypeConversionError& ex) {
+		return false;
+	}
+}
+IPAACA_EXPORT bool PayloadEntryProxy::is_list()
+{
+	return json_value && json_value->IsArray();
+}
+IPAACA_EXPORT bool PayloadEntryProxy::is_map()
+{
+	return json_value && json_value->IsObject();
+}
+
+//}}}
+
+// Payload//{{{
+
+IPAACA_EXPORT void Payload::on_lock()
+{
+	Locker locker(_payload_operation_mode_lock);
+	IPAACA_DEBUG("Starting payload batch update mode ...")
+	_update_on_every_change = false;
+	std::stringstream ss;
+	ss << std::this_thread::get_id();
+	_writing_thread_id = ss.str();
+}
+IPAACA_EXPORT void Payload::on_unlock()
+{
+	Locker locker(_payload_operation_mode_lock);
+	IPAACA_DEBUG("... applying payload batch update with " << _collected_modifications.size() << " modifications and " << _collected_removals.size() << " removals ...")
+	_internal_merge_and_remove(_collected_modifications, _collected_removals, _batch_update_writer_name);
+	_update_on_every_change = true;
+	_batch_update_writer_name = "";
+	_collected_modifications.clear();
+	_collected_removals.clear();
+	IPAACA_DEBUG("... exiting payload batch update mode.")
+	_writing_thread_id = "";
+}
+
+IPAACA_EXPORT void Payload::initialize(std::shared_ptr<IUInterface> iu)
+{
+	_iu = std::weak_ptr<IUInterface>(iu);
+}
+
+IPAACA_EXPORT PayloadEntryProxy Payload::operator[](const std::string& key)
+{
+	return PayloadEntryProxy(this, key);
+}
+
+IPAACA_EXPORT Payload::operator std::map<std::string, std::string>()
+{
+	std::map<std::string, std::string> result;
+	std::for_each(_document_store.begin(), _document_store.end(), [&result](std::pair<std::string, PayloadDocumentEntry::ptr> pair) {
+			result[pair.first] =  json_value_cast<std::string>(pair.second->document);
+			});
+	return result;
+}
+
+IPAACA_EXPORT void Payload::_internal_set(const std::string& k, PayloadDocumentEntry::ptr v, const std::string& writer_name) {
+	Locker locker(_payload_operation_mode_lock);
+	if (_update_on_every_change) {
+		std::map<std::string, PayloadDocumentEntry::ptr> _new;
+		std::vector<std::string> _remove;
+		_new[k] = v;
+		_iu.lock()->_modify_payload(true, _new, _remove, writer_name );
+		IPAACA_DEBUG(" Setting local payload item \"" << k << "\" to " << v)
+		_document_store[k] = v;
+		mark_revision_change();
+	} else {
+		IPAACA_DEBUG("queueing a payload set operation")
+		_batch_update_writer_name = writer_name;
+		_collected_modifications[k] = v;
+		// revoke deletions of this updated key
+		//_collected_removals.erase(k);
+		std::vector<std::string> new_removals;
+		for (auto& rk: _collected_removals) {
+			if (rk!=k) new_removals.push_back(rk);
+		}
+		_collected_removals = new_removals;
+	}
+}
+IPAACA_EXPORT void Payload::_internal_remove(const std::string& k, const std::string& writer_name) {
+	Locker locker(_payload_operation_mode_lock);
+	if (_update_on_every_change) {
+		std::map<std::string, PayloadDocumentEntry::ptr> _new;
+		std::vector<std::string> _remove;
+		_remove.push_back(k);
+		_iu.lock()->_modify_payload(true, _new, _remove, writer_name );
+		_document_store.erase(k);
+		mark_revision_change();
+	} else {
+		IPAACA_DEBUG("queueing a payload remove operation")
+		_batch_update_writer_name = writer_name;
+		_collected_removals.push_back(k);
+		//_collected_removals.insert(k);
+		// revoke updates of this deleted key
+		_collected_modifications.erase(k);
+	}
+}
+IPAACA_EXPORT void Payload::_internal_replace_all(const std::map<std::string, PayloadDocumentEntry::ptr>& new_contents, const std::string& writer_name)
+{
+	Locker locker(_payload_operation_mode_lock);
+	if (_update_on_every_change) {
+		std::vector<std::string> _remove;
+		_iu.lock()->_modify_payload(false, new_contents, _remove, writer_name );
+		_document_store = new_contents;
+		mark_revision_change();
+	} else {
+		IPAACA_DEBUG("queueing a payload replace_all operation")
+		_batch_update_writer_name = writer_name;
+		_collected_modifications.clear();
+		for (auto& kv: new_contents) {
+			_collected_modifications[kv.first] = kv.second;
+		}
+		// take all existing keys and flag to remove them, unless overridden in current update
+		for (auto& kv: _document_store) {
+			if (! new_contents.count(kv.first)) {
+				_collected_removals.push_back(kv.first);
+				//_collected_removals.insert(kv.first);
+				_collected_modifications.erase(kv.first);
+			}
+		}
+	}
+}
+IPAACA_EXPORT void Payload::_internal_merge(const std::map<std::string, PayloadDocumentEntry::ptr>& contents_to_merge, const std::string& writer_name)
+{
+	Locker locker(_payload_operation_mode_lock);
+	if (_update_on_every_change) {
+		std::vector<std::string> _remove;
+		_iu.lock()->_modify_payload(true, contents_to_merge, _remove, writer_name );
+		for (auto& kv: contents_to_merge) {
+			_document_store[kv.first] = kv.second;
+		}
+		mark_revision_change();
+	} else {
+		IPAACA_DEBUG("queueing a payload merge operation")
+		std::set<std::string> updated_keys;
+		_batch_update_writer_name = writer_name;
+		for (auto& kv: contents_to_merge) {
+			_collected_modifications[kv.first] = kv.second;
+			//_collected_removals.erase(kv.first); // moved here
+			updated_keys.insert(kv.first);
+		}
+		// revoke deletions of updated keys
+		std::vector<std::string> new_removals;
+		for (auto& rk: _collected_removals) {
+			if (! updated_keys.count(rk)) new_removals.push_back(rk);
+		}
+		_collected_removals = new_removals;
+	}
+}
+IPAACA_EXPORT void Payload::_internal_merge_and_remove(const std::map<std::string, PayloadDocumentEntry::ptr>& contents_to_merge, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	// this function is called by exiting the batch update mode only, so no extra locking here
+	_iu.lock()->_modify_payload(true, contents_to_merge, keys_to_remove, writer_name );
+	for (auto& k: keys_to_remove) {
+		_document_store.erase(k);
+	}
+	for (auto& kv: contents_to_merge) {
+		_document_store[kv.first] = kv.second;
+	}
+	mark_revision_change();
+}
+IPAACA_EXPORT PayloadDocumentEntry::ptr Payload::get_entry(const std::string& k) {
+	if (! _update_on_every_change) {
+		std::stringstream ss;
+		ss << std::this_thread::get_id();
+		if (_writing_thread_id == ss.str()) {
+			IPAACA_DEBUG("Payload locked by current thread, looking for payload key in caches first")
+			// in batch mode, read from cached writed first!
+			// case 1: deleted key
+			if (std::find(_collected_removals.begin(), _collected_removals.end(), k) != _collected_removals.end()) {
+				IPAACA_DEBUG("Key removed, returning null")
+				for (auto& cr : _collected_removals) {
+					IPAACA_DEBUG("  cached removal: " << cr)
+				}
+				return PayloadDocumentEntry::create_null();
+			}
+			// case 2: updated key - use last known state!
+			auto it = _collected_modifications.find(k);
+			if (it!=_collected_modifications.end()) {
+				IPAACA_DEBUG("Key updated, returning current version")
+				return it->second;
+			}
+			// case 3: key not in the caches yet, just continue below
+		}
+	}
+	if (_document_store.count(k)>0) return _document_store[k];
+	else return PayloadDocumentEntry::create_null();  // contains Document with 'null' value
+}
+IPAACA_EXPORT std::string Payload::get(const std::string& k) { // DEPRECATED
+	if (_document_store.count(k)>0) return _document_store[k]->document.GetString();
+	return "";
+}
+
+IPAACA_EXPORT void Payload::set(const std::map<std::string, std::string>& all_elems)
+{
+	std::map<std::string, PayloadDocumentEntry::ptr> newmap;
+	for (auto& kv: all_elems) {
+		newmap[kv.first] = PayloadDocumentEntry::from_unquoted_string_value(kv.second);
+	}
+	_internal_replace_all(newmap);
+}
+
+IPAACA_EXPORT void Payload::_remotely_enforced_wipe()
+{
+	_document_store.clear();
+	mark_revision_change();
+}
+IPAACA_EXPORT void Payload::_remotely_enforced_delitem(const std::string& k)
+{
+	_document_store.erase(k);
+	mark_revision_change();
+}
+IPAACA_EXPORT void Payload::_remotely_enforced_setitem(const std::string& k, PayloadDocumentEntry::ptr entry)
+{
+	_document_store[k] = entry;
+	mark_revision_change();
+}
+IPAACA_EXPORT PayloadIterator Payload::begin()
+{
+	return PayloadIterator(this, _document_store.begin());
+}
+IPAACA_EXPORT PayloadIterator Payload::end()
+{
+	return PayloadIterator(this, _document_store.end());
+}
+
+//}}}
+
+// PayloadIterator//{{{
+IPAACA_EXPORT PayloadIterator::PayloadIterator(Payload* payload, PayloadDocumentStore::iterator&& ref_it)
+: _payload(payload), reference_payload_revision(payload->internal_revision), raw_iterator(std::move(ref_it))
+{
+}
+IPAACA_EXPORT PayloadIterator::PayloadIterator(const PayloadIterator& iter)
+: _payload(iter._payload), reference_payload_revision(iter.reference_payload_revision), raw_iterator(iter.raw_iterator)
+{
+}
+
+IPAACA_EXPORT PayloadIterator& PayloadIterator::operator++()
+{
+	if (_payload->revision_changed(reference_payload_revision)) throw PayloadIteratorInvalidError();
+	++raw_iterator;
+	return *this;
+}
+
+IPAACA_EXPORT std::pair<std::string, PayloadEntryProxy> PayloadIterator::operator*()
+{
+	if (_payload->revision_changed(reference_payload_revision)) throw PayloadIteratorInvalidError();
+	if (raw_iterator == _payload->_document_store.end()) throw PayloadIteratorInvalidError();
+	return std::pair<std::string, PayloadEntryProxy>(raw_iterator->first, PayloadEntryProxy(_payload, raw_iterator->first));
+}
+IPAACA_EXPORT std::shared_ptr<std::pair<std::string, PayloadEntryProxy> > PayloadIterator::operator->()
+{
+	if (_payload->revision_changed(reference_payload_revision)) throw PayloadIteratorInvalidError();
+	if (raw_iterator == _payload->_document_store.end()) throw PayloadIteratorInvalidError();
+	return std::make_shared<std::pair<std::string, PayloadEntryProxy> >(raw_iterator->first, PayloadEntryProxy(_payload, raw_iterator->first));
+}
+
+IPAACA_EXPORT bool PayloadIterator::operator==(const PayloadIterator& ref)
+{
+	if (_payload->revision_changed(reference_payload_revision)) throw PayloadIteratorInvalidError();
+	return (raw_iterator==ref.raw_iterator);
+}
+IPAACA_EXPORT bool PayloadIterator::operator!=(const PayloadIterator& ref)
+{
+	if (_payload->revision_changed(reference_payload_revision)) throw PayloadIteratorInvalidError();
+	return (raw_iterator!=ref.raw_iterator);
+}
+//}}}
+
+// PayloadEntryProxyMapIterator//{{{
+IPAACA_EXPORT PayloadEntryProxyMapIterator::PayloadEntryProxyMapIterator(PayloadEntryProxy* proxy_, RawIterator&& raw_iter)
+: proxy(proxy_), raw_iterator(std::move(raw_iter))
+{
+}
+
+IPAACA_EXPORT PayloadEntryProxyMapIterator& PayloadEntryProxyMapIterator::operator++()
+{
+	//IPAACA_DEBUG("Map iterator incrementing");
+	raw_iterator++;
+	return *this;
+}
+
+IPAACA_EXPORT std::pair<std::string, PayloadEntryProxy> PayloadEntryProxyMapIterator::operator*()
+{
+	std::string key = raw_iterator->name.GetString();
+	//IPAACA_DEBUG("Deref map iterator key '" << key << "'");
+	//IPAACA_DEBUG(" of proxy " << (off_t) proxy << "");
+	return std::pair<std::string, PayloadEntryProxy>(key, (*proxy)[key] ); // generates child Proxy
+}
+
+IPAACA_EXPORT std::shared_ptr<std::pair<std::string, PayloadEntryProxy> > PayloadEntryProxyMapIterator::operator->()
+{
+	std::string key = raw_iterator->name.GetString();
+	return std::make_shared<std::pair<std::string, PayloadEntryProxy> >(key, (*proxy)[key] ); // generates child Proxy
+}
+IPAACA_EXPORT bool PayloadEntryProxyMapIterator::operator==(const PayloadEntryProxyMapIterator& other_iter)
+{
+	return raw_iterator==other_iter.raw_iterator;
+}
+IPAACA_EXPORT bool PayloadEntryProxyMapIterator::operator!=(const PayloadEntryProxyMapIterator& other_iter)
+{
+	return raw_iterator!=other_iter.raw_iterator;
+}
+//}}}
+// PayloadEntryProxyMapDecorator//{{{
+PayloadEntryProxyMapIterator PayloadEntryProxyMapDecorator::begin()
+{
+	return PayloadEntryProxyMapIterator(proxy, proxy->json_value->MemberBegin());
+}
+PayloadEntryProxyMapIterator PayloadEntryProxyMapDecorator::end()
+{
+	return PayloadEntryProxyMapIterator(proxy, proxy->json_value->MemberEnd());
+}
+//}}}
+
+// PayloadEntryProxyListIterator//{{{
+IPAACA_EXPORT PayloadEntryProxyListIterator::PayloadEntryProxyListIterator(PayloadEntryProxy* proxy_, size_t idx, size_t size_)
+: proxy(proxy_), current_idx(idx), size(size_)
+{
+}
+
+IPAACA_EXPORT PayloadEntryProxyListIterator& PayloadEntryProxyListIterator::operator++()
+{
+	if (current_idx!=size) current_idx++;
+	return *this;
+}
+
+IPAACA_EXPORT PayloadEntryProxy PayloadEntryProxyListIterator::operator*()
+{
+	return (*proxy)[current_idx];
+}
+
+IPAACA_EXPORT std::shared_ptr<PayloadEntryProxy> PayloadEntryProxyListIterator::operator->()
+{
+	return std::make_shared<PayloadEntryProxy>((*proxy)[current_idx]);
+}
+IPAACA_EXPORT bool PayloadEntryProxyListIterator::operator==(const PayloadEntryProxyListIterator& other_iter)
+{
+	return (proxy==other_iter.proxy) && (current_idx==other_iter.current_idx);
+}
+IPAACA_EXPORT bool PayloadEntryProxyListIterator::operator!=(const PayloadEntryProxyListIterator& other_iter)
+{
+	return (current_idx!=other_iter.current_idx) || (proxy!=other_iter.proxy);
+}
+//}}}
+// PayloadEntryProxyListDecorator//{{{
+PayloadEntryProxyListIterator PayloadEntryProxyListDecorator::begin()
+{
+	return PayloadEntryProxyListIterator(proxy, 0, proxy->json_value->Size());
+}
+PayloadEntryProxyListIterator PayloadEntryProxyListDecorator::end()
+{
+	size_t size = proxy->json_value->Size();
+	return PayloadEntryProxyListIterator(proxy, size, size);
+}
+//}}}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-string-utils.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
 #include <ipaaca/ipaaca.h>
 
+#include <cctype>
+#include <string>
+#include <algorithm>
+
+
 namespace ipaaca {
 
+std::string str_trim(const std::string &s)
+{
+	auto wsfront = std::find_if_not(s.begin(), s.end(), [](int c){ return std::isspace(c); } );
+	auto wsback = std::find_if_not(s.rbegin(), s.rend(), [](int c){ return std::isspace(c); } ).base();
+	return (wsback<=wsfront ? std::string() : std::string(wsfront, wsback));
+}
+
 std::string str_join(const std::set<std::string>& set,const std::string& sep)
 {
 	if(set.size()==0)
@@ -42,28 +87,34 @@ std::string str_join(const std::vector<std::string>& vec,const std::string& sep)
 	return tmp;
 }
 
-void str_split_wipe(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
+int str_split_wipe(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
 {
 	tokens.clear();
 	std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
 	std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
+	int count = 0;
 	while (std::string::npos != pos || std::string::npos != lastPos)
 	{
+		count++;
 		tokens.push_back(str.substr(lastPos, pos - lastPos));
 		lastPos = str.find_first_not_of(delimiters, pos);
 		pos = str.find_first_of(delimiters, lastPos);
 	}
+	return count;
 }
-void str_split_append(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
+int str_split_append(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
 {
 	std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
 	std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
+	int count = 0;
 	while (std::string::npos != pos || std::string::npos != lastPos)
 	{
+		count++;
 		tokens.push_back(str.substr(lastPos, pos - lastPos));
 		lastPos = str.find_first_not_of(delimiters, pos);
 		pos = str.find_first_of(delimiters, lastPos);
 	}
+	return count;
 }
 
 } // namespace ipaaca

ipaacalib/cpp/src/ipaaca-tester.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+/**
+ * \file   ipaaca-tester.cc
+ *
+ * \brief Multifunction tester component, C++ version
+ *
+ * This file is not used in the ipaaca library, but produces
+ * a separate program, if enabled in CMakeLists.txt
+ *
+ * \author Ramin Yaghoubzadeh (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2017
+ */
+
+#include <ipaaca/ipaaca.h>
+
+#include <cstdio>
+#include <iomanip>
+
+#include <thread>
+#include <chrono>
+
+#if _WIN32 || _WIN64
+	double get_time_as_secs() { return 0.0; } // TODO implement time function for Windows when required
+#else
+	#include <sys/time.h>
+	double get_time_as_secs() {
+		struct timeval tv;
+		if (gettimeofday(&tv, NULL)) return 0.0;
+		return (0.001 * ((double)tv.tv_sec * 1000000.0 + tv.tv_usec));
+	}
+#endif
+
+class TesterCpp {
+	public:
+	void handle_iu_inbuf(std::shared_ptr<ipaaca::IUInterface> iu, ipaaca::IUEventType etype, bool local)
+	{
+		std::cout << std::fixed << std::setprecision(3) << get_time_as_secs() << " ";
+		std::cout << ipaaca::iu_event_type_to_str(etype) << " category=" << iu->category() << " uid=" << iu->uid() << std::endl;
+		//
+		auto links = iu->get_all_links();
+		if (links.size()>0) {
+			std::cout << "links={" << std::endl;
+			for (auto kv : links) {
+				std::cout << "\t" << kv.first << ": [";
+				bool first = true;
+				for (const auto& lnk : kv.second) {
+					if (first) { first=false; } else { std::cout << ", "; }
+					std::cout << lnk;
+				}
+				std::cout << "]";
+			}
+			std::cout << "}" << std::endl;
+		}
+		//
+		std::cout << "payload={" << std::endl;
+		for (auto kv : iu->payload()) {
+			std::cout << "\t'" << kv.first << "': " << ((std::string) kv.second) << ',' << std::endl;
+		}
+		std::cout << "}" << std::endl;
+                if (etype == IU_ADDED) {
+                    std::cout << "Will send a modification to a received new IU" << std::endl;
+                    int cnt=5;
+                    while(cnt>0) {
+                        try {
+                            iu->payload()["seen_by_cpp"] = true;
+                            cnt = 0;
+                        } catch(...) {
+                            std::cout << "... failed, but we try more than once ..." << std::endl;
+                            cnt--;
+			    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+                        }
+                    }
+                }
+	}
+
+	int run()
+	{
+		ipaaca::OutputBuffer::ptr ob = ipaaca::OutputBuffer::create("testerCpp");
+		ipaaca::InputBuffer::ptr ib = ipaaca::InputBuffer::create("testerCpp", std::set<std::string>{"testcategory"}); // MQTT requires # as a wildcard!
+		ib->set_resend(true);
+		ib->register_handler(IPAACA_BIND_CLASS_HANDLER(&TesterCpp::handle_iu_inbuf, this));
+		std::cout << "Listening for all IU events and sending a Message after 1 sec ..." << std::endl;
+		std::this_thread::sleep_for(std::chrono::seconds(1));
+                auto msg = ipaaca::IU::create("testcategory");
+                msg->payload()["hello"] = "world";
+                ob->add(msg);
+                int i = 0;
+                while(true) {
+			std::this_thread::sleep_for(std::chrono::seconds(5));
+                        auto msg = ipaaca::Message::create("testcate2");
+                        msg->payload()["num"] = ++i;
+                        ob->add(msg);
+		}
+		return 0;
+	}
+
+};
+
+int main(int argc, char** argv)
+{
+        /*
+        auto config = ipaaca::get_global_config(true);
+        for (auto it = config->begin(); it!=config->end(); ++it ) {
+            std::cout << it->first << "=" << it->second << std::endl;
+        }
+        exit(1);
+        */
+
+	ipaaca::__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_DEBUG;
+	TesterCpp tester;
+	tester.run();
+}
+
+

ipaacalib/cpp/src/ipaaca.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
 #include <ipaaca/ipaaca.h>
-#include <cstdlib>
 
 namespace ipaaca {
 
-using namespace rsb;
-using namespace rsb::filter;
-using namespace rsb::converter;
-using namespace rsb::patterns;
-
-// util and init//{{{
-
-bool Initializer::_initialized = false;
-
-//const LinkSet EMPTY_LINK_SET = LinkSet();
-//const std::set<std::string> EMPTY_LINK_SET();
-bool Initializer::initialized() { return _initialized; }
-void Initializer::initialize_ipaaca_rsb_if_needed()
-{
-	if (_initialized) return;
-	ParticipantConfig config = ParticipantConfig::fromConfiguration();
-	Factory::getInstance().setDefaultParticipantConfig(config);
-	
-	boost::shared_ptr<IUConverter> iu_converter(new IUConverter());
-	converterRepository<std::string>()->registerConverter(iu_converter);
-	
-	boost::shared_ptr<IUPayloadUpdateConverter> payload_update_converter(new IUPayloadUpdateConverter());
-	converterRepository<std::string>()->registerConverter(payload_update_converter);
-	
-	boost::shared_ptr<IULinkUpdateConverter> link_update_converter(new IULinkUpdateConverter());
-	converterRepository<std::string>()->registerConverter(link_update_converter);
-	
-	boost::shared_ptr<ProtocolBufferConverter<protobuf::IUCommission> > iu_commission_converter(new ProtocolBufferConverter<protobuf::IUCommission> ());
-	converterRepository<std::string>()->registerConverter(iu_commission_converter);
-	
-	boost::shared_ptr<ProtocolBufferConverter<protobuf::IURetraction> > iu_retraction_converter(new ProtocolBufferConverter<protobuf::IURetraction> ());
-	converterRepository<std::string>()->registerConverter(iu_retraction_converter);
-	
-	boost::shared_ptr<IntConverter> int_converter(new IntConverter());
-	converterRepository<std::string>()->registerConverter(int_converter);
-	
-	_initialized = true;
-	//IPAACA_TODO("initialize all converters")
-}
-
-std::string generate_uuid_string()
-{
+// UUID generation
+IPAACA_EXPORT std::string generate_uuid_string()//{{{
+{
+#if _WIN32 || _WIN64
+	// Windows
+	UUID uuid;
+	RPC_STATUS stat;
+	stat = UuidCreate(&uuid);
+	if (stat == RPC_S_OK) {
+		unsigned char* uuid_str = NULL;
+		stat = UuidToString(&uuid, &uuid_str);
+		if (stat == RPC_S_OK) {
+			std::string result((const char*) uuid_str, 16);
+			RpcStringFree(&uuid_str);
+			return result;
+		}
+		throw UUIDGenerationError();
+	} else {
+		throw UUIDGenerationError();
+	}
+#else
+	// POSIX
 	uuid_t uuidt;
 	uuid_generate(uuidt);
 #ifdef __MACOSX__
+	//   (Mac)
 	uuid_string_t uuidstr;
 	uuid_unparse_lower(uuidt, uuidstr);
 	return uuidstr;
 #else
+	//   (Linux)
 	char result_c[37];
 	uuid_unparse_lower(uuidt, result_c);
 	return result_c;
 #endif
-}
-
-/*
-void init_inprocess_too() {
-	//ParticipantConfig config = Factory::getInstance().getDefaultParticipantConfig();
-	ParticipantConfig config = ParticipantConfig::fromFile("rsb.cfg");
-	//ParticipantConfig::Transport inprocess = config.getTransport("inprocess");
-	//inprocess.setEnabled(true);
-	//config.addTransport(inprocess);
-	Factory::getInstance().setDefaultParticipantConfig(config);
-}
-*/
-//}}}
-
-std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj)//{{{
-{
-	os << "{";
-	bool first = true;
-	for (LinkMap::const_iterator it=obj._links.begin(); it!=obj._links.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << it->first << "': [";
-		bool firstinner = true;
-		for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			if (firstinner) { firstinner=false; } else { os << ", "; }
-			os << "'" << *it2 << "'";
-		}
-		os << "]";
-	}
-	os << "}";
-	return os;
-}
-//}}}
-std::ostream& operator<<(std::ostream& os, const Payload& obj)//{{{
-{
-	os << "{";
-	bool first = true;
-	for (std::map<std::string, std::string>::const_iterator it=obj._store.begin(); it!=obj._store.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << it->first << "':'" << it->second << "'";
-	}
-	os << "}";
-	return os;
-}
-//}}}
-std::ostream& operator<<(std::ostream& os, const IUInterface& obj)//{{{
-{
-	os << "IUInterface(uid='" << obj.uid() << "'";
-	os << ", category='" << obj.category() << "'";
-	os << ", revision=" << obj.revision();
-	os << ", committed=" << (obj.committed()?"True":"False");
-	os << ", owner_name='" << obj.owner_name() << "'";
-	os << ", payload=";
-	os << obj.const_payload();
-	os << ", links=";
-	os << obj._links;
-	os << ")";
-	return os;
-}
-//}}}
-std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj)//{{{
-{
-	os << "PayloadUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
-	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
-	os << ", new_items = {";
-	bool first = true;
-	for (std::map<std::string, std::string>::const_iterator it=obj.new_items.begin(); it!=obj.new_items.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << it->first << "':'" << it->second << "'";
-	}
-	os << "}, keys_to_remove = [";
-	first = true;
-	for (std::vector<std::string>::const_iterator it=obj.keys_to_remove.begin(); it!=obj.keys_to_remove.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << *it << "'";
-	}
-	os << "])";
-	return os;
-}
-//}}}
-std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj)//{{{
-{
-	os << "LinkUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
-	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
-	os << ", new_links = {";
-	bool first = true;
-	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj.new_links.begin(); it!=obj.new_links.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << it->first << "': [";
-		bool ffirst = true;
-		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			if (ffirst) { ffirst=false; } else { os << ", "; }
-			os << "'" << *it2 << "'";
-		}
-		os << "]";
-	}
-	os << "}, links_to_remove = {";
-	first = true;
-	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj.links_to_remove.begin(); it!=obj.links_to_remove.end(); ++it) {
-		if (first) { first=false; } else { os << ", "; }
-		os << "'" << it->first << "': [";
-		bool ffirst = true;
-		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			if (ffirst) { ffirst=false; } else { os << ", "; }
-			os << "'" << *it2 << "'";
-		}
-		os << "]";
-	}
-	os << "})";
-	return os;
-}
-//}}}
-
-// SmartLinkMap//{{{
-
-LinkSet SmartLinkMap::empty_link_set;
-void SmartLinkMap::_add_and_remove_links(const LinkMap& add, const LinkMap& remove)
-{
-	// remove specified links
-	for (LinkMap::const_iterator it = remove.begin(); it != remove.end(); ++it ) {
-		// if link type exists
-		if (_links.count(it->first) > 0) {
-			// remove one by one
-			for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-				_links[it->first].erase(*it2);
-			}
-			// wipe the type key if no more links are left
-			if (_links[it->first].size() == 0) {
-				_links.erase(it->first);
-			}
-		}
-	}
-	// add specified links
-	for (LinkMap::const_iterator it = add.begin(); it != add.end(); ++it ) {
-		for (LinkSet::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			_links[it->first].insert(*it2);
-		}
-	}
-}
-void SmartLinkMap::_replace_links(const LinkMap& links)
-{
-	//_links.clear();
-	_links=links;
-}
-const LinkSet& SmartLinkMap::get_links(const std::string& key)
-{
-	LinkMap::const_iterator it = _links.find(key);
-	if (it==_links.end()) return empty_link_set;
-	return it->second;
-}
-const LinkMap& SmartLinkMap::get_all_links()
-{
-	return _links;
-}
-//}}}
-
-// IUEventHandler//{{{
-IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
-: _function(function), _event_mask(event_mask), _for_all_categories(false)
-{
-	if (category=="") {
-		_for_all_categories = true;
-	} else {
-		_categories.insert(category);
-	}
-}
-IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
-: _function(function), _event_mask(event_mask), _for_all_categories(false)
-{
-	if (categories.size()==0) {
-		_for_all_categories = true;
-	} else {
-		_categories = categories;
-	}
-}
-void IUEventHandler::call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
-{
-	if (_condition_met(event_type, category)) {
-		//IUInterface::ptr iu = buffer->get(uid);
-		//if (iu) {
-			_function(iu, event_type, local);
-		//}
-	}
-}
-//}}}
-
-// Buffer//{{{
-void Buffer::_allocate_unique_name(const std::string& basename, const std::string& function) {
-	std::string uuid = ipaaca::generate_uuid_string();
-	_basename = basename;
-	_uuid = uuid.substr(0,8);
-	_unique_name = "/ipaaca/component/" + _basename + "ID" + _uuid + "/" + function;
-}
-void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
-{
-	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, categories));
-	_event_handlers.push_back(handler);
-}
-void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
-{
-	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, category));
-	_event_handlers.push_back(handler);
-}
-void Buffer::call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
-{
-	//IPAACA_INFO("handling an event " << ipaaca::iu_event_type_to_str(event_type) << " for IU " << iu->uid())
-	for (std::vector<IUEventHandler::ptr>::iterator it = _event_handlers.begin(); it != _event_handlers.end(); ++it) {
-		(*it)->call(this, iu, local, event_type, category);
-	}
-}
-//}}}
-
-// Callbacks for OutputBuffer//{{{
-CallbackIUPayloadUpdate::CallbackIUPayloadUpdate(Buffer* buffer): _buffer(buffer) { }
-CallbackIULinkUpdate::CallbackIULinkUpdate(Buffer* buffer): _buffer(buffer) { }
-CallbackIUCommission::CallbackIUCommission(Buffer* buffer): _buffer(buffer) { }
-
-boost::shared_ptr<int> CallbackIUPayloadUpdate::call(const std::string& methodName, boost::shared_ptr<IUPayloadUpdate> update)
-{
-	IUInterface::ptr iui = _buffer->get(update->uid);
-	if (! iui) {
-		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid)
-		return boost::shared_ptr<int>(new int(0));
-	}
-	IU::ptr iu = boost::static_pointer_cast<IU>(iui);
-	iu->_revision_lock.lock();
-	if ((update->revision != 0) && (update->revision != iu->_revision)) {
-		IPAACA_INFO("Remote write operation failed because request was out of date; IU " << update->uid)
-		iu->_revision_lock.unlock();
-		return boost::shared_ptr<int>(new int(0));
-	}
-	if (update->is_delta) {
-		for (std::vector<std::string>::const_iterator it=update->keys_to_remove.begin(); it!=update->keys_to_remove.end(); ++it) {
-			iu->payload()._internal_remove(*it, update->writer_name); //_buffer->unique_name());
-		}
-		for (std::map<std::string, std::string>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
-			iu->payload()._internal_set(it->first, it->second, update->writer_name); //_buffer->unique_name());
-		}
-	} else {
-		iu->payload()._internal_replace_all(update->new_items, update->writer_name); //_buffer->unique_name());
-	}
-	_buffer->call_iu_event_handlers(iu, true, IU_UPDATED, iu->category());
-	revision_t revision = iu->revision();
-	iu->_revision_lock.unlock();
-	return boost::shared_ptr<int>(new int(revision));
-}
-
-boost::shared_ptr<int> CallbackIULinkUpdate::call(const std::string& methodName, boost::shared_ptr<IULinkUpdate> update)
-{
-	IUInterface::ptr iui = _buffer->get(update->uid);
-	if (! iui) {
-		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid)
-		return boost::shared_ptr<int>(new int(0));
-	}
-	IU::ptr iu = boost::static_pointer_cast<IU>(iui);
-	iu->_revision_lock.lock();
-	if ((update->revision != 0) && (update->revision != iu->_revision)) {
-		IPAACA_INFO("Remote write operation failed because request was out of date; IU " << update->uid)
-		iu->_revision_lock.unlock();
-		return boost::shared_ptr<int>(new int(0));
-	}
-	if (update->is_delta) {
-		iu->modify_links(update->new_links, update->links_to_remove, update->writer_name);
-	} else {
-		iu->set_links(update->new_links, update->writer_name);
-	}
-	_buffer->call_iu_event_handlers(iu, true, IU_LINKSUPDATED, iu->category());
-	revision_t revision = iu->revision();
-	iu->_revision_lock.unlock();
-	return boost::shared_ptr<int>(new int(revision));
-}
-boost::shared_ptr<int> CallbackIUCommission::call(const std::string& methodName, boost::shared_ptr<protobuf::IUCommission> update)
-{
-	IUInterface::ptr iui = _buffer->get(update->uid());
-	if (! iui) {
-		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid())
-		return boost::shared_ptr<int>(new int(0));
-	}
-	IU::ptr iu = boost::static_pointer_cast<IU>(iui);
-	iu->_revision_lock.lock();
-	if ((update->revision() != 0) && (update->revision() != iu->_revision)) {
-		IPAACA_INFO("Remote write operation failed because request was out of date; IU " << update->uid())
-		iu->_revision_lock.unlock();
-		return boost::shared_ptr<int>(new int(0));
-	}
-	if (iu->committed()) {
-		return boost::shared_ptr<int>(new int(0));
-	} else {
-	}
-	iu->_internal_commit(update->writer_name());
-	_buffer->call_iu_event_handlers(iu, true, IU_LINKSUPDATED, iu->category());
-	revision_t revision = iu->revision();
-	iu->_revision_lock.unlock();
-	return boost::shared_ptr<int>(new int(revision));
-}
-
-//}}}
-
-// OutputBuffer//{{{
-
-OutputBuffer::OutputBuffer(const std::string& basename)
-:Buffer(basename, "OB")
-{
-	_id_prefix = _basename + "-" + _uuid + "-IU-";
-	_initialize_server();
-}
-void OutputBuffer::_initialize_server()
-{
-	_server = Factory::getInstance().createServer( Scope( _unique_name ) );
-	_server->registerMethod("updatePayload", Server::CallbackPtr(new CallbackIUPayloadUpdate(this)));
-	_server->registerMethod("updateLinks", Server::CallbackPtr(new CallbackIULinkUpdate(this)));
-	_server->registerMethod("commit", Server::CallbackPtr(new CallbackIUCommission(this)));
-}
-OutputBuffer::ptr OutputBuffer::create(const std::string& basename)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return OutputBuffer::ptr(new OutputBuffer(basename));
-}
-IUInterface::ptr OutputBuffer::get(const std::string& iu_uid)
-{
-	IUStore::iterator it = _iu_store.find(iu_uid);
-	if (it==_iu_store.end()) return IUInterface::ptr();
-	return it->second;
-}
-std::set<IUInterface::ptr> OutputBuffer::get_ius()
-{
-	std::set<IUInterface::ptr> set;
-	for (IUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second);
-	return set;
-}
-
-void OutputBuffer::_send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
-{
-	IULinkUpdate* lup = new ipaaca::IULinkUpdate();
-	Informer<ipaaca::IULinkUpdate>::DataPtr ldata(lup);
-	lup->uid = iu->uid();
-	lup->is_delta = is_delta;
-	lup->revision = revision;
-	lup->is_delta = true;
-	lup->new_links = new_links;
-	if (is_delta) lup->links_to_remove = links_to_remove;
-	if (writer_name=="") lup->writer_name = _unique_name;
-	else lup->writer_name = writer_name;
-	Informer<AnyType>::Ptr informer = _get_informer(iu->category());
-	informer->publish(ldata);
-}
-
-void OutputBuffer::_send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
-{
-	IUPayloadUpdate* pup = new ipaaca::IUPayloadUpdate();
-	Informer<ipaaca::IUPayloadUpdate>::DataPtr pdata(pup);
-	pup->uid = iu->uid();
-	pup->is_delta = is_delta;
-	pup->revision = revision;
-	pup->new_items = new_items;
-	if (is_delta) pup->keys_to_remove = keys_to_remove;
-	if (writer_name=="") pup->writer_name = _unique_name;
-	else pup->writer_name = writer_name;
-	Informer<AnyType>::Ptr informer = _get_informer(iu->category());
-	informer->publish(pdata);
-}
-
-void OutputBuffer::_send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name)
-{
-	Informer<protobuf::IUCommission>::DataPtr data(new protobuf::IUCommission());
-	data->set_uid(iu->uid());
-	data->set_revision(revision);
-	if (writer_name=="") data->set_writer_name(_unique_name);
-	else data->set_writer_name(writer_name);
-	
-	Informer<AnyType>::Ptr informer = _get_informer(iu->category());
-	informer->publish(data);
-}
-
-void OutputBuffer::add(IU::ptr iu)
-{
-	if (_iu_store.count(iu->uid()) > 0) {
-		throw IUPublishedError();
-	}
-	_iu_store[iu->uid()] = iu;
-	iu->_associate_with_buffer(this); //shared_from_this());
-	_publish_iu(iu);
-}
-
-void OutputBuffer::_publish_iu(IU::ptr iu)
-{
-	Informer<AnyType>::Ptr informer = _get_informer(iu->_category);
-	Informer<ipaaca::IU>::DataPtr iu_data(iu);
-	informer->publish(iu_data);
-}
-
-Informer<AnyType>::Ptr OutputBuffer::_get_informer(const std::string& category)
-{
-	if (_informer_store.count(category) > 0) {
-		return _informer_store[category];
-	} else {
-		//IPAACA_INFO("Making new informer for category " << category)
-		std::string scope_string = "/ipaaca/category/" + category;
-		Informer<AnyType>::Ptr informer = Factory::getInstance().createInformer<AnyType> ( Scope(scope_string));
-		_informer_store[category] = informer;
-		return informer;
-	}
-}
-boost::shared_ptr<IU> OutputBuffer::remove(const std::string& iu_uid)
-{
-	IUStore::iterator it = _iu_store.find(iu_uid);
-	if (it == _iu_store.end()) throw IUNotFoundError();
-	IU::ptr iu = it->second;
-	_retract_iu(iu);
-	_iu_store.erase(iu_uid);
-	return iu;
-}
-boost::shared_ptr<IU> OutputBuffer::remove(IU::ptr iu)
-{
-	return remove(iu->uid()); // to make sure it is in the store
-}
-
-void OutputBuffer::_retract_iu(IU::ptr iu)
-{
-	Informer<protobuf::IURetraction>::DataPtr data(new protobuf::IURetraction());
-	data->set_uid(iu->uid());
-	data->set_revision(iu->revision());
-	Informer<AnyType>::Ptr informer = _get_informer(iu->category());
-	informer->publish(data);
-}
-
-
-//}}}
-
-// InputBuffer//{{{
-InputBuffer::InputBuffer(const std::string& basename, const std::set<std::string>& category_interests)
-:Buffer(basename, "IB")
-{
-	for (std::set<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
-		_create_category_listener_if_needed(*it);
-	}
-}
-InputBuffer::InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests)
-:Buffer(basename, "IB")
-{
-	for (std::vector<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
-		_create_category_listener_if_needed(*it);
-	}
-}
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1)
-:Buffer(basename, "IB")
-{
-	_create_category_listener_if_needed(category_interest1);
-}
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
-:Buffer(basename, "IB")
-{
-	_create_category_listener_if_needed(category_interest1);
-	_create_category_listener_if_needed(category_interest2);
-}
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
-:Buffer(basename, "IB")
-{
-	_create_category_listener_if_needed(category_interest1);
-	_create_category_listener_if_needed(category_interest2);
-	_create_category_listener_if_needed(category_interest3);
-}
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
-:Buffer(basename, "IB")
-{
-	_create_category_listener_if_needed(category_interest1);
-	_create_category_listener_if_needed(category_interest2);
-	_create_category_listener_if_needed(category_interest3);
-	_create_category_listener_if_needed(category_interest4);
-}
-
-
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::set<std::string>& category_interests)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
-}
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::vector<std::string>& category_interests)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
-}
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interest1));
-}
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2));
-}
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3));
-}
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
-{
-	Initializer::initialize_ipaaca_rsb_if_needed();
-	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3, category_interest4));
-}
-
-IUInterface::ptr InputBuffer::get(const std::string& iu_uid)
-{
-	RemotePushIUStore::iterator it = _iu_store.find(iu_uid); // TODO genericize
-	if (it==_iu_store.end()) return IUInterface::ptr();
-	return it->second;
-}
-std::set<IUInterface::ptr> InputBuffer::get_ius()
-{
-	std::set<IUInterface::ptr> set;
-	for (RemotePushIUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second); // TODO genericize
-	return set;
-}
-
-
-RemoteServerPtr InputBuffer::_get_remote_server(const std::string& unique_server_name)
-{
-	std::map<std::string, RemoteServerPtr>::iterator it = _remote_server_store.find(unique_server_name);
-	if (it!=_remote_server_store.end()) return it->second;
-	RemoteServerPtr remote_server = Factory::getInstance().createRemoteServer(Scope(unique_server_name));
-	_remote_server_store[unique_server_name] = remote_server;
-	return remote_server;
-}
-
-ListenerPtr InputBuffer::_create_category_listener_if_needed(const std::string& category)
-{
-	std::map<std::string, ListenerPtr>::iterator it = _listener_store.find(category);
-	if (it!=_listener_store.end()) return it->second;
-	//IPAACA_INFO("Creating a new listener for category " << category)
-	std::string scope_string = "/ipaaca/category/" + category;
-	ListenerPtr listener = Factory::getInstance().createListener( Scope(scope_string) );
-	HandlerPtr event_handler = HandlerPtr(
-			new EventFunctionHandler(
-				boost::bind(&InputBuffer::_handle_iu_events, this, _1)
-			)
-		);
-	listener->addHandler(event_handler);
-	_listener_store[category] = listener;
-	return listener;
-	/*
-		'''Return (or create, store and return) a category listener.'''
-		if iu_category in self._listener_store: return self._informer_store[iu_category]
-		cat_listener = rsb.createListener(rsb.Scope("/ipaaca/category/"+str(iu_category)), config=self._participant_config)
-		cat_listener.addHandler(self._handle_iu_events)
-		self._listener_store[iu_category] = cat_listener
-		self._category_interests.append(iu_category)
-		logger.info("Added listener in scope "+"/ipaaca/category/"+iu_category)
-		return cat_listener
-	*/
-}
-void InputBuffer::_handle_iu_events(EventPtr event)
-{
-	std::string type = event->getType();
-	if (type == "ipaaca::RemotePushIU") {
-		boost::shared_ptr<RemotePushIU> iu = boost::static_pointer_cast<RemotePushIU>(event->getData());
-		if (_iu_store.count(iu->category()) > 0) {
-			// already got the IU... ignore
-		} else {
-			_iu_store[iu->uid()] = iu;
-			iu->_set_buffer(this);
-			call_iu_event_handlers(iu, false, IU_ADDED, iu->category() );
-		}
-		//IPAACA_INFO( "New RemotePushIU state: " << (*iu) )
-	} else {
-		RemotePushIUStore::iterator it;
-		if (type == "ipaaca::IUPayloadUpdate") {
-			boost::shared_ptr<IUPayloadUpdate> update = boost::static_pointer_cast<IUPayloadUpdate>(event->getData());
-			//IPAACA_INFO("** writer name: " << update->writer_name)
-			if (update->writer_name == _unique_name) {
-				return;
-			}
-			it = _iu_store.find(update->uid);
-			if (it == _iu_store.end()) {
-				IPAACA_INFO("Ignoring UPDATED message for an IU that we did not fully receive before")
-				return;
-			}
-			//
-			it->second->_apply_update(update);
-			call_iu_event_handlers(it->second, false, IU_UPDATED, it->second->category() );
-			//
-			//
-		} else if (type == "ipaaca::IULinkUpdate") {
-			boost::shared_ptr<IULinkUpdate> update = boost::static_pointer_cast<IULinkUpdate>(event->getData());
-			if (update->writer_name == _unique_name) {
-				return;
-			}
-			it = _iu_store.find(update->uid);
-			if (it == _iu_store.end()) {
-				IPAACA_INFO("Ignoring LINKSUPDATED message for an IU that we did not fully receive before")
-				return;
-			}
-			//
-			it->second->_apply_link_update(update);
-			call_iu_event_handlers(it->second, false, IU_LINKSUPDATED, it->second->category() );
-			//
-			//
-		} else if (type == "ipaaca::protobuf::IUCommission") {
-			boost::shared_ptr<protobuf::IUCommission> update = boost::static_pointer_cast<protobuf::IUCommission>(event->getData());
-			if (update->writer_name() == _unique_name) {
-				return;
-			}
-			it = _iu_store.find(update->uid());
-			if (it == _iu_store.end()) {
-				IPAACA_INFO("Ignoring COMMITTED message for an IU that we did not fully receive before")
-				return;
-			}
-			//
-			it->second->_apply_commission();
-			it->second->_revision = update->revision();
-			call_iu_event_handlers(it->second, false, IU_COMMITTED, it->second->category() );
-			//
-			//
-		} else if (type == "ipaaca::protobuf::IURetraction") {
-			boost::shared_ptr<protobuf::IURetraction> update = boost::static_pointer_cast<protobuf::IURetraction>(event->getData());
-			it = _iu_store.find(update->uid());
-			if (it == _iu_store.end()) {
-				IPAACA_INFO("Ignoring RETRACTED message for an IU that we did not fully receive before")
-				return;
-			}
-			//
-			it->second->_revision = update->revision();
-			it->second->_apply_retraction();
-			// remove from InputBuffer     FIXME: this is a crossover between retracted and deleted behavior
-			_iu_store.erase(it->first);
-			// and call the handler. IU reference is still valid for this call, although removed from buffer.
-			call_iu_event_handlers(it->second, false, IU_COMMITTED, it->second->category() );
-			//
-		} else {
-			std::cout << "(Unhandled Event type " << type << " !)" << std::endl;
-			return;
-		}
-		//IPAACA_INFO( "New RemotePushIU state: " << *(it->second) )
-	}
-}
-
-//}}}
-
-
-
-// IUInterface//{{{
-
-IUInterface::IUInterface()
-: _buffer(NULL), _committed(false), _retracted(false)
-{
-}
-
-void IUInterface::_set_uid(const std::string& uid) {
-	if (_uid != "") {
-		throw IUAlreadyHasAnUIDError();
-	}
-	_uid = uid;
-}
-
-void IUInterface::_set_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
-	if (_buffer) {
-		throw IUAlreadyInABufferError();
-	}
-	_buffer = buffer;
-	
-}
-
-void IUInterface::_set_owner_name(const std::string& owner_name) {
-	if (_owner_name != "") {
-		throw IUAlreadyHasAnOwnerNameError();
-	}
-	_owner_name = owner_name;
-}
-
-/// set the buffer pointer and the owner names of IU and Payload
-void IUInterface::_associate_with_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
-	_set_buffer(buffer); // will throw if already set
-	_set_owner_name(buffer->unique_name());
-	payload()._set_owner_name(buffer->unique_name());
-}
-
-/// C++-specific convenience function to add one single link
-void IUInterface::add_link(const std::string& type, const std::string& target, const std::string& writer_name)
-{
-	LinkMap none;
-	LinkMap add;
-	add[type].insert(target);
-	_modify_links(true, add, none, writer_name);
-	_add_and_remove_links(add, none);
-}
-/// C++-specific convenience function to remove one single link
-void IUInterface::remove_link(const std::string& type, const std::string& target, const std::string& writer_name)
-{
-	LinkMap none;
-	LinkMap remove;
-	remove[type].insert(target);
-	_modify_links(true, none, remove, writer_name);
-	_add_and_remove_links(none, remove);
-}
-
-void IUInterface::add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
-{
-	LinkMap none;
-	LinkMap add;
-	add[type] = targets;
-	_modify_links(true, add, none, writer_name);
-	_add_and_remove_links(add, none);
-}
-
-void IUInterface::remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
-{
-	LinkMap none;
-	LinkMap remove;
-	remove[type] = targets;
-	_modify_links(true, none, remove, writer_name);
-	_add_and_remove_links(none, remove);
-}
-
-void IUInterface::modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name)
-{
-	_modify_links(true, add, remove, writer_name);
-	_add_and_remove_links(add, remove);
-}
-
-void IUInterface::set_links(const LinkMap& links, const std::string& writer_name)
-{
-	LinkMap none;
-	_modify_links(false, links, none, writer_name);
-	_replace_links(links);
-}
-
-//}}}
-
-// IU//{{{
-IU::ptr IU::create(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
-{
-	IU::ptr iu = IU::ptr(new IU(category, access_mode, read_only, payload_type)); /* params */ //));
-	iu->_payload.initialize(iu);
-	return iu;
-}
-
-IU::IU(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
-{
-	_revision = 1;
-	_uid = ipaaca::generate_uuid_string();
-	_category = category;
-	_payload_type = payload_type;
-	// payload initialization deferred to IU::create(), above
-	_read_only = read_only;
-	_access_mode = access_mode;
-	_committed = false;
-}
-
-void IU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
-{
-	_revision_lock.lock();
-	if (_committed) {
-		_revision_lock.unlock();
-		throw IUCommittedError();
-	}
-	_increase_revision_number();
-	if (is_published()) {
-		_buffer->_send_iu_link_update(this, is_delta, _revision, new_links, links_to_remove, writer_name);
-	}
-	_revision_lock.unlock();
-}
-void IU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
-{
-	_revision_lock.lock();
-	if (_committed) {
-		_revision_lock.unlock();
-		throw IUCommittedError();
-	}
-	_increase_revision_number();
-	if (is_published()) {
-		_buffer->_send_iu_payload_update(this, is_delta, _revision, new_items, keys_to_remove, writer_name);
-	}
-	_revision_lock.unlock();
-}
-
-void IU::commit()
-{
-	_internal_commit();
-}
-
-void IU::_internal_commit(const std::string& writer_name)
-{
-	_revision_lock.lock();
-	if (_committed) {
-		_revision_lock.unlock();
-		throw IUCommittedError();
-	}
-	_increase_revision_number();
-	_committed = true;
-	if (is_published()) {
-		_buffer->_send_iu_commission(this, _revision, writer_name);
-	}
-	_revision_lock.unlock();
-}
-//}}}
-
-// RemotePushIU//{{{
-
-RemotePushIU::ptr RemotePushIU::create()
-{
-	RemotePushIU::ptr iu = RemotePushIU::ptr(new RemotePushIU(/* params */));
-	iu->_payload.initialize(iu);
-	return iu;
-}
-RemotePushIU::RemotePushIU()
-{
-	// nothing
-}
-void RemotePushIU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
-{
-	if (_committed) {
-		throw IUCommittedError();
-	}
-	if (_read_only) {
-		throw IUReadOnlyError();
-	}
-	RemoteServerPtr server = boost::static_pointer_cast<InputBuffer>(_buffer)->_get_remote_server(_owner_name);
-	IULinkUpdate::ptr update = IULinkUpdate::ptr(new IULinkUpdate());
-	update->uid = _uid;
-	update->revision = _revision;
-	update->is_delta = is_delta;
-	update->writer_name = _buffer->unique_name();
-	update->new_links = new_links;
-	update->links_to_remove = links_to_remove;
-	boost::shared_ptr<int> result = server->call<int>("updateLinks", update, IPAACA_REMOTE_SERVER_TIMEOUT); // TODO
-	if (*result == 0) {
-		throw IUUpdateFailedError();
-	} else {
-		_revision = *result;
-	}
-}
-void RemotePushIU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
-{
-	if (_committed) {
-		throw IUCommittedError();
-	}
-	if (_read_only) {
-		throw IUReadOnlyError();
-	}
-	RemoteServerPtr server = boost::static_pointer_cast<InputBuffer>(_buffer)->_get_remote_server(_owner_name);
-	IUPayloadUpdate::ptr update = IUPayloadUpdate::ptr(new IUPayloadUpdate());
-	update->uid = _uid;
-	update->revision = _revision;
-	update->is_delta = is_delta;
-	update->writer_name = _buffer->unique_name();
-	update->new_items = new_items;
-	update->keys_to_remove = keys_to_remove;
-	boost::shared_ptr<int> result = server->call<int>("updatePayload", update, IPAACA_REMOTE_SERVER_TIMEOUT); // TODO
-	if (*result == 0) {
-		throw IUUpdateFailedError();
-	} else {
-		_revision = *result;
-	}
-}
-
-void RemotePushIU::commit()
-{
-	if (_read_only) {
-		throw IUReadOnlyError();
-	}
-	if (_committed) {
-		// Following python version: ignoring multiple commit
-		return;
-	}
-	RemoteServerPtr server = boost::static_pointer_cast<InputBuffer>(_buffer)->_get_remote_server(_owner_name);
-	boost::shared_ptr<protobuf::IUCommission> update = boost::shared_ptr<protobuf::IUCommission>(new protobuf::IUCommission());
-	update->set_uid(_uid);
-	update->set_revision(_revision);
-	update->set_writer_name(_buffer->unique_name());
-	boost::shared_ptr<int> result = server->call<int>("commit", update, IPAACA_REMOTE_SERVER_TIMEOUT); // TODO
-	if (*result == 0) {
-		throw IUUpdateFailedError();
-	} else {
-		_revision = *result;
-	}
-}
-
-void RemotePushIU::_apply_link_update(IULinkUpdate::ptr update)
-{
-	_revision = update->revision;
-	if (update->is_delta) {
-		_add_and_remove_links(update->new_links, update->links_to_remove);
-	} else {
-		_replace_links(update->new_links);
-	}
-}
-void RemotePushIU::_apply_update(IUPayloadUpdate::ptr update)
-{
-	_revision = update->revision;
-	if (update->is_delta) {
-		for (std::vector<std::string>::const_iterator it=update->keys_to_remove.begin(); it!=update->keys_to_remove.end(); ++it) {
-			_payload._remotely_enforced_delitem(*it);
-		}
-		for (std::map<std::string, std::string>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
-			_payload._remotely_enforced_setitem(it->first, it->second);
-		}
-	} else {
-		_payload._remotely_enforced_wipe();
-		for (std::map<std::string, std::string>::const_iterator it=update->new_items.begin(); it!=update->new_items.end(); ++it) {
-			_payload._remotely_enforced_setitem(it->first, it->second);
-		}
-	}
-}
-void RemotePushIU::_apply_commission()
-{
-	_committed = true;
-}
-void RemotePushIU::_apply_retraction()
-{
-	_retracted = true;
-}
-void Payload::_remotely_enforced_wipe()
-{
-	_store.clear();
-}
-void Payload::_remotely_enforced_delitem(const std::string& k)
-{
-	_store.erase(k);
-}
-void Payload::_remotely_enforced_setitem(const std::string& k, const std::string& v)
-{
-	_store[k] = v;
-}
-
-//}}}
-
-
-
-
-// PayloadEntryProxy//{{{
-
-PayloadEntryProxy::PayloadEntryProxy(Payload* payload, const std::string& key)
-: _payload(payload), _key(key)
-{
-}
-PayloadEntryProxy& PayloadEntryProxy::operator=(const std::string& value)
-{
-	_payload->set(_key, value);
-	return *this;
-}
-PayloadEntryProxy::operator std::string()
-{
-	return _payload->get(_key);
-}
-PayloadEntryProxy::operator long()
-{
-	return atol(operator std::string().c_str());
-}
-PayloadEntryProxy::operator double()
-{
-	return atof(operator std::string().c_str());
-}
-//}}}
-
-// Payload//{{{
-
-void Payload::initialize(boost::shared_ptr<IUInterface> iu)
-{
-	_iu = iu;
-}
-
-PayloadEntryProxy Payload::operator[](const std::string& key)
-{
-	//boost::shared_ptr<PayloadEntryProxy> p(new PayloadEntryProxy(this, key));
-	return PayloadEntryProxy(this, key);
-}
-Payload::operator std::map<std::string, std::string>()
-{
-	return _store;
-}
-
-inline void Payload::_internal_set(const std::string& k, const std::string& v, const std::string& writer_name) {
-	std::map<std::string, std::string> _new;
-	std::vector<std::string> _remove;
-	_new[k]=v;
-	_iu->_modify_payload(true, _new, _remove, writer_name );
-	_store[k] = v;
-}
-inline void Payload::_internal_remove(const std::string& k, const std::string& writer_name) {
-	std::map<std::string, std::string> _new;
-	std::vector<std::string> _remove;
-	_remove.push_back(k);
-	_iu->_modify_payload(true, _new, _remove, writer_name );
-	_store.erase(k);
-}
-void Payload::_internal_replace_all(const std::map<std::string, std::string>& new_contents, const std::string& writer_name)
-{
-	std::vector<std::string> _remove;
-	_iu->_modify_payload(false, new_contents, _remove, writer_name );
-	_store = new_contents;
-}
-inline std::string Payload::get(const std::string& k) {
-	if (_store.count(k)>0) return _store[k];
-	else return IPAACA_PAYLOAD_DEFAULT_STRING_VALUE;
-}
-//}}}
-
-// IUConverter//{{{
-
-IUConverter::IUConverter()
-: Converter<std::string> ("ipaaca::IU", "ipaaca-iu", true)
-{
-}
-
-std::string IUConverter::serialize(const AnnotatedData& data, std::string& wire)
-{
-	// Ensure that DATA actually holds a datum of the data-type we expect.
-	assert(data.first == getDataType()); // "ipaaca::IU"
-	// NOTE: a dynamic_pointer_cast cannot be used from void*
-	boost::shared_ptr<const IU> obj = boost::static_pointer_cast<const IU> (data.second);
-	boost::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
-	// transfer obj data to pbo
-	pbo->set_uid(obj->uid());
-	pbo->set_revision(obj->revision());
-	pbo->set_category(obj->category());
-	pbo->set_payload_type(obj->payload_type());
-	pbo->set_owner_name(obj->owner_name());
-	pbo->set_committed(obj->committed());
-	pbo->set_access_mode(ipaaca::protobuf::IU::PUSH); // TODO
-	pbo->set_read_only(obj->read_only());
-	for (std::map<std::string, std::string>::const_iterator it=obj->_payload._store.begin(); it!=obj->_payload._store.end(); ++it) {
-		protobuf::PayloadItem* item = pbo->add_payload();
-		item->set_key(it->first);
-		item->set_value(it->second);
-		item->set_type("str"); // FIXME other types than str (later)
-	}
-	for (LinkMap::const_iterator it=obj->_links._links.begin(); it!=obj->_links._links.end(); ++it) {
-		protobuf::LinkSet* links = pbo->add_links();
-		links->set_type(it->first);
-		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			links->add_targets(*it2);
-		}
-	}
-	pbo->SerializeToString(&wire);
-	return getWireSchema();
-
-}
-
-AnnotatedData IUConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
-	assert(wireSchema == getWireSchema()); // "ipaaca-iu"
-	boost::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
-	pbo->ParseFromString(wire);
-	IUAccessMode mode = static_cast<IUAccessMode>(pbo->access_mode());
-	switch(mode) {
-		case IU_ACCESS_PUSH:
-			{
-			// Create a "remote push IU"
-			boost::shared_ptr<RemotePushIU> obj = RemotePushIU::create();
-			// transfer pbo data to obj
-			obj->_uid = pbo->uid();
-			obj->_revision = pbo->revision();
-			obj->_category = pbo->category();
-			obj->_payload_type = pbo->payload_type();
-			obj->_owner_name = pbo->owner_name();
-			obj->_committed = pbo->committed();
-			obj->_read_only = pbo->read_only();
-			obj->_access_mode = IU_ACCESS_PUSH;
-			for (int i=0; i<pbo->payload_size(); i++) {
-				const protobuf::PayloadItem& it = pbo->payload(i);
-				obj->_payload._store[it.key()] = it.value();
-			}
-			for (int i=0; i<pbo->links_size(); i++) {
-				const protobuf::LinkSet& pls = pbo->links(i);
-				LinkSet& ls = obj->_links._links[pls.type()];
-				for (int j=0; j<pls.targets_size(); j++) {
-					ls.insert(pls.targets(j));
-				}
-			}
-			//return std::make_pair(getDataType(), obj);
-			return std::make_pair("ipaaca::RemotePushIU", obj);
-			break;
-			}
-		default:
-			// other cases not handled yet! ( TODO )
-			throw NotImplementedError();
-	}
-}
-
-//}}}
-
-// IUPayloadUpdateConverter//{{{
-
-IUPayloadUpdateConverter::IUPayloadUpdateConverter()
-: Converter<std::string> ("ipaaca::IUPayloadUpdate", "ipaaca-iu-payload-update", true)
-{
-}
-
-std::string IUPayloadUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
-{
-	assert(data.first == getDataType()); // "ipaaca::IUPayloadUpdate"
-	boost::shared_ptr<const IUPayloadUpdate> obj = boost::static_pointer_cast<const IUPayloadUpdate> (data.second);
-	boost::shared_ptr<protobuf::IUPayloadUpdate> pbo(new protobuf::IUPayloadUpdate());
-	// transfer obj data to pbo
-	pbo->set_uid(obj->uid);
-	pbo->set_revision(obj->revision);
-	pbo->set_writer_name(obj->writer_name);
-	pbo->set_is_delta(obj->is_delta);
-	for (std::map<std::string, std::string>::const_iterator it=obj->new_items.begin(); it!=obj->new_items.end(); ++it) {
-		protobuf::PayloadItem* item = pbo->add_new_items();
-		item->set_key(it->first);
-		item->set_value(it->second);
-		item->set_type("str"); // FIXME other types than str (later)
-	}
-	for (std::vector<std::string>::const_iterator it=obj->keys_to_remove.begin(); it!=obj->keys_to_remove.end(); ++it) {
-		pbo->add_keys_to_remove(*it);
-	}
-	pbo->SerializeToString(&wire);
-	return getWireSchema();
-
-}
-
-AnnotatedData IUPayloadUpdateConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
-	assert(wireSchema == getWireSchema()); // "ipaaca-iu-payload-update"
-	boost::shared_ptr<protobuf::IUPayloadUpdate> pbo(new protobuf::IUPayloadUpdate());
-	pbo->ParseFromString(wire);
-	boost::shared_ptr<IUPayloadUpdate> obj(new IUPayloadUpdate());
-	// transfer pbo data to obj
-	obj->uid = pbo->uid();
-	obj->revision = pbo->revision();
-	obj->writer_name = pbo->writer_name();
-	obj->is_delta = pbo->is_delta();
-	for (int i=0; i<pbo->new_items_size(); i++) {
-		const protobuf::PayloadItem& it = pbo->new_items(i);
-		obj->new_items[it.key()] = it.value();
-	}
-	for (int i=0; i<pbo->keys_to_remove_size(); i++) {
-		obj->keys_to_remove.push_back(pbo->keys_to_remove(i));
-	}
-	return std::make_pair(getDataType(), obj);
-}
-
-//}}}
-
-// IULinkUpdateConverter//{{{
-
-IULinkUpdateConverter::IULinkUpdateConverter()
-: Converter<std::string> ("ipaaca::IULinkUpdate", "ipaaca-iu-link-update", true)
-{
-}
-
-std::string IULinkUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
-{
-	assert(data.first == getDataType()); // "ipaaca::IULinkUpdate"
-	boost::shared_ptr<const IULinkUpdate> obj = boost::static_pointer_cast<const IULinkUpdate> (data.second);
-	boost::shared_ptr<protobuf::IULinkUpdate> pbo(new protobuf::IULinkUpdate());
-	// transfer obj data to pbo
-	pbo->set_uid(obj->uid);
-	pbo->set_revision(obj->revision);
-	pbo->set_writer_name(obj->writer_name);
-	pbo->set_is_delta(obj->is_delta);
-	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj->new_links.begin(); it!=obj->new_links.end(); ++it) {
-		protobuf::LinkSet* links = pbo->add_new_links();
-		links->set_type(it->first);
-		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			links->add_targets(*it2);
-		}
-	}
-	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj->links_to_remove.begin(); it!=obj->links_to_remove.end(); ++it) {
-		protobuf::LinkSet* links = pbo->add_links_to_remove();
-		links->set_type(it->first);
-		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
-			links->add_targets(*it2);
-		}
-	}
-	pbo->SerializeToString(&wire);
-	return getWireSchema();
-
-}
-
-AnnotatedData IULinkUpdateConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
-	assert(wireSchema == getWireSchema()); // "ipaaca-iu-link-update"
-	boost::shared_ptr<protobuf::IULinkUpdate> pbo(new protobuf::IULinkUpdate());
-	pbo->ParseFromString(wire);
-	boost::shared_ptr<IULinkUpdate> obj(new IULinkUpdate());
-	// transfer pbo data to obj
-	obj->uid = pbo->uid();
-	obj->revision = pbo->revision();
-	obj->writer_name = pbo->writer_name();
-	obj->is_delta = pbo->is_delta();
-	for (int i=0; i<pbo->new_links_size(); ++i) {
-		const protobuf::LinkSet& it = pbo->new_links(i);
-		for (int j=0; j<it.targets_size(); ++j) {
-			obj->new_links[it.type()].insert(it.targets(j)); // = vec;
-		}
-	}
-	for (int i=0; i<pbo->links_to_remove_size(); ++i) {
-		const protobuf::LinkSet& it = pbo->links_to_remove(i);
-		for (int j=0; j<it.targets_size(); ++j) {
-			obj->links_to_remove[it.type()].insert(it.targets(j));
-		}
-	}
-	return std::make_pair(getDataType(), obj);
-}
-
-//}}}
-
-// IntConverter//{{{
-
-IntConverter::IntConverter()
-: Converter<std::string> ("int", "int32", true)
-{
-}
-
-std::string IntConverter::serialize(const AnnotatedData& data, std::string& wire)
-{
-	// Ensure that DATA actually holds a datum of the data-type we expect.
-	assert(data.first == getDataType()); // "int"
-	// NOTE: a dynamic_pointer_cast cannot be used from void*
-	boost::shared_ptr<const int> obj = boost::static_pointer_cast<const int> (data.second);
-	boost::shared_ptr<protobuf::IntMessage> pbo(new protobuf::IntMessage());
-	// transfer obj data to pbo
-	pbo->set_value(*obj);
-	pbo->SerializeToString(&wire);
-	return getWireSchema();
-
-}
+#endif
+}//}}}
 
-AnnotatedData IntConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
-	assert(wireSchema == getWireSchema()); // "int"
-	boost::shared_ptr<protobuf::IntMessage> pbo(new protobuf::IntMessage());
-	pbo->ParseFromString(wire);
-	boost::shared_ptr<int> obj = boost::shared_ptr<int>(new int(pbo->value()));
-	return std::make_pair("int", obj);
-}
+IPAACA_EXPORT std::string __ipaaca_static_option_default_payload_type("JSON");
+IPAACA_EXPORT std::string __ipaaca_static_option_default_channel("default");
+IPAACA_EXPORT unsigned int __ipaaca_static_option_log_level(IPAACA_LOG_LEVEL_WARNING);
 
-//}}}
+IPAACA_EXPORT std::string __ipaaca_static_option_rsb_host("");
+IPAACA_EXPORT std::string __ipaaca_static_option_rsb_port("");
+IPAACA_EXPORT std::string __ipaaca_static_option_rsb_transport("");
+IPAACA_EXPORT std::string __ipaaca_static_option_rsb_socketserver("");
 
 } // of namespace ipaaca
 

ipaacalib/cpp/src/rsb.conf

-[transport.spread]
-host = localhost
-port = 4803
-enabled = 1
-

ipaacalib/cpp/src/util/notifier.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Social Cognitive Systems Group
+ *                         (formerly the Sociable Agents Group)
+ *                         CITEC, Bielefeld University
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+/**
+ * \file   util/notifier.cc
+ *
+ * \brief Component notification (i.e. module-level introspection).
+ *
+ * \author Ramin Yaghoubzadeh (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   March, 2015
+ */
+
+#include <ipaaca/util/notifier.h>
+
+namespace ipaaca {
+namespace util {
+
+ComponentNotifier::~ComponentNotifier() 
+{
+	//LOG_IPAACA_CONSOLE("~ComponentNotifier")
+	if (initialized) {
+		go_down();
+	}
+}
+
+ComponentNotifier::ComponentNotifier(const std::string& componentName, const std::string& componentFunction, const std::set<std::string>& sendCategories, const std::set<std::string>& recvCategories)
+: initialized(false), gone_down(false), name(componentName), function(componentFunction)
+{
+	send_categories = ipaaca::str_join(sendCategories, ",");
+	recv_categories = ipaaca::str_join(recvCategories, ",");
+	// create private in/out buffer pair since none was specified
+	out_buf = ipaaca::OutputBuffer::create(componentName);
+	in_buf = ipaaca::InputBuffer::create(componentName, _IPAACA_COMP_NOTIF_CATEGORY);
+}
+
+ComponentNotifier::ComponentNotifier(const std::string& componentName, const std::string& componentFunction, const std::set<std::string>& sendCategories, const std::set<std::string>& receiveCategories, ipaaca::OutputBuffer::ptr outBuf, ipaaca::InputBuffer::ptr inBuf)
+: initialized(false), name(componentName), function(componentFunction), out_buf(outBuf), in_buf(inBuf)
+{
+	send_categories = ipaaca::str_join(sendCategories, ",");
+	recv_categories = ipaaca::str_join(receiveCategories, ",");
+}
+
+ComponentNotifier::ptr ComponentNotifier::create(const std::string& componentName, const std::string& componentFunction, const std::set<std::string>& sendCategories, const std::set<std::string>& recvCategories)
+{
+	return ComponentNotifier::ptr(new ComponentNotifier(componentName, componentFunction, sendCategories, recvCategories));
+}
+ComponentNotifier::ptr ComponentNotifier::create(const std::string& componentName, const std::string& componentFunction, const std::set<std::string>& sendCategories, const std::set<std::string>& recvCategories, ipaaca::OutputBuffer::ptr outBuf, ipaaca::InputBuffer::ptr inBuf)
+{
+	return ComponentNotifier::ptr(new ComponentNotifier(componentName, componentFunction, sendCategories, recvCategories, outBuf, inBuf));
+}
+
+void ComponentNotifier::handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+{
+	if ((event_type == IU_ADDED) || (event_type == IU_UPDATED) || (event_type == IU_MESSAGE)) {
+		Locker locker(lock);
+		IPAACA_DEBUG("Received a componentNotify")
+		std::string cName = iu->payload()[_IPAACA_COMP_NOTIF_NAME];
+		std::string cState = iu->payload()[_IPAACA_COMP_NOTIF_STATE];
+		if (cName != name) {
+			// call all registered notification handlers
+			for (std::vector<IUEventHandlerFunction>::iterator it = _handlers.begin(); it != _handlers.end(); ++it) {
+				(*it)(iu, event_type, local);
+			}
+			// send own info only if the remote component is a newly initialized one
+			if (cState=="new") {
+				//IPAACA_DEBUG("Submitting own componentNotify for new remote component")
+				submit_notify(_IPAACA_COMP_NOTIF_STATE_OLD);
+			}
+		}
+	}
+}
+
+void ComponentNotifier::add_notification_handler(ipaaca::IUEventHandlerFunction function)
+{
+	Locker locker(lock);
+	_handlers.push_back(function);
+}
+
+void ComponentNotifier::submit_notify(const std::string& current_state)
+{
+	ipaaca::Message::ptr iu = ipaaca::Message::create(_IPAACA_COMP_NOTIF_CATEGORY);
+	iu->payload()[_IPAACA_COMP_NOTIF_NAME] = name;
+	iu->payload()[_IPAACA_COMP_NOTIF_STATE] = current_state;
+	iu->payload()[_IPAACA_COMP_NOTIF_FUNCTION] = function;
+	iu->payload()[_IPAACA_COMP_NOTIF_SEND_CATS] = send_categories;
+	iu->payload()[_IPAACA_COMP_NOTIF_RECV_CATS] = recv_categories;
+	out_buf->add(iu);
+	IPAACA_DEBUG( "Sending a componentNotify: " << name << ": " << current_state << " (" << function << ", " << send_categories << ", " << recv_categories << ")" )
+}
+
+void ComponentNotifier::initialize() {
+	Locker locker(lock);
+	if (!initialized) {
+		initialized = true;
+		in_buf->register_handler(std::bind(&ComponentNotifier::handle_iu_event, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+		submit_notify(_IPAACA_COMP_NOTIF_STATE_NEW);
+	}
+}
+
+void ComponentNotifier::go_down() {
+	Locker locker(lock);
+	if (initialized && (!gone_down)) {
+		gone_down = true;
+		submit_notify(_IPAACA_COMP_NOTIF_STATE_DOWN);
+	}
+}
+
+}}
+

ipaacalib/cpp/test/CMakeLists.txt

@@ -3,13 +3,16 @@ cmake_minimum_required (VERSION 2.6)
 # project name
 project (ipaaca_cpp_test)
 
+# use C++11 (starting with proto v2 / ipaaca-c++ release 12)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
 ## use the following line to enable console debug messages in ipaaca
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_DEBUG_MESSAGES")
 
 # find cmake modules locally too
 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
 
-find_package(Boost COMPONENTS system filesystem thread regex REQUIRED)
+find_package(Boost COMPONENTS system filesystem thread regex unit_test_framework REQUIRED)
 link_directories(${Boost_LIBRARY_DIRS})
 include_directories(${Boost_INCLUDE_DIRS})
 
@@ -17,6 +20,9 @@ find_package(Protobuf REQUIRED)
 link_directories(${PROTOBUF_LIBRARY_DIRS})
 include_directories(${PROTOBUF_INCLUDE_DIRS})
 
+# for boost unit_test to create main()
+add_definitions(-DBOOST_TEST_DYN_LINK)
+
 #set(RSBLIBS rsc rsbcore)
 
 set(LIBS ${LIBS} ipaaca )
@@ -41,9 +47,14 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_
 # add local include directory
 include_directories( ${PROJECT_SOURCE_DIR}/include )
 
+# add includes and builds from parent dir (ipaaca lib)
+include_directories( ${PROJECT_SOURCE_DIR}/../include )
+include_directories( ${PROJECT_SOURCE_DIR}/../build )
+link_directories( ${PROJECT_SOURCE_DIR}/../build )
+
 # add lib and include directory from pulled dependencies
-include_directories( ${PROJECT_SOURCE_DIR}/../../../dist/include )
-link_directories( ${PROJECT_SOURCE_DIR}/../../../dist/lib )
+include_directories( ${PROJECT_SOURCE_DIR}/../../../deps/include )
+link_directories( ${PROJECT_SOURCE_DIR}/../../../deps/lib )
 
 # specify source files for ipaaca (auto-generated ones are in build/ )
 set (SOURCE
@@ -67,3 +78,7 @@ install (
 	ARCHIVE DESTINATION lib
 	)
 
+
+enable_testing()
+add_test(TestIpaacaCpp testipaaca)
+

ipaacalib/cpp/test/src/Makefile

@@ -2,11 +2,11 @@ CONFIG = -DIPAACA_DEBUG_MESSAGES
 #IPAACASOURCES = ../../src/ipaaca.cc ipaaca.pb.cc
 #TEXTSOURCES = ${IPAACASOURCES} testipaaca.cc
 TEXTSOURCES = testipaaca.cc
-CCFLAGS=-I../../../../dist/include -I. -I../../src -I/usr/local/include -I/opt/local/include ${CONFIG}
-BOOSTLIBS = -L/opt/local/lib -lboost_regex-mt -lboost_date_time-mt -lboost_program_options-mt -lboost_thread-mt -lboost_filesystem-mt -lboost_signals-mt -lboost_system-mt
+CCFLAGS=-I../../build -I../../../../deps/include -I../../../../dist/include -I. -I../../src -I/usr/local/include -I/opt/local/include ${CONFIG}
+BOOSTLIBS = -L/opt/local/lib -lboost_regex-mt -lboost_date_time-mt -lboost_thread-mt 
 PROTOLIBS = -L/opt/local/lib -lprotobuf
 #LIBS = ${BOOSTLIBS} ${PROTOLIBS} -L/usr/local/lib -lrsc -lrsbcore
-LIBS = -L../../../../dist/lib -lipaaca
+LIBS = -L../../../../deps/lib -L../../../../dist/lib -lipaaca
 
 COMPILER = gfilt
 

ipaacalib/cpp/src/ipaaca-test-main.cc → ipaacalib/cpp/test/src/ipaaca-test-main.cc

-#include <ipaaca.h>
+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Sociable Agents Group
+ *                         CITEC, Bielefeld University   
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <../include/ipaaca/ipaaca.h>
 #include <typeinfo>
 
 //#include <rsc/logging/Logger.h>
@@ -24,7 +56,7 @@ int main() {
 	try{
 		//initialize_ipaaca_rsb();
 		
-		InputBuffer::ptr ib = InputBuffer::create("Tester", "testcategory");
+		InputBuffer::ptr ib = InputBuffer::create("Tester", "spam");
 		ib->register_handler(my_first_iu_handler);
 		
 		while (true) {
@@ -50,7 +82,7 @@ int main() {
 		ob->register_handler(iu_handler_for_remote_changes);
 		//std::cout << "Buffer: " << ob->unique_name() << std::endl;
 		
-		IU::ptr iu = IU::create("testcategory");
+		IU::ptr iu = IU::create("spam");
 		ob->add(iu);
 		
 		std::cout << "Updating in 1 sec" << std::endl;
@@ -66,11 +98,20 @@ int main() {
 		
 		iu->add_link("grin", "DUMMY_IU_UID_1234efef1234");
 		
-		std::cout << "Interpreted as  long  value: " << iu->_payload["TEST"].to_int() << std::endl;
-		std::cout << "Interpreted as double value: " << iu->_payload["TEST"].to_float() << std::endl;
+		//std::cout << "Interpreted as  long  value: " << iu->_payload["TEST"].to_int() << std::endl;
+		//std::cout << "Interpreted as double value: " << iu->_payload["TEST"].to_float() << std::endl;
 		
 		std::cout << "Committing and quitting in 1 sec" << std::endl;
 		sleep(1);
+		int c = 0;
+		while(true) {
+			std::stringstream ss;
+			ss << c;
+                        iu->_payload["data"] = ss.str();
+			std::cout << "iu->_payload[\"data\"]=" << ss.str() << std::endl;
+			c++;
+			sleep(1);
+		}
 		iu->commit();
 	} catch (ipaaca::Exception& e) {
 		std::cout << "== IPAACA EXCEPTION == " << e.what() << std::endl;

ipaacalib/cpp/test/src/ipaaca-test-resend.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Sociable Agents Group
+ *                         CITEC, Bielefeld University   
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <../include/ipaaca/ipaaca.h>
+#include <typeinfo>
+#include <iostream>
+
+using namespace ipaaca;
+
+void my_first_iu_handler(IUInterface::ptr iu, IUEventType type, bool local)
+{
+	std::cout<<"Update!"<<std::endl;	
+}
+
+int main() {
+	try{
+		OutputBuffer::ptr output_buffer = OutputBuffer::create("Tester");
+		IU::ptr iu = IU::create("cat1");
+		output_buffer->add(iu);
+		
+		InputBuffer::ptr input_buffer = InputBuffer::create("InputTester","cat1");
+		input_buffer->set_resend(true);
+		input_buffer->register_handler(my_first_iu_handler);
+		iu->payload()["key"]="Dummy";
+		sleep(1);
+		std::cout<<"Input buffer #of ius: "<<input_buffer->get_ius().size()<<std::endl;
+		
+	} catch (ipaaca::Exception& e) {
+		std::cout << "== IPAACA EXCEPTION == " << e.what() << std::endl;
+	}
+}
+
+
+

ipaacalib/cpp/test/src/testipaaca.cc

-#include <ipaaca.h>
+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Sociable Agents Group
+ *                         CITEC, Bielefeld University   
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
 #include <typeinfo>
 
-using namespace ipaaca;
+#define BOOST_TEST_MODULE TestIpaacaCpp
+#include <boost/test/unit_test.hpp>
 
-const char RECV_CATEGORY[] = "WORD";
-const char SEND_CATEGORY[] = "TEXT";
+using namespace ipaaca;
 
-class TextSender {
-	protected:
-		OutputBuffer::ptr _ob;
-		InputBuffer::ptr  _ib;
+class TestReceiver {
 	public:
-		TextSender();
-		void outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
+		InputBuffer::ptr  _ib;
+		std::string received_info;
+		TestReceiver();
 		void inbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
-		IUInterface::ptr find_last_iu();
-		void publish_text_to_print(const std::string& text, const std::string& parent_iu_uid="");
 };
 
-TextSender::TextSender() {
-	_ob = OutputBuffer::create("TextSenderOut");
-	_ob->register_handler(boost::bind(&TextSender::outbuffer_handle_iu_event, this, _1, _2, _3));
-	_ib = InputBuffer::create("TextSenderIn", RECV_CATEGORY);
-	_ib->register_handler(boost::bind(&TextSender::inbuffer_handle_iu_event, this, _1, _2, _3));
+TestReceiver::TestReceiver()
+{
+	_ib = ipaaca::InputBuffer::create("TestReceiver", "cppTestCategory");
+	_ib->register_handler(boost::bind(&TestReceiver::inbuffer_handle_iu_event, this, _1, _2, _3));
+	received_info = "NOTHING RECEIVED YET";
 }
 
-void TextSender::outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+void TestReceiver::inbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
 {
-	std::cout << "(own IU event " << iu_event_type_to_str(event_type) << " " << iu->uid() << ")" << std::endl;
-	if (event_type == IU_UPDATED) {
-		std::set<std::string> parent_uids = iu->get_links("GRIN");
-		if (parent_uids.size() > 0) {
-			std::string parent_uid = *(parent_uids.begin());
-			std::cout << "updating parent ..." << std::endl;
-			std::set<std::string> next_uids = iu->get_links("SUCCESSOR");
-			if (next_uids.size() > 0) {
-				std::string next_uid = *(next_uids.begin());
-				IUInterface::ptr next_iu = _ob->get(next_uid);
-				std::set<std::string> next_letter_grin_links = next_iu->get_links("GRIN");
-				if (next_letter_grin_links.count(parent_uid) == 0) {
-					// next letter belongs to new word
-					IUInterface::ptr parent_iu = _ib->get(parent_uid);
-					parent_iu->payload()["STATE"] = "REALIZED";
-				} else {
-					IUInterface::ptr parent_iu = _ib->get(parent_uid);
-					parent_iu->payload()["STATE"] = "STARTED";
-				}
-			} else {
-				// there are no more letters, this is the end of the final word
-				IUInterface::ptr parent_iu = _ib->get(parent_uid);
-				parent_iu->payload()["STATE"] = "REALIZED";
-			}
-			std::cout << " ... done." << std::endl;
+	if (event_type == IU_ADDED) {
+		received_info = (std::string) iu->payload()["word"];
+		{
+			ipaaca::Locker locker(iu->payload());
+			iu->payload()["replyVector"] = std::vector<double> { 1.0, 2.0, 3.0 };
+			iu->payload()["replyComment"] = "OK";
 		}
-	} else {
 	}
 }
 
-void TextSender::inbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
-{
-	if (event_type == IU_LINKSUPDATED) {
-		std::cout << "links updated" << std::endl;
-	} else if (event_type == IU_ADDED) {
-		std::string word = iu->payload()["WORD"];
-		std::cout << "Received new word: " << word << std::endl;
-		publish_text_to_print(word, iu->uid());
-	} else if (event_type == IU_RETRACTED) {
-		std::string retracted_uid = iu->uid();
-	} else {
-		std::cout << "(IU event " << iu_event_type_to_str(event_type) << " " << iu->uid() << ")" << std::endl;
-	}
+
+class TestSender {
+	public:
+		OutputBuffer::ptr _ob;
+		std::vector<double> double_vec;
+		std::string comment;
+		long num_replies;
+		TestSender();
+		void publish_one_message();
+		void outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
+};
+
+TestSender::TestSender() {
+	_ob = OutputBuffer::create("TestSender");
+	_ob->register_handler(boost::bind(&TestSender::outbuffer_handle_iu_event, this, _1, _2, _3));
+	comment = "NO COMMENT YET";
+	num_replies = 0;
 }
 
-IUInterface::ptr TextSender::find_last_iu() {
-	std::set<IUInterface::ptr> ius = _ob->get_ius();
-	for (std::set<IUInterface::ptr>::iterator it = ius.begin(); it!=ius.end(); ++it) {
-		if ((*it)->get_links("SUCCESSOR").size() == 0) return *it;
+void TestSender::outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+{
+	if (event_type == IU_UPDATED) {
+		num_replies++;
+		double_vec = iu->payload()["replyVector"];
+		comment = (std::string) iu->payload()["replyComment"];
 	}
-	return IUInterface::ptr();
 }
 
-void TextSender::publish_text_to_print(const std::string& text, const std::string& parent_iu_uid) {
-	IUInterface::ptr previous_iu = find_last_iu();
-	if (previous_iu) {
-		// insert a blank if we already have words in the buffer
-		IU::ptr iu = IU::create( SEND_CATEGORY );
-		iu->payload()["CONTENT"] = " ";
-		_ob->add(iu);
-		previous_iu->add_link( "SUCCESSOR", iu->uid() );
-		iu->add_link( "PREDECESSOR", previous_iu->uid() );
-		if (parent_iu_uid != "") iu->add_link( "GRIN", parent_iu_uid );
-		previous_iu = iu;
-	}
-	for (int i=0; i<text.size(); ++i) {
-		IU::ptr iu = IU::create( SEND_CATEGORY );
-		iu->payload()["CONTENT"] = std::string(1, text.at(i));
-		_ob->add(iu);
-		if (previous_iu) {
-			previous_iu->add_link( "SUCCESSOR", iu->uid() );
-			iu->add_link( "PREDECESSOR", previous_iu->uid() );
-			if (parent_iu_uid != "") iu->add_link( "GRIN", parent_iu_uid );
-		}
-		if (previous_iu) std::cout << "previous IU: " << *previous_iu << std::endl;
-		previous_iu = iu;
-	}
+void TestSender::publish_one_message()
+{
+	ipaaca::IU::ptr iu = ipaaca::IU::create("cppTestCategory");
+	iu->payload()["word"] = "OK";
+	_ob->add(iu);
 }
-	
-int old_main() {
-	TextSender sender;
+
+BOOST_AUTO_TEST_SUITE (testIpaacaCpp)
+
+
+BOOST_AUTO_TEST_CASE( testIpaacaCpp01 )
+{
+	TestSender sender;
+	TestReceiver receiver;
+	std::cout << "Publishing one message and waiting 1s for replies from other module." << std::endl;
+	sender.publish_one_message();
 	sleep(1);
-	sender.publish_text_to_print("(INIT)");
-	std::cout << "Press Ctrl-C to cancel..." << std::endl;
-	while (true) sleep(1);
+	std::cout << "Checking for changes." << std::endl;
+	BOOST_CHECK( receiver.received_info == "OK" );
+	BOOST_CHECK( sender.num_replies == 1 );
+	BOOST_CHECK( sender.comment == "OK" );
+	BOOST_CHECK( sender.double_vec.size() == 3 );
+	std::cout << "Complete." << std::endl;
 }
 
-int main() {
-	std::cerr << "TODO: implement Ipaaca C++ test cases." << std::endl;
-	return 0;
-}
+BOOST_AUTO_TEST_SUITE_END( )
 

ipaacalib/java/.gitignore

@@ -6,3 +6,4 @@ dist
 privateprops
 .project
 .classpath
+/bin/