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/build.xml

+<project name="ipaacalib" default="build" basedir=".">
+  <import file="../../hmibuild/build-recurse.xml" />
+</project>

ipaacalib/cpp/CMakeLists.txt

+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 )
+
+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)
+
+		#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(ProtocolBuffers REQUIRED)
+	link_directories(${PROTOBUF_LIBRARY_DIRS})
+	include_directories(${PROTOBUF_INCLUDE_DIRS})
+
+    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)
+
+	# 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)
+
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES})
+
+
+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)
+
+# 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} ${IPAACA_CXX_DEFINES}")
+
+# add include dir for auto-generated headers placed in build/
+include_directories( ${PROJECT_SOURCE_DIR}/build )
+
+# add local include directory
+include_directories( ${PROJECT_SOURCE_DIR}/include )
+# add lib and include directory from pulled dependencies
+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)
+install (
+	TARGETS ipaaca ipaaca-tester-cpp
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION lib
+	ARCHIVE DESTINATION lib
+	)
+install(
+	DIRECTORY include
+	DESTINATION .
+	FILES_MATCHING PATTERN "*.h" PATTERN "*.hh" PATTERN "*.hpp" PATTERN "*.inl"
+	)
+install(
+	FILES build/ipaaca/ipaaca.pb.h
+	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

+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

+<?xml version="1.0" encoding="UTF-8"?>
+<project name="IpaacaCpp"  default="dist">
+   <import file="../../../hmibuild/build.xml" />
+   <target name="check-proto-files">
+      <echo message="Checking whether compiled protobuf files are already present..." />
+      <available file="build/ipaaca/ipaaca.pb.h" property="pb.present"/>
+   </target>
+   <target name="-proto-yes" depends="check-proto-files" if="pb.present">
+      <echo message="Built protobuf files found, skipping compilation" />
+   </target>
+   <target name="-proto-no" depends="check-proto-files" unless="pb.present">
+      <echo message="Compiling protobuf files" />
+      <mkdir dir="${build.dir}/ipaaca" />
+      <exec executable="protoc">
+         <arg value="--proto_path=../proto" />
+         <arg value="../proto/ipaaca.proto" />
+         <arg value="--cpp_out=build/ipaaca/" />
+      </exec>
+  </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

+cmake_minimum_required (VERSION 2.6)
+
+# project name
+project (ipaaca_cpp_example_component)
+
+## use the following line to enable console debug messages in ipaaca
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_DEBUG_MESSAGES")
+
+# find cmake modules locally too
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
+
+find_package(Boost COMPONENTS system filesystem thread regex REQUIRED)
+link_directories(${Boost_LIBRARY_DIRS})
+include_directories(${Boost_INCLUDE_DIRS})
+
+find_package(Protobuf REQUIRED)
+link_directories(${PROTOBUF_LIBRARY_DIRS})
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+
+#set(RSBLIBS rsc rsbcore)
+
+set(LIBS ${LIBS} ipaaca )
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES})
+#${RSBLIBS})
+
+# enhance the default search paths (headers, libs ...)
+set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
+
+# Compiler defines copied from the old build system
+set(CXX_DEFINES "-D_BSD_SOURCE -DUSE_AV -DMGC_USE_DOUBLE -DLEDA_PREFIX -D__NO_CAST_TO_LOCAL_TYPE__ -DDBGLVL=0")
+if (DEFINED APPLE)
+	message(STATUS "Adding extra options for building on Mac OS X")
+	set(CXX_DEFINES "${CXX_DEFINES} -D__MACOSX__")
+	link_directories( /opt/local/lib )
+	include_directories( /opt/local/include )
+endif(DEFINED APPLE)
+
+# Combine the extra compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_DEFINES}")
+
+# add local include directory
+include_directories( ${PROJECT_SOURCE_DIR}/include )
+
+# add lib and include directory from pulled dependencies
+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
+	src/example-component.cc
+	)
+
+add_executable(example-component ${SOURCE})
+target_link_libraries(example-component ${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 example-component
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION lib
+	ARCHIVE DESTINATION lib
+	)
+

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)
+//
+// *****************************
+// ***                       ***
+// ***   C++ usage example   ***
+// ***                       ***
+// *****************************
+//
+// Example class highlighting the use of the C++ interface
+// to ipaaca2. This class uses a setup similar to an ipaaca1
+// 'Component' (the concept does not exist anymore in ipaaca2).
+//
+
+#include <ipaaca/ipaaca.h>
+#include <typeinfo>
+
+using namespace ipaaca;
+
+/// Test component for ipaaca2
+///  The interface is much more flexible than in ipaaca1.
+///  This example class provides an interface similar to ipaaca1.
+class LegacyComponent {
+	protected:
+		/// Make a buffer pair, as in ipaaca1.
+		///  NOTE1: This is no longer a restriction. You can have
+		///  multiple buffers, no input buffer, etc.
+		///  NOTE2: Most objects are referred to using smart pointers
+		///    using the type name <className>::ptr - don't use '*'
+		OutputBuffer::ptr _out_buf;
+		InputBuffer::ptr  _in_buf;
+	public:
+		/// Constructor to set up the component
+		LegacyComponent();
+		/// IU event handler function. Can be a member function,
+		///   a static function, anything. Use boost::bind on registration.
+		///   NOTE1: you can register any number of handlers on any Buffer.
+		///   NOTE2: this example function has the appropriate signature.
+		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();
+};
+
+LegacyComponent::LegacyComponent() {
+	/// First create the buffer pair
+	///  Create an output buffer
+	_out_buf = OutputBuffer::create("MyOutputBuffer");
+	///  Create an input buffer with category interest
+	///    NOTE: You can pass up to four categories as strings
+	//       to the constructor, or use an std::vector<std::string>
+	_in_buf = InputBuffer::create("MyInputBuffer", "myCategoryInterest");
+	
+	/// Now register the IU handler on both buffers.
+	///   NOTE1: we could register separate handlers instead.
+	///   NOTE2: boost::bind enables use of simple closures:
+	///     You could specify constants for the handler function, as long as the
+	///      remaining open arguments form the correct signature for IU handlers.
+	///      ** If you simply want to use a class member function, use it as below **
+	///    NOTE3: the Buffers are 'live' immediately on creation. As soon as
+	///      you connect a handler, it can be triggered (no backend connect etc.).
+	///      If this is not what you want, you should set a flag when you are
+	///      ready to actually start, and have the handlers honor that flag.
+	_out_buf->register_handler(boost::bind(&LegacyComponent::handle_iu_event, this, _1, _2, _3));
+	_in_buf->register_handler(boost::bind(&LegacyComponent::handle_iu_event, this, _1, _2, _3));
+}
+
+void LegacyComponent::handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+{
+	if (local) {
+		std::cout << "[Received update of self-owned IU]" << std::endl;
+		// could do processing here to cope with remote change of own IU
+	
+	} else {
+		// event on a remote IU
+		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)
+			std::string description = iu->payload()["description"];
+			double fraction = iu->payload()["fraction"];
+			/// let's also get the grounded-in links
+			std::set<std::string> grin_links = iu->get_links("GRIN");
+			
+			std::cout << "[ Current description: " << description << "]" << std::endl;
+			
+			/// let's also react by emitting an IU ourselves (function below)
+			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;
+			std::string description = iu->payload()["description"];
+			std::cout << "[ Current description: " << description << "]" << std::endl;
+		
+		} else if (event_type == IU_LINKSUPDATED) {
+			std::cout << "[IU links updated.]" << std::endl;
+			
+		} else if (event_type == IU_COMMITTED) {
+			std::cout << "[IU " << iu->uid() << " has been committed to.]" << std::endl;
+		
+		} else if (event_type == IU_RETRACTED) {
+			std::cout << "[IU " << iu->uid() << " has been retracted.]" << std::endl;
+		
+		} else if (event_type == IU_DELETED) {
+			std::cout << "[IU " << iu->uid() << " has been deleted.]" << std::endl;
+		
+		} else {
+			// Possible to stringify the type:
+			std::cout << "[(IU event " << iu_event_type_to_str(event_type) << " " << iu->uid() << ")]" << std::endl;
+		}
+	}
+}
+
+void LegacyComponent::publish_reply_iu(const std::string& text, const std::string& received_iu_uid) {
+	/// create a new IU
+	IU::ptr iu = IU::create( "myResultCategory" );
+	/// Add something to the payload
+	iu->payload()["description"] = "SomeResult";
+	/// Now add a grounded-in link pointing to the IU received before
+	///   There are no limitations to the link group names.
+	///   "GRIN" is a convention for the "grounded-in" function of the GAM.
+	iu->add_link("GRIN", received_iu_uid);
+	/// 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 = Message::create( "myCategoryInterest"); //helloWorld" );
+	iu->payload()["description"] = "Hello world";
+	_out_buf->add(iu);
+}
+
+int main() {
+	std::cout << "Creating buffers..." << std::endl;
+	LegacyComponent compo;
+	sleep(1);
+	std::cout << "Publishing an initial IU..." << std::endl;
+	compo.publish_hello_world();
+	std::cout << "*** Running main loop, press Ctrl-C to cancel... ***" << std::endl;
+	/// NOTE: custom main loop no longer required.
+	while (true) sleep(1);
+}
+