ipaacalib/cpp/src/ipaaca-config.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-config.cc
+ *
+ * \brief Source file for IPAACA configuration handling
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2019
+ */
+
+#include <ipaaca/ipaaca.h>
+
+extern char **environ;
+
+namespace ipaaca {
+
+template<>
+int Config::get_with_default_internal<int>(const std::string& key, int const& default_value, bool warn)
+{
+    auto it = _data.find(key);
+    if (it==_data.end()) {
+        config_key_not_found(key, default_value, warn);
+        return default_value;
+    }
+    std::size_t processed;
+    int res = std::stoi(it->second, &processed);
+    if (processed != it->second.size()) {
+        config_conversion_failed(key, default_value);
+        return default_value;
+    }
+    return res;
+}
+template<>
+std::string Config::get_with_default_internal<std::string>(const std::string& key, std::string const& default_value, bool warn)
+{
+    auto it = _data.find(key);
+    if (it==_data.end()) {
+        config_key_not_found(key, default_value, warn);
+        return default_value;
+    }
+    return it->second;
+}
+
+Config::ptr get_global_config(bool auto_parse_on_demand){
+    static bool first = true;
+    static Config::ptr global_config = std::make_shared<Config>();
+    if (first) {
+        first = false;
+        IPAACA_DEBUG("This is IPAACA-C++ version " << IPAACA_PROTOCOL_VERSION_MAJOR << "." << IPAACA_PROTOCOL_VERSION_MINOR << " (release " << IPAACA_CPP_RELEASE_NUMBER << " with nominal release date " << IPAACA_CPP_RELEASE_DATE << ") - library compiled on " << __DATE__)
+        if (auto_parse_on_demand) {
+            IPAACA_DEBUG("Populating global configuration from default sources")
+            global_config->populate_from_global_sources();
+        }
+    }
+    return global_config;
+}
+void Config::populate_from_global_sources()
+{
+    _messages_delivered.clear(); // message variable warnings
+    populate_from_any_conf_files();
+    populate_from_environment();
+}
+bool Config::get_key_and_value(const std::string& s, std::string& key, std::string& value)
+{
+    bool good = true;
+    size_t pos = 0;
+    for (pos=0; pos<s.size(); ++pos) {
+        auto c = s[pos]; //std::tolower(s[pos]);
+        if (c=='=') {
+            value = ipaaca::str_trim(s.substr(pos+1));
+            break;
+        } else if (c=='_') {
+            key += '.';
+        } else if (c=='.') {
+            key += '.';
+        } else if ((c>='a')&&(c<='z')) {
+            key += c;
+        } else if ((c>='A')&&(c<='Z')) {
+            key += (c+32);
+        } else {
+            good = false;
+            break;
+        }
+    }
+    if (!good) {
+        IPAACA_ERROR("Malformed configuration ignored: " << s.substr(0, pos+1))
+    }
+    return good;
+}
+void Config::populate_from_environment()
+{
+    int i = 1;
+    char* envline = *environ;
+    while (envline) {
+        if(strncmp(envline, "IPAACA_", 7) == 0) {
+            if (strlen(envline) > 1023) {
+                IPAACA_ERROR("Ignoring overly long environment entry starting with IPAACA_")
+            } else {
+                std::string s(envline);
+                s = s.substr(7);
+                std::string key("");
+                std::string value("");
+                bool good = get_key_and_value(s, key, value);
+                if (good) {
+                    IPAACA_INFO("Configuration set from environment: " << key << "=\"" << value << "\"");
+                    _data[key] = value;
+                }
+            }
+        }
+        envline = *(environ+i);
+        i++;
+    }
+}
+void Config::populate_from_any_conf_files()
+{
+    std::fstream f1;
+    f1.open("ipaaca.conf", std::fstream::in);
+    bool had_file = false;
+    if (f1.is_open()) {
+        IPAACA_DEBUG("Including configuration from ./ipaaca.conf")
+        populate_from_conf_file(f1);
+        f1.close();
+        had_file = true;
+    } else {
+        std::fstream f2;
+		char* homedir = std::getenv("HOME"); // TODO: windows
+		if (homedir) {
+			std::string conf_in_home(homedir);
+			conf_in_home += "/.config/ipaaca.conf";
+			f2.open(conf_in_home, std::fstream::in);
+			if (f2.is_open()) {
+				IPAACA_DEBUG("Including configuration from ~/.config/ipaaca.conf")
+					populate_from_conf_file(f2);
+				f2.close();
+				had_file = true;
+			}
+		}
+    }
+    if (!had_file) {
+        IPAACA_INFO("Could not load ipaaca.conf either here or in ~/.config")
+    }
+}
+void Config::populate_from_conf_file(std::fstream& fs)
+{
+    std::string line;
+    while (std::getline(fs, line)) {
+        //std::cout << "--->  " << line << std::endl;
+        line = ipaaca::str_trim(line);
+        std::string key("");
+        std::string value("");
+        if ((line.length() > 0) && (line[0] != '#') && (line[0] != '[')) {
+            bool good = get_key_and_value(line, key, value);
+            if (good) {
+                IPAACA_INFO("Configuration set from conf file: " << key << "=\"" << value << "\"");
+                _data[key] = value;
+            }
+        }
+    }
+}
+
+} // of namespace ipaaca
+
+

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)
+		return "";
+	std::string::size_type size=sep.length()*set.size();
+	for(std::set<std::string>::const_iterator it = set.begin(); it !=set.end(); it++)
+	{
+		size+=(*it).length();
+	}
+	std::string tmp;
+	tmp.reserve(size);
+	tmp=*(set.begin());
+	std::set<std::string>::const_iterator it = set.begin();
+	it++;
+	for(; it !=set.end(); it++)
+	{
+		tmp=tmp+sep+(*it);
+	}
+	return tmp;
+}
+
+std::string str_join(const std::vector<std::string>& vec,const std::string& sep)
+{
+	if(vec.size()==0)
+		return "";
+	std::string::size_type size=sep.length()*vec.size();
+	for(unsigned int i=0;i<vec.size();i++)
+	{
+		size+=vec[i].length();
+	}
+	std::string tmp;
+	tmp.reserve(size);
+	tmp=vec[0];
+	for(unsigned int i=1;i<vec.size();i++)
+	{
+		tmp=tmp+sep+vec[i];
+	}
+	return tmp;
+}
+
+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;
+}
+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>
+
+namespace ipaaca {
+
+// 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
+#endif
+}//}}}
+
+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/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

+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 unit_test_framework REQUIRED)
+link_directories(${Boost_LIBRARY_DIRS})
+include_directories(${Boost_INCLUDE_DIRS})
+
+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 )
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES})
+#${RSBLIBS})
+
+# enhance the default search paths (headers, libs ...)
+set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
+
+# Compiler defines copied from the old build system
+set(CXX_DEFINES "-D_BSD_SOURCE -DUSE_AV -DMGC_USE_DOUBLE -DLEDA_PREFIX -D__NO_CAST_TO_LOCAL_TYPE__ -DDBGLVL=0")
+if (DEFINED APPLE)
+	message(STATUS "Adding extra options for building on Mac OS X")
+	set(CXX_DEFINES "${CXX_DEFINES} -D__MACOSX__")
+	link_directories( /opt/local/lib )
+	include_directories( /opt/local/include )
+endif(DEFINED APPLE)
+
+# Combine the extra compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_DEFINES}")
+
+# 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}/../../../deps/include )
+link_directories( ${PROJECT_SOURCE_DIR}/../../../deps/lib )
+
+# specify source files for ipaaca (auto-generated ones are in build/ )
+set (SOURCE
+	src/testipaaca.cc
+	)
+
+# compile all files to "ipaaca" shared library
+add_executable(testipaaca ${SOURCE})
+# and link all the required external libs (found above using find_package etc.)
+target_link_libraries(testipaaca ${LIBS})
+
+set(DEFAULT_BIN_SUBDIR bin)
+set(DEFAULT_LIB_SUBDIR lib)
+set(DEFAULT_DATA_SUBDIR share/data)
+set(DEFAULT_INCLUDE_SUBDIR include)
+set(CMAKE_INSTALL_PREFIX "")
+install (
+	TARGETS testipaaca
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION lib
+	ARCHIVE DESTINATION lib
+	)
+
+
+enable_testing()
+add_test(TestIpaacaCpp testipaaca)
+

ipaacalib/cpp/test/src/.gitignore

+ipaaca.pb.cc
+ipaaca.pb.h
+

ipaacalib/cpp/test/src/Makefile

+CONFIG = -DIPAACA_DEBUG_MESSAGES
+#IPAACASOURCES = ../../src/ipaaca.cc ipaaca.pb.cc
+#TEXTSOURCES = ${IPAACASOURCES} testipaaca.cc
+TEXTSOURCES = testipaaca.cc
+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../../../../deps/lib -L../../../../dist/lib -lipaaca
+
+COMPILER = gfilt
+
+all: testipaaca
+	
+
+testipaaca:
+	${COMPILER} ${CCFLAGS} -o testipaaca ${TEXTSOURCES} ${LIBS}
+
+protoc:
+	protoc --proto_path=../../../proto ../../../proto/ipaaca.proto --cpp_out=.
+
+clean:
+	rm -f testipaaca ipaaca.pb.h ipaaca.pb.cc
+
+

ipaacalib/cpp/test/src/ipaaca-test-main.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 <rsc/logging/Logger.h>
+//#include <rsc/logging/LoggerFactory.h>
+// //rsc::logging::LoggerFactory::getInstance().reconfigure(rsc::logging::Logger::LEVEL_ALL);
+
+//
+//   TESTS
+//
+
+using namespace ipaaca;
+
+#ifdef MAKE_RECEIVER
+void my_first_iu_handler(IUInterface::ptr iu, IUEventType type, bool local)
+{
+	std::cout << "" << iu_event_type_to_str(type) << " " << (local?"(of local IU)":"(of remote IU)") << "" << std::endl;
+	if (type == IU_LINKSUPDATED) {
+		std::cout << "  setting something in the remote payload" << std::endl;
+		iu->payload()["new_field"] = "remotely_set";
+	}
+}
+int main() {
+	try{
+		//initialize_ipaaca_rsb();
+		
+		InputBuffer::ptr ib = InputBuffer::create("Tester", "spam");
+		ib->register_handler(my_first_iu_handler);
+		
+		while (true) {
+			sleep(1);
+		}
+		
+	} catch (ipaaca::Exception& e) {
+		std::cout << "== IPAACA EXCEPTION == " << e.what() << std::endl;
+	}
+}
+#else
+#ifdef MAKE_SENDER
+void iu_handler_for_remote_changes(IUInterface::ptr iu, IUEventType type, bool local)
+{
+	std::cout << "" << iu_event_type_to_str(type) << " " << (local?"(of local IU)":"(of remote IU)") << "" << std::endl;
+}
+int main() {
+	try{
+		//initialize_ipaaca_rsb();
+		
+		
+		OutputBuffer::ptr ob = OutputBuffer::create("Tester");
+		ob->register_handler(iu_handler_for_remote_changes);
+		//std::cout << "Buffer: " << ob->unique_name() << std::endl;
+		
+		IU::ptr iu = IU::create("spam");
+		ob->add(iu);
+		
+		std::cout << "Updating in 1 sec" << std::endl;
+		sleep(1);
+		
+		std::cout << "_payload.get(\"TEST\") = \"" << iu->_payload.get("TEST") << "\"" << std::endl;
+		std::cout << "_payload[\"TEST\"] = \"" << (std::string) iu->_payload["TEST"] << "\"" << std::endl;
+		iu->_payload["TEST"] = "123.5-WAS-SET";
+		std::cout << "_payload[\"TEST\"] = \"" << (std::string) iu->_payload["TEST"] << "\"" << std::endl;
+		
+		std::string s = "The string \"" + iu->_payload["TEST"].to_str() + "\" is the new value.";
+		std::cout << "Concatenation test: " << s << std::endl;
+		
+		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 << "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;
+	}
+}
+
+#endif
+#endif
+

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/rsb.conf

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