ipaacalib/cpp/src/ipaaca-backend-mqtt.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-backend-mqtt.cc
+ *
+ * \brief Source file for the MQTT backend
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2019
+ */
+
+#include <ipaaca/ipaaca.h>
+
+#include <thread>
+#include <chrono>
+
+namespace ipaaca {
+#include <ipaaca/ipaaca-backend-mqtt.h>
+namespace backend {
+namespace mqtt {
+
+// The following is a required static library initialization hook.
+//   This way, the backend gets registered into the global store just by getting selectively
+//   compiled in (i.e. without insertion into the general code or plugin loading).
+//   The back-end name is taken from the one provided in the BackEnd constructor.
+IPAACA_EXPORT static bool __initialize_mqtt_backend = BackEndLibrary::get()->register_backend(MQTTBackEnd::get());
+
+// MQTTBackEnd{{{
+// The backend class is the interface to the rest of the IPAACA library,
+//  which does not know any of the implementation details here.
+//  It is available via its (unique) given name (here "mqtt", just below)
+IPAACA_EXPORT MQTTBackEnd::MQTTBackEnd()
+: BackEnd("mqtt") {
+}
+IPAACA_EXPORT BackEnd::ptr MQTTBackEnd::get() {
+    static ptr backend_singleton;
+    if (!backend_singleton) {
+        ::mosqpp::lib_init();
+        backend_singleton = std::shared_ptr<MQTTBackEnd>(new MQTTBackEnd());
+    }
+    return backend_singleton;
+}
+IPAACA_EXPORT Informer::ptr MQTTBackEnd::createInformer(const std::string& scope)
+{
+    auto res = std::make_shared<MQTTInformer>(generate_client_id(), scope, get_global_config());
+    res->wait_live();
+    // TODO wait for it to come live?
+    return res;
+}
+IPAACA_EXPORT Listener::ptr MQTTBackEnd::createListener(const std::string& scope, InputBuffer* buf)
+{
+    auto res = std::make_shared<MQTTListener>(generate_client_id(), scope, buf, get_global_config());
+    res->wait_live();
+    // TODO wait for it to come live?
+    return res;
+}
+IPAACA_EXPORT LocalServer::ptr MQTTBackEnd::createLocalServer(const std::string& scope, OutputBuffer* buf)
+{
+    auto res = std::make_shared<MQTTLocalServer>(generate_client_id(), scope, buf, get_global_config());
+    res->wait_live();
+    // TODO wait for it to come live?
+    return res;
+}
+IPAACA_EXPORT RemoteServer::ptr MQTTBackEnd::createRemoteServer(const std::string& scope)
+{
+    auto res = std::make_shared<MQTTRemoteServer>(generate_client_id(), scope, get_global_config());
+    res->wait_live();
+    //res->wait_live();
+    // TODO wait for it to come live?
+    return res;
+}
+IPAACA_EXPORT void MQTTBackEnd::teardown()
+{
+    IPAACA_DEBUG("MQTTBackEnd sleeping for 1 sec before teardown, for messages in transit.")
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+//}}}
+
+//
+// Internal implementation follows
+//
+
+// ParticipantCore{{{
+IPAACA_EXPORT ParticipantCore::ParticipantCore()
+: _running(false), _live(false)
+{
+}
+IPAACA_EXPORT void ParticipantCore::signal_live() {
+    IPAACA_DEBUG("Notifying to wake up an async MQTT session (now live)")
+    _live = true;
+    _condvar.notify_one();
+}
+IPAACA_EXPORT bool ParticipantCore::wait_live(long timeout_milliseconds) {
+    IPAACA_DEBUG("Waiting for an MQTT session to come live")
+    std::unique_lock<std::mutex> lock(_condvar_mutex);
+    // mqtt handlers will notify this after connect or subscribe (depending on the subclass)
+    auto success = _condvar.wait_for(lock, std::chrono::milliseconds(timeout_milliseconds), [this]{return this->_live;});
+    if (!success) {
+        IPAACA_ERROR("Backend timeout: failed to go live")
+        return false; // TODO throw here or in construction wrapper (below)
+    }
+    return true;
+}
+//}}}
+
+// MQTTParticipant{{{
+IPAACA_EXPORT int MQTTParticipant::get_next_mid() {
+    static int _curmid = 0;
+    _curmid++;
+    return _curmid;
+}
+
+IPAACA_EXPORT MQTTParticipant::MQTTParticipant(const std::string& client_id, const std::string& scope, Config::ptr config)
+: ParticipantCore(), ::mosqpp::mosquittopp(client_id.c_str(), true), _scope(scope)
+{
+    //threaded_set(true);
+    _client_id = client_id;
+    // get connection parameters from config
+    if (config) {
+        host = config->get_with_default_and_warning<std::string>("transport.mqtt.host", "localhost");
+        std::cout << "HOST from config: " << host << std::endl;
+        port = config->get_with_default_and_warning<int>("transport.mqtt.port", 1883);
+        keepalive = config->get_with_default<int>("transport.mqtt.keepalive", 60);
+    } else {
+        host = "localhost";
+        port = 1883;
+        keepalive = 60;
+        IPAACA_ERROR("No Config provided in MQTT backend, using defaults: host=localhost port=1883 keepalive=60")
+    }
+    IPAACA_DEBUG("Created MQTTParticipant on " << host << ":" << port << " for scope " << _scope << " with prepared client id " << _client_id)
+}
+
+IPAACA_EXPORT void MQTTParticipant::connect_and_background()
+{
+    static const char* mosquitto_reasons[] = {
+        //"MOSQ_ERR_CONN_PENDING" is -1
+        "MOSQ_ERR_SUCCESS",
+        "MOSQ_ERR_NOMEM",
+        "MOSQ_ERR_PROTOCOL",
+        "MOSQ_ERR_INVAL",
+        "MOSQ_ERR_NO_CONN",
+        "MOSQ_ERR_CONN_REFUSED",
+        "MOSQ_ERR_NOT_FOUND",
+        "MOSQ_ERR_CONN_LOST",
+        "MOSQ_ERR_TLS",
+        "MOSQ_ERR_PAYLOAD_SIZE",
+        "MOSQ_ERR_NOT_SUPPORTED",
+        "MOSQ_ERR_AUTH",
+        "MOSQ_ERR_ACL_DENIED",
+        "MOSQ_ERR_UNKNOWN",
+        "MOSQ_ERR_ERRNO",
+        "MOSQ_ERR_EAI",
+        "MOSQ_ERR_PROXY"
+    };
+    int res = connect(host.c_str(), port, keepalive);
+    loop_start();
+    if (res!=0) {
+        const char* reason = "unknown";
+        if (res==-1) {
+            reason = "MOSQ_ERR_CONN_PENDING";
+        } else if ((res>0) && (res<17)) {
+            reason = mosquitto_reasons[res];
+        }
+        IPAACA_ERROR("MQTT connect (for scope " << _scope << ") returned an error " << res << " (mosquitto's " << reason << ") - please double-check parameters")
+        if (res==14) {
+            IPAACA_ERROR("The underlying system error: errno " << errno << " (" << strerror(errno) << ")")
+        }
+        throw BackEndConnectionFailedError();
+    } else {
+        IPAACA_DEBUG("connect OK for scope " << _scope)
+    }
+}
+IPAACA_EXPORT void MQTTParticipant::on_error()
+{
+    IPAACA_ERROR("MQTT error")
+}
+
+IPAACA_EXPORT void MQTTParticipant::on_disconnect(int rc)
+{
+    IPAACA_ERROR("MQTT disconnect of " << _scope << " with rc " << rc)
+}
+//}}}
+
+// MQTTInformer {{{
+IPAACA_EXPORT MQTTInformer::MQTTInformer(const std::string& client_id, const std::string& scope, Config::ptr config)
+: MQTTParticipant(client_id, scope, config)
+{
+    IPAACA_DEBUG("Create MQTTInformer for scope " << ((std::string) scope))
+    connect_and_background();
+}
+IPAACA_EXPORT void MQTTInformer::on_connect(int rc)
+{
+    signal_live();
+}
+IPAACA_EXPORT bool MQTTInformer::internal_publish(const std::string& wire)
+{
+    IPAACA_DEBUG("Trying to publish via MQTT, topic " << _scope)
+    //int mid = MQTTParticipant::get_next_mid();
+    int result = mosquittopp::publish(NULL, _scope.c_str(), wire.size(), wire.c_str(), 2, false);
+    return (result==0);
+}
+//}}}
+
+// MQTTListener {{{
+IPAACA_EXPORT MQTTListener::MQTTListener(const std::string& client_id, const std::string& scope, InputBuffer* buffer_ptr, Config::ptr config)
+: MQTTParticipant(client_id, scope, config), Listener(buffer_ptr)
+{
+    IPAACA_DEBUG("Create MQTTListener for scope " << ((std::string) scope))
+    connect_and_background();
+}
+IPAACA_EXPORT void MQTTListener::on_connect(int rc)
+{
+    int res = subscribe(NULL, _scope.c_str(), 2);
+    if (res!=0) {
+        IPAACA_ERROR("subscribe (on topic " << _scope << ") returned an error " << res)
+    } else {
+        IPAACA_DEBUG("subscribe returned OK for topic " << _scope)
+    }
+}
+
+IPAACA_EXPORT void MQTTListener::on_subscribe(int mid, int qos_count, const int * granted_qos)
+{
+    //IPAACA_DEBUG("on_subscribe: " << mid << " " << qos_count << " for scope " << _scope)
+    if (qos_count < 1) {
+        IPAACA_WARNING("No QoS grants reported")
+    } else if (qos_count > 1) {
+        IPAACA_WARNING("More than one QoS grant reported for Listener, should not happen")
+    } else {
+        int qos = granted_qos[0];
+        if (qos!=2) {
+            IPAACA_WARNING("MQTT QoS level 2 (guaranteed delivery) has NOT been granted on " << _scope << " (we got level " << qos << ")")
+        }
+    }
+    signal_live();
+}
+
+IPAACA_EXPORT void MQTTListener::on_message(const struct mosquitto_message * message) {
+    // internal_deserialize expects a string, which we construct here from the received char* and len
+    auto event = ipaaca::converters::internal_deserialize(std::string((const char*) message->payload, message->payloadlen));
+    //std::cout << "GOT AN EVENT of type " << event->getType() << std::endl;
+    // let the Listener base class handle the propagation into a Buffer:
+    Listener::relay_received_event_to_buffer_threaded(event);
+}
+//}}}
+
+// MQTTLocalServer {{{
+IPAACA_EXPORT MQTTLocalServer::MQTTLocalServer(const std::string& client_id, const std::string& scope, ipaaca::OutputBuffer* buffer_ptr, Config::ptr config)
+: MQTTParticipant(client_id, scope, config), LocalServer(buffer_ptr)
+{
+    IPAACA_DEBUG("Create MQTTLocalServer for scope " << ((std::string) scope));
+    connect_and_background();
+}
+IPAACA_EXPORT void MQTTLocalServer::on_connect(int rc)
+{
+    //IPAACA_DEBUG("LocalServer::on_connect: " << rc)
+    int res = subscribe(NULL, _scope.c_str(), 2);
+    if (res!=0) {
+        IPAACA_ERROR("subscribe (on topic " << _scope << ") returned an error " << res)
+    } else {
+        IPAACA_DEBUG("subscribe returned OK for topic " << _scope)
+    }
+}
+
+IPAACA_EXPORT void MQTTLocalServer::on_subscribe(int mid, int qos_count, const int * granted_qos)
+{
+    //IPAACA_DEBUG("LocalServer::on_subscribe: " << mid << " " << qos_count << " for scope " << _scope)
+    if (qos_count < 1) {
+        IPAACA_WARNING("No QoS grants reported")
+    } else if (qos_count > 1) {
+        IPAACA_WARNING("More than one QoS grant reported for Listener, should not happen")
+    } else {
+        int qos = granted_qos[0];
+        if (qos!=2) {
+            IPAACA_WARNING("MQTT QoS level 2 (guaranteed delivery) has NOT been granted on " << _scope << " (we got level " << qos << ")")
+        }
+    }
+    signal_live();
+}
+IPAACA_EXPORT void MQTTLocalServer::send_result_for_request(const std::string& request_endpoint, const std::string& request_uid, int64_t result)
+{
+    std::string wire;
+    std::shared_ptr<protobuf::RemoteRequestResult> pbo(new protobuf::RemoteRequestResult());
+    pbo->set_request_uid(request_uid);
+    pbo->set_result(result);
+    wire = ipaaca::converters::internal_serialize(pbo);
+    IPAACA_DEBUG("Trying to send result to RemoteServer " << request_endpoint)
+    int send_res = mosquittopp::publish(NULL, request_endpoint.c_str(), wire.size(), wire.c_str(), 2, false);
+}
+
+IPAACA_EXPORT void MQTTLocalServer::on_message(const struct mosquitto_message * message)
+{
+    auto event = ipaaca::converters::internal_deserialize(std::string((const char*) message->payload, message->payloadlen));
+    auto type = event->getType();
+    IPAACA_DEBUG("LocalServer " << _scope << " got an object of type " << type)
+    int64_t result = 0;
+    std::string request_endpoint("");
+    std::string request_uid("");
+    if (type == "ipaaca::IUPayloadUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IUPayloadUpdate>(event->getData());
+        request_uid = obj->request_uid;
+        request_endpoint = obj->request_endpoint;
+        result = LocalServer::attempt_to_apply_remote_payload_update(obj);
+    } else if (type == "ipaaca::IULinkUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IULinkUpdate>(event->getData());
+        request_uid = obj->request_uid;
+        result = LocalServer::attempt_to_apply_remote_link_update(obj);
+    } else if (type == "ipaaca::protobuf::IUCommission") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUCommission>(event->getData());
+        request_uid = obj->request_uid();
+        result = LocalServer::attempt_to_apply_remote_commission(obj);
+    } else if (type == "ipaaca::protobuf::IUResendRequest") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUResendRequest>(event->getData());
+        request_uid = obj->request_uid();
+        result = LocalServer::attempt_to_apply_remote_resend_request(obj);
+    } else {
+        IPAACA_ERROR("MQTTLocalServer: unhandled request wire type " << type)
+    }
+    if (request_uid.length()) {
+        send_result_for_request(request_endpoint, request_uid, result);
+    } else {
+        IPAACA_ERROR("MQTTLocalServer: cannot reply since request_uid is unknown")
+    }
+}
+//}}}
+
+// MQTTRemoteServer{{{
+// RemoteServer (= the side that sends requests to the owner of a remote IU)
+IPAACA_EXPORT MQTTRemoteServer::MQTTRemoteServer(const std::string& client_id, const std::string& scope, Config::ptr config)
+: MQTTParticipant(client_id, scope, config) {
+    _remote_end_scope = _scope;
+    auto uuid = ipaaca::generate_uuid_string().substr(0,8);
+    _name = "LocalServer_" +  uuid; // TODO add e.g. pid as in Python
+    _scope = "/ipaaca/remotes/" + _name; // overwrites constructed MQTTParticipant::_scope here (!)
+    IPAACA_DEBUG("Create MQTTRemoteServer for remote scope " << ((std::string) _remote_end_scope) << " and reply listener on " << _scope)
+    connect_and_background();
+}
+IPAACA_EXPORT int64_t MQTTRemoteServer::request_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::IUPayloadUpdate", update));
+}
+IPAACA_EXPORT int64_t MQTTRemoteServer::request_remote_link_update(std::shared_ptr<IULinkUpdate> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::IULinkUpdate", update));
+}
+IPAACA_EXPORT int64_t MQTTRemoteServer::request_remote_commission(std::shared_ptr<protobuf::IUCommission> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::protobuf::IUCommission", update));
+}
+IPAACA_EXPORT int64_t MQTTRemoteServer::request_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::protobuf::IUResendRequest", update));
+}
+IPAACA_EXPORT void MQTTRemoteServer::on_connect(int rc)
+{
+    int res = subscribe(NULL, _scope.c_str(), 2);
+    if (res!=0) {
+        IPAACA_ERROR("subscribe (on topic " << _scope << ") returned an error " << res)
+    } else {
+        IPAACA_DEBUG("subscribe returned OK for topic " << _scope)
+    }
+}
+
+IPAACA_EXPORT void MQTTRemoteServer::on_subscribe(int mid, int qos_count, const int * granted_qos)
+{
+    if (qos_count < 1) {
+        IPAACA_WARNING("No QoS grants reported")
+    } else if (qos_count > 1) {
+        IPAACA_WARNING("More than one QoS grant reported for Listener, should not happen")
+    } else {
+        int qos = granted_qos[0];
+        if (qos!=2) {
+            IPAACA_WARNING("MQTT QoS level 2 (guaranteed delivery) has NOT been granted on " << _scope << " (we got level " << qos << ")")
+        }
+    }
+    signal_live();
+}
+
+IPAACA_EXPORT void MQTTRemoteServer::on_message(const struct mosquitto_message * message)
+{
+    auto event = ipaaca::converters::internal_deserialize(std::string((const char*) message->payload, message->payloadlen));
+    auto type = event->getType();
+    IPAACA_DEBUG("RemoteServer " << _scope << " for remote " << _remote_end_scope << " got an object of type " << type)
+    if (type == "ipaaca::protobuf::RemoteRequestResult") {
+        auto reply = std::static_pointer_cast<ipaaca::protobuf::RemoteRequestResult>(event->getData());
+        auto uid = reply->request_uid();
+        auto result = reply->result();
+        PendingRequest::ptr pending_request;
+        {
+            ipaaca::Locker locker(_pending_requests_lock);
+            auto it = _pending_requests.find(uid);
+            if (it != _pending_requests.end()) {
+                pending_request = it->second;
+                _pending_requests.erase(it);
+            }
+        }
+        if (pending_request) {
+            pending_request->reply_with_result(result);
+        } else {
+            IPAACA_ERROR("MQTTRemoteServer: got a reply for a request that is not pending: " << uid)
+        }
+    } else {
+        IPAACA_ERROR("MQTTRemoteServer: unhandled request wire type " << type)
+    }
+}
+
+IPAACA_EXPORT PendingRequest::ptr MQTTRemoteServer::queue_pending_request(Event::ptr request)
+{
+    PendingRequest::ptr pending_request = std::make_shared<PendingRequest>(request);
+    {
+        ipaaca::Locker locker(_pending_requests_lock);
+        if ((_MQTT_REMOTE_SERVER_MAX_QUEUED_REQUESTS > 0) && (_pending_requests.size() >= _MQTT_REMOTE_SERVER_MAX_QUEUED_REQUESTS)) {
+            IPAACA_ERROR("MQTTRemoteServer: maximum number of pending requests exceeded")
+            throw BackEndBadConditionError();
+        } else {
+            _pending_requests[pending_request->_request_uid] = pending_request;
+            return pending_request;
+        }
+    }
+}
+IPAACA_EXPORT int64_t MQTTRemoteServer::blocking_call(Event::ptr request)
+{
+    std::string wire;
+    auto pending_request = queue_pending_request(request);
+    if (request->getType() == "ipaaca::IUPayloadUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IUPayloadUpdate>(request->getData());
+        obj->request_uid = pending_request->_request_uid;
+        obj->request_endpoint = _scope;
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::IULinkUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IULinkUpdate>(request->getData());
+        obj->request_uid = pending_request->_request_uid;
+        obj->request_endpoint = _scope;
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::protobuf::IUCommission") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUCommission>(request->getData());
+        obj->set_request_uid(pending_request->_request_uid);
+        obj->set_request_endpoint(_scope);
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::protobuf::IUResendRequest") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUResendRequest>(request->getData());
+        obj->set_request_uid(pending_request->_request_uid);
+        obj->set_request_endpoint(_scope);
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else {
+        IPAACA_ERROR("Unhandled request type " << request->getType())
+        throw BackEndBadConditionError();
+    }
+    IPAACA_DEBUG("Trying to send request to remote LocalServer at " << _remote_end_scope)
+    int send_res = mosquittopp::publish(NULL, _remote_end_scope.c_str(), wire.size(), wire.c_str(), 2, false);
+    IPAACA_DEBUG("Waiting for the remote server")
+    auto result = pending_request->wait_for_reply();
+    IPAACA_DEBUG("RPC wait ended.")
+    if (result<0) {
+        IPAACA_WARNING("A RemoteServer request timed out, remote end was " << _remote_end_scope)
+        return 0;
+    } else {
+        return result;
+    }
+}
+
+//}}}
+
+
+} // of namespace mqtt
+} // of namespace backend
+} // of namespace ipaaca
+

ipaacalib/cpp/src/ipaaca-backend-ros.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-backend-ros.cc
+ *
+ * \brief Source file for the ROS backend
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2019
+ */
+
+#include <ipaaca/ipaaca.h>
+
+#include "b64/b64.h"
+
+namespace ipaaca {
+#include <ipaaca/ipaaca-backend-ros.h>
+namespace backend {
+namespace ros {
+
+// The following is a required static library initialization hook.
+//   This way, the backend gets registered into the global store just by getting selectively
+//   compiled in (i.e. without insertion into the general code or plugin loading).
+//   The back-end name is taken from the one provided in the BackEnd constructor.
+IPAACA_EXPORT static bool __initialize_ros_backend = BackEndLibrary::get()->register_backend(ROSBackEnd::get());
+
+// ROSBackEnd{{{
+// The backend class is the interface to the rest of the IPAACA library,
+//  which does not know any of the implementation details here.
+//  It is available via its (unique) given name (here "ros", just below)
+IPAACA_EXPORT ROSBackEnd::ROSBackEnd()
+: BackEnd("ros"), _need_init(true), _node_handle(NULL)
+{
+}
+void sigint_ros_shutdown(int signal)
+{
+    std::cout << "SIGINT" << std::endl;
+    ::ros::shutdown();
+    exit(0);
+}
+IPAACA_EXPORT void ROSBackEnd::init_once()
+{
+    if (_need_init) {
+        IPAACA_INFO("Initializing ROS back-end ...")
+        std::string client_id = generate_client_id();
+        const char* fakename = client_id.c_str(); //"ipaaca_cpp_bin";
+        _cfakename = (char*) malloc(32);
+        strncpy(_cfakename, fakename, 31);
+        char* fake_argv[] = { _cfakename, NULL };
+        int fake_argc = 1;
+        int num_spinner_threads = 4;
+        _need_init = false;
+        IPAACA_INFO("Initializing ROS node ...")
+        ::ros::init(fake_argc, fake_argv, fakename, ::ros::init_options::AnonymousName); // | ::ros::init_options::NoRosout
+        //
+        IPAACA_INFO("Starting ROS node ...")
+        _node_handle = new ::ros::NodeHandle(); // internally calls ::ros::start()
+        //
+        signal(SIGINT, sigint_ros_shutdown);
+        //
+        IPAACA_INFO("Starting ROS spinner thread ...")
+        _spinner = new ::ros::AsyncSpinner(num_spinner_threads);
+        _spinner->start();
+    }
+}
+IPAACA_EXPORT void ROSBackEnd::teardown()
+{
+    IPAACA_INFO("Stopping ROS spinner thread ...")
+    _spinner->stop();
+    delete _spinner;
+    _spinner = NULL;
+    IPAACA_INFO("Shutting down ROS node ...")
+    ::ros::shutdown();
+    delete _node_handle;
+    _node_handle = NULL;
+    free(_cfakename);
+}
+IPAACA_EXPORT BackEnd::ptr ROSBackEnd::get() {
+    static ptr backend_singleton;
+    if (!backend_singleton) {
+        backend_singleton = std::shared_ptr<ROSBackEnd>(new ROSBackEnd());
+    }
+    return backend_singleton;
+}
+IPAACA_EXPORT Informer::ptr ROSBackEnd::createInformer(const std::string& scope)
+{
+    init_once();
+    auto res = std::make_shared<ROSInformer>(_node_handle, scope, get_global_config());
+    return res;
+}
+IPAACA_EXPORT Listener::ptr ROSBackEnd::createListener(const std::string& scope, InputBuffer* buf)
+{
+    init_once();
+    auto res = std::make_shared<ROSListener>(_node_handle, scope, buf, get_global_config());
+    return res;
+}
+IPAACA_EXPORT LocalServer::ptr ROSBackEnd::createLocalServer(const std::string& scope, OutputBuffer* buf)
+{
+    init_once();
+    auto res = std::make_shared<ROSLocalServer>(_node_handle, scope, buf, get_global_config());
+    return res;
+}
+IPAACA_EXPORT RemoteServer::ptr ROSBackEnd::createRemoteServer(const std::string& scope)
+{
+    init_once();
+    auto res = std::make_shared<ROSRemoteServer>(_node_handle, scope, get_global_config());
+    return res;
+}
+//}}}
+
+//
+// Internal implementation follows
+//
+
+// ParticipantCore{{{
+IPAACA_EXPORT ParticipantCore::ParticipantCore()
+: _running(false), _live(false)
+{
+}
+IPAACA_EXPORT void ParticipantCore::signal_live() {
+    IPAACA_DEBUG("Notifying to wake up an async ROS session (now live)")
+    _live = true;
+    _condvar.notify_one();
+}
+IPAACA_EXPORT bool ParticipantCore::wait_live(long timeout_milliseconds) {
+    IPAACA_DEBUG("Waiting for an ROS session to come live")
+    std::unique_lock<std::mutex> lock(_condvar_mutex);
+    // ros handlers will notify this after connect or subscribe (depending on the subclass)
+    auto success = _condvar.wait_for(lock, std::chrono::milliseconds(timeout_milliseconds), [this]{return this->_live;});
+    if (!success) {
+        IPAACA_ERROR("Backend timeout: failed to go live")
+        return false; // TODO throw here or in construction wrapper (below)
+    }
+    return true;
+}
+//}}}
+
+// ROSParticipant{{{
+IPAACA_EXPORT ROSParticipant::ROSParticipant(::ros::NodeHandle* node, const std::string& scope, Config::ptr config)
+: ParticipantCore(), _node_handle(node), _scope(scope)
+{
+    //_client_id = client_id;
+    // get connection parameters from config
+    if (config) {
+        host = config->get_with_default_and_warning<std::string>("transport.ros.host", "localhost");
+        port = config->get_with_default_and_warning<int>("transport.ros.port", 1883);
+        keepalive = config->get_with_default<int>("transport.ros.keepalive", 60);
+    } else {
+        host = "localhost";
+        port = 1883;
+        keepalive = 60;
+        IPAACA_ERROR("No Config provided in ROS backend, using defaults: host=localhost port=1883 keepalive=60")
+    }
+    //IPAACA_DEBUG("Created ROSParticipant on " << host << ":" << port << " for scope " << _scope) // << " with prepared client id " << _client_id)
+    //IPAACA_DEBUG("Created ROSParticipant for scope " << _scope) // << " with prepared client id " << _client_id)
+}
+
+//}}}
+
+// ROSInformer {{{
+IPAACA_EXPORT ROSInformer::ROSInformer(::ros::NodeHandle* node, const std::string& scope, Config::ptr config)
+: ROSParticipant(node, scope, config)
+{
+    IPAACA_DEBUG("Create ROS Publisher for scope " << ((std::string) scope))
+    _ros_pub = node->advertise<std_msgs::String>(scope, 100, true); // latch == true
+    //connect_and_background();
+}
+IPAACA_EXPORT bool ROSInformer::internal_publish(const std::string& wire)
+{
+    IPAACA_DEBUG("Trying to publish via ROS, topic " << _scope)
+    //int mid = ROSParticipant::get_next_mid();
+    std_msgs::String msg;
+    msg.data = base64_encode(wire);
+    // // This would be a way to ensure that an event has at least
+    // // one actual recipient (e.g. if you know there must be a receiver
+    // // by convention and wait to avoid lost events due to connection delay)
+    //while (_ros_pub.getNumSubscribers() == 0) {
+    //    std::this_thread().sleep_for(std::chrono::milliseconds(10));
+    //}
+    _ros_pub.publish(msg);
+    IPAACA_DEBUG("... returned from publish.")
+    return true;
+}
+//}}}
+
+// ROSListener {{{
+IPAACA_EXPORT ROSListener::ROSListener(::ros::NodeHandle* node, const std::string& scope, InputBuffer* buffer_ptr, Config::ptr config)
+: ROSParticipant(node, scope, config), Listener(buffer_ptr)
+{
+    IPAACA_DEBUG("Create ROSListener for scope " << ((std::string) scope))
+    _ros_sub = node->subscribe(scope, 1000, &ROSListener::on_message, this, ::ros::TransportHints().tcpNoDelay().reliable().unreliable());
+}
+IPAACA_EXPORT void ROSListener::on_message(const std_msgs::String::ConstPtr& msg) {
+    // internal_deserialize expects a string, which we construct here from the received char* and len
+    auto message = base64_decode(msg->data);
+    auto event = ipaaca::converters::internal_deserialize(message);
+    std::cout << "GOT AN EVENT of type " << event->getType() << std::endl;
+    // let the Listener base class handle the propagation into a Buffer:
+    Listener::relay_received_event_to_buffer_threaded(event);
+}
+//}}}
+
+// ROSLocalServer {{{
+IPAACA_EXPORT ROSLocalServer::ROSLocalServer(::ros::NodeHandle* node, const std::string& scope, ipaaca::OutputBuffer* buffer_ptr, Config::ptr config)
+: ROSParticipant(node, scope, config), LocalServer(buffer_ptr)
+{
+    IPAACA_DEBUG("Create ROSLocalServer for scope " << ((std::string) scope));
+    _ros_sub = node->subscribe(scope, 1000, &ROSLocalServer::on_message, this, ::ros::TransportHints().tcpNoDelay().reliable().unreliable());
+}
+//    int res = subscribe(NULL, _scope.c_str(), 2);
+IPAACA_EXPORT ::ros::Publisher ROSLocalServer::get_publisher(const std::string& endpoint)
+{
+    if (_ros_pubs.count(endpoint)) return _ros_pubs[endpoint];
+    _ros_pubs[endpoint] = _node_handle->advertise<std_msgs::String>(endpoint, 100, true); // latch == true
+    return _ros_pubs[endpoint];
+}
+IPAACA_EXPORT void ROSLocalServer::send_result_for_request(const std::string& request_endpoint, const std::string& request_uid, int64_t result)
+{
+    std::string wire;
+    std::shared_ptr<protobuf::RemoteRequestResult> pbo(new protobuf::RemoteRequestResult());
+    pbo->set_request_uid(request_uid);
+    pbo->set_result(result);
+    wire = ipaaca::converters::internal_serialize(pbo);
+    IPAACA_DEBUG("Trying to send result to RemoteServer " << request_endpoint)
+    std_msgs::String msg;
+    msg.data = base64_encode(wire);
+    auto pub = get_publisher(request_endpoint);
+    // // if latching should be insufficient for reliable RPC, activate this:
+    //while (pub.getNumSubscribers() == 0) {
+    //    std::this_thread().sleep_for(std::chrono::milliseconds(10));
+    //}
+    pub.publish(msg);
+}
+
+IPAACA_EXPORT void ROSLocalServer::on_message(const std_msgs::String::ConstPtr& msg)
+{
+    auto message = base64_decode(msg->data);
+    auto event = ipaaca::converters::internal_deserialize(message);
+    auto type = event->getType();
+    IPAACA_DEBUG("LocalServer " << _scope << " got an object of type " << type)
+    int64_t result = 0;
+    std::string request_endpoint("");
+    std::string request_uid("");
+    if (type == "ipaaca::IUPayloadUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IUPayloadUpdate>(event->getData());
+        request_uid = obj->request_uid;
+        request_endpoint = obj->request_endpoint;
+        result = LocalServer::attempt_to_apply_remote_payload_update(obj);
+    } else if (type == "ipaaca::IULinkUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IULinkUpdate>(event->getData());
+        request_uid = obj->request_uid;
+        result = LocalServer::attempt_to_apply_remote_link_update(obj);
+    } else if (type == "ipaaca::protobuf::IUCommission") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUCommission>(event->getData());
+        request_uid = obj->request_uid();
+        result = LocalServer::attempt_to_apply_remote_commission(obj);
+    } else if (type == "ipaaca::protobuf::IUResendRequest") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUResendRequest>(event->getData());
+        request_uid = obj->request_uid();
+        result = LocalServer::attempt_to_apply_remote_resend_request(obj);
+    } else {
+        IPAACA_ERROR("ROSLocalServer: unhandled request wire type " << type)
+    }
+    if (request_uid.length()) {
+        send_result_for_request(request_endpoint, request_uid, result);
+    } else {
+        IPAACA_ERROR("ROSLocalServer: cannot reply since request_uid is unknown")
+    }
+}
+//}}}
+
+// ROSRemoteServer{{{
+// RemoteServer (= the side that sends requests to the owner of a remote IU)
+IPAACA_EXPORT ROSRemoteServer::ROSRemoteServer(::ros::NodeHandle* node, const std::string& scope, Config::ptr config)
+: ROSParticipant(node, scope, config) {
+    _remote_end_scope = _scope;
+    auto uuid = ipaaca::generate_uuid_string().substr(0,8);
+    _name = "LocalServer_" +  uuid; // TODO add e.g. pid as in Python
+    _scope = "/ipaaca/remotes/" + _name; // overwrites constructed ROSParticipant::_scope here (!)
+    IPAACA_DEBUG("Create ROSRemoteServer for remote scope " << ((std::string) _remote_end_scope) << " and reply listener on " << _scope)
+    _ros_sub = node->subscribe(_scope, 1000, &ROSRemoteServer::on_message, this, ::ros::TransportHints().tcpNoDelay().reliable().unreliable());
+    _ros_pub = node->advertise<std_msgs::String>(_remote_end_scope, 100, true); // latch == true
+}
+IPAACA_EXPORT int64_t ROSRemoteServer::request_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::IUPayloadUpdate", update));
+}
+IPAACA_EXPORT int64_t ROSRemoteServer::request_remote_link_update(std::shared_ptr<IULinkUpdate> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::IULinkUpdate", update));
+}
+IPAACA_EXPORT int64_t ROSRemoteServer::request_remote_commission(std::shared_ptr<protobuf::IUCommission> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::protobuf::IUCommission", update));
+}
+IPAACA_EXPORT int64_t ROSRemoteServer::request_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update)
+{
+    return blocking_call(std::make_shared<Event>("ipaaca::protobuf::IUResendRequest", update));
+}
+
+IPAACA_EXPORT void ROSRemoteServer::on_message(const std_msgs::String::ConstPtr& msg)
+{
+    auto message = base64_decode(msg->data);
+    auto event = ipaaca::converters::internal_deserialize(message);
+    auto type = event->getType();
+    IPAACA_DEBUG("RemoteServer " << _scope << " for remote " << _remote_end_scope << " got an object of type " << type)
+    if (type == "ipaaca::protobuf::RemoteRequestResult") {
+        auto reply = std::static_pointer_cast<ipaaca::protobuf::RemoteRequestResult>(event->getData());
+        auto uid = reply->request_uid();
+        auto result = reply->result();
+        PendingRequest::ptr pending_request;
+        {
+            ipaaca::Locker locker(_pending_requests_lock);
+            auto it = _pending_requests.find(uid);
+            if (it != _pending_requests.end()) {
+                pending_request = it->second;
+                _pending_requests.erase(it);
+            }
+        }
+        if (pending_request) {
+            pending_request->reply_with_result(result);
+        } else {
+            IPAACA_ERROR("ROSRemoteServer: got a reply for a request that is not pending: " << uid)
+        }
+    } else {
+        IPAACA_ERROR("ROSRemoteServer: unhandled request wire type " << type)
+    }
+}
+
+IPAACA_EXPORT PendingRequest::ptr ROSRemoteServer::queue_pending_request(Event::ptr request)
+{
+    PendingRequest::ptr pending_request = std::make_shared<PendingRequest>(request);
+    {
+        ipaaca::Locker locker(_pending_requests_lock);
+        if ((_ROS_REMOTE_SERVER_MAX_QUEUED_REQUESTS > 0) && (_pending_requests.size() >= _ROS_REMOTE_SERVER_MAX_QUEUED_REQUESTS)) {
+            IPAACA_ERROR("ROSRemoteServer: maximum number of pending requests exceeded")
+            throw BackEndBadConditionError();
+        } else {
+            _pending_requests[pending_request->_request_uid] = pending_request;
+            return pending_request;
+        }
+    }
+}
+IPAACA_EXPORT int64_t ROSRemoteServer::blocking_call(Event::ptr request)
+{
+    std::string wire;
+    auto pending_request = queue_pending_request(request);
+    if (request->getType() == "ipaaca::IUPayloadUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IUPayloadUpdate>(request->getData());
+        obj->request_uid = pending_request->_request_uid;
+        obj->request_endpoint = _scope;
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::IULinkUpdate") {
+        auto obj = std::static_pointer_cast<ipaaca::IULinkUpdate>(request->getData());
+        obj->request_uid = pending_request->_request_uid;
+        obj->request_endpoint = _scope;
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::protobuf::IUCommission") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUCommission>(request->getData());
+        obj->set_request_uid(pending_request->_request_uid);
+        obj->set_request_endpoint(_scope);
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else if (request->getType() == "ipaaca::protobuf::IUResendRequest") {
+        auto obj = std::static_pointer_cast<ipaaca::protobuf::IUResendRequest>(request->getData());
+        obj->set_request_uid(pending_request->_request_uid);
+        obj->set_request_endpoint(_scope);
+        wire = ipaaca::converters::internal_serialize(obj);
+    } else {
+        IPAACA_ERROR("Unhandled request type " << request->getType())
+        throw BackEndBadConditionError();
+    }
+    IPAACA_DEBUG("Trying to send request to remote LocalServer at " << _remote_end_scope)
+    std_msgs::String msg;
+    msg.data = base64_encode(wire);
+    _ros_pub.publish(msg);
+    IPAACA_DEBUG("Waiting for the remote server")
+    auto result = pending_request->wait_for_reply();
+    IPAACA_DEBUG("RPC wait ended.")
+    if (result<0) {
+        IPAACA_WARNING("A RemoteServer request timed out, remote end was " << _remote_end_scope)
+        return 0;
+    } else {
+        return result;
+    }
+}
+
+//}}}
+
+
+} // of namespace ros
+} // of namespace backend
+} // of namespace ipaaca
+

ipaacalib/cpp/src/ipaaca-backend.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-backend.cc
+ *
+ * \brief Source file for abstract backend participant implementation
+ *   (used in the core library and as a base to derive specific backends).
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   December, 2018
+ */
+
+#include <ipaaca/ipaaca.h>
+
+namespace ipaaca {
+namespace backend {
+
+// LocalServer (= the side that owns the actual IUs and tries to honor remote requests){{{
+IPAACA_EXPORT int64_t LocalServer::attempt_to_apply_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update)
+{
+	IUInterface::ptr iui = _buffer->get(update->uid);
+	if (! iui) {
+		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid)
+		return 0;
+	}
+	IU::ptr iu = std::static_pointer_cast<IU>(iui);
+	iu->_revision_lock.lock();
+	if ((update->revision != 0) && (update->revision != iu->_revision)) {
+		IPAACA_WARNING("Remote write operation failed because request was out of date; IU " << update->uid)
+		IPAACA_WARNING(" Referred-to revision was " << update->revision << " while local one is " << iu->_revision)
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->committed()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->retracted()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->committed()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->retracted()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	}
+	if (update->is_delta) {
+		// FIXME TODO this is an unsolved problem atm: deletions in a delta update are
+		// sent individually. We should have something like _internal_merge_and_remove
+		for (std::vector<std::string>::const_iterator it=update->keys_to_remove.begin(); it!=update->keys_to_remove.end(); ++it) {
+			iu->payload()._internal_remove(*it, update->writer_name); //_buffer->unique_name());
+		}
+		// but it is solved for pure merges:
+		iu->payload()._internal_merge(update->new_items, update->writer_name);
+	} else {
+		iu->payload()._internal_replace_all(update->new_items, update->writer_name); //_buffer->unique_name());
+	}
+	_buffer->call_iu_event_handlers(iu, true, IU_UPDATED, iu->category());
+	revision_t revision = iu->revision();
+	iu->_revision_lock.unlock();
+	return revision;
+}
+
+IPAACA_EXPORT int64_t LocalServer::attempt_to_apply_remote_link_update(std::shared_ptr<IULinkUpdate> update)
+{
+	IUInterface::ptr iui = _buffer->get(update->uid);
+	if (! iui) {
+		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid)
+		return 0;
+	}
+	IU::ptr iu = std::static_pointer_cast<IU>(iui);
+	iu->_revision_lock.lock();
+	if ((update->revision != 0) && (update->revision != iu->_revision)) {
+		IPAACA_WARNING("Remote write operation failed because request was out of date; IU " << update->uid)
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->committed()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->retracted()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->committed()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->retracted()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	}
+	if (update->is_delta) {
+		iu->modify_links(update->new_links, update->links_to_remove, update->writer_name);
+	} else {
+		iu->set_links(update->new_links, update->writer_name);
+	}
+	_buffer->call_iu_event_handlers(iu, true, IU_LINKSUPDATED, iu->category());
+	revision_t revision = iu->revision();
+	iu->_revision_lock.unlock();
+	return revision;
+}
+IPAACA_EXPORT int64_t LocalServer::attempt_to_apply_remote_commission(std::shared_ptr<protobuf::IUCommission> update)
+{
+	IUInterface::ptr iui = _buffer->get(update->uid());
+	if (! iui) {
+		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid())
+		return 0;
+	}
+	IU::ptr iu = std::static_pointer_cast<IU>(iui);
+	iu->_revision_lock.lock();
+	if ((update->revision() != 0) && (update->revision() != iu->_revision)) {
+		IPAACA_WARNING("Remote write operation failed because request was out of date; IU " << update->uid())
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->committed()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else if (iu->retracted()) {
+		iu->_revision_lock.unlock();
+		return 0;
+	} else {
+	}
+	iu->_internal_commit(update->writer_name());
+	_buffer->call_iu_event_handlers(iu, true, IU_LINKSUPDATED, iu->category());
+	revision_t revision = iu->revision();
+	iu->_revision_lock.unlock();
+	return revision;
+}
+IPAACA_EXPORT int64_t LocalServer::attempt_to_apply_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update)
+{
+	IUInterface::ptr iui = _buffer->get(update->uid());
+	if (! iui) {
+		IPAACA_WARNING("Remote InBuffer tried to spuriously write non-existent IU " << update->uid())
+		return 0;
+	}
+	IU::ptr iu = std::static_pointer_cast<IU>(iui);
+	if ((update->has_hidden_scope_name() == true)&&(update->hidden_scope_name().compare("") != 0)){
+		revision_t revision = iu->revision();
+		_buffer->_publish_iu_resend(iu, update->hidden_scope_name());
+		return revision;
+	} else {
+		revision_t revision = 0;
+		return revision;
+	}
+}
+//}}}
+
+
+IPAACA_EXPORT void Listener::relay_received_event_to_buffer(Event::ptr event)
+{
+    //std::cout << "Will relay it" << std::endl;
+    _buffer->_handle_iu_events(event);
+}
+IPAACA_EXPORT void Listener::relay_received_event_to_buffer_threaded(Event::ptr event)
+{
+    auto buffer = _buffer; // avoid a 'this' lambda capture
+    std::thread dispatcher(
+            [buffer,event] () {
+                    buffer->_handle_iu_events(event);
+            });
+    dispatcher.detach();
+}
+
+
+} // of namespace backend
+} // of namespace ipaaca
+

ipaacalib/cpp/src/ipaaca-buffers.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>
+
+#define VERBOSE_HANDLERS 0  // remove later
+
+namespace ipaaca {
+
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj)//{{{
+{
+	os << "PayloadUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
+	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
+	os << ", new_items = {";
+	bool first = true;
+	for (auto& newit: obj.new_items) {
+		if (first) { first=false; } else { os << ", "; }
+		//os << "'" << it->first << "':'" << it->second << "'";
+		os << "'" << newit.first << "': " << newit.second;
+	}
+	os << "}, keys_to_remove = [";
+	first = true;
+	for (std::vector<std::string>::const_iterator it=obj.keys_to_remove.begin(); it!=obj.keys_to_remove.end(); ++it) {
+		if (first) { first=false; } else { os << ", "; }
+		os << "'" << *it << "'";
+	}
+	os << "])";
+	return os;
+}
+//}}}
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj)//{{{
+{
+	os << "LinkUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
+	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
+	os << ", new_links = {";
+	bool first = true;
+	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj.new_links.begin(); it!=obj.new_links.end(); ++it) {
+		if (first) { first=false; } else { os << ", "; }
+		os << "'" << it->first << "': [";
+		bool ffirst = true;
+		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			if (ffirst) { ffirst=false; } else { os << ", "; }
+			os << "'" << *it2 << "'";
+		}
+		os << "]";
+	}
+	os << "}, links_to_remove = {";
+	first = true;
+	for (std::map<std::string, std::set<std::string> >::const_iterator it=obj.links_to_remove.begin(); it!=obj.links_to_remove.end(); ++it) {
+		if (first) { first=false; } else { os << ", "; }
+		os << "'" << it->first << "': [";
+		bool ffirst = true;
+		for (std::set<std::string>::const_iterator it2=it->second.begin(); it2!=it->second.end(); ++it2) {
+			if (ffirst) { ffirst=false; } else { os << ", "; }
+			os << "'" << *it2 << "'";
+		}
+		os << "]";
+	}
+	os << "})";
+	return os;
+}
+//}}}
+
+// IUEventHandler//{{{
+IPAACA_EXPORT IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
+: _function(function), _event_mask(event_mask), _for_all_categories(false)
+{
+	if (category=="") {
+		_for_all_categories = true;
+	} else {
+		_categories.insert(category);
+	}
+}
+IPAACA_EXPORT IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
+: _function(function), _event_mask(event_mask), _for_all_categories(false)
+{
+	if (categories.size()==0) {
+		_for_all_categories = true;
+	} else {
+		_categories = categories;
+	}
+}
+IPAACA_EXPORT void IUEventHandler::call(Buffer* buffer, std::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
+{
+	if (_condition_met(event_type, category)) {
+#if VERBOSE_HANDLERS == 1
+			std::cout << "[" << pthread_self() << " handler ENTER]" << std::endl;
+#endif
+			_function(iu, event_type, local);
+#if VERBOSE_HANDLERS == 1
+			std::cout << "[" << pthread_self() << " handler EXIT]" << std::endl;
+#endif
+	}
+}
+//}}}
+
+// Buffer//{{{
+IPAACA_EXPORT void Buffer::_allocate_unique_name(const std::string& basename, const std::string& function) {
+	std::string uuid = ipaaca::generate_uuid_string();
+	_basename = basename;
+	_uuid = uuid.substr(0,8);
+	_unique_name = "/ipaaca/component/" + _basename + "ID" + _uuid + "/" + function;
+}
+IPAACA_EXPORT void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
+{
+	//IPAACA_DEBUG("register_handler " << event_mask << " " << categories)
+	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, categories));
+	_event_handlers.push_back(handler);
+}
+IPAACA_EXPORT void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
+{
+	//IPAACA_DEBUG("register_handler " << event_mask << " " << category)
+	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, category));
+	_event_handlers.push_back(handler);
+}
+IPAACA_EXPORT void Buffer::call_iu_event_handlers(std::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
+{
+	//IPAACA_DEBUG("handling an event " << ipaaca::iu_event_type_to_str(event_type) << " for IU " << iu->uid())
+	for (std::vector<IUEventHandler::ptr>::iterator it = _event_handlers.begin(); it != _event_handlers.end(); ++it) {
+		(*it)->call(this, iu, local, event_type, category);
+	}
+}
+//}}}
+
+/*
+// Callbacks for OutputBuffer//{{{
+IPAACA_EXPORT CallbackIUPayloadUpdate::CallbackIUPayloadUpdate(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIULinkUpdate::CallbackIULinkUpdate(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIUCommission::CallbackIUCommission(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIUResendRequest::CallbackIUResendRequest(Buffer* buffer): _buffer(buffer) { }
+*/
+
+//}}}
+
+// OutputBuffer//{{{
+
+IPAACA_EXPORT OutputBuffer::OutputBuffer(const std::string& basename, const std::string& channel)
+:Buffer(basename, "OB")
+{
+	_id_prefix = _basename + "-" + _uuid + "-IU-";
+	_channel = (channel=="") ? __ipaaca_static_option_default_channel: channel;
+	_initialize_server();
+}
+IPAACA_EXPORT void OutputBuffer::_initialize_server()
+{
+	_server = ipaaca::backend::get_default_backend()->createLocalServer( ipaaca::backend::get_default_backend()->make_valid_scope( _unique_name + "/Server" ), this );
+        //_server.connect_to_buffer(this);
+	/*_server->registerMethod("updatePayload", LocalServer::CallbackPtr(new CallbackIUPayloadUpdate(this)));
+	_server->registerMethod("updateLinks", LocalServer::CallbackPtr(new CallbackIULinkUpdate(this)));
+	_server->registerMethod("commit", LocalServer::CallbackPtr(new CallbackIUCommission(this)));
+	_server->registerMethod("resendRequest", LocalServer::CallbackPtr(new CallbackIUResendRequest(this)));
+        */
+}
+IPAACA_EXPORT OutputBuffer::ptr OutputBuffer::create(const std::string& basename)
+{
+	Initializer::initialize_backend();
+	return OutputBuffer::ptr(new OutputBuffer(basename));
+}
+IPAACA_EXPORT IUInterface::ptr OutputBuffer::get(const std::string& iu_uid)
+{
+	IUStore::iterator it = _iu_store.find(iu_uid);
+	if (it==_iu_store.end()) return IUInterface::ptr();
+	return it->second;
+}
+IPAACA_EXPORT std::set<IUInterface::ptr> OutputBuffer::get_ius()
+{
+	std::set<IUInterface::ptr> set;
+	for (IUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second);
+	return set;
+}
+
+IPAACA_EXPORT void OutputBuffer::_send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+{
+	auto lup = std::make_shared<IULinkUpdate>();
+	lup->uid = iu->uid();
+	lup->is_delta = is_delta;
+	lup->revision = revision;
+	lup->is_delta = true;
+	lup->new_links = new_links;
+	if (is_delta) lup->links_to_remove = links_to_remove;
+	if (writer_name=="") lup->writer_name = _unique_name;
+	else lup->writer_name = writer_name;
+	auto informer = _get_informer(iu->category());
+	informer->publish(lup);
+}
+
+IPAACA_EXPORT void OutputBuffer::_send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, PayloadDocumentEntry::ptr>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+{
+	auto pup = std::make_shared<IUPayloadUpdate>();
+	pup->payload_type = iu->payload_type();
+	pup->uid = iu->uid();
+	pup->is_delta = is_delta;
+	pup->revision = revision;
+	pup->new_items = new_items;
+	if (is_delta) pup->keys_to_remove = keys_to_remove;
+	if (writer_name=="") pup->writer_name = _unique_name;
+	else pup->writer_name = writer_name;
+	auto informer = _get_informer(iu->category());
+	informer->publish(pup);
+}
+
+IPAACA_EXPORT void OutputBuffer::_send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name)
+{
+	auto data = std::make_shared<protobuf::IUCommission>();
+	data->set_uid(iu->uid());
+	data->set_revision(revision);
+	if (writer_name=="") data->set_writer_name(_unique_name);
+	else data->set_writer_name(writer_name);
+
+	auto informer = _get_informer(iu->category());
+	informer->publish(data);
+}
+
+IPAACA_EXPORT void OutputBuffer::add(IU::ptr iu)
+{
+	if (_iu_store.count(iu->uid()) > 0) {
+		throw IUPublishedError();
+	}
+	if (iu->is_published()) {
+		throw IUPublishedError();
+	} else if (iu->retracted()) {
+		throw IURetractedError();
+	}
+	if (iu->access_mode() != IU_ACCESS_MESSAGE) {
+		// (for Message-type IUs: do not actually store them)
+		_iu_store[iu->uid()] = iu;
+	}
+	iu->_associate_with_buffer(this);
+	_publish_iu(iu);
+}
+
+IPAACA_EXPORT void OutputBuffer::_publish_iu(IU::ptr iu)
+{
+	auto informer = _get_informer(iu->_category);
+	informer->publish(iu);
+}
+
+IPAACA_EXPORT void OutputBuffer::_publish_iu_resend(IU::ptr iu, const std::string& hidden_scope_name)
+{
+	auto informer = _get_informer(hidden_scope_name);
+	informer->publish(iu);
+}
+
+IPAACA_EXPORT ipaaca::backend::Informer::ptr OutputBuffer::_get_informer(const std::string& category)
+{
+	if (_informer_store.count(category) > 0) {
+		return _informer_store[category];
+	} else {
+		//IPAACA_INFO("Creating new informer for category " << category << " on channel " << _channel)
+		std::string scope_string = "/ipaaca/channel/" + _channel + "/category/" + category;
+		IPAACA_INFO("Creating new informer for " << scope_string)
+
+		auto informer = ipaaca::backend::get_default_backend()->createInformer(ipaaca::backend::get_default_backend()->make_valid_scope(scope_string));
+		_informer_store[category] = informer;
+		return informer;
+	}
+}
+IPAACA_EXPORT std::shared_ptr<IU> OutputBuffer::remove(const std::string& iu_uid)
+{
+	IUStore::iterator it = _iu_store.find(iu_uid);
+	if (it == _iu_store.end()) {
+		IPAACA_WARNING("Removal of IU " << iu_uid << " requested, but not present in our OutputBuffer")
+		//throw IUNotFoundError();
+	}
+	IU::ptr iu = it->second;
+	_retract_iu(iu);
+	_iu_store.erase(iu_uid);
+	return iu;
+}
+IPAACA_EXPORT std::shared_ptr<IU> OutputBuffer::remove(IU::ptr iu)
+{
+	return remove(iu->uid()); // to make sure it is in the store
+}
+
+IPAACA_EXPORT void OutputBuffer::_retract_iu(IU::ptr iu)
+{
+	if (iu->_retracted) return; // ignore subsequent retractions
+	iu->_retracted = true;
+	auto data = std::make_shared<protobuf::IURetraction>();
+	data->set_uid(iu->uid());
+	data->set_revision(iu->revision());
+	auto informer = _get_informer(iu->category());
+	informer->publish(data);
+}
+
+IPAACA_EXPORT void OutputBuffer::_retract_all_internal()
+{
+	for (IUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) {
+		if (!(it->second->_retracted)) {
+			_retract_iu(it->second);
+		}
+	}
+}
+
+IPAACA_EXPORT OutputBuffer::~OutputBuffer()
+{
+	_retract_all_internal();
+}
+
+//}}}
+
+// InputBuffer//{{{
+IPAACA_EXPORT InputBuffer::InputBuffer(const BufferConfiguration& bufferconfiguration)
+:Buffer(bufferconfiguration.get_basename(), "IB")
+{
+	_channel = bufferconfiguration.get_channel();
+	for (std::vector<std::string>::const_iterator it=bufferconfiguration.get_category_interests().begin(); it!=bufferconfiguration.get_category_interests().end(); ++it) {
+		_create_category_listener_if_needed(*it);
+	}
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::set<std::string>& category_interests)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	for (std::set<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
+		_create_category_listener_if_needed(*it);
+	}
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	for (std::vector<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
+		_create_category_listener_if_needed(*it);
+	}
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	_create_category_listener_if_needed(category_interest1);
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	_create_category_listener_if_needed(category_interest1);
+	_create_category_listener_if_needed(category_interest2);
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	_create_category_listener_if_needed(category_interest1);
+	_create_category_listener_if_needed(category_interest2);
+	_create_category_listener_if_needed(category_interest3);
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
+:Buffer(basename, "IB")
+{
+	_channel = __ipaaca_static_option_default_channel;
+	_create_category_listener_if_needed(category_interest1);
+	_create_category_listener_if_needed(category_interest2);
+	_create_category_listener_if_needed(category_interest3);
+	_create_category_listener_if_needed(category_interest4);
+	_create_category_listener_if_needed(_uuid);
+	triggerResend = false;
+}
+
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const BufferConfiguration& bufferconfiguration)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(bufferconfiguration));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::set<std::string>& category_interests)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::vector<std::string>& category_interests)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interest1));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3));
+}
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
+{
+	Initializer::initialize_backend();
+	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3, category_interest4));
+}
+
+IPAACA_EXPORT void InputBuffer::set_resend(bool resendActive)
+{
+	triggerResend = resendActive;
+}
+
+IPAACA_EXPORT bool InputBuffer::get_resend()
+{
+	return triggerResend;
+}
+
+IPAACA_EXPORT IUInterface::ptr InputBuffer::get(const std::string& iu_uid)
+{
+	RemotePushIUStore::iterator it = _iu_store.find(iu_uid);
+	if (it==_iu_store.end()) return IUInterface::ptr();
+	return it->second;
+}
+IPAACA_EXPORT std::set<IUInterface::ptr> InputBuffer::get_ius()
+{
+	std::set<IUInterface::ptr> set;
+	for (RemotePushIUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second);
+	return set;
+}
+
+IPAACA_EXPORT ipaaca::backend::RemoteServer::ptr InputBuffer::_get_remote_server(const std::string& unique_server_name)
+{
+	std::string fullname = unique_server_name + "/Server";
+	auto it = _remote_server_store.find(fullname);
+	if (it != _remote_server_store.end()) return it->second;
+	auto remote_server = ipaaca::backend::get_default_backend()->createRemoteServer(ipaaca::backend::get_default_backend()->make_valid_scope(fullname));
+	_remote_server_store[fullname] = remote_server;
+	return remote_server;
+}
+
+IPAACA_EXPORT ipaaca::backend::Listener::ptr InputBuffer::_create_category_listener_if_needed(const std::string& category)
+{
+	auto it = _listener_store.find(category);
+	if (it!=_listener_store.end()) {
+		return it->second;
+	}
+	std::string scope_string = "/ipaaca/channel/" + _channel + "/category/" + category;
+	IPAACA_INFO("Creating new listener for " << scope_string)
+
+	auto listener = ipaaca::backend::get_default_backend()->createListener( ipaaca::backend::get_default_backend()->make_valid_scope(scope_string), this );
+	/*HandlerPtr event_handler = HandlerPtr(
+			new EventFunctionHandler(
+				std::bind(&InputBuffer::_handle_iu_events, this, _1)
+			)
+		);
+	listener->addHandler(event_handler);
+	*/
+        _listener_store[category] = listener;
+	return listener;
+}
+IPAACA_EXPORT void InputBuffer::_trigger_resend_request(ipaaca::backend::Event::ptr event) {
+	if (!triggerResend) return;
+	std::string type = event->getType();
+	std::string uid = "";
+	std::string writerName = "";
+	if (type == "ipaaca::IUPayloadUpdate") {
+		std::shared_ptr<IUPayloadUpdate> update = std::static_pointer_cast<IUPayloadUpdate>(event->getData());
+		uid = update->uid;
+		writerName = update->writer_name;
+	} else if (type == "ipaaca::IULinkUpdate") {
+		std::shared_ptr<IULinkUpdate> update = std::static_pointer_cast<IULinkUpdate>(event->getData());
+		uid = update->uid;
+		writerName = update->writer_name;
+	} else if (type == "ipaaca::protobuf::IUCommission") {
+		std::shared_ptr<protobuf::IUCommission> update = std::static_pointer_cast<protobuf::IUCommission>(event->getData());
+		uid = update->uid();
+		writerName = update->writer_name();
+	} else {
+		IPAACA_ERROR("_trigger_resend_request: called for unhandled event type " << type)
+		return;
+	}
+
+	if (!writerName.empty()) {
+		auto server = _get_remote_server(writerName);
+		if (!uid.empty()) {
+			std::shared_ptr<protobuf::IUResendRequest> update = std::shared_ptr<protobuf::IUResendRequest>(new protobuf::IUResendRequest());
+			update->set_uid(uid);
+			update->set_hidden_scope_name(_uuid);
+			int result = server->request_remote_resend_request(update);
+			if (result == 0) {
+				throw IUResendRequestFailedError();
+			}
+		}
+	}
+}
+IPAACA_EXPORT void InputBuffer::_handle_iu_events(ipaaca::backend::Event::ptr event)
+{
+	std::string type = event->getType();
+	if (type == "ipaaca::RemotePushIU") {
+		std::shared_ptr<RemotePushIU> iu = std::static_pointer_cast<RemotePushIU>(event->getData());
+		if (_iu_store.count(iu->category()) > 0) {
+			// already got the IU... ignore
+		} else {
+			_iu_store[iu->uid()] = iu;
+			iu->_set_buffer(this);
+			call_iu_event_handlers(iu, false, IU_ADDED, iu->category() );
+		}
+	} else if (type == "ipaaca::RemoteMessage") {
+		std::shared_ptr<RemoteMessage> iu = std::static_pointer_cast<RemoteMessage>(event->getData());
+		call_iu_event_handlers(iu, false, IU_MESSAGE, iu->category() );
+	} else {
+		RemotePushIUStore::iterator it;
+		if (type == "ipaaca::IUPayloadUpdate") {
+			std::shared_ptr<IUPayloadUpdate> update = std::static_pointer_cast<IUPayloadUpdate>(event->getData());
+			if (update->writer_name == _unique_name) {
+				return;
+			}
+			it = _iu_store.find(update->uid);
+			if (it == _iu_store.end()) {
+				_trigger_resend_request(event);
+				IPAACA_INFO("UPDATED message for an IU that we did not fully receive before")
+				return;
+			}
+			it->second->_apply_update(update);
+			call_iu_event_handlers(it->second, false, IU_UPDATED, it->second->category() );
+		} else if (type == "ipaaca::IULinkUpdate") {
+			std::shared_ptr<IULinkUpdate> update = std::static_pointer_cast<IULinkUpdate>(event->getData());
+			if (update->writer_name == _unique_name) {
+				return;
+			}
+			it = _iu_store.find(update->uid);
+			if (it == _iu_store.end()) {
+				_trigger_resend_request(event);
+				IPAACA_INFO("LINKSUPDATED message for an IU that we did not fully receive before")
+				return;
+			}
+			it->second->_apply_link_update(update);
+			call_iu_event_handlers(it->second, false, IU_LINKSUPDATED, it->second->category() );
+		} else if (type == "ipaaca::protobuf::IUCommission") {
+			std::shared_ptr<protobuf::IUCommission> update = std::static_pointer_cast<protobuf::IUCommission>(event->getData());
+			if (update->writer_name() == _unique_name) {
+				return;
+			}
+			it = _iu_store.find(update->uid());
+			if (it == _iu_store.end()) {
+				_trigger_resend_request(event);
+				IPAACA_INFO("COMMITTED message for an IU that we did not fully receive before")
+				return;
+			}
+			it->second->_apply_commission();
+			it->second->_revision = update->revision();
+			call_iu_event_handlers(it->second, false, IU_COMMITTED, it->second->category() );
+		} else if (type == "ipaaca::protobuf::IURetraction") {
+			std::shared_ptr<protobuf::IURetraction> update = std::static_pointer_cast<protobuf::IURetraction>(event->getData());
+			it = _iu_store.find(update->uid());
+			if (it == _iu_store.end()) {
+				IPAACA_INFO("Ignoring RETRACTED message for an IU that we did not fully receive before")
+				return;
+			}
+			it->second->_revision = update->revision();
+			it->second->_apply_retraction();
+			auto final_iu_ref = it->second;
+			////// remove from InputBuffer?  FIXME: unclear issue - resolve in ipaaca3
+			////_iu_store.erase(it->first);
+			// and call the handler. IU reference is still valid for this call, even if removed from buffer.
+			call_iu_event_handlers(final_iu_ref, false, IU_RETRACTED, it->second->category() );
+			//
+		} else {
+			IPAACA_WARNING("(Unhandled Event type " << type << " !)");
+			return;
+		}
+	}
+}
+//}}}
+
+} // of namespace ipaaca

ipaacalib/cpp/src/ipaaca-cmdline-parser.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>
+
+#if _WIN32 || _WIN64
+  // no getopt
+#else
+#include <getopt.h>
+#endif
+
+namespace ipaaca {
+
+//
+// Command line options implementation
+//
+
+
+void CommandLineOptions::set_option(const std::string& name, bool expect, const char* optarg) {
+	param_set[name] = true;
+	if (expect) {
+		param_opts[name] = optarg;
+	}
+}
+std::string CommandLineOptions::get_param(const std::string& o) {
+	std::map<std::string, std::string>::iterator it = param_opts.find(o);
+	if (it==param_opts.end()) return "";
+	return it->second;
+}
+bool CommandLineOptions::is_set(const std::string& o) {
+	std::map<std::string, bool>::iterator it = param_set.find(o);
+	if (it==param_set.end()) return false;
+	return it->second;
+}
+void CommandLineOptions::dump() {
+	for (std::map<std::string, bool>::iterator it=param_set.begin(); it!=param_set.end(); ++it) {
+		std::map<std::string, std::string>::iterator it2 = param_opts.find( it->first );
+		if (it2 == param_opts.end()) {
+			std::cout << it->first << "\t<true>" << std::endl;
+		} else {
+			std::cout << it->first << "\t" << it2->second << std::endl;
+		}
+	}
+}
+
+// Command line parser implementation
+
+CommandLineParser::CommandLineParser()
+: library_options_handled(true)
+{
+	initialize_parser_defaults();
+}
+
+void CommandLineParser::initialize_parser_defaults()
+{
+	add_option("help",           0  , false, "");
+	add_option("verbose",        'v', false, "");
+	add_option("character-name", 'c', true, "UnknownCharacter");
+	add_option("component-name", 'n', true, "UnknownComponent");
+	if (library_options_handled) {
+		add_option("ipaaca-payload-type", 0, true, "JSON");
+		add_option("ipaaca-default-channel", 0, true, "default");
+		add_option("ipaaca-enable-logging", 0, true, "WARNING");
+		add_option("rsb-enable-logging", 0, true, "ERROR");
+		add_option("rsb-host", 0, true, ""); // empty = don't set
+		add_option("rsb-port", 0, true, ""); // empty = don't set
+		add_option("rsb-transport", 0, true, ""); // empty = don't set
+		add_option("rsb-socket-server", 0, true, ""); // empty = don't set
+	}
+}
+
+bool CommandLineParser::consume_library_option(const std::string& name, bool expect, const char* optarg)
+{
+	if (name=="ipaaca-payload-type") {
+		std::string newtype = optarg;
+		if (newtype=="MAP") newtype="STR";
+		if ((newtype=="JSON") || (newtype=="STR")) {
+			IPAACA_DEBUG("Setting default payload type " << newtype)
+			__ipaaca_static_option_default_payload_type = newtype;
+		} else {
+			IPAACA_WARNING("Ignoring unknown default payload type " << newtype << " - should be one of JSON or STR")
+		}
+	} else if (name=="ipaaca-default-channel") {
+		std::string newch = optarg;
+		IPAACA_DEBUG("Setting default channel " << newch)
+		__ipaaca_static_option_default_channel = newch;
+	} else if (name=="rsb-host") {
+		std::string newhost = optarg;
+		IPAACA_DEBUG("Setting RSB host " << newhost)
+		__ipaaca_static_option_rsb_host = newhost;
+	} else if (name=="rsb-port") {
+		std::string newport = optarg;
+		IPAACA_DEBUG("Setting RSB port " << newport)
+		__ipaaca_static_option_rsb_port = newport;
+	} else if (name=="rsb-transport") {
+		std::string newtrans = optarg;
+		IPAACA_DEBUG("Setting RSB transport " << newtrans)
+		__ipaaca_static_option_rsb_transport = newtrans;
+	} else if (name=="rsb-socket-server") {
+		std::string newsockserv = optarg;
+		IPAACA_DEBUG("Setting RSB transport.socket.server " << newsockserv)
+		__ipaaca_static_option_rsb_socketserver = newsockserv;
+	} else if (name=="ipaaca-enable-logging") {
+		std::string level(optarg);
+		if ((level=="NONE") || (level=="SILENT")) {
+			IPAACA_DEBUG("Will set log level to NONE")
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_NONE;
+		} else if (level=="DEBUG") {
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_DEBUG;
+			IPAACA_DEBUG("Just set log level to DEBUG")
+		} else if (level=="INFO") {
+			IPAACA_DEBUG("Set log level to INFO")
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_INFO;
+		} else if (level=="WARNING") {
+			IPAACA_DEBUG("Set log level to WARNING")
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_WARNING;
+		} else if (level=="ERROR") {
+			IPAACA_DEBUG("Set log level to ERROR")
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_ERROR;
+		} else if (level=="CRITICAL") {
+			IPAACA_DEBUG("Set log level to CRITICAL")
+			__ipaaca_static_option_log_level = IPAACA_LOG_LEVEL_CRITICAL;
+		} else {
+			IPAACA_WARNING("Unknown log level " << optarg)
+			IPAACA_WARNING("Valid levels are: NONE, DEBUG, INFO, WARNING, ERROR, CRITICAL ")
+		}
+	} else if (name=="rsb-enable-logging") {
+		IPAACA_WARNING("Unimplemented option ignored: " << name)
+		IPAACA_IMPLEMENT_ME
+	} else {
+		return false;
+	}
+	return true;
+}
+
+void CommandLineParser::dump_options()
+{
+	for (std::map<std::string, bool>::const_iterator it = options.begin(); it!=options.end(); ++it) {
+		const std::string& optn = it->first;
+		bool expect = it->second;
+		char shortn = shortopt[optn];
+		std::string shortns; shortns += shortn;
+		if (optn != "help") {
+			if (shortn) std::cout << "    -" << shortns << " | --" << optn << " ";
+			else std::cout << "    --" << optn << " ";
+			if (expect) {
+				std::cout << "<param>";
+				std::cout << " (default: '" << defaults[optn] << "')";
+			}
+			std::cout << std::endl;
+		}
+	}
+}
+
+void CommandLineParser::add_option(const std::string& optname, char shortoptn, bool expect_param, const std::string& defaultv)
+{
+	longopt[shortoptn] = optname;
+	shortopt[optname] = shortoptn;
+	options[optname] = expect_param;
+	defaults[optname] = defaultv;
+	set_flag[optname] = 0;
+}
+
+CommandLineOptions::ptr CommandLineParser::parse(int argc, char* const* argv)
+{
+#if _WIN32 || _WIN64
+	IPAACA_ERROR("IMPLEMENT ME: command line parsing for Windows. (req'd: getopt)")
+	throw NotImplementedError();
+#else
+	IPAACA_DEBUG("")
+	int len = options.size();
+	struct option long_options[len+1];
+	int i=0;
+	std::string short_options_str = "";
+	for (std::map<std::string, bool>::const_iterator it = options.begin(); it!=options.end(); ++it) {
+		const std::string& optn = it->first;
+		bool expect = it->second;
+		char shortn = shortopt[optn];
+		int* write_to = &(set_flag[optn]);
+		if (shortn > ' ') {
+			short_options_str += shortn;
+			if (expect) short_options_str += ':';
+		}
+		long_options[i].name = optn.c_str();
+		long_options[i].has_arg = (expect?required_argument:no_argument);
+		long_options[i].flag = (expect?write_to:0);
+		long_options[i].val = shortn;
+		i++;
+	}
+	long_options[i].name = 0;
+	long_options[i].has_arg = 0;
+	long_options[i].flag = 0;
+	long_options[i].val = 0;
+	CommandLineOptions::ptr clo = CommandLineOptions::ptr(new CommandLineOptions());
+	int c;
+	bool keep_going = true;
+	while (keep_going)
+	{
+		// getopt_long stores the option index here.
+		int option_index = 0;
+		c = getopt_long (argc, argv, short_options_str.c_str(), long_options, &option_index);
+		// Detect the end of the options. 
+		if (c == -1) break;
+		
+		bool do_set_option = false;
+		std::string longname;
+		std::string longoption;
+		bool expect;
+		switch (c)
+		{
+			case 0:
+				{
+				longname = long_options[option_index].name;
+				if (longname == "help") {
+					std::cout << "Options:" << std::endl;
+					dump_options();
+					exit(0);
+				}
+				longoption = long_options[option_index].name;
+				expect = options[longoption];
+				do_set_option = true;
+				}
+				break;
+
+			case '?':
+				break;
+
+			default:
+				std::string s;
+				s += c;
+				longoption = longopt[c];
+				expect = options[longoption];
+				do_set_option = true;
+		}
+		if (do_set_option) {
+			if (library_options_handled) {
+				do_set_option = ! consume_library_option(longoption, expect, optarg );
+			}
+			if (do_set_option) {
+				clo->set_option(longoption, expect, optarg);
+			}
+		}
+	}
+	ensure_defaults_in( clo );
+	return clo;
+#endif
+}
+
+void CommandLineParser::ensure_defaults_in( CommandLineOptions::ptr clo )
+{
+	for (std::map<std::string, bool>::const_iterator it = options.begin(); it!=options.end(); ++it) {
+		const std::string& optn = it->first;
+		bool expect = it->second;
+		char shortn = shortopt[optn];
+		if (expect && (! clo->is_set(optn))) {
+			clo->set_option(optn, true, defaults[optn].c_str());
+		}
+	}
+}
+
+} // namespace ipaaca
+

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)
+