docs/patches/python-paho-mqtt-preventConnectionLockup-RYT.patch

+--- client.py.sav	2018-12-14 18:30:04.836523913 +0100
++++ client.py	2018-12-14 19:23:13.759468147 +0100
+@@ -983,7 +983,7 @@
+ 
+         # sockpairR is used to break out of select() before the timeout, on a
+         # call to publish() etc.
+-        rlist = [self._sock, self._sockpairR]
++        rlist = [self._sock, self._sockpairR] if self._sock else [self._sockpairR]
+         try:
+             socklist = select.select(rlist, wlist, [], timeout)
+         except TypeError:

ipaacalib/cpp/CMakeLists.txt

@@ -3,50 +3,146 @@ cmake_minimum_required (VERSION 2.6)
 # project name
 project (ipaaca_cpp)
 
+#set (CMAKE_CXX_STANDARD 11)
+
+## 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
+##  (this entails a slight slowdown since dynamic log level checks made at the very least)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_DEBUG_MESSAGES")
-
+# expose the full RSB api in the headers (set only in ipaaca itself)
+#  !! NOTE: at the moment required in any ipaaca cpp project in Windows !!
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_EXPOSE_FULL_RSB_API")
+## use the following line to enable building mock IUs (FakeIU)
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_BUILD_MOCK_OBJECTS")
 # find cmake modules locally too
-set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules )
+
+if(WIN32) # Check if we are on Windows
+	if(MSVC) # Check if we are using the Visual Studio compiler
+		#set_target_properties(TestProject PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS")
+		#
+		#   Setup section for Windows build (using precompiled rsb + deps)
+		#
+		#   You need the rsx precompiled archive, even if you build rsb yourself,
+		#   for the dependencies. Make sure to grab the right version (bitness
+		#   and Visual Studio version). Tested with the rsx-0.10 branch.
+		#   Please unpack the rsx archive into the repo dir (where ipaaca also is).
+		#   Then set these environment variables before building rsb or ipaaca:
+		#
+		#   set BOOST_ROOT=%SOA_REPO_DIR%\rsx\boost
+		#   set PROTOBUF_ROOT=%SOA_REPO_DIR%\rsx\protobuf
+		#   set SPREAD_ROOT=%SOA_REPO_DIR%\rsx\spread
+		#
+		#
+		
+		set(LIBS ${LIBS} rpcrt4)
 
-find_package(Boost COMPONENTS system filesystem thread regex REQUIRED)
-link_directories(${Boost_LIBRARY_DIRS})
-include_directories(${Boost_INCLUDE_DIRS})
-#set(BOOSTLIBS boost_regex-mt boost_date_time-mt boost_program_options-mt boost_thread-mt boost_filesystem-mt boost_signals-mt boost_system-mt)
+		#set(Boost_USE_STATIC_LIBS ON)
+		#set(Boost_USE_MULTITHREADED ON)
+	
+		#find_package(Boost COMPONENTS date_time program_options system filesystem thread signals regex REQUIRED)
+		#link_directories(${Boost_LIBRARY_DIRS})
+		#include_directories(${Boost_INCLUDE_DIRS})
+		
+		## Windows linkage hack: overriding the determined libs to remove boost_thread (causes multiple-definition issues)
+		#set(CORRECT_BOOST_LIBS "")
+		#foreach(BLIB ${Boost_LIBRARIES})
+		#			list(APPEND CORRECT_BOOST_LIBS ${BLIB})
+		#endforeach(BLIB ${Boost_LIBRARIES})
+		#set(Boost_LIBRARIES ${CORRECT_BOOST_LIBS})
+		
+		# Using custom Protobuf script (from rsc) because it honors PROTOBUF_ROOT
+		#find_package(ProtocolBuffers REQUIRED PATHS "\\Libs\\protobuf")
+		#link_directories(${PROTOBUF_LIBRARY_DIRS})
+		#include_directories(${PROTOBUF_INCLUDE_DIRS})
+		#message(STATUS "############################")
+		#message(STATUS ${PROTOBUF_INCLUDE_DIRS})
+		set(PROTOBUF_LIBRARY optimized "C:\\libs\\protobuf\\x64\\lib\\libprotobuf.lib" debug "C:\\libs\\protobuf\\x64\\lib\\libprotobufd.lib")
+		link_directories( "C:\\libs\\protobuf\\x64\\lib" )
+		include_directories( "C:\\libs\\protobuf\\x64\\include" )
+		
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MT")
+		set(CompilerFlags
+			CMAKE_CXX_FLAGS
+			CMAKE_CXX_FLAGS_DEBUG
+			CMAKE_CXX_FLAGS_RELEASE
+			CMAKE_C_FLAGS
+			CMAKE_C_FLAGS_DEBUG
+			CMAKE_C_FLAGS_RELEASE
+			)
+		foreach(CompilerFlag ${CompilerFlags})
+		  string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+		endforeach()
+			
+	else()
+		message(SEND_ERROR "Unsupported compiler! Please build with MSVC++ 19.x (Visual Studio 2017).")
+	endif()
+else()
+	#
+	#
+	# Setup section for Linux or OS X (using 'rsb' soa project)
+	#
+	#
+	find_package(Boost COMPONENTS system filesystem thread regex REQUIRED)
+	link_directories(${Boost_LIBRARY_DIRS})
+	include_directories(${Boost_INCLUDE_DIRS})
+	#set(BOOSTLIBS boost_regex-mt boost_date_time-mt boost_program_options-mt boost_thread-mt boost_filesystem-mt boost_signals-mt boost_system-mt)
 
-find_package(Protobuf REQUIRED)
-link_directories(${PROTOBUF_LIBRARY_DIRS})
-include_directories(${PROTOBUF_INCLUDE_DIRS})
+	find_package(ProtocolBuffers REQUIRED)
+	link_directories(${PROTOBUF_LIBRARY_DIRS})
+	include_directories(${PROTOBUF_INCLUDE_DIRS})
 
-#set(PROTOLIBS protobuf)
-set(RSBLIBS rsc rsbcore)
+    set(PROTOBUF_INPUT_DIRECTORY "${PROJECT_SOURCE_DIR}")
+    set(PROTOBUF_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/build/ipaaca")
+    file(MAKE_DIRECTORY ${PROTOBUF_OUTPUT_DIRECTORY})
+    set(PROTOBUF_ARGUMENTS "--cpp_out=${PROTOBUF_OUTPUT_DIRECTORY}")
+    execute_process(COMMAND protoc ${PROTOBUF_ARGUMENTS} ipaaca.proto
+            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/../proto/
+            RESULT_VARIABLE PROTOBUF_RESULT
+            OUTPUT_VARIABLE PROTOBUF_OUTPUT_VARIABLE)
 
-#set(LIBS ${LIBS} ${BOOSTLIBS} ${PROTOLIBS} ${RSBLIBS})
-#set(LIBS ${LIBS} ${PROTOLIBS} ${RSBLIBS})
-set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES} ${RSBLIBS})
+	# change for each new rsb version
+        if (DEFINED APPLE)
+        	#set(RSBLIBS rsc0.14 rsb0.14)
+        	#set(RSBLIBS rsc0.10 rsb.0.10)
+        else(DEFINED APPLE)
+		#set(RSBLIBS ${PROJECT_SOURCE_DIR}/../../deps/lib/librsc0.14.so ${PROJECT_SOURCE_DIR}/../../deps/lib/librsb0.14.so )
+		set(LIBS ${LIBS} uuid)
+	endif(DEFINED APPLE)
+	# enhance the default search paths (headers, libs ...)
+	set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
+	# MacPorts compatibility
+	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)
+endif(WIN32)
 
-if (NOT DEFINED APPLE)
-	set(LIBS ${LIBS} uuid)
-endif(NOT DEFINED APPLE)
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES})
 
-# enhance the default search paths (headers, libs ...)
-set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
 
-## Ace2 uses deprecated style (non-template friend functions and non-const char*s)
-##  We just hide the warnings here
-#set(CXX_OLD_CODE_CONVENIENCE_FLAGS "-Wno-non-template-friend -Wno-write-strings")
+if(NOT DEFINED WIN32)
+	if (DEFINED APPLE)
+		message(STATUS "No extra pthread flags needed on Mac")
+	else()
+		message(STATUS "Adding extra pthread flags for Linux")
+		# needs -lpthread AND -pthread
+		set(LIBS ${LIBS} pthread)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+	endif()
+endif(NOT DEFINED WIN32)
 
-# 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)
+# Hide the rsb-induced boost-signals warning (FOR NOW)
+#set(IPAACA_CXX_DEFINES "${IPAACA_CXX_DEFINES} -DBOOST_SIGNALS_NO_DEPRECATION_WARNING")
+
+## Compiler defines copied from the old build system
+#set(IPAACA_CXX_DEFINES "${IPAACA_CXX_DEFINES} -D_DEFAULT_SOURCE -DUSE_AV -DMGC_USE_DOUBLE -DLEDA_PREFIX -D__NO_CAST_TO_LOCAL_TYPE__ -DDBGLVL=0")
 
 # Combine the extra compiler flags
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_DEFINES}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${IPAACA_CXX_DEFINES}")
 
 # add include dir for auto-generated headers placed in build/
 include_directories( ${PROJECT_SOURCE_DIR}/build )
@@ -57,38 +153,153 @@ include_directories( ${PROJECT_SOURCE_DIR}/include )
 include_directories( ${PROJECT_SOURCE_DIR}/../../deps/include )
 link_directories( ${PROJECT_SOURCE_DIR}/../../deps/lib )
 
+###
+### Back-ends  (will include any and all that are compileable)
+###
+#
+if(WIN32)
+if(MSVC)
+# fixed configuration for Windows
+set(LIBS ${LIBS} "C:\\libs\\mosquitto\\x64\\mosquitto.lib" "C:\\libs\\mosquitto\\x64\\mosquittopp.lib")
+link_directories( "C:\\libs\\mosquitto\\x64" )
+include_directories( "C:\\libs\\mosquitto\\x64\\include" )
+set(BACKEND_SOURCES ${BACKEND_SOURCES} src/ipaaca-backend-mqtt.cc)
+endif(MSVC)
+else()
+# dynamic checks under Unix
+
+# 1: MQTT
+find_library(MOSQUITTO_LIB mosquittopp)
+if(MOSQUITTO_LIB)
+    message(STATUS "=== MQTT backend ===    enabled")
+    set(LIBS ${LIBS} mosquittopp)
+    set(BACKEND_SOURCES ${BACKEND_SOURCES} src/ipaaca-backend-mqtt.cc)
+else()
+    message(STATUS "=== MQTT backend ===    DISABLED (mosquittopp not found)")
+endif()
+
+# 2: ROS
+set (ROSBASE $ENV{ROS_ROOT}/../..)
+find_library(ROSCPP_LIB roscpp PATHS ${ROSBASE})
+if(ROSCPP_LIB)
+    message(STATUS "=== ROS backend ===    enabled")
+    include_directories($ENV{ROS_ROOT}/../../include)
+    link_directories($ENV{ROS_ROOT}/../../lib)
+    set(LIBS ${LIBS} roscpp roscpp_serialization rosconsole)
+    set(BACKEND_SOURCES ${BACKEND_SOURCES} src/ipaaca-backend-ros.cc)
+else()
+    message(STATUS "=== ROS backend ===    DISABLED (roscpp not found)")
+endif()
+
+#
+# Now make sure that at least one of those backends is available
+#
+if(NOT BACKEND_SOURCES)
+    message(SEND_ERROR "\nWill not build IPAACA without any backends!\n")
+endif()
+
+endif() # of Unix block
+
 # specify source files for ipaaca (auto-generated ones are in build/ )
 set (SOURCE
 	src/ipaaca.cc
+        src/ipaaca-config.cc
+        src/ipaaca-converters.cc
+        src/ipaaca-backend.cc
+	src/ipaaca-buffers.cc
+	src/ipaaca-initializer.cc
+        src/ipaaca-iuinterface.cc
+	src/ipaaca-ius.cc
+	src/ipaaca-links.cc
+	src/ipaaca-locking.cc
+	src/ipaaca-payload.cc
 	src/ipaaca-cmdline-parser.cc
 	src/ipaaca-string-utils.cc
+	src/util/notifier.cc
+        src/b64/b64.cc
 	build/ipaaca/ipaaca.pb.cc
 	)
+set (SOURCE ${SOURCE} ${BACKEND_SOURCES})
+
+#set (JSON_TEST_SOURCE
+#	src/ipaaca.cc
+#	src/ipaaca-buffers.cc
+#	src/ipaaca-fake.cc
+#	src/ipaaca-internal.cc
+#	src/ipaaca-iuinterface.cc
+#	src/ipaaca-json.cc    # main
+#	src/ipaaca-locking.cc
+#	src/ipaaca-links.cc
+#	src/ipaaca-payload.cc
+#	src/ipaaca-cmdline-parser.cc
+#	src/ipaaca-string-utils.cc
+#	# more stuff going beyond the fake test case
+#	src/ipaaca-ius.cc
+#	build/ipaaca/ipaaca.pb.cc
+#	)
+#
+set (TESTER_SOURCE
+	src/ipaaca-tester.cc    # main
+	src/ipaaca.cc
+        src/ipaaca-config.cc
+        src/ipaaca-converters.cc
+        src/ipaaca-backend.cc
+	src/ipaaca-buffers.cc
+	src/ipaaca-initializer.cc
+	src/ipaaca-iuinterface.cc
+	src/ipaaca-ius.cc
+	src/ipaaca-links.cc
+	src/ipaaca-locking.cc
+	src/ipaaca-payload.cc
+	src/ipaaca-cmdline-parser.cc
+	src/ipaaca-string-utils.cc
+	src/util/notifier.cc
+        src/b64/b64.cc
+	build/ipaaca/ipaaca.pb.cc
+	)
+set (TESTER_SOURCE ${TESTER_SOURCE} ${BACKEND_SOURCES})
+
+if(WIN32)
+if(MSVC)
+  if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+    set(CMAKE_INSTALL_PREFIX "C:/Libs/ipaaca/x64")
+  endif()
+endif()
+else()
+  # this is for building with cmake/soa
+  set(CMAKE_INSTALL_PREFIX "")
+endif()
 
 # compile all files to "ipaaca" shared library
 add_library(ipaaca SHARED ${SOURCE})
 # and link all the required external libs (found above using find_package etc.)
 target_link_libraries(ipaaca ${LIBS})
 
+#add_executable (ipaaca-test-json ${JSON_TEST_SOURCE})
+#target_link_libraries (ipaaca-test-json ${LIBS})
+
+add_executable (ipaaca-tester-cpp ${TESTER_SOURCE})
+target_compile_options (ipaaca-tester-cpp PRIVATE "-DIPAACA_STATIC_BINARY")
+target_link_libraries (ipaaca-tester-cpp ${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 ipaaca
+	TARGETS ipaaca ipaaca-tester-cpp
 	RUNTIME DESTINATION bin
 	LIBRARY DESTINATION lib
 	ARCHIVE DESTINATION lib
 	)
 install(
 	DIRECTORY include
-	DESTINATION /
+	DESTINATION .
 	FILES_MATCHING PATTERN "*.h" PATTERN "*.hh" PATTERN "*.hpp" PATTERN "*.inl"
 	)
 install(
 	FILES build/ipaaca/ipaaca.pb.h
-	DESTINATION /include/ipaaca/
+	DESTINATION include/ipaaca/
 	)
 
 

ipaacalib/cpp/CMakeModules/FindProtocolBuffers.cmake

+# Locate and configure the Google Protocol Buffers library.
+# A modified version of the original macro from CMake 2.8.
+# Defines the following variables:
+#
+#   PROTOBUF_FOUND - Found the Google Protocol Buffers library
+#   PROTOBUF_INCLUDE_DIRS - Include directories for Google Protocol Buffers
+#   PROTOBUF_LIBRARIES - The protobuf library
+#
+# The following cache variables are also defined:
+#   PROTOBUF_LIBRARY - The protobuf library
+#   PROTOBUF_PROTOC_LIBRARY   - The protoc library
+#   PROTOBUF_INCLUDE_DIR - The include directory for protocol buffers
+#   PROTOBUF_PROTOC_EXECUTABLE - The protoc compiler
+#
+# These variables are read for additional hints:
+#   PROTOBUF_ROOT - Root directory of the protobuf installation if not found
+#                   automatically
+#
+#  ====================================================================
+#  Example:
+#
+#   find_package(ProtocolBuffers REQUIRED)
+#   include_directories(${PROTOBUF_INCLUDE_DIRS})
+#
+#   include_directories(${CMAKE_CURRENT_BINARY_DIR})
+#   PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS foo.proto)
+#   add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS})
+#   target_link_libraries(bar ${PROTOBUF_LIBRARY})
+#
+# NOTE: You may need to link against pthreads, depending
+# on the platform.
+#  ====================================================================
+#
+# PROTOBUF_GENERATE_CPP ([CPP srcs hdrs] [JAVA files] [PYTHON files] PROTOFILES files... [PROTOROOT root] [OUTPATH path] [EXPORT_MACRO macroName] [DEBUG])
+#   srcs = Variable to define with autogenerated
+#          source files
+#   hdrs = Variable to define with autogenerated
+#          header files
+#   PROTOROOT = Root under which the proto files are located. Paths starting
+#               from this root are used under OUTPATH as directory structure
+#               for the generated files. Defaults to CMAKE_CURRENT_SOURCE_DIR.
+#   OUTPATH = Path to store generated files under. Default is
+#             CMAKE_CURRENT_BINARY_DIR.
+#   EXPORT_MACRO = Tells protoc to generate DLL export definitions using the
+#                  specified macro name
+#   DEBUG = if set, debug messages will be generated
+#
+#  ====================================================================
+
+
+#=============================================================================
+# Copyright 2009 Kitware, Inc.
+# Copyright 2009 Philip Lowman <philip@yhbt.com>
+# Copyright 2008 Esben Mose Hansen, Ange Optimization ApS
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+INCLUDE(ParseArguments)
+
+FUNCTION(PROTOBUF_GENERATE)
+
+    # argument parsing
+    PARSE_ARGUMENTS(ARG "PROTOROOT;PROTOFILES;OUTPATH;INCLUDES;EXPORT_MACRO;CPP;JAVA;PYTHON;MATLAB" "DEBUG" ${ARGN})
+
+    IF(NOT ARG_PROTOFILES)
+        MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() called without any proto files")
+        RETURN()
+    ENDIF(NOT ARG_PROTOFILES)
+    LIST(LENGTH ARG_PROTOROOT PROTOROOT_LENGTH)
+    #IF(PROTOROOT_LENGTH GREATER 1)
+    #    MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() called with too many protoroots, only one is allowed")
+    #    RETURN()
+    #ENDIF()
+    LIST(LENGTH ARG_OUTPATH OUTPATH_LENGTH)
+    IF(OUTPATH_LENGTH GREATER 1)
+        MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() called with too many outpaths, only one is allowed")
+        RETURN()
+    ENDIF()
+    LIST(LENGTH ARG_EXPORT_MACRO EXPORT_MACRO_LENGTH)
+    IF(EXPORT_MACRO_LENGTH GREATER 1)
+        MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() called with too many export macro names, only one is allowed")
+        RETURN()
+    ENDIF()
+    
+    # decide whether to build CPP
+    LIST(LENGTH ARG_CPP CPP_LENGTH)
+    IF(CPP_LENGTH EQUAL 0)
+        SET(BUILD_CPP FALSE)
+    ELSE()
+        IF(NOT CPP_LENGTH EQUAL 2)
+            MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() CPP argument expects two parameters SRC_VAR and HDR_VAR")
+            RETURN()
+        ENDIF()
+        SET(BUILD_CPP TRUE)
+        LIST(GET ARG_CPP 0 RESULT_CPP_SRCS)
+        LIST(GET ARG_CPP 1 RESULT_CPP_HDRS)
+    ENDIF()
+    
+    # decide whether to build java
+    LIST(LENGTH ARG_JAVA JAVA_LENGTH)
+    IF(JAVA_LENGTH EQUAL 0)
+        SET(BUILD_JAVA FALSE)
+    ELSE()
+        IF(NOT JAVA_LENGTH EQUAL 1)
+            MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() JAVA argument expects one parameter JAVA_VAR")
+            RETURN()
+        ENDIF()
+        SET(BUILD_JAVA TRUE)
+        LIST(GET ARG_JAVA 0 RESULT_JAVA)
+    ENDIF()
+    
+    # decide whether to build PYTHON
+    LIST(LENGTH ARG_PYTHON PYTHON_LENGTH)
+    IF(PYTHON_LENGTH EQUAL 0)
+        SET(BUILD_PYTHON FALSE)
+    ELSE()
+        IF(NOT PYTHON_LENGTH EQUAL 1)
+            MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() PYTHON argument expects one parameter PYTHON_VAR")
+            RETURN()
+        ENDIF()
+        SET(BUILD_PYTHON TRUE)
+        LIST(GET ARG_PYTHON 0 RESULT_PYTHON)
+    ENDIF()
+    
+    # decide whether to build MATLAB
+    LIST(LENGTH ARG_MATLAB MATLAB_LENGTH)
+    IF(MATLAB_LENGTH EQUAL 0)
+        SET(BUILD_MATLAB FALSE)
+    ELSE()
+        IF(NOT MATLAB_LENGTH EQUAL 1)
+            MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE() MATLAB argument expects one parameter MATLAB_VAR")
+            RETURN()
+        ENDIF()
+        SET(BUILD_MATLAB TRUE)
+        LIST(GET ARG_MATLAB 0 RESULT_MATLAB)
+    ENDIF()
+    
+    # create proper export macro for CPP if desired
+    IF(EXPORT_MACRO_LENGTH EQUAL 1)
+        SET(ARG_EXPORT "dllexport_decl=${ARG_EXPORT_MACRO}:")
+        MESSAGE(STATUS "Enabling export macro ${ARG_EXPORT_MACRO} for CPP")
+    ENDIF()
+    
+    SET(OUTPATH ${CMAKE_CURRENT_BINARY_DIR})
+    IF(OUTPATH_LENGTH EQUAL 1)
+        SET(OUTPATH ${ARG_OUTPATH})
+    ENDIF()
+    SET(PROTOROOTS ${CMAKE_CURRENT_SOURCE_DIR})
+    IF(PROTOROOT_LENGTH GREATER 0)
+        SET(PROTOROOTS ${ARG_PROTOROOT})
+    ENDIF()
+    
+    SET(ARG_EXPORT "")
+    IF(EXPORT_MACRO_LENGTH EQUAL 1)
+        SET(ARG_EXPORT "dllexport_decl=${ARG_EXPORT_MACRO}:")
+    ENDIF()
+    
+    # build command line for additional includes paths
+    SET(INCLUDE_CMD_LINE)
+    FOREACH(P ${ARG_INCLUDES})
+        LIST(APPEND INCLUDE_CMD_LINE "--proto_path" ${P})
+    ENDFOREACH()
+    
+    IF(ARG_DEBUG)
+        MESSAGE("OUTPATH: ${OUTPATH}")
+        MESSAGE("PROTOROOTS: ${PROTOROOTS}")
+        MESSAGE("INCLUDE_CMD_LINE: ${INCLUDE_CMD_LINE}")
+    ENDIF()
+
+    SET(MATCHED_FILE_PATHS)
+    FOREACH(PROTOFILE ${ARG_PROTOFILES})
+    
+        FILE(TO_CMAKE_PATH ${PROTOFILE} PROTOFILE)
+    
+        # ensure that the file ends with .proto
+        STRING(REGEX MATCH "\\.proto$$" PROTOEND ${PROTOFILE})
+        IF(NOT PROTOEND)
+            MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' does not end with .proto")
+        ENDIF()
+    
+        GET_FILENAME_COMPONENT(PROTO_PATH ${PROTOFILE} PATH)
+        GET_FILENAME_COMPONENT(ABS_FILE ${PROTOFILE} ABSOLUTE)
+        GET_FILENAME_COMPONENT(FILE_WE ${PROTOFILE} NAME_WE)
+        
+        STRING(LENGTH ${ABS_FILE} ABS_FILE_LENGTH)
+        
+        IF(ARG_DEBUG)
+            MESSAGE("file ${PROTOFILE}:")
+            MESSAGE("  PATH=${PROTO_PATH}")
+            MESSAGE("  ABS_FILE=${ABS_FILE}")
+            MESSAGE("  FILE_WE=${FILE_WE}")
+            MESSAGE("  PROTOROOTS=${PROTOROOTS}")
+        ENDIF()
+        
+        # find out if the file is in one of the specified proto root
+        # we mimic the protoc logic here by taking the first matching proto_path
+        SET(MATCH_PATH)
+        FOREACH(ROOT ${PROTOROOTS})
+        
+            IF(ARG_DEBUG)
+                MESSAGE("  ROOT=${ROOT}")
+            ENDIF()
+        
+            FILE(RELATIVE_PATH REL_ABS ${ROOT} ${ABS_FILE})
+            STRING(LENGTH ${REL_ABS} REL_LENGTH)
+            
+            IF(ARG_DEBUG)
+                MESSAGE("    REL_ABS=${REL_ABS}")
+                MESSAGE("    REL_LENGTH=${REL_LENGTH}")
+            ENDIF()
+            
+            IF(${REL_LENGTH} GREATER 0 AND ${REL_LENGTH} LESS ${ABS_FILE_LENGTH})
+                # we did not need to go directories up, hence the path is shorter
+                # and this is a match... bad assumption but works
+                SET(MATCH_PATH ${REL_ABS})
+                SET(MATCH_ROOT ${ROOT})
+                IF(ARG_DEBUG)
+                    MESSAGE("  MATCH_ROOT=${MATCH_ROOT}")
+                ENDIF()
+                BREAK()
+            ENDIF()
+            
+        ENDFOREACH()
+        
+        IF(ARG_DEBUG)
+            MESSAGE("  MATCH_PATH=${MATCH_PATH}")
+        ENDIF()
+        
+        IF(NOT MATCH_PATH)
+            MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' is not in protoroots '${PROTOROOTS}'")
+        ENDIF()
+        LIST(APPEND MATCHED_FILE_PATHS ${ABS_FILE})
+        
+        # build the result file name
+        FILE(RELATIVE_PATH ROOT_CLEANED_FILE ${MATCH_ROOT} ${ABS_FILE})
+        IF(ARG_DEBUG)
+            MESSAGE("  ROOT_CLEANED_FILE=${ROOT_CLEANED_FILE}")
+        ENDIF()
+        STRING(REGEX REPLACE "\\.proto$$" "" EXT_CLEANED_FILE ${ROOT_CLEANED_FILE})
+        IF(ARG_DEBUG)
+            MESSAGE("  EXT_CLEANED_FILE=${EXT_CLEANED_FILE}")
+        ENDIF()
+        
+        SET(CPP_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.cc")
+        SET(HDR_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.h")
+        SET(PYTHON_FILE "${OUTPATH}/${EXT_CLEANED_FILE}_pb2.py")
+        
+        # determine the java file name
+        FILE(READ ${PROTOFILE} PROTO_CONTENT)
+        
+        # first the package
+        # TODO jwienke: ignore comments... see below TODO
+        SET(PACKAGE_REGEX "package[\t ]+([^;\n\r]+);")
+        STRING(REGEX MATCH ${PACKAGE_REGEX} PACKAGE_LINE ${PROTO_CONTENT})
+        IF(ARG_DEBUG)
+            MESSAGE("  PACKAGE_LINE=${PACKAGE_LINE}")
+        ENDIF()
+        SET(PACKAGE "")
+        IF(PACKAGE_LINE)
+            STRING(REGEX REPLACE ${PACKAGE_REGEX} "\\1" PACKAGE ${PACKAGE_LINE})
+        ENDIF()
+        STRING(REPLACE "." "/" JAVA_PACKAGE_PATH "${PACKAGE}")
+        IF(ARG_DEBUG)
+            MESSAGE("  PACKAGE=${PACKAGE}")
+            MESSAGE("  JAVA_PACKAGE_PATH=${JAVA_PACKAGE_PATH}")
+        ENDIF()
+        
+        # then the java class name
+        
+        # this is the default
+        # TODO jwienke: how to integrate that this line must not start with //?
+        #               cmake regex are strange, because ^ and $ match beginning
+        #               and end of file and not of each line
+        SET(JAVA_CLASS_REGEX "option[\t ]+java_outer_classname[\t ]+=[\t ]+\"([^\"]+)\"")
+        STRING(REGEX MATCH ${JAVA_CLASS_REGEX} JAVA_CLASS_LINE ${PROTO_CONTENT})
+        IF(ARG_DEBUG)
+            MESSAGE("  JAVA_CLASS_LINE=${JAVA_CLASS_LINE}")
+        ENDIF()
+        SET(JAVA_CLASS ${FILE_WE})
+        IF(JAVA_CLASS_LINE)
+            STRING(REGEX REPLACE ${JAVA_CLASS_REGEX} "\\1" JAVA_CLASS ${JAVA_CLASS_LINE})
+            # Now that we have the real java class name, this must be replaced
+            # in the original file name proposal. However, the subpath in the
+            # file system is also part of EXT_CLEANED_FILE. Hence, we need to
+            # do some replace logic again...
+        ENDIF()
+        IF(ARG_DEBUG)
+            MESSAGE("  JAVA_CLASS=${JAVA_CLASS}")
+        ENDIF()
+        
+        # finally deduce the real java name
+        SET(JAVA_FILE "${OUTPATH}/${JAVA_PACKAGE_PATH}/${JAVA_CLASS}.java")
+
+        IF(ARG_DEBUG)
+            MESSAGE("  CPP_FILE=${CPP_FILE}")
+            MESSAGE("  HDR_FILE=${HDR_FILE}")
+            MESSAGE("  JAVA_FILE=${JAVA_FILE}")
+            MESSAGE("  PYTHON_FILE=${PYTHON_FILE}")
+        ENDIF()
+        
+        # generate and use a list of protoroot arguments to pass to protoc
+        SET(ROOT_ARGS)
+        FOREACH(ROOT ${PROTOROOTS})
+            LIST(APPEND ROOT_ARGS "--proto_path" ${ROOT})
+        ENDFOREACH()
+        
+        IF(BUILD_CPP)
+            LIST(APPEND CPP_SRCS "${CPP_FILE}")
+            LIST(APPEND CPP_HDRS "${HDR_FILE}")
+    
+            ADD_CUSTOM_COMMAND(
+                OUTPUT "${CPP_FILE}"
+                       "${HDR_FILE}"
+                COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
+                COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+                ARGS "--cpp_out=${ARG_EXPORT}${OUTPATH}" ${ROOT_ARGS} ${INCLUDE_CMD_LINE} "${ABS_FILE}"
+                DEPENDS ${ABS_FILE}
+                COMMENT "Running C++ protocol buffer compiler on ${ABS_FILE} with root ${MATCH_ROOT}, generating: ${CPP_FILE}"
+                VERBATIM)
+        ENDIF()
+        
+        IF(BUILD_JAVA)
+            LIST(APPEND JAVA_FILES "${JAVA_FILE}")
+    
+            ADD_CUSTOM_COMMAND(
+                OUTPUT "${JAVA_FILE}"
+                COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
+                COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+                ARGS "--java_out=${OUTPATH}" ${ROOT_ARGS} ${INCLUDE_CMD_LINE} "${ABS_FILE}"
+                DEPENDS ${ABS_FILE}
+                COMMENT "Running Java protocol buffer compiler on ${ABS_FILE} with root ${MATCH_ROOT}, generating: ${JAVA_FILE}"
+                VERBATIM)
+        ENDIF()
+        
+        IF(BUILD_PYTHON)
+            LIST(APPEND PYTHON_FILES "${PYTHON_FILE}")
+    
+            ADD_CUSTOM_COMMAND(
+                OUTPUT "${PYTHON_FILE}"
+                COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
+                COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+                ARGS "--python_out=${OUTPATH}" ${ROOT_ARGS} ${INCLUDE_CMD_LINE} "${ABS_FILE}"
+                DEPENDS ${ABS_FILE}
+                COMMENT "Running Python protocol buffer compiler on ${ABS_FILE} with root ${MATCH_ROOT}, generating: ${PYTHON_FILE}"
+                VERBATIM)
+        ENDIF()
+            
+    ENDFOREACH()
+
+    IF(BUILD_CPP)
+        SET_SOURCE_FILES_PROPERTIES(${${CPP_SRCS}} ${${CPP_HDRS}} PROPERTIES GENERATED TRUE)
+        SET(${RESULT_CPP_SRCS} ${CPP_SRCS} PARENT_SCOPE)
+        SET(${RESULT_CPP_HDRS} ${CPP_HDRS} PARENT_SCOPE)
+    ENDIF()
+
+    IF(BUILD_JAVA)
+        SET_SOURCE_FILES_PROPERTIES(${${JAVA_FILES}} PROPERTIES GENERATED TRUE)
+        SET(${RESULT_JAVA} ${JAVA_FILES} PARENT_SCOPE)
+    ENDIF()
+
+    IF(BUILD_PYTHON)
+        SET_SOURCE_FILES_PROPERTIES(${${PYTHON_FILES}} PROPERTIES GENERATED TRUE)
+        SET(${RESULT_PYTHON} ${PYTHON_FILES} PARENT_SCOPE)
+    ENDIF()
+    
+    IF(BUILD_MATLAB)
+        ADD_CUSTOM_COMMAND(
+            OUTPUT ${OUTPATH}
+            COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
+            COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+            ARGS "--matlab_out=${OUTPATH}" ${ROOT_ARGS} ${INCLUDE_CMD_LINE} ${MATCHED_FILE_PATHS}
+            DEPENDS ${MATCHED_FILE_PATHS}
+            COMMENT "Running Matlab protocol buffer compiler to generate files in ${OUTPATH}"
+            VERBATIM)
+    ENDIF()
+
+    IF(BUILD_MATLAB)
+        SET(${RESULT_MATLAB} ${OUTPATH} PARENT_SCOPE)
+    ENDIF()
+    
+ENDFUNCTION()
+
+MACRO(PROTOBUF_GENERATE_CPP SRCS HDRS)
+    PROTOBUF_GENERATE(${ARGN} CPP ${SRCS} ${HDRS})
+ENDMACRO()
+
+FIND_PATH(PROTOBUF_INCLUDE_DIR NAMES google/protobuf/service.h
+          HINTS "${PROTOBUF_ROOT}/include"
+          DOC "The Google Protocol Buffers Headers")
+
+# Google's provided vcproj files generate libraries with a "lib"
+# prefix on Windows
+IF(WIN32)
+    SET(PROTOBUF_ORIG_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
+    SET(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
+ENDIF()
+
+FIND_LIBRARY(PROTOBUF_LIBRARY NAMES protobuf
+             HINTS "${PROTOBUF_ROOT}/bin"
+                   "${PROTOBUF_ROOT}/lib"
+             DOC "The Google Protocol Buffers Library"
+)
+FIND_LIBRARY(PROTOBUF_PROTOC_LIBRARY NAMES protoc
+             HINTS "${PROTOBUF_ROOT}/bin"
+                   "${PROTOBUF_ROOT}/lib"
+             DOC "The Google Protocol Buffers Compiler Library"
+)
+FIND_PROGRAM(PROTOBUF_PROTOC_EXECUTABLE NAMES protoc
+             HINTS "${PROTOBUF_ROOT}/bin"
+             DOC "The Google Protocol Buffers Compiler"
+)
+IF(PROTOBUF_PROTOC_EXECUTABLE AND NOT PROTOBUF_PROTOC_MATLAB)
+    # check whether this protoc version supports matlab
+    EXECUTE_PROCESS(COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} "-h"
+                    ERROR_VARIABLE PROTOC_HELP_TEXT
+                    OUTPUT_QUIET)
+    STRING(REGEX MATCH "--matlab_out" PROTOC_MATLAB_OUT "${PROTOC_HELP_TEXT}")
+    IF(PROTOC_MATLAB_OUT)
+        SET(PROTOBUF_PROTOC_MATLAB TRUE CACHE BOOL "Whether protoc is able to generate matlab output.")
+        MESSAGE(STATUS "protoc supports matlab")
+    ELSE()
+        SET(PROTOBUF_PROTOC_MATLAB FALSE CACHE BOOL "Whether protoc is able to generate matlab output.")
+        MESSAGE(STATUS "protoc does not support matlab")
+    ENDIF()
+ENDIF()
+SET(PROTOBUF_PROTOC_VERSION "PROTOBUF_PROTOC_VERSION-NOTFOUND")
+IF(PROTOBUF_PROTOC_EXECUTABLE)
+    EXECUTE_PROCESS(COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} --version
+                    OUTPUT_VARIABLE PROTOBUF_PROTOC_VERSION_TEMP
+                    RESULT_VARIABLE PROTOBUF_PROTOC_VERSION_RESULT)
+    STRING(REGEX REPLACE ".*([0-9]\\.[0-9]\\.[0-9]).*" "\\1"
+           PROTOBUF_PROTOC_VERSION_TEMP "${PROTOBUF_PROTOC_VERSION_TEMP}")
+    IF(PROTOBUF_PROTOC_VERSION_TEMP)
+        SET(PROTOBUF_PROTOC_VERSION "${PROTOBUF_PROTOC_VERSION_TEMP}")
+    ENDIF()
+ENDIF()
+
+SET(KNOWN_VERSIONS 2.6.0 2.5.1 2.5.0 2.4.1 2.4.0 2.3.0)
+# if we know the compiler version, we should favor it
+IF(PROTOBUF_PROTOC_VERSION)
+    LIST(INSERT KNOWN_VERSIONS 0 ${PROTOBUF_PROTOC_VERSION})
+ENDIF()
+SET(JAVA_NAMES ${PROTOBUF_JAVA_NAME} protobuf.jar protobuf-java.jar)
+FOREACH(VERSION ${KNOWN_VERSIONS})
+    LIST(APPEND JAVA_NAMES "protobuf-java-${VERSION}.jar")
+ENDFOREACH()
+
+FIND_FILE(PROTOBUF_JAVA_LIBRARY
+          NAMES ${JAVA_NAMES}
+          HINTS ${PROTOBUF_JAVA_ROOT}
+                "${PROTOBUF_JAVA_ROOT}/share/java"
+                "/usr/share/java"
+                "/usr/share/java/protobuf-java"
+                "/usr/share/protobuf/lib"
+                "${CMAKE_INSTALL_PREFIX}/lib/java"
+                "${CMAKE_INSTALL_PREFIX}/share/java")
+
+MARK_AS_ADVANCED(PROTOBUF_INCLUDE_DIR
+                 PROTOBUF_LIBRARY
+                 PROTOBUF_PROTOC_LIBRARY
+                 PROTOBUF_PROTOC_EXECUTABLE
+                 PROTOBUF_JAVA_LIBRARY
+                 PROTOBUF_PROTOC_MATLAB)
+
+# Restore original find library prefixes
+IF(WIN32)
+    SET(CMAKE_FIND_LIBRARY_PREFIXES "${PROTOBUF_ORIG_FIND_LIBRARY_PREFIXES}")
+ENDIF()
+
+INCLUDE(FindPackageHandleStandardArgs) 
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(PROTOBUF DEFAULT_MSG PROTOBUF_LIBRARY PROTOBUF_INCLUDE_DIR)
+
+IF(PROTOBUF_FOUND)
+    SET(PROTOBUF_INCLUDE_DIRS ${PROTOBUF_INCLUDE_DIR})
+    SET(PROTOBUF_LIBRARIES    ${PROTOBUF_LIBRARY})
+ENDIF()

ipaacalib/cpp/CMakeModules/ParseArguments.cmake

+# Parse arguments passed to a function into several lists separated by
+# upper-case identifiers and options that do not have an associated list e.g.:
+#
+# SET(arguments
+#   hello OPTION3 world
+#   LIST3 foo bar
+#   OPTION2
+#   LIST1 fuz baz
+#   )
+# PARSE_ARGUMENTS(ARG "LIST1;LIST2;LIST3" "OPTION1;OPTION2;OPTION3" ${arguments})
+#
+# results in 7 distinct variables:
+#  * ARG_DEFAULT_ARGS: hello;world
+#  * ARG_LIST1: fuz;baz
+#  * ARG_LIST2:
+#  * ARG_LIST3: foo;bar
+#  * ARG_OPTION1: FALSE
+#  * ARG_OPTION2: TRUE
+#  * ARG_OPTION3: TRUE
+#
+# taken from http://www.cmake.org/Wiki/CMakeMacroParseArguments 
+
+MACRO(PARSE_ARGUMENTS prefix arg_names option_names)
+    SET(DEFAULT_ARGS)
+    FOREACH(arg_name ${arg_names})    
+        SET(${prefix}_${arg_name})
+    ENDFOREACH(arg_name)
+    FOREACH(option ${option_names})
+        SET(${prefix}_${option} FALSE)
+    ENDFOREACH(option)
+    
+    SET(current_arg_name DEFAULT_ARGS)
+    SET(current_arg_list)
+    FOREACH(arg ${ARGN})            
+        SET(larg_names ${arg_names})    
+        LIST(FIND larg_names "${arg}" is_arg_name)                   
+        IF (is_arg_name GREATER -1)
+            SET(${prefix}_${current_arg_name} ${current_arg_list})
+            SET(current_arg_name ${arg})
+            SET(current_arg_list)
+        ELSE (is_arg_name GREATER -1)
+            SET(loption_names ${option_names})    
+            LIST(FIND loption_names "${arg}" is_option)            
+            IF (is_option GREATER -1)
+                SET(${prefix}_${arg} TRUE)
+            ELSE (is_option GREATER -1)
+                SET(current_arg_list ${current_arg_list} ${arg})
+            ENDIF (is_option GREATER -1)
+        ENDIF (is_arg_name GREATER -1)
+    ENDFOREACH(arg)
+    SET(${prefix}_${current_arg_name} ${current_arg_list})
+ENDMACRO(PARSE_ARGUMENTS)

ipaacalib/cpp/build-windows.bat

+@echo off
+md build
+cd build
+md ipaaca
+
+\Users\ryaghoub\Documents\Develop\repo\protobuf\bin\protoc.exe --proto_path=../../proto ../../proto/ipaaca.proto --cpp_out=build/ipaaca/
+
+cmake .. -DBoost_DEBUG:bool=True -DBOOST_LIBRARYDIR:string=C:\Users\ryaghoub\Downloads\boost_1_57_0__built__boost_subdir_moved_to_stage_include\stage\lib -DBoost_USE_STATIC_LIBS=ON -DBoost_USE_MULTITHREADED=ON -DPROTOBUF_ROOT:string=C:\Users\ryaghoub\Documents\Develop\repo\protobuf
+
+msbuild INSTALL.vcxproj
+

ipaacalib/cpp/build.properties

@@ -2,5 +2,8 @@ language=cpp
 resolve.status=beta
 resource.path=${shared.resources}/;
 rebuild.list=
+publish.resolver=asap.sftp.publish
 dist.dir=../../dist
+deps.dir=../../deps
+test.binary=testipaaca
 

ipaacalib/cpp/build.xml

@@ -16,7 +16,26 @@
          <arg value="../proto/ipaaca.proto" />
          <arg value="--cpp_out=build/ipaaca/" />
       </exec>
-   </target>
+  </target>
    <target name="-pre-compilation" depends="-proto-yes,-proto-no" />
+   <target name="-compilation" depends="-build-setup, -pre-compilation">
+      <!-- echo message="Using temporary RSBProtocol_DIR=${cmake.base.dir}/rsc_tmp/share/rsbprotocol0.10" / -->
+      <cmake srcdir="${cmake.base.dir}"
+         bindir="${build.dir}"
+         buildtype="Debug">
+         <generator name="Visual Studio 14 Win64" platform="windows" buildtype="Release" buildargs="ALL_BUILD.vcxproj">
+             <variable name="CMAKE_INSTALL_PREFIX" type="PATH" value="../${zip.tmp.dir}" />
+         </generator>
+         <generator name="Visual Studio 10" platform="windows" buildargs="ALL_BUILD.vcxproj">
+             <variable name="CMAKE_INSTALL_PREFIX" type="PATH" value="../${zip.tmp.dir}" />
+         </generator>
+         <generator name="Unix Makefiles">
+             <variable name="CMAKE_INSTALL_PREFIX" type="PATH" value="" />
+         </generator>
+         <variable name="SPREAD_ROOT" type="FILEPATH" value="${env.SPREAD_ROOT}" />
+         <variable name="PROTOBUF_ROOT" type="FILEPATH" value="${env.PROTOBUF_ROOT}" />
+      </cmake>
+   </target>
+
 </project>
 

ipaacalib/cpp/examples/CMakeLists.txt

@@ -42,8 +42,8 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_
 include_directories( ${PROJECT_SOURCE_DIR}/include )
 
 # add lib and include directory from pulled dependencies
-include_directories( ${PROJECT_SOURCE_DIR}/../../../dist/include )
-link_directories( ${PROJECT_SOURCE_DIR}/../../../dist/lib )
+include_directories( ${PROJECT_SOURCE_DIR}/../../../dist/include ${PROJECT_SOURCE_DIR}/../../../deps/include )
+link_directories( ${PROJECT_SOURCE_DIR}/../../../dist/lib ${PROJECT_SOURCE_DIR}/../../../deps/lib )
 
 # specify source files for ipaaca (auto-generated ones are in build/ )
 set (SOURCE

ipaacalib/cpp/examples/src/example-component.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Sociable Agents Group
+ *                         CITEC, Bielefeld University   
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
 //
 // Ipaaca 2 (ipaaca-rsb)
 //
@@ -12,7 +44,7 @@
 // 'Component' (the concept does not exist anymore in ipaaca2).
 //
 
-#include <ipaaca.h>
+#include <ipaaca/ipaaca.h>
 #include <typeinfo>
 
 using namespace ipaaca;
@@ -39,6 +71,7 @@ class LegacyComponent {
 		void handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
 		/// example publishing function to produce a 'grounded' IU
 		void publish_reply_iu(const std::string& text, const std::string& received_iu_uid);
+		void publish_reply_message(const std::string& text, const std::string& received_iu_uid);
 		void publish_hello_world();
 };
 
@@ -73,7 +106,15 @@ void LegacyComponent::handle_iu_event(IUInterface::ptr iu, IUEventType event_typ
 	
 	} else {
 		// event on a remote IU
-		if (event_type == IU_ADDED) {
+		if (event_type == IU_MESSAGE) {
+			std::cout << "[Received new Message!]" << std::endl;
+			
+			std::string description = iu->payload()["description"];
+			std::cout << "[ Current description: " << description << "]" << std::endl;
+			
+			/// let's also react by emitting an IU ourselves (function below)
+			publish_reply_iu("important-result", iu->uid());
+		} else if (event_type == IU_ADDED) {
 			std::cout << "[Received new IU!]" << std::endl;
 			
 			/// new Payload class enables dynamic typing to some degree (numeric default 0)
@@ -85,7 +126,7 @@ void LegacyComponent::handle_iu_event(IUInterface::ptr iu, IUEventType event_typ
 			std::cout << "[ Current description: " << description << "]" << std::endl;
 			
 			/// let's also react by emitting an IU ourselves (function below)
-			publish_reply_iu("important-result", iu->uid());
+			publish_reply_message("important-result", iu->uid());
 		
 		} else if (event_type == IU_UPDATED) {
 			std::cout << "[Received IU payload update for IU " << iu->uid() << "]" << std::endl;
@@ -123,9 +164,15 @@ void LegacyComponent::publish_reply_iu(const std::string& text, const std::strin
 	/// add to output buffer ( = "publish")
 	_out_buf->add(iu);
 }
+void LegacyComponent::publish_reply_message(const std::string& text, const std::string& received_iu_uid) {
+	IU::ptr iu = Message::create( "myResultCategory" );
+	iu->payload()["description"] = "SomeResult";
+	iu->add_link("GRIN", received_iu_uid);
+	_out_buf->add(iu);
+}
 
 void LegacyComponent::publish_hello_world() {
-	IU::ptr iu = IU::create( "myCategoryInterest"); //helloWorld" );
+	IU::ptr iu = Message::create( "myCategoryInterest"); //helloWorld" );
 	iu->payload()["description"] = "Hello world";
 	_out_buf->add(iu);
 }

ipaacalib/cpp/include/b64/b64.h

+
+/**
+ * `b64.h' - b64
+ *
+ * copyright (c) 2014 joseph werle
+ */
+
+/*
+From https://github.com/littlstar/b64.c/blob/master/LICENSE :
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Little Star Media, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#ifndef B64_H
+#define B64_H 1
+
+// RYT start
+#include <string>
+std::string base64_encode(const std::string& bin);
+std::string base64_decode(const std::string& b64);
+// RYT end
+
+/**
+ *  Memory allocation functions to use. You can define b64_malloc and
+ * b64_realloc to custom functions if you want.
+ */
+
+#ifndef b64_malloc
+#  define b64_malloc(ptr) malloc(ptr)
+#endif
+#ifndef b64_realloc
+#  define b64_realloc(ptr, size) realloc(ptr, size)
+#endif
+
+/**
+ * Base64 index table.
+ */
+
+static const char b64_table[] = {
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+  'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+  'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+  'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+  'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+  'w', 'x', 'y', 'z', '0', '1', '2', '3',
+  '4', '5', '6', '7', '8', '9', '+', '/'
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Encode `unsigned char *' source with `size_t' size.
+ * Returns a `char *' base64 encoded string.
+ */
+
+char *
+b64_encode (const unsigned char *, size_t);
+
+/**
+ * Dencode `char *' source with `size_t' size.
+ * Returns a `unsigned char *' base64 decoded string.
+ */
+unsigned char *
+b64_decode (const char *, size_t);
+
+/**
+ * Dencode `char *' source with `size_t' size.
+ * Returns a `unsigned char *' base64 decoded string + size of decoded string.
+ */
+unsigned char *
+b64_decode_ex (const char *, size_t, size_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

ipaacalib/cpp/include/ipaaca/ipaaca-backend-mqtt.h

+/*
+ * 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.h
+ *
+ * \brief Header file for abstract backend participant implementation
+ *   (used in the core library and as a base to derive specific backends).
+ *
+ * Users should not include this file directly, but use ipaaca.h
+ *
+ * \b Note: This file is only included during compilation of ipaaca,
+ * for regular use, the full internal API is not exposed.
+ * Users generally need never touch the internal transport layer.
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2019
+ */
+
+#ifndef __ipaaca_backend_mqtt_h_INCLUDED__
+#define __ipaaca_backend_mqtt_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+}
+// Backend-specific include[s]
+#include <mosquittopp.h>
+namespace ipaaca {
+
+#define _MQTT_REMOTE_SERVER_MAX_QUEUED_REQUESTS 0
+
+namespace backend {
+namespace mqtt {
+
+//
+// START of backend-specific implementation
+//
+// here: MQTT
+
+// helper to encapsulate a wait-until-live mechanism
+//  you can take this for other backends and adopt the friend class name
+class ParticipantCore {
+    friend class MQTTBackEnd;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::condition_variable _condvar;
+        IPAACA_MEMBER_VAR_EXPORT std::mutex _condvar_mutex;
+        IPAACA_MEMBER_VAR_EXPORT bool _running;
+        IPAACA_MEMBER_VAR_EXPORT bool _live;
+    protected:
+        IPAACA_HEADER_EXPORT ParticipantCore();
+        IPAACA_HEADER_EXPORT void signal_live();
+        IPAACA_HEADER_EXPORT bool wait_live(long timeout_milliseconds = 15000);
+};
+
+class MQTTParticipant: public ParticipantCore, public mosqpp::mosquittopp {
+    public:
+        typedef std::shared_ptr<MQTTParticipant> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::string _scope;
+        IPAACA_MEMBER_VAR_EXPORT std::string _client_id;
+        IPAACA_MEMBER_VAR_EXPORT std::string host;
+        IPAACA_MEMBER_VAR_EXPORT int port;
+        IPAACA_MEMBER_VAR_EXPORT int keepalive;
+    public:
+        IPAACA_HEADER_EXPORT MQTTParticipant(const MQTTParticipant& orig) = delete; // forbid copy-construction for backend
+        IPAACA_HEADER_EXPORT inline virtual ~MQTTParticipant() { }
+        IPAACA_HEADER_EXPORT MQTTParticipant(const std::string& client_id, const std::string& scope, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT void connect_and_background();
+        IPAACA_HEADER_EXPORT virtual void on_error();
+        IPAACA_HEADER_EXPORT virtual void on_disconnect(int rc);
+        IPAACA_HEADER_EXPORT static int get_next_mid();
+        /* // available mosquittopp callbacks:
+        virtual void on_connect(int rc) {return;}
+        virtual void on_disconnect(int rc) {return;}
+        virtual void on_publish(int mid) {return;}
+        virtual void on_message(const struct mosquitto_message * message) {return;}
+        virtual void on_subscribe(int mid, int qos_count, const int * granted_qos) {return;}
+        virtual void on_unsubscribe(int mid) {return;}
+        virtual void on_log(int level, const char * str) {return;}
+        virtual void on_error() {return;}
+        */
+};
+
+class MQTTInformer: public MQTTParticipant, public Informer {
+    public:
+        typedef std::shared_ptr<MQTTInformer> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::string _client_id;
+    public:
+        IPAACA_HEADER_EXPORT MQTTInformer(const std::string& client_id, const std::string& scope, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual void on_connect(int rc);
+        IPAACA_HEADER_EXPORT virtual bool internal_publish(const std::string& wire);
+};
+
+class MQTTListener: public MQTTParticipant, public Listener {
+    public:
+        typedef std::shared_ptr<MQTTListener> ptr;
+    public:
+        IPAACA_HEADER_EXPORT MQTTListener(const std::string& client_id, const std::string& scope, InputBuffer* buffer_ptr, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual void on_connect(int rc);
+        IPAACA_HEADER_EXPORT virtual void on_subscribe(int mid, int qos_count, const int * granted_qos);
+        IPAACA_HEADER_EXPORT virtual void on_message(const struct mosquitto_message * message);
+};
+
+class MQTTLocalServer: public MQTTParticipant, public LocalServer {
+    public:
+        typedef std::shared_ptr<MQTTLocalServer> ptr;
+    protected:
+        IPAACA_HEADER_EXPORT void send_result_for_request(const std::string& request_endpoint, const std::string& request_uid, int64_t result);
+    public:
+        IPAACA_HEADER_EXPORT MQTTLocalServer(const std::string& client_id, const std::string& scope, ipaaca::OutputBuffer* buffer_ptr, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual void on_connect(int rc);
+        IPAACA_HEADER_EXPORT virtual void on_subscribe(int mid, int qos_count, const int * granted_qos);
+        IPAACA_HEADER_EXPORT virtual void on_message(const struct mosquitto_message * message);
+};
+
+class MQTTRemoteServer: public MQTTParticipant, public RemoteServer {
+    public:
+        typedef std::shared_ptr<RemoteServer> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::map<std::string, PendingRequest::ptr> _pending_requests;
+        IPAACA_MEMBER_VAR_EXPORT ipaaca::Lock _pending_requests_lock;
+        IPAACA_MEMBER_VAR_EXPORT std::string _remote_end_scope; // this is the actual important scope,
+            // MQTTParticipant::_scope is repurposed here for receiving replies
+        IPAACA_MEMBER_VAR_EXPORT std::string _name; // using this (unique) auto-generated name
+    public:
+        IPAACA_HEADER_EXPORT MQTTRemoteServer(const std::string& client_id, const std::string& scope, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT int64_t request_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_link_update(std::shared_ptr<IULinkUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_commission(std::shared_ptr<protobuf::IUCommission> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update);
+        IPAACA_HEADER_EXPORT virtual void on_connect(int rc);
+        IPAACA_HEADER_EXPORT virtual void on_subscribe(int mid, int qos_count, const int * granted_qos);
+        IPAACA_HEADER_EXPORT virtual void on_message(const struct mosquitto_message * message);
+        IPAACA_HEADER_EXPORT PendingRequest::ptr queue_pending_request(Event::ptr request);
+        IPAACA_HEADER_EXPORT int64_t blocking_call(Event::ptr request);
+};
+
+
+class MQTTBackEnd: public BackEnd
+{
+    public:
+        typedef std::shared_ptr<MQTTBackEnd> ptr;
+        friend class BackEndLibrary;
+    protected:
+        IPAACA_HEADER_EXPORT MQTTBackEnd();
+    public:
+        IPAACA_HEADER_EXPORT static BackEnd::ptr get();
+        IPAACA_HEADER_EXPORT void teardown();
+        IPAACA_HEADER_EXPORT Informer::ptr createInformer(const std::string& scope);
+        IPAACA_HEADER_EXPORT Listener::ptr createListener(const std::string& scope, InputBuffer* buf);
+        IPAACA_HEADER_EXPORT LocalServer::ptr createLocalServer(const std::string& scope, OutputBuffer* buf);
+        IPAACA_HEADER_EXPORT RemoteServer::ptr createRemoteServer(const std::string& scope);
+        IPAACA_HEADER_EXPORT inline std::string make_valid_scope(const std::string& scope) override { return scope; }
+};
+
+} // of namespace mqtt
+} // of namespace backend
+
+#endif // of __ipaaca_backend_mqtt_h_INCLUDED__

ipaacalib/cpp/include/ipaaca/ipaaca-backend-ros.h

+/*
+ * 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.h
+ *
+ * \brief Header file for abstract backend participant implementation
+ *   (used in the core library and as a base to derive specific backends).
+ *
+ * Users should not include this file directly, but use ipaaca.h
+ *
+ * \b Note: This file is only included during compilation of ipaaca,
+ * for regular use, the full internal API is not exposed.
+ * Users generally need never touch the internal transport layer.
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   January, 2019
+ */
+
+#ifndef __ipaaca_backend_ros_h_INCLUDED__
+#define __ipaaca_backend_ros_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+}
+// Backend-specific include[s]
+#include "ros/ros.h"
+#include "std_msgs/String.h"
+namespace ipaaca {
+
+#define _ROS_REMOTE_SERVER_MAX_QUEUED_REQUESTS 0
+
+namespace backend {
+namespace ros {
+
+//
+// START of backend-specific implementation
+//
+// here: ROS
+
+// helper to encapsulate a wait-until-live mechanism
+//  you can take this for other backends and adopt the friend class name
+class ParticipantCore {
+    friend class ROSBackEnd;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::condition_variable _condvar;
+        IPAACA_MEMBER_VAR_EXPORT std::mutex _condvar_mutex;
+        IPAACA_MEMBER_VAR_EXPORT bool _running;
+        IPAACA_MEMBER_VAR_EXPORT bool _live;
+    protected:
+        IPAACA_HEADER_EXPORT ParticipantCore();
+        IPAACA_HEADER_EXPORT void signal_live();
+        IPAACA_HEADER_EXPORT bool wait_live(long timeout_milliseconds = 15000);
+};
+
+class ROSParticipant: public ParticipantCore {
+    public:
+        typedef std::shared_ptr<ROSParticipant> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::string _scope;
+        IPAACA_MEMBER_VAR_EXPORT std::string host;
+        IPAACA_MEMBER_VAR_EXPORT int port;
+        IPAACA_MEMBER_VAR_EXPORT int keepalive;
+    protected:
+        // a pointer; odd, but see the ROSBackEnd constructor & destructor
+        ::ros::NodeHandle* _node_handle;
+    public:
+        IPAACA_HEADER_EXPORT ROSParticipant(const ROSParticipant& orig) = delete; // forbid copy-construction for backend
+        IPAACA_HEADER_EXPORT inline virtual ~ROSParticipant() { }
+        IPAACA_HEADER_EXPORT ROSParticipant(::ros::NodeHandle* node, const std::string& scope, Config::ptr config = nullptr);
+};
+
+class ROSInformer: public ROSParticipant, public Informer {
+    public:
+        typedef std::shared_ptr<ROSInformer> ptr;
+    protected:
+        ::ros::Publisher _ros_pub;
+    public:
+        IPAACA_HEADER_EXPORT ROSInformer(::ros::NodeHandle* node, const std::string& scope, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual bool internal_publish(const std::string& wire);
+};
+
+class ROSListener: public ROSParticipant, public Listener {
+    public:
+        typedef std::shared_ptr<ROSListener> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT ::ros::Subscriber _ros_sub;
+    public:
+        IPAACA_HEADER_EXPORT ROSListener(::ros::NodeHandle* node, const std::string& scope, InputBuffer* buffer_ptr, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual void on_message(const std_msgs::String::ConstPtr& msg);
+};
+
+class ROSLocalServer: public ROSParticipant, public LocalServer {
+    public:
+        typedef std::shared_ptr<ROSLocalServer> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT ::ros::Subscriber _ros_sub;
+        IPAACA_MEMBER_VAR_EXPORT std::map<std::string, ::ros::Publisher> _ros_pubs;
+    protected:
+        IPAACA_HEADER_EXPORT void send_result_for_request(const std::string& request_endpoint, const std::string& request_uid, int64_t result);
+        IPAACA_HEADER_EXPORT ::ros::Publisher get_publisher(const std::string& endpoint);
+    public:
+        IPAACA_HEADER_EXPORT ROSLocalServer(::ros::NodeHandle* node, const std::string& scope, ipaaca::OutputBuffer* buffer_ptr, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT virtual void on_message(const std_msgs::String::ConstPtr& msg);
+};
+
+class ROSRemoteServer: public ROSParticipant, public RemoteServer {
+    public:
+        typedef std::shared_ptr<RemoteServer> ptr;
+    protected:
+        IPAACA_MEMBER_VAR_EXPORT std::map<std::string, PendingRequest::ptr> _pending_requests;
+        IPAACA_MEMBER_VAR_EXPORT ipaaca::Lock _pending_requests_lock;
+        IPAACA_MEMBER_VAR_EXPORT std::string _remote_end_scope; // this is the actual important scope,
+            // ROSParticipant::_scope is repurposed here for receiving replies
+        IPAACA_MEMBER_VAR_EXPORT std::string _name; // using this (unique) auto-generated name
+        IPAACA_MEMBER_VAR_EXPORT ::ros::Subscriber _ros_sub;
+        IPAACA_MEMBER_VAR_EXPORT ::ros::Publisher _ros_pub;
+    public:
+        IPAACA_HEADER_EXPORT ROSRemoteServer(::ros::NodeHandle* node, const std::string& scope, Config::ptr config = nullptr);
+        IPAACA_HEADER_EXPORT int64_t request_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_link_update(std::shared_ptr<IULinkUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_commission(std::shared_ptr<protobuf::IUCommission> update);
+        IPAACA_HEADER_EXPORT int64_t request_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update);
+        IPAACA_HEADER_EXPORT PendingRequest::ptr queue_pending_request(Event::ptr request);
+        IPAACA_HEADER_EXPORT int64_t blocking_call(Event::ptr request);
+        IPAACA_HEADER_EXPORT virtual void on_message(const std_msgs::String::ConstPtr& msg);
+};
+
+
+class ROSBackEnd: public BackEnd
+{
+    public:
+        typedef std::shared_ptr<ROSBackEnd> ptr;
+        friend class BackEndLibrary;
+    protected:
+        bool _need_init;
+        char* _cfakename;
+        ::ros::NodeHandle* _node_handle;
+        ::ros::AsyncSpinner* _spinner;
+    protected:
+        IPAACA_HEADER_EXPORT ROSBackEnd();
+    public:
+        IPAACA_HEADER_EXPORT static BackEnd::ptr get();
+        IPAACA_HEADER_EXPORT void teardown();
+        IPAACA_HEADER_EXPORT void init_once();
+        IPAACA_HEADER_EXPORT Informer::ptr createInformer(const std::string& scope);
+        IPAACA_HEADER_EXPORT Listener::ptr createListener(const std::string& scope, InputBuffer* buf);
+        IPAACA_HEADER_EXPORT LocalServer::ptr createLocalServer(const std::string& scope, OutputBuffer* buf);
+        IPAACA_HEADER_EXPORT RemoteServer::ptr createRemoteServer(const std::string& scope);
+        IPAACA_HEADER_EXPORT inline std::string make_valid_scope(const std::string& scope) override {
+            // strip the leading slash for the ROS node name (removing this
+            // extra rule would lead to a global (non-movable) namespace
+            if (scope.length() && (scope[0] == '/')) return scope.substr(1);
+            else return scope;
+        }
+};
+
+} // of namespace ros
+} // of namespace backend
+
+#endif // of __ipaaca_backend_ros_h_INCLUDED__

ipaacalib/cpp/include/ipaaca/ipaaca-backend.h

+/*
+ * 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.h
+ *
+ * \brief Header file for abstract backend participant implementation
+ *   (used in the core library and as a base to derive specific backends).
+ *
+ * Users should not include this file directly, but use ipaaca.h
+ *
+ * \b Note: This file is only included during compilation of ipaaca,
+ * for regular use, the full internal API is not exposed.
+ * Users generally need never touch the internal transport layer.
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   December, 2018
+ */
+
+#ifndef __ipaaca_backend_h_INCLUDED__
+#define __ipaaca_backend_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+namespace backend {
+
+#if _WIN32 || _WIN64
+inline std::string generate_client_id()
+{
+    // '-' not allowed e.g. in ROS
+    std::string uuid = ipaaca::generate_uuid_string().substr(0,8);
+    return uuid;
+}
+#else
+// get simplified basename of the process name from /proc
+//  (we could also decide to route argv here instead)
+inline std::string get_simplified_process_name()
+{
+    std::fstream fs;
+    fs.open("/proc/self/cmdline", std::fstream::in);
+    if (!fs.is_open()) {
+        IPAACA_DEBUG("Could not open /proc/self/cmdline")
+        return "ipaaca_cpp";
+    }
+    std::string line;
+    std::vector<std::string> tokens;
+    if (!std::getline(fs, line)) {
+        IPAACA_DEBUG("Failed to read a line from /proc/self/cmdline")
+        fs.close();
+        return "ipaaca_cpp";
+    }
+    fs.close();
+    int cnt = ipaaca::str_split_append(line, tokens, "\000");
+    if (cnt < 1) {
+        IPAACA_DEBUG("Failed to get process name from /proc/self/cmdline")
+        return "ipaaca_cpp";
+    }
+    line = tokens[0];
+    cnt = ipaaca::str_split_wipe(line, tokens, "/");
+    if (cnt < 1) {
+        IPAACA_DEBUG("Failed to parse process name in /proc/self/cmdline")
+        return "ipaaca_cpp";
+    }
+    std::string procname;
+    line = tokens[cnt-1];
+    for (auto ch: line) {
+        if ((ch>='a' && ch<='z') || (ch>='A' && ch<='Z') || (ch>='0' && ch<='9') || (ch=='_')) {
+            procname += ch;
+        } else if (ch=='-' || ch=='.' || ch==' ') {
+            procname += '_';
+        }
+    }
+    if (procname=="") {
+        IPAACA_DEBUG("Only unacceptable characters in process name from /proc/self/cmdline")
+        return "ipaaca_cpp";
+    } else {
+        return procname;
+    }
+}
+inline std::string generate_client_id()
+{
+    //std::stringstream ss;
+    //ss << "Process_" << getpid() << "_ClientID_" << ipaaca::generate_uuid_string();
+    //return ss.str();
+    std::string uuid = get_simplified_process_name() + "_" + ipaaca::generate_uuid_string().substr(0,8);
+    return uuid;
+}
+#endif
+
+/*
+ * class Scope {
+    public:
+        std::string scope_string;
+        Scope(const std::string& sc): scope_string(sc) {}
+        Scope(const Scope& scope): scope_string(scope.scope_string) {}
+        inline operator std::string() const { return scope_string; }
+};
+*/
+
+// RSB-like wrapper for {wire type; void ref to deserialized obj}
+//  to avoid modifying the event handling side.
+class Event {
+    public:
+        typedef std::shared_ptr<Event> ptr;
+    protected:
+        std::string _type;
+        std::shared_ptr<void> _data;
+    public:
+        inline Event(const std::string& type, std::shared_ptr<void> data): _type(type), _data(data) { }
+        inline std::string getType() const { return _type; }
+        inline std::shared_ptr<void> getData() const { return _data; }
+};
+
+
+class PendingRequest {
+    /** Encapsulation of a pending remote request with
+    a facility to keep the requesting thread locked
+    until the reply or a timeout unlocks it. */
+    public:
+        typedef std::shared_ptr<PendingRequest> ptr;
+    protected:
+        Event::ptr _pending_request;
+        std::condition_variable _condvar;
+        std::mutex _condvar_mutex;
+        // block var
+    public:
+        std::string _request_uid;
+        int _result;
+    public:
+        inline PendingRequest(Event::ptr req) {
+            std::string uuid = ipaaca::generate_uuid_string();
+            _request_uid = uuid.substr(0,8);
+            _pending_request = req;
+            _result = -1;
+        }
+        /// reply_with_result is called by the backend when a remote request reply has been received (and it was a known tracked request)
+        inline void reply_with_result(int result) {
+            _result = result;
+            _condvar.notify_one(); // wake up the waiting thread
+        };
+        /// wait_for_reply is called internally by the user thread that attempts to modify remote IUs, it waits until the remote end replies
+        inline int wait_for_reply(long timeout_milliseconds = 30000) {
+            std::unique_lock<std::mutex> lock(_condvar_mutex);
+            // the remote end will set the result >=0 (from the other thread), which suffices to continue
+            auto success = _condvar.wait_for(lock, std::chrono::milliseconds(timeout_milliseconds), [this]{return this->_result >= 0;});
+            if (!success) {
+                IPAACA_ERROR("Request timeout: we did not receive a reply for a remote server request")
+                // TODO could throw instead
+            }
+            return _result;
+        }
+};
+
+//
+// Abstract interface
+//
+
+class Informer {
+    public:
+        typedef std::shared_ptr<Informer> ptr;
+    protected:
+        std::string _client_id;
+    public:
+        IPAACA_HEADER_EXPORT inline virtual ~Informer() { }
+        template<typename Data> IPAACA_HEADER_EXPORT inline bool publish(Data d) { return internal_publish(ipaaca::converters::internal_serialize(d)); }
+    public:
+        //
+        // You MUST override these functions in the backend versions:
+        //
+        IPAACA_HEADER_EXPORT virtual bool internal_publish(const std::string& wire) { IPAACA_ERROR("Attempt to invoke abstract version of Informer::internal_publish"); throw NotImplementedError(); }
+};
+/*
+IPAACA_HEADER_EXPORT virtual bool publish(ipaaca::IU::ptr) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(ipaaca::Message::ptr) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(ipaaca::IUPayloadUpdate::ptr) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(ipaaca::IULinkUpdate::ptr) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::RemoteRequestResult>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IURetraction>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IUCommission>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IUResendRequest>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IUPayloadUpdateRequest>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IULinkUpdateRequest>) = 0;
+IPAACA_HEADER_EXPORT virtual bool publish(std::shared_ptr<protobuf::IUCommissionRequest>
+*/
+
+class Listener {
+    public:
+        typedef std::shared_ptr<Listener> ptr;
+    protected:
+        ipaaca::InputBuffer* _buffer;
+    protected:
+        Listener(ipaaca::InputBuffer* buffer): _buffer(buffer) { }
+    public:
+        IPAACA_HEADER_EXPORT inline virtual ~Listener() { }
+        //inline Listener(const Scope& scope, InputBuffer* buffer_ptr, Config::ptr config = nullptr)) {}
+        void relay_received_event_to_buffer(Event::ptr event);
+        void relay_received_event_to_buffer_threaded(Event::ptr event);
+};
+
+class LocalServer {
+    public:
+        typedef std::shared_ptr<LocalServer> ptr;
+    protected:
+        ipaaca::OutputBuffer* _buffer;
+    protected:
+        LocalServer(ipaaca::OutputBuffer* buffer): _buffer(buffer) { }
+    public:
+        //inline LocalServer(const Scope& scope, ipaaca::OutputBuffer* buffer_ptr, Config::ptr config = nullptr): _buffer(buffer_ptr);
+        IPAACA_HEADER_EXPORT inline virtual ~LocalServer() { }
+        //IPAACA_HEADER_EXPORT virtual int64_t attempt_to_apply_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update) = 0;
+        //IPAACA_HEADER_EXPORT virtual int64_t attempt_to_apply_remote_link_update(std::shared_ptr<IULinkUpdate> update) = 0;
+        //IPAACA_HEADER_EXPORT virtual int64_t attempt_to_apply_remote_commission(std::shared_ptr<protobuf::IUCommission> update) = 0;
+        //IPAACA_HEADER_EXPORT virtual int64_t attempt_to_apply_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update) = 0;
+        IPAACA_HEADER_EXPORT int64_t attempt_to_apply_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t attempt_to_apply_remote_link_update(std::shared_ptr<IULinkUpdate> update);
+        IPAACA_HEADER_EXPORT int64_t attempt_to_apply_remote_commission(std::shared_ptr<protobuf::IUCommission> update);
+        IPAACA_HEADER_EXPORT int64_t attempt_to_apply_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update);
+
+};
+
+class RemoteServer {
+    public:
+        typedef std::shared_ptr<RemoteServer> ptr;
+    public:
+        //inline RemoteServer(const Scope& scope, Config::ptr config = nullptr) {
+        //}
+        IPAACA_HEADER_EXPORT inline virtual ~RemoteServer() { }
+        IPAACA_HEADER_EXPORT virtual int64_t request_remote_payload_update(std::shared_ptr<IUPayloadUpdate> update) = 0;
+        IPAACA_HEADER_EXPORT virtual int64_t request_remote_link_update(std::shared_ptr<IULinkUpdate> update) = 0;
+        IPAACA_HEADER_EXPORT virtual int64_t request_remote_commission(std::shared_ptr<protobuf::IUCommission> update) = 0;
+        IPAACA_HEADER_EXPORT virtual int64_t request_remote_resend_request(std::shared_ptr<protobuf::IUResendRequest> update) = 0;
+};
+
+class BackEnd {
+    public:
+        typedef std::shared_ptr<BackEnd> ptr;
+    protected:
+        std::string _backend_name;
+    public:
+        BackEnd(std::string backend_name): _backend_name(backend_name) { }
+        inline std::string name() const { return _backend_name; }
+        virtual ~BackEnd() {}
+        virtual void teardown() = 0;
+        virtual LocalServer::ptr createLocalServer(const std::string& scope, OutputBuffer* buf) = 0;
+        virtual Informer::ptr createInformer(const std::string& scope) = 0;
+        virtual RemoteServer::ptr createRemoteServer(const std::string& scope) = 0;
+        virtual Listener::ptr createListener(const std::string& scope, InputBuffer* buf) = 0;
+        virtual std::string make_valid_scope(const std::string& scope) = 0;
+};
+
+class BackEndLibrary {
+    public:
+        typedef std::shared_ptr<BackEndLibrary> ptr;
+    protected:
+        std::map<std::string, BackEnd::ptr> _backends;
+    public:
+        BackEndLibrary() { }
+        inline static BackEndLibrary::ptr get() {
+            static BackEndLibrary::ptr lib;
+            if (!lib) {
+                lib = std::make_shared<BackEndLibrary>();
+            }
+            return lib;
+        }
+        inline bool register_backend(BackEnd::ptr backend) {
+            if (_backends.count(backend->name())) {
+                IPAACA_ERROR("Not registering another BackEnd with already known name: " << backend->name())
+                return false;
+            } else {
+                _backends[backend->name()] = backend;
+                return true;
+            }
+        }
+        inline BackEnd::ptr get_default_backend() {
+            static BackEnd::ptr _singleton;
+            if (_singleton) return _singleton;
+            if (_backends.size() == 0) {
+                IPAACA_ERROR("No backends are registered inside the library - cannot continue")
+                throw BackEndNotFoundError();
+            }
+            std::string preferred_backend = get_global_config()->get_with_default<std::string>("backend", "");
+            if (preferred_backend != "") {
+                if (_backends.count(preferred_backend)) {
+                    _singleton = _backends[preferred_backend];
+                } else {
+                    IPAACA_ERROR("Failed to initialize the selected BackEnd " << preferred_backend)
+                    throw BackEndNotFoundError();
+                }
+            } else {
+                // just return the first value // FIXME config or clean precedence rule
+                for (auto kv: _backends) {
+                    IPAACA_WARNING("No 'backend' config found, selecting BackEnd " << kv.second->name())
+                    _singleton = kv.second;
+                    break;
+                }
+            }
+            if (_singleton) return _singleton;
+            throw BackEndNotFoundError(); // should not be reached; silence warnings
+        }
+};
+
+inline BackEnd::ptr get_default_backend() {
+    return BackEndLibrary::get()->get_default_backend();
+}
+
+
+} // of namespace backend
+
+
+#endif
+

ipaacalib/cpp/include/ipaaca/ipaaca-buffers.h

+/*
+ * 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.
+ */
+
+#ifndef __ipaaca_buffers_h_INCLUDED__
+#define __ipaaca_buffers_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+// Convenience macro to abstract from the bind implementation being used
+//  and possible future signature changes.
+#define IPAACA_BIND_CLASS_HANDLER(fn, inst) std::bind(fn, inst, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
+
+
+/// Store for local IUs (used in OutputBuffer)
+class IUStore: public std::map<std::string, std::shared_ptr<IU> >
+{
+};
+/// Store for RemotePushIUs (used in InputBuffer)
+class RemotePushIUStore: public std::map<std::string, std::shared_ptr<RemotePushIU> >
+{
+};
+
+typedef std::set<std::string> LinkSet;
+typedef std::map<std::string, LinkSet> LinkMap;
+
+/// Container for IU links that gracefully returns the empty set if required
+class SmartLinkMap {//{{{
+	friend std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj);
+	friend class IUInterface;
+	friend class IU;
+	friend class ipaaca::converters::IUConverter;
+	//friend class ipaaca::converters::MessageConverter;
+	public:
+		IPAACA_HEADER_EXPORT const LinkSet& get_links(const std::string& key);
+		IPAACA_HEADER_EXPORT const LinkMap& get_all_links();
+
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT LinkMap _links;
+		/// The empty link set is returned if undefined links are read for an IU.
+		IPAACA_MEMBER_VAR_EXPORT static LinkSet empty_link_set;
+	protected:
+		IPAACA_HEADER_EXPORT void _add_and_remove_links(const LinkMap& add, const LinkMap& remove);
+		IPAACA_HEADER_EXPORT void _replace_links(const LinkMap& links);
+};//}}}
+
+/// The empty link set is returned if undefined links are read for an IU.
+IPAACA_MEMBER_VAR_EXPORT const LinkSet EMPTY_LINK_SET;
+
+/// Configuration object that can be passed to Buffer constructors.
+class BufferConfiguration//{{{
+{
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT std::string _basename;
+		IPAACA_MEMBER_VAR_EXPORT std::vector<std::string> _category_interests;
+		IPAACA_MEMBER_VAR_EXPORT std::string _channel;
+	public:
+		IPAACA_HEADER_EXPORT inline BufferConfiguration(const std::string& basename): _basename(basename), _channel(__ipaaca_static_option_default_channel) { }
+		IPAACA_HEADER_EXPORT inline const std::string& get_basename() const { return _basename; }
+		IPAACA_HEADER_EXPORT inline const std::vector<std::string>& get_category_interests() const { return _category_interests; }
+		IPAACA_HEADER_EXPORT inline const std::string& get_channel() const { return _channel; }
+	public:
+		// setters, initialization helpers
+		IPAACA_HEADER_EXPORT inline BufferConfiguration& set_basename(const std::string& basename) { _basename = basename; return *this; }
+		IPAACA_HEADER_EXPORT inline BufferConfiguration& add_category_interest(const std::string& category) { _category_interests.push_back(category); return *this; }
+		IPAACA_HEADER_EXPORT inline BufferConfiguration& set_channel(const std::string& channel) { _channel = channel; return *this; }
+};//}}}
+
+/// Builder object for BufferConfiguration, not required for C++ [DEPRECATED]
+class BufferConfigurationBuilder: private BufferConfiguration//{{{
+{
+	public:
+		[[deprecated("Use setters in BufferConfiguration instead of the Builder")]]
+		IPAACA_HEADER_EXPORT inline BufferConfigurationBuilder(const std::string& basename): BufferConfiguration(basename) {}
+		IPAACA_HEADER_EXPORT inline void set_basename(const std::string& basename)
+		{
+			_basename = basename;
+		}
+		IPAACA_HEADER_EXPORT inline void add_category_interest(const std::string& category)
+		{
+			_category_interests.push_back(category);
+		}
+		IPAACA_HEADER_EXPORT inline void set_channel(const std::string& channel)
+		{
+			_channel = channel;
+		}
+
+		IPAACA_HEADER_EXPORT const BufferConfiguration& get_buffer_configuration() { return *this; }
+
+};//}}}
+
+/** \brief Type of user-space functions that can be registered on a Buffer to receive IU events.
+ *
+ * The signature of these functions is void(shared_ptr<IUInterface> iu, IUEventType evt_type, bool local), where:<br/>
+ *     iu can be used mostly like a locally-generated IU reference (e.g. iu->payload() ...)<br/>
+ *     evt_type is one of IU_ADDED, IU_UPDATED, IU_RETRACTED, IU_DELETED, IU_LINKSUPDATED, IU_COMMITTED, IU_MESSAGE<br/>
+ *     local indicates that a remote change to a local IU (in an OutputBuffer) was effected
+ *
+ *     See #Buffer::register_handler for examples on how to use your own handlers.
+ */
+IPAACA_HEADER_EXPORT typedef std::function<void (std::shared_ptr<IUInterface>, IUEventType, bool)> IUEventHandlerFunction;
+
+/** \brief Internal handler type used in Buffer (wraps used-specified IUEventHandlerFunction)
+ */
+class IUEventHandler {//{{{
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT IUEventHandlerFunction _function;
+		IPAACA_MEMBER_VAR_EXPORT IUEventType _event_mask;
+		IPAACA_MEMBER_VAR_EXPORT bool _for_all_categories;
+		IPAACA_MEMBER_VAR_EXPORT std::set<std::string> _categories;
+	protected:
+		IPAACA_HEADER_EXPORT inline bool _condition_met(IUEventType event_type, const std::string& category)
+		{
+			return ((_event_mask&event_type)!=0) && (_for_all_categories || (_categories.count(category)>0));
+		}
+	public:
+		IPAACA_HEADER_EXPORT IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category);
+		IPAACA_HEADER_EXPORT IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
+		IPAACA_HEADER_EXPORT void call(Buffer* buffer, std::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
+	typedef std::shared_ptr<IUEventHandler> ptr;
+};//}}}
+
+/**
+ * \brief Buffer base class. Derived classes use its handler registration functionality.
+ *
+ * \b Note: This class is never instantiated directly (use OutputBuffer and InputBuffer, respectively).
+ */
+class Buffer {
+	friend class IU;
+	friend class RemotePushIU;
+	/*friend class CallbackIUPayloadUpdate;
+	friend class CallbackIULinkUpdate;
+	friend class CallbackIUCommission;
+	friend class CallbackIUResendRequest;*/
+        friend class ipaaca::backend::LocalServer;
+        friend class ipaaca::backend::Listener;
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT std::string _uuid;
+		IPAACA_MEMBER_VAR_EXPORT std::string _basename;
+		IPAACA_MEMBER_VAR_EXPORT std::string _unique_name;
+		IPAACA_MEMBER_VAR_EXPORT std::string _id_prefix;
+		IPAACA_MEMBER_VAR_EXPORT std::string _channel;
+		IPAACA_MEMBER_VAR_EXPORT std::vector<IUEventHandler::ptr> _event_handlers;
+	protected:
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _publish_iu_resend(std::shared_ptr<IU> iu, const std::string& hidden_scope_name) = 0;
+
+
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _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="undef") = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _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="undef") = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef") = 0;
+		IPAACA_HEADER_EXPORT void _allocate_unique_name(const std::string& basename, const std::string& function);
+		IPAACA_HEADER_EXPORT inline Buffer(const std::string& basename, const std::string& function) {
+			_allocate_unique_name(basename, function);
+			_channel = __ipaaca_static_option_default_channel;
+		}
+		IPAACA_HEADER_EXPORT void call_iu_event_handlers(std::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
+	public:
+		IPAACA_HEADER_EXPORT virtual inline ~Buffer() { }
+		IPAACA_HEADER_EXPORT inline const std::string& unique_name() { return _unique_name; }
+		/** \brief Register a user-specified handler for IU events. Unless specified, it triggers for all event types for all category interests of the buffer.
+		 *
+		 * \param function A function [object] that can be converted to #IUEventHandlerFunction (examples below)
+		 * \param event_mask Which event types to relay to the user (default: all)
+		 * \param category The category to filter for (default: do not filter)
+		 *
+		 * \b Examples:
+		 *
+		 * Adding a plain function as a handler:<br/>
+		 *     <pre>
+		 *     void global_iu_handler(IUInterface::ptr iu, IUEventType type, bool local) { do_something(); }
+		 *     ...
+		 *     int main() {
+		 *         OutputBuffer::ptr outbuf = OutputBuffer::create("mybufname");
+		 *         outbuf->register_handler(global_iu_handler);
+		 *         ...
+		 *     }
+		 *     </pre>
+		 *
+		 * Adding a class member as a handler (using macro or std::bind):<br/>
+		 *     <pre>
+		 *     class MyClass {
+		 *         protected:
+		 *             void my_internal_iu_handler(IUInterface::ptr iu, #IUEventType type, bool local) { do_something(); }
+		 *             InputBuffer::ptr inbuf;
+		 *         public:
+		 *             MyClass() {
+		 *                 inbuf = InputBuffer::create("bufname", "categoryInterest");
+		 *                 // Using the macro may protect you against future code adaptations:
+		 *                 inbuf->register_handler(IPAACA_BIND_CLASS_HANDLER(&MyClass::my_internal_iu_handler, this));
+		 *                 // it is currently identical to:
+		 *                 // inbuf->register_handler(std::bind(&MyClass::my_internal_iu_handler, this, \
+		 *                          std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+		 *             }
+		 *     };
+		 *     </pre>
+		 *
+		 * Adding a lambda function as a handler (C++11):<br/>
+		 *     <pre>
+		 *     inbuf->register_handler([](IUInterface::ptr iu, #IUEventType event_type, bool local) {
+		 *         do_something();
+		 *     });
+		 *     </pre>
+		 *
+		 */
+		IPAACA_HEADER_EXPORT void register_handler(IUEventHandlerFunction function, IUEventType event_mask = IU_ALL_EVENTS, const std::string& category="");
+		/// This version of register_handler takes a set of several category interests instead of just one.
+		IPAACA_HEADER_EXPORT void register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual std::shared_ptr<IUInterface> get(const std::string& iu_uid) = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual std::set<std::shared_ptr<IUInterface> > get_ius() = 0;
+
+		IPAACA_HEADER_EXPORT inline const std::string& channel() { return _channel; }
+};
+//}}}
+
+/**
+ * \brief A buffer to which own IUs can be added to publish them
+ *
+ * Use #OutputBuffer::create to obtain a smart pointer to a new output buffer.
+ * 
+ * Use #OutputBuffer::add to add (= publish) an IU.
+ *
+ * Use #OutputBuffer::remove to remove (= retract) an IU.
+ *
+ * Use #Buffer::register_handler to register a handler that will respond to remote changes to own published IUs.
+ */
+class OutputBuffer: public Buffer {
+	friend class IU;
+	friend class RemotePushIU;
+        friend class ipaaca::backend::LocalServer;
+	protected:
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT IUStore _iu_store;
+		IPAACA_MEMBER_VAR_EXPORT Lock _iu_id_counter_lock;
+#ifdef IPAACA_EXPOSE_FULL_RSB_API
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, ipaaca::backend::Informer::ptr> _informer_store;
+		IPAACA_MEMBER_VAR_EXPORT ipaaca::backend::LocalServer::ptr _server;
+		IPAACA_HEADER_EXPORT ipaaca::backend::Informer::ptr _get_informer(const std::string& category);
+#endif
+	protected:
+		IPAACA_HEADER_EXPORT void _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="undef") _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT void _publish_iu_resend(std::shared_ptr<IU> iu, const std::string& hidden_scope_name) _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT void _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="undef") _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name) _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT void _publish_iu(std::shared_ptr<IU> iu);
+		/// mark and send IU retraction on own IU (removal from buffer is in remove(IU))
+		IPAACA_HEADER_EXPORT void _retract_iu(std::shared_ptr<IU> iu);
+		/// mark and send retraction for all unretracted IUs (without removal, used in ~OutputBuffer)
+		IPAACA_HEADER_EXPORT void _retract_all_internal();
+	protected:
+		/// \b Note: constructor is protected. Use create()
+		IPAACA_HEADER_EXPORT OutputBuffer(const std::string& basename, const std::string& channel=""); // empty string auto-replaced with __ipaaca_static_option_default_channel
+		IPAACA_HEADER_EXPORT void _initialize_server();
+	public:
+		IPAACA_HEADER_EXPORT static std::shared_ptr<OutputBuffer> create(const std::string& basename);
+		/// OutputBuffer destructor will retract all IUs that are still live
+		IPAACA_HEADER_EXPORT ~OutputBuffer();
+		IPAACA_HEADER_EXPORT void add(std::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT std::shared_ptr<IU> remove(const std::string& iu_uid);
+		IPAACA_HEADER_EXPORT std::shared_ptr<IU> remove(std::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT std::shared_ptr<IUInterface> get(const std::string& iu_uid) _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT std::set<std::shared_ptr<IUInterface> > get_ius() _IPAACA_OVERRIDE_;
+	typedef std::shared_ptr<OutputBuffer> ptr;
+};
+//}}}
+
+/**
+ * \brief A buffer in which remote IUs (and changes to them) are received.
+ *
+ * Use InputBuffer::create() to obtain a smart pointer to a new input buffer.
+ *
+ * Set category interests (IU filter) via the different versions of create().
+ *
+ * Use Buffer::register_handler() to register a handler that will respond to relevant remote IUs.
+ */
+class InputBuffer: public Buffer {
+	friend class IU;
+	friend class RemotePushIU;
+        friend class ipaaca::backend::Listener;
+#ifdef IPAACA_EXPOSE_FULL_RSB_API
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, ipaaca::backend::Listener::ptr> _listener_store;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, ipaaca::backend::RemoteServer::ptr> _remote_server_store;
+		IPAACA_MEMBER_VAR_EXPORT RemotePushIUStore _iu_store;
+		IPAACA_HEADER_EXPORT ipaaca::backend::RemoteServer::ptr _get_remote_server(const std::string& unique_server_name);
+		IPAACA_HEADER_EXPORT ipaaca::backend::Listener::ptr _create_category_listener_if_needed(const std::string& category);
+		IPAACA_HEADER_EXPORT void _handle_iu_events(ipaaca::backend::Event::ptr event);
+		IPAACA_HEADER_EXPORT void _trigger_resend_request(ipaaca::backend::Event::ptr event);
+#endif
+	protected:
+		IPAACA_HEADER_EXPORT inline void _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="undef") _IPAACA_OVERRIDE_
+		{
+			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_link_update() should never be invoked")
+		}
+		IPAACA_HEADER_EXPORT inline void _publish_iu_resend(std::shared_ptr<IU> iu, const std::string& hidden_scope_name) _IPAACA_OVERRIDE_
+		{
+			IPAACA_WARNING("(ERROR) InputBuffer::_publish_iu_resend() should never be invoked")
+		}
+		IPAACA_HEADER_EXPORT inline void _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="undef") _IPAACA_OVERRIDE_
+		{
+			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_payload_update() should never be invoked")
+		}
+		IPAACA_HEADER_EXPORT inline void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef") _IPAACA_OVERRIDE_
+		{
+			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_commission() should never be invoked")
+		}
+		/*IPAACA_HEADER_EXPORT inline void _send_iu_resendrequest(IUInterface* iu, revision_t revision, const std::string& writer_name="undef")
+		{
+			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_resendrequest() should never be invoked")
+		}*/
+	protected:
+		/// \b Note: all constructors are protected. Use create()
+		IPAACA_HEADER_EXPORT InputBuffer(const BufferConfiguration& bufferconfiguration);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::set<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
+		IPAACA_HEADER_EXPORT 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);
+
+		IPAACA_MEMBER_VAR_EXPORT bool triggerResend;
+
+	public:
+		/// Specify whether old but previously unseen IUs should be requested to be sent to the buffer over a hidden channel.
+		IPAACA_HEADER_EXPORT void set_resend(bool resendActive);
+		IPAACA_HEADER_EXPORT bool get_resend();
+		/// Create InputBuffer according to configuration in BufferConfiguration object
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const BufferConfiguration& bufferconfiguration);
+		/// Create InputBuffer from name and set of category interests
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const std::string& basename, const std::set<std::string>& category_interests);
+		/// Create InputBuffer from name and vector of category interests
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const std::string& basename, const std::vector<std::string>& category_interests);
+		/// Convenience function: create InputBuffer from name and one category interest
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1);
+		/// Convenience function: create InputBuffer from name and two category interests [DEPRECATED]
+		[[deprecated("Use create(string, set<string>) instead")]]
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
+		/// Convenience function: create InputBuffer from name and three category interests [DEPRECATED]
+		[[deprecated("Use create(string, set<string>) instead")]]
+		IPAACA_HEADER_EXPORT static std::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
+		/// Convenience function: create InputBuffer from name and four category interests [DEPRECATED]
+		[[deprecated("Use create(string, set<string>) instead")]]
+		IPAACA_HEADER_EXPORT static std::shared_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);
+		IPAACA_HEADER_EXPORT ~InputBuffer() {
+			IPAACA_IMPLEMENT_ME
+		}
+		IPAACA_HEADER_EXPORT std::shared_ptr<IUInterface> get(const std::string& iu_uid) _IPAACA_OVERRIDE_;
+		IPAACA_HEADER_EXPORT std::set<std::shared_ptr<IUInterface> > get_ius() _IPAACA_OVERRIDE_;
+	typedef std::shared_ptr<InputBuffer> ptr;
+};
+//}}}
+
+/// Internal, transport-independent, representation of payload updates
+class IUPayloadUpdate {//{{{
+	public:
+		IPAACA_MEMBER_VAR_EXPORT std::string uid;
+		IPAACA_MEMBER_VAR_EXPORT revision_t revision;
+		IPAACA_MEMBER_VAR_EXPORT std::string writer_name;
+		IPAACA_MEMBER_VAR_EXPORT bool is_delta;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, PayloadDocumentEntry::ptr> new_items;
+		IPAACA_MEMBER_VAR_EXPORT std::vector<std::string> keys_to_remove;
+		IPAACA_MEMBER_VAR_EXPORT std::string payload_type; // to handle legacy mode
+                IPAACA_MEMBER_VAR_EXPORT std::string request_uid;      // for lightweight back-ends
+                IPAACA_MEMBER_VAR_EXPORT std::string request_endpoint; // for lightweight back-ends
+	friend std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj);
+	typedef std::shared_ptr<IUPayloadUpdate> ptr;
+};//}}}
+
+/// Internal, transport-independent, representation of link updates
+class IULinkUpdate {//{{{
+	public:
+		IPAACA_MEMBER_VAR_EXPORT std::string uid;
+		IPAACA_MEMBER_VAR_EXPORT revision_t revision;
+		IPAACA_MEMBER_VAR_EXPORT std::string writer_name;
+		IPAACA_MEMBER_VAR_EXPORT bool is_delta;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::set<std::string> > new_links;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::set<std::string> > links_to_remove;
+                IPAACA_MEMBER_VAR_EXPORT std::string request_uid;      // for lightweight back-ends
+                IPAACA_MEMBER_VAR_EXPORT std::string request_endpoint; // for lightweight back-ends
+	friend std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj);
+	typedef std::shared_ptr<IULinkUpdate> ptr;
+};//}}}
+
+
+#endif

ipaacalib/cpp/include/ipaaca/ipaaca-cmdline-parser.h

+/*
+ * 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-cmdline_parser.h
+ *
+ * \brief Header file for basic command line parser
+ *
+ * Users should not include this file directly, but use ipaaca.h
+ *
+ * \author Ramin Yaghoubzadeh (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   February, 2019
+ */
+
+#ifndef __ipaaca_cmdline_parser_h_INCLUDED__
+#define __ipaaca_cmdline_parser_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+// in ipaaca-cmdline-parser.cc
+// additional misc classes ( Command line options )//{{{
+/** \brief Command line argument container for CommandLineParser
+ *
+ * Contains the results of argument parsing from CommandLineParser::parse()
+ *
+ * The parser is preconfigured to handle some standard options:
+ *
+ * Option                          | Function
+ * --------------------------------|------------------------------------------------------------------------------
+ * --help                          | Print list of available options
+ * --verbose                       | Set verbose flag
+ * --character-name <name>         | Set character name (legacy)
+ * --component-name <name>         | Set component name (legacy)
+ * --ipaaca-payload-type <type>    | Set default ipaaca payload type (default JSON, set STR for legacy protocol)
+ * --ipaaca-default-channel <name> | Set default channel name (default 'default')
+ * --ipaaca-enable-logging <level> | Set console log level, one of NONE, DEBUG, INFO, WARNING, ERROR, CRITICAL
+ * --rsb-enable-logging <level>    | Set rsb (transport) log level
+ *
+ */
+class CommandLineOptions {
+	public:
+		IPAACA_HEADER_EXPORT inline CommandLineOptions()
+		{ }
+		IPAACA_HEADER_EXPORT inline ~CommandLineOptions() {
+		}
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> param_opts;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, bool> param_set;
+	public:
+		IPAACA_HEADER_EXPORT void set_option(const std::string& name, bool expect, const char* optarg);
+		/// Get the option argument or default value (if the option expected an argument)
+		IPAACA_HEADER_EXPORT std::string get_param(const std::string& o);
+		/// Check whether option has been set
+		IPAACA_HEADER_EXPORT bool is_set(const std::string& o);
+		IPAACA_HEADER_EXPORT void dump();
+	public:
+		typedef std::shared_ptr<CommandLineOptions> ptr;
+};
+
+/**
+ * \brief Command line parser for ipaaca programs.
+ *
+ * The parser is preconfigured to handle some standard options:
+ *
+ * Option                          | Function
+ * --------------------------------|------------------------------------------------------------------------------
+ * --help                          | Print list of available options
+ * --verbose                       | Set verbose flag
+ * --character-name <name>         | Set character name (legacy)
+ * --component-name <name>         | Set component name (legacy)
+ * --ipaaca-payload-type <type>    | Set default ipaaca payload type (default JSON, set STR for legacy protocol)
+ * --ipaaca-default-channel <name> | Set default channel name (default 'default')
+ * --ipaaca-enable-logging <level> | Set console log level, one of NONE, DEBUG, INFO, WARNING, ERROR, CRITICAL
+ * --rsb-enable-logging <level>    | Set rsb (transport) log level
+ *
+ */
+class CommandLineParser {
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT std::map<char, std::string> longopt; // letter->name
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, char> shortopt; // letter->name
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, bool> options; //  name / expect_param
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> defaults; // for opt params
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, int> set_flag; // for paramless opts
+	protected:
+		IPAACA_HEADER_EXPORT CommandLineParser();
+		IPAACA_MEMBER_VAR_EXPORT bool library_options_handled;
+		IPAACA_HEADER_EXPORT bool consume_library_option(const std::string& name, bool expect, const char* optarg);
+		IPAACA_HEADER_EXPORT void ensure_defaults_in( CommandLineOptions::ptr clo );
+	public:
+		IPAACA_HEADER_EXPORT inline ~CommandLineParser() { }
+		/// Create a new parser object reference.
+		IPAACA_HEADER_EXPORT static inline std::shared_ptr<CommandLineParser> create() {
+			return std::shared_ptr<CommandLineParser>(new CommandLineParser());
+		}
+		IPAACA_HEADER_EXPORT void initialize_parser_defaults();
+		IPAACA_HEADER_EXPORT void dump_options();
+		/** \brief Add a user-defined option
+		 *
+		 * \param optname      The long option name, e.g. verbose for --verbose
+		 * \param shortn       The short option (or \0 for none)
+		 * \param expect_param Whether an argument is expected for the option
+		 * \param defaultv     The default string value (unused if expect_param is false)
+		 */
+		IPAACA_HEADER_EXPORT void add_option(const std::string& optname, char shortn, bool expect_param, const std::string& defaultv);
+		/** \brief Parse argument list and return result.
+		 *
+		 * Parse argument list (e.g. from main()) with the parser, consuming the internal options.
+		 * The remaining options are packaged into a CommandLineOptions object.
+		 */
+		IPAACA_HEADER_EXPORT CommandLineOptions::ptr parse(int argc, char* const* argv);
+	public:
+		typedef std::shared_ptr<CommandLineParser> ptr;
+};
+//}}}
+
+#endif
+

ipaacalib/cpp/include/ipaaca/ipaaca-config.h

+/*
+ * 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.h
+ *
+ * \brief Header file for abstract backend participant implementation
+ *   (used in the core library and as a base to derive specific backends).
+ *
+ * Users should not include this file directly, but use ipaaca.h
+ *
+ * \b Note: This file is only included during compilation of ipaaca,
+ * for regular use, the full internal API is not exposed.
+ * Users generally need never touch the internal transport layer.
+ *
+ * \author Ramin Yaghoubzadeh Torky (ryaghoubzadeh@uni-bielefeld.de)
+ * \date   December, 2018
+ */
+
+#ifndef __ipaaca_config_h_INCLUDED__
+#define __ipaaca_config_h_INCLUDED__
+
+#ifndef __ipaaca_h_INCLUDED__
+#error "Please do not include this file directly, use ipaaca.h instead"
+#endif
+
+class Config {
+    public:
+        typedef std::shared_ptr<Config> ptr;
+    protected:
+        std::map<std::string, std::string> _data;
+        std::set<std::string> _messages_delivered;
+        template<typename T> T get_with_default_internal(const std::string& key, T const& default_value, bool warn);
+        template<typename T> void config_key_not_found(const std::string& key, T const& default_value, bool warn)
+        {
+            if (!_messages_delivered.count(key)) {
+                if (warn) { IPAACA_WARNING("Config: no key '" << key << "', using default value " << default_value) }
+                else { IPAACA_DEBUG("Config: no key '" << key << "', using default value " << default_value) }
+                _messages_delivered.insert(key);
+            }
+        }
+        template<typename T> void config_conversion_failed(const std::string& key, T const& default_value)
+        {
+            if (!_messages_delivered.count(key)) {
+                IPAACA_WARNING("Config: failed conversion for key '" << key << "', using default value " << default_value)
+                _messages_delivered.insert(key);
+            }
+        }
+        bool get_key_and_value(const std::string& line, std::string& key, std::string& value);
+    public:
+        inline std::map<std::string, std::string>::const_iterator data_cbegin() const { return _data.begin(); }
+        inline std::map<std::string, std::string>::const_iterator data_cend() const { return _data.end(); }
+        void populate_from_global_sources();
+        void populate_from_environment();
+        void populate_from_any_conf_files();
+        void populate_from_conf_file(std::fstream& fs);
+        template<typename T> T get_with_default(const std::string& key, T const& default_value) {
+            return get_with_default_internal(key, default_value, false);
+        }
+        template<typename T> T get_with_default_and_warning(const std::string& key, T const& default_value) {
+            return get_with_default_internal(key, default_value, true);
+        }
+        //inline std::map<std::string, std::string>::iterator begin() { return std::map<std::string, std::string>::begin(); }
+        //inline std::map<std::string, std::string>::iterator end() { return std::map<std::string, std::string>::end(); }
+};
+
+Config::ptr get_global_config(bool auto_parse_on_demand=true);
+
+#endif
+