ipaacalib/cpp/test/CMakeLists.txt

+cmake_minimum_required (VERSION 2.6)
+
+# project name
+project (ipaaca_cpp_test)
+
+# use C++11 (starting with proto v2 / ipaaca-c++ release 12)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+## use the following line to enable console debug messages in ipaaca
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIPAACA_DEBUG_MESSAGES")
+
+# find cmake modules locally too
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
+
+find_package(Boost COMPONENTS system filesystem thread regex unit_test_framework REQUIRED)
+link_directories(${Boost_LIBRARY_DIRS})
+include_directories(${Boost_INCLUDE_DIRS})
+
+find_package(Protobuf REQUIRED)
+link_directories(${PROTOBUF_LIBRARY_DIRS})
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+
+# for boost unit_test to create main()
+add_definitions(-DBOOST_TEST_DYN_LINK)
+
+#set(RSBLIBS rsc rsbcore)
+
+set(LIBS ${LIBS} ipaaca )
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES})
+#${RSBLIBS})
+
+# enhance the default search paths (headers, libs ...)
+set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
+
+# Compiler defines copied from the old build system
+set(CXX_DEFINES "-D_BSD_SOURCE -DUSE_AV -DMGC_USE_DOUBLE -DLEDA_PREFIX -D__NO_CAST_TO_LOCAL_TYPE__ -DDBGLVL=0")
+if (DEFINED APPLE)
+	message(STATUS "Adding extra options for building on Mac OS X")
+	set(CXX_DEFINES "${CXX_DEFINES} -D__MACOSX__")
+	link_directories( /opt/local/lib )
+	include_directories( /opt/local/include )
+endif(DEFINED APPLE)
+
+# Combine the extra compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_OLD_CODE_CONVENIENCE_FLAGS} ${CXX_DEFINES}")
+
+# add local include directory
+include_directories( ${PROJECT_SOURCE_DIR}/include )
+
+# add includes and builds from parent dir (ipaaca lib)
+include_directories( ${PROJECT_SOURCE_DIR}/../include )
+include_directories( ${PROJECT_SOURCE_DIR}/../build )
+link_directories( ${PROJECT_SOURCE_DIR}/../build )
+
+# add lib and include directory from pulled dependencies
+include_directories( ${PROJECT_SOURCE_DIR}/../../../deps/include )
+link_directories( ${PROJECT_SOURCE_DIR}/../../../deps/lib )
+
+# specify source files for ipaaca (auto-generated ones are in build/ )
+set (SOURCE
+	src/testipaaca.cc
+	)
+
+# compile all files to "ipaaca" shared library
+add_executable(testipaaca ${SOURCE})
+# and link all the required external libs (found above using find_package etc.)
+target_link_libraries(testipaaca ${LIBS})
+
+set(DEFAULT_BIN_SUBDIR bin)
+set(DEFAULT_LIB_SUBDIR lib)
+set(DEFAULT_DATA_SUBDIR share/data)
+set(DEFAULT_INCLUDE_SUBDIR include)
+set(CMAKE_INSTALL_PREFIX "")
+install (
+	TARGETS testipaaca
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION lib
+	ARCHIVE DESTINATION lib
+	)
+
+
+enable_testing()
+add_test(TestIpaacaCpp testipaaca)
+

ipaacalib/cpp/test/src/.gitignore

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

ipaacalib/cpp/test/src/Makefile

+CONFIG = -DIPAACA_DEBUG_MESSAGES
+#IPAACASOURCES = ../../src/ipaaca.cc ipaaca.pb.cc
+#TEXTSOURCES = ${IPAACASOURCES} testipaaca.cc
+TEXTSOURCES = testipaaca.cc
+CCFLAGS=-I../../build -I../../../../deps/include -I../../../../dist/include -I. -I../../src -I/usr/local/include -I/opt/local/include ${CONFIG}
+BOOSTLIBS = -L/opt/local/lib -lboost_regex-mt -lboost_date_time-mt -lboost_thread-mt 
+PROTOLIBS = -L/opt/local/lib -lprotobuf
+#LIBS = ${BOOSTLIBS} ${PROTOLIBS} -L/usr/local/lib -lrsc -lrsbcore
+LIBS = -L../../../../deps/lib -L../../../../dist/lib -lipaaca
+
+COMPILER = gfilt
+
+all: testipaaca
+	
+
+testipaaca:
+	${COMPILER} ${CCFLAGS} -o testipaaca ${TEXTSOURCES} ${LIBS}
+
+protoc:
+	protoc --proto_path=../../../proto ../../../proto/ipaaca.proto --cpp_out=.
+
+clean:
+	rm -f testipaaca ipaaca.pb.h ipaaca.pb.cc
+
+

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

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

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

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

ipaacalib/cpp/test/src/testipaaca.cc

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2022 Sociable Agents Group
+ *                         CITEC, Bielefeld University   
+ *
+ * http://opensource.cit-ec.de/projects/ipaaca/
+ * http://purl.org/net/ipaaca
+ *
+ * This file may be licensed under the terms of of the
+ * GNU Lesser General Public License Version 3 (the ``LGPL''),
+ * or (at your option) any later version.
+ *
+ * Software distributed under the License is distributed
+ * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied. See the LGPL for the specific language
+ * governing rights and limitations.
+ *
+ * You should have received a copy of the LGPL along with this
+ * program. If not, go to http://www.gnu.org/licenses/lgpl.html
+ * or write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+ *
+ * The development of this software was supported by the
+ * Excellence Cluster EXC 277 Cognitive Interaction Technology.
+ * The Excellence Cluster EXC 277 is a grant of the Deutsche
+ * Forschungsgemeinschaft (DFG) in the context of the German
+ * Excellence Initiative.
+ */
+
+#include <ipaaca/ipaaca.h>
+#include <typeinfo>
+
+#define BOOST_TEST_MODULE TestIpaacaCpp
+#include <boost/test/unit_test.hpp>
+
+using namespace ipaaca;
+
+class TestReceiver {
+	public:
+		InputBuffer::ptr  _ib;
+		std::string received_info;
+		TestReceiver();
+		void inbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
+};
+
+TestReceiver::TestReceiver()
+{
+	_ib = ipaaca::InputBuffer::create("TestReceiver", "cppTestCategory");
+	_ib->register_handler(boost::bind(&TestReceiver::inbuffer_handle_iu_event, this, _1, _2, _3));
+	received_info = "NOTHING RECEIVED YET";
+}
+
+void TestReceiver::inbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+{
+	if (event_type == IU_ADDED) {
+		received_info = (std::string) iu->payload()["word"];
+		{
+			ipaaca::Locker locker(iu->payload());
+			iu->payload()["replyVector"] = std::vector<double> { 1.0, 2.0, 3.0 };
+			iu->payload()["replyComment"] = "OK";
+		}
+	}
+}
+
+
+class TestSender {
+	public:
+		OutputBuffer::ptr _ob;
+		std::vector<double> double_vec;
+		std::string comment;
+		long num_replies;
+		TestSender();
+		void publish_one_message();
+		void outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local);
+};
+
+TestSender::TestSender() {
+	_ob = OutputBuffer::create("TestSender");
+	_ob->register_handler(boost::bind(&TestSender::outbuffer_handle_iu_event, this, _1, _2, _3));
+	comment = "NO COMMENT YET";
+	num_replies = 0;
+}
+
+void TestSender::outbuffer_handle_iu_event(IUInterface::ptr iu, IUEventType event_type, bool local)
+{
+	if (event_type == IU_UPDATED) {
+		num_replies++;
+		double_vec = iu->payload()["replyVector"];
+		comment = (std::string) iu->payload()["replyComment"];
+	}
+}
+
+void TestSender::publish_one_message()
+{
+	ipaaca::IU::ptr iu = ipaaca::IU::create("cppTestCategory");
+	iu->payload()["word"] = "OK";
+	_ob->add(iu);
+}
+
+BOOST_AUTO_TEST_SUITE (testIpaacaCpp)
+
+
+BOOST_AUTO_TEST_CASE( testIpaacaCpp01 )
+{
+	TestSender sender;
+	TestReceiver receiver;
+	std::cout << "Publishing one message and waiting 1s for replies from other module." << std::endl;
+	sender.publish_one_message();
+	sleep(1);
+	std::cout << "Checking for changes." << std::endl;
+	BOOST_CHECK( receiver.received_info == "OK" );
+	BOOST_CHECK( sender.num_replies == 1 );
+	BOOST_CHECK( sender.comment == "OK" );
+	BOOST_CHECK( sender.double_vec.size() == 3 );
+	std::cout << "Complete." << std::endl;
+}
+
+BOOST_AUTO_TEST_SUITE_END( )
+

java/.gitignore → ipaacalib/java/.gitignore

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

java/build.properties → ipaacalib/java/build.properties

 language=java
 resolve.status=beta
 resource.path=
-#resource.path=${shared.repository}/Humanoids;${shared.repository}/3dmodels;${shared.repository}/HMI/HmiElckerlyc/resources;${shared.repository}/logbackconfig;${shared.repository}/shaders;
+publish.resolver=soa.core.repository
 run.jvmargs= -Xms128m -Xmx512m  -Xss5M
 rebuild.list=
+publish.resolver=asap.sftp.publish
+dist.dir=../../dist
+javac.source=1.8
+javac.target=1.8
+

java/build.xml → ipaacalib/java/build.xml.DISABLED

 <?xml version="1.0" encoding="UTF-8"?>
-<project name="IpaacaJava"  default="run">
-   <import file="../../soashared/ant/build.xml" />
+<project name="ipaaca-java"  default="run">
+   <import file="../../../hmibuild/build.xml" />
 
    <target name="-pre-compilation">
      <echo message="Compiling protobuf file" />
@@ -11,4 +11,5 @@
         <arg value="--java_out=generatedsrc/" />
      </exec>
    </target>
+   
 </project>

java/ivy.xml → ipaacalib/java/ivy.xml

-<ivy-module version="2.0">
-   <info organisation="ipaaca" module="ipaaca"/>
-   <configurations>
-      <include file="${ivy.settings.dir}/configurations.xml"/>
-   </configurations>
-   <dependencies>
-      <dependency org="slf4j"   name="slf4j-api"              rev="latest.release"  />
-      <dependency org="google"  name="guava"                  rev="latest.release"  />
-      <dependency org="google"  name="protobuf-java"                  rev="latest.release"  />
-      <dependency org="rsb"  name="rsb"                  rev="latest.release"  />
-   </dependencies>
-</ivy-module>
+<ivy-module version="2.0">
+   <info organisation="ipaaca" module="ipaaca-java"/>
+   <configurations>
+      <include file="${ivy.settings.dir}/configurations.xml"/>
+   </configurations>
+   <dependencies>
+      <dependency org="slf4j"   name="slf4j-api"              rev="latest.release"  />
+      <dependency org="google"  name="guava"                  rev="latest.release"  />
+      <dependency org="google"  name="protobuf-java"          rev="2.6.1"  />
+      <dependency org="rsb"     name="rsb"                    rev="latest.release"  />
+      <dependency org="lombok"  name="lombok"                 rev="latest.release"  />
+      <dependency org="apache"  name="commons-lang"           rev="latest.release"  />
+   </dependencies>
+</ivy-module>

java/src/ipaaca/AbstractIU.java → ipaacalib/java/src/ipaaca/AbstractIU.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
 package ipaaca;
 
+import ipaaca.protobuf.Ipaaca.IU;
 import ipaaca.protobuf.Ipaaca.PayloadItem;
 
 import java.util.ArrayList;
@@ -25,10 +58,13 @@ public abstract class AbstractIU
     protected Payload payload;
     protected String category;
     protected boolean committed = false;
+    protected boolean retracted = false;
     private String uid;
-    protected int revision;
+    protected long revision;
     private boolean readOnly = false;
 
+    public abstract IU.AccessMode getAccessMode();
+    
     protected SetMultimap<String, String> links = HashMultimap.create();
     private final SetMultimap<String, String> EMPTYLINKS = HashMultimap.create();
 
@@ -114,7 +150,7 @@ public abstract class AbstractIU
         this.readOnly = readOnly;
     }
 
-    public void setRevision(int revision)
+    public void setRevision(long revision)
     {
         this.revision = revision;
     }
@@ -154,7 +190,7 @@ public abstract class AbstractIU
         return buffer;
     }
 
-    public int getRevision()
+    public long getRevision()
     {
         return revision;
     }
@@ -169,6 +205,11 @@ public abstract class AbstractIU
         return committed;
     }
 
+    public boolean isRetracted()
+    {
+        return retracted;
+    }
+
     public void setBuffer(Buffer buffer)
     {
         this.buffer = buffer;
@@ -186,6 +227,8 @@ public abstract class AbstractIU
 
     public abstract void commit();
 
+    public abstract void retract();
+
     // XXX: might not be valid for all types of IUs
     public abstract void commit(String writerName);
 
@@ -199,7 +242,7 @@ public abstract class AbstractIU
         List<PayloadItem> items = new ArrayList<PayloadItem>();
         for (Entry<String, String> entry : newPayload.entrySet())
         {
-            PayloadItem item = PayloadItem.newBuilder().setKey(entry.getKey()).setValue(entry.getValue()).setType("") // TODO:default type?
+            PayloadItem item = PayloadItem.newBuilder().setKey(entry.getKey()).setValue(entry.getValue()).setType("STR")
                     .build();
             items.add(item);
         }
@@ -209,6 +252,8 @@ public abstract class AbstractIU
     abstract void setPayload(List<PayloadItem> newItems, String writerName);
 
     abstract void putIntoPayload(String key, String value, String writer);
+    
+    abstract void putIntoPayload(Map<? extends String, ? extends String> newItems, String writer);
 
     abstract void removeFromPayload(Object key, String writer);
 

ipaacalib/java/src/ipaaca/Buffer.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import ipaaca.Initializer;
+
+/**
+ * Base class for InputBuffer and OutputBuffer.
+ */
+public abstract class Buffer
+{
+    private final String owningComponentName;
+
+    private List<IUEventHandler> eventHandlers = new ArrayList<IUEventHandler>();
+    protected final String uuid = UUID.randomUUID().toString().replaceAll("-", "").substring(0, 8);
+    protected String uniqueName;
+
+    public String getUniqueShortName()
+    {
+    	return owningComponentName + "ID" + uuid;
+    }
+
+    public String getUniqueName()
+    {
+        return uniqueName;
+    }
+
+    public String getOwningComponentName()
+    {
+        return owningComponentName;
+    }
+
+    // def __init__(self, owning_component_name, participant_config=None):
+    // '''Create a Buffer.
+    //
+    // Keyword arguments:
+    // owning_compontent_name --
+    // participant_config -- RSB configuration
+    // '''
+    // super(Buffer, self).__init__()
+    // self._owning_component_name = owning_component_name
+    // self._participant_config = participant_config #rsb.ParticipantConfig.fromDefaultSources() if participant_config is None else participant_config
+    // self._uuid = str(uuid.uuid4())[0:8]
+    // # Initialise with a temporary, but already unique, name
+    // self._unique_name = "undef-"+self._uuid
+    // self._iu_store = IUStore()
+    // self._iu_event_handlers = []
+    /**
+     * @param owningComponentName name of the entity that owns this Buffer
+     * @param participantConfig RSB configuration
+     */
+    public Buffer(String owningComponentName)
+    {
+        Initializer.initializeIpaacaRsb();
+        this.owningComponentName = owningComponentName;
+        uniqueName = "undef-" + uuid;
+    }
+
+    // def register_handler(self, handler_function, for_event_types=None, for_categories=None):
+    // """Register a new IU event handler function.
+    //
+    // Keyword arguments:
+    // handler_function -- a function with the signature (IU, event_type, local)
+    // for_event_types -- a list of event types or None if handler should
+    // be called for all event types
+    // for_categories -- a list of category names or None if handler should
+    // be called for all categoires
+    //
+    // """
+    // handler = IUEventHandler(handler_function=handler_function, for_event_types=for_event_types, for_categories=for_categories)
+    // self._iu_event_handlers.append(handler)
+
+    public void registerHandler(IUEventHandler handler)
+    {
+        eventHandlers.add(handler);
+    }
+    
+    public void removeHandler(IUEventHandler handler)
+    {
+        eventHandlers.remove(handler);
+    }
+
+    public void registerHandler(HandlerFunctor func) {
+    	IUEventHandler handler;
+    	handler = new IUEventHandler(func);
+    	registerHandler(handler);
+    }
+
+    public void registerHandler(HandlerFunctor func, Set<String> categories) {
+    	IUEventHandler handler;
+    	handler = new IUEventHandler(func, categories);
+    	registerHandler(handler);
+    }
+
+    public void registerHandler(HandlerFunctor func, EnumSet<IUEventType> eventTypes) {
+    	IUEventHandler handler;
+    	handler = new IUEventHandler(func, eventTypes);
+    	registerHandler(handler);
+    }
+
+    public void registerHandler(HandlerFunctor func, EnumSet<IUEventType> eventTypes, Set<String> categories) {
+    	IUEventHandler handler;
+    	handler = new IUEventHandler(func, eventTypes, categories);
+    	registerHandler(handler);
+    }
+
+    // def call_iu_event_handlers(self, uid, local, event_type, category):
+    // """Call registered IU event handler functions registered for this event_type and category."""
+    // for h in self._iu_event_handlers:
+    // # print('calling an update handler for '+event_type+' -> '+str(h))
+    // h.call(self, uid, local=local, event_type=event_type, category=category)
+    /**
+     * Call registered IU event handler functions registered for this event_type and category.
+     */
+    protected void callIuEventHandlers(String uid, boolean local, IUEventType type, String category)
+    {
+        for (IUEventHandler h : eventHandlers)
+        {
+            h.call(this, uid, local, type, category);
+        }
+    }
+
+    public abstract AbstractIU getIU(String iuid);
+}

ipaacalib/java/src/ipaaca/BufferConfiguration.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+
+import java.util.HashSet;
+import java.util.Set;
+
+
+class BufferConfiguration {
+	String _owningComponentName;
+	Set<String> _category_interests;
+	String _channel;
+	boolean _resendActive;
+	// 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 BufferConfiguration(String owningComponentName) {
+		this._owningComponentName = owningComponentName;
+		this._channel = "default";
+		this._resendActive = false;
+		this._category_interests = new HashSet<String>();
+	}
+
+	public String getOwningComponentName() {
+		return this._owningComponentName;
+	}
+
+	public Set<String> getCategoryInterests() {
+		return this._category_interests;
+	}
+
+	public String getChannel() {
+		return this._channel;
+	}
+
+	public boolean getResendActive() {
+		return this._resendActive;
+	}
+	// public:
+	// 	IPAACA_HEADER_EXPORT inline BufferConfiguration(const std::string basename) { _basename = basename; }
+	// 	IPAACA_HEADER_EXPORT const std::string get_basename() const { return _basename; }
+	// 	IPAACA_HEADER_EXPORT const std::vector<std::string> get_category_interests() const { return _category_interests; }
+	// 	IPAACA_HEADER_EXPORT const std::string get_channel() const { return _channel; }
+
+}

ipaacalib/java/src/ipaaca/BufferConfigurationBuilder.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+
+package ipaaca;
+
+public class BufferConfigurationBuilder extends BufferConfiguration {
+
+	public BufferConfigurationBuilder(String owningComponentName) {
+		super(owningComponentName);
+	}
+
+	public void setOwningComponentName(String owningComponentName) {
+		this._owningComponentName = owningComponentName;
+	}
+
+	public void addCategoryInterest(String category) {
+		this._category_interests.add(category);
+	}
+
+	public void setChannel(String channel) {
+		this._channel = channel;
+	}
+
+	public void setResendActive(boolean resendActive) {
+		this._resendActive = resendActive;
+	}
+
+	public BufferConfiguration getBufferConfiguration() {
+		return this;
+	}
+
+	// public:
+	// 	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_BufferConfiguration() { return *this; }
+}

ipaacalib/java/src/ipaaca/HandlerFunctor.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+public interface HandlerFunctor
+{
+    void handle(AbstractIU iu, IUEventType type, boolean local);
+}

ipaacalib/java/src/ipaaca/IUAccessMode.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+public enum IUAccessMode
+{
+    PUSH, REMOTE, MESSAGE;
+}

ipaacalib/java/src/ipaaca/IUCommittedException.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+/**
+ * Error indicating that an IU is immutable because it has been committed to.
+ * @author hvanwelbergen
+ * 
+ */
+public class IUCommittedException extends RuntimeException
+{
+    private static final long serialVersionUID = 1L;
+    private final AbstractIU iu;
+
+    public AbstractIU getIU()
+    {
+        return iu;
+    }
+
+    public IUCommittedException(AbstractIU iu)
+    {
+        super("Writing to IU " + iu.getUid() + " failed -- it has been committed to.");
+        this.iu = iu;
+    }
+}

java/src/ipaaca/IUConverter.java → ipaacalib/java/src/ipaaca/IUConverter.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
 package ipaaca;
+
 import ipaaca.protobuf.Ipaaca.IU;
 import ipaaca.protobuf.Ipaaca.LinkSet;
 import ipaaca.protobuf.Ipaaca.PayloadItem;
@@ -9,16 +42,16 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Map.Entry;
 
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.SetMultimap;
-import com.google.protobuf.InvalidProtocolBufferException;
-
 import rsb.converter.ConversionException;
 import rsb.converter.Converter;
 import rsb.converter.ConverterSignature;
 import rsb.converter.UserData;
 import rsb.converter.WireContents;
 
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.SetMultimap;
+import com.google.protobuf.InvalidProtocolBufferException;
+
 /**
  * Serializes AbstractIUs into protocolbuffer IUs and vice versa.
  * @author hvanwelbergen
@@ -27,12 +60,12 @@ import rsb.converter.WireContents;
 public class IUConverter implements Converter<ByteBuffer>
 {
     private final ConverterSignature signature;
-    
+
     public IUConverter(ConverterSignature signature)
     {
         this.signature = signature;
     }
-    
+
     @Override
     public ConverterSignature getSignature()
     {
@@ -42,38 +75,28 @@ public class IUConverter implements Converter<ByteBuffer>
     @Override
     public WireContents<ByteBuffer> serialize(Class<?> typeInfo, Object obj) throws ConversionException
     {
-        AbstractIU iua = (AbstractIU)obj;
+        AbstractIU iua = (AbstractIU) obj;
         List<PayloadItem> payloadItems = new ArrayList<PayloadItem>();
-        for(Entry<String, String> entry:iua.getPayload().entrySet())
+        for (Entry<String, String> entry : iua.getPayload().entrySet())
         {
-            payloadItems.add(PayloadItem.newBuilder()
-                    .setKey(entry.getKey())
-                    .setValue(entry.getValue())
-                    .setType("")
-                    .build());
+            payloadItems.add(PayloadItem.newBuilder().setKey(entry.getKey()).setValue(entry.getValue()).setType("STR").build());
         }
-        
+
         List<LinkSet> links = new ArrayList<LinkSet>();
-        for (Entry<String, Collection<String>> entry:iua.getAllLinks().asMap().entrySet())
+        for (Entry<String, Collection<String>> entry : iua.getAllLinks().asMap().entrySet())
         {
             links.add(LinkSet.newBuilder().setType(entry.getKey()).addAllTargets(entry.getValue()).build());
         }
-        
-        IU iu = IU.newBuilder()
-                .setUid(iua.getUid())
-                .setRevision(iua.getRevision())
-                .setCategory(iua.getCategory())
-                .setOwnerName(iua.getOwnerName())
-                .setCommitted(iua.isCommitted())
-                .setAccessMode(IU.AccessMode.PUSH) //TODO for other access modes (also in Python version)
-                .setReadOnly(iua.isReadOnly())
-                .setPayloadType("MAP")
-                .addAllPayload(payloadItems)
-                .addAllLinks(links)
-                .build();
-        return new WireContents<ByteBuffer>(ByteBuffer.wrap(iu.toByteArray()),"ipaaca-iu");        
+
+        IU.AccessMode accessMode = iua.getAccessMode();
+        IU iu = IU.newBuilder().setUid(iua.getUid()).setRevision((int) iua.getRevision()).setCategory(iua.getCategory())
+                .setOwnerName(iua.getOwnerName()).setCommitted(iua.isCommitted()).setAccessMode(accessMode)
+                .setReadOnly(iua.isReadOnly()).setPayloadType("STR").addAllPayload(payloadItems).addAllLinks(links).build();
+        String wireFormat = (accessMode == IU.AccessMode.MESSAGE) ? "ipaaca-messageiu" : "ipaaca-iu";
+        return new WireContents<ByteBuffer>(ByteBuffer.wrap(iu.toByteArray()), wireFormat);
     }
 
+
     @Override
     public UserData<?> deserialize(String wireSchema, ByteBuffer buffer) throws ConversionException
     {
@@ -81,33 +104,51 @@ public class IUConverter implements Converter<ByteBuffer>
         try
         {
             iu = IU.newBuilder().mergeFrom(buffer.array()).build();
+            // If there are rsb buffer read-only issues in some build, use this code instead of the above line:
+            //int size = buffer.capacity();
+            //byte[] array = new byte[size];
+            //buffer.get(array, 0, size);
+            //iu = IU.newBuilder().mergeFrom(array).build();
+
         }
         catch (InvalidProtocolBufferException e)
         {
             throw new RuntimeException(e);
         }
 
-        if(iu.getAccessMode() == IU.AccessMode.PUSH)
+        if (iu.getAccessMode() == IU.AccessMode.PUSH)
         {
             RemotePushIU iuout = new RemotePushIU(iu.getUid());
-            iuout.setCategory(iu.getCategory());
-            iuout.committed = iu.getCommitted();
-            iuout.setOwnerName(iu.getOwnerName());
-            iuout.setRevision(iu.getRevision());
-            iuout.setReadOnly(iu.getReadOnly());            
-            iuout.payload = new Payload(iuout,iu.getPayloadList());            
-            SetMultimap<String, String> links = HashMultimap.create();
-            for(LinkSet ls: iu.getLinksList())
-            {
-                links.putAll(ls.getType(),ls.getTargetsList());
-            }
-            iuout.setLinksLocally(links);
-            return new UserData<RemotePushIU>(iuout, RemotePushIU.class);            
+            copyIU(iu, iuout);
+            return new UserData<RemotePushIU>(iuout, RemotePushIU.class);
+        }
+        else if(iu.getAccessMode() == IU.AccessMode.MESSAGE)
+        {
+            RemoteMessageIU iuout = new RemoteMessageIU(iu.getUid());
+            copyIU(iu,iuout);
+            return new UserData<RemoteMessageIU>(iuout, RemoteMessageIU.class);
         }
         else
         {
-            throw new RuntimeException("We can only handle IUs with access mode 'PUSH' for now!");
+            throw new RuntimeException("Trying to deserialize IU with accesmode: "+iu.getAccessMode()+". " +
+            		"We can only handle IUs with access mode 'PUSH' or 'MESSAGE' for now!");
+        }
+    }
+
+    private void copyIU(IU iu, AbstractIU iuout)
+    {
+        iuout.setCategory(iu.getCategory());
+        iuout.committed = iu.getCommitted();
+        iuout.setOwnerName(iu.getOwnerName());
+        iuout.setRevision(iu.getRevision());
+        iuout.setReadOnly(iu.getReadOnly());
+        iuout.payload = new Payload(iuout, iu.getPayloadList());
+        SetMultimap<String, String> links = HashMultimap.create();
+        for (LinkSet ls : iu.getLinksList())
+        {
+            links.putAll(ls.getType(), ls.getTargetsList());
         }
+        iuout.setLinksLocally(links);
     }
 
 }

ipaacalib/java/src/ipaaca/IUEventHandler.java

+/*
+ * This file is part of IPAACA, the
+ *  "Incremental Processing Architecture
+ *   for Artificial Conversational Agents".  
+ *
+ * Copyright (c) 2009-2013 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.
+ */
+
+package ipaaca;
+
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Wrapper for IU event handling functions.
+ * @author hvanwelbergen
+ */
+public class IUEventHandler
+{
+    private final EnumSet<IUEventType> eventTypes;
+    private Set<String> categories;
+    private final HandlerFunctor handleFunctor;
+
+    // def __init__(self, handler_function, for_event_types=None, for_categories=None):
+    // """Create an IUEventHandler.
+    //
+    // Keyword arguments:
+    // handler_function -- the handler function with the signature
+    // (IU, event_type, local)
+    // for_event_types -- a list of event types or None if handler should
+    // be called for all event types
+    // for_categories -- a list of category names or None if handler should
+    // be called for all categoires
+    // """
+    // super(IUEventHandler, self).__init__()
+    // self._handler_function = handler_function
+    // self._for_event_types = (
+    // None if for_event_types is None else
+    // (for_event_types[:] if hasattr(for_event_types, '__iter__') else [for_event_types]))
+    // self._for_categories = (
+    // None if for_categories is None else
+    // (for_categories[:] if hasattr(for_categories, '__iter__') else [for_categories]))
+    
+    public IUEventHandler(HandlerFunctor func)
+    {
+        this.handleFunctor = func;
+        this.categories = new HashSet<String>();
+        this.eventTypes = EnumSet.allOf(IUEventType.class);
+    }
+    
+    public IUEventHandler(HandlerFunctor func, Set<String> categories)
+    {
+        this.handleFunctor = func;
+        this.categories = categories;
+        this.eventTypes = EnumSet.allOf(IUEventType.class);
+    }
+    
+    public IUEventHandler(HandlerFunctor func, EnumSet<IUEventType> eventTypes)
+    {
+        this.handleFunctor = func;
+        this.eventTypes = eventTypes;
+        this.categories = new HashSet<String>();
+    }
+
+    public IUEventHandler(HandlerFunctor func, EnumSet<IUEventType> eventTypes, Set<String> categories)
+    {
+        this.eventTypes = eventTypes;
+        this.categories = categories;
+        this.handleFunctor = func;
+    }
+
+    // def condition_met(self, event_type, category):
+    // """Check whether this IUEventHandler should be called.
+    //
+    // Keyword arguments:
+    // event_type -- type of the IU event
+    // category -- category of the IU which triggered the event
+    // """
+    // type_condition_met = (self._for_event_types is None or event_type in self._for_event_types)
+    // cat_condition_met = (self._for_categories is None or category in self._for_categories)
+    // return type_condition_met and cat_condition_met
+    /**
+     * Check whether this IUEventHandler should be called.
+     * @param type type of the IU event
+     * @param category category of the IU which triggered the event
+     */
+    private boolean conditionMet(IUEventType type, String category)
+    {
+    	if (this.categories.isEmpty()) { // match any category
+    		return this.eventTypes.contains(type);
+    	}
+    	else
+    	{
+    		return this.eventTypes.contains(type) && this.categories.contains(category);
+    	}
+    }
+
+    // def call(self, buffer, iu_uid, local, event_type, category):
+    // """Call this IUEventHandler's function, if it applies.
+    //
+    // Keyword arguments:
+    // buffer -- the buffer in which the IU is stored
+    // iu_uid -- the uid of the IU
+    // local -- is the IU local or remote to this component? @RAMIN: Is this correct?
+    // event_type -- IU event type
+    // category -- category of the IU
+    // """
+    // if self.condition_met(event_type, category):
+    // iu = buffer._iu_store[iu_uid]
+    // self._handler_function(iu, event_type, local)
+    public void call(Buffer buf, String iuUid, boolean local, IUEventType type, String category)
+    {
+        if (conditionMet(type, category))
+        {
+            AbstractIU iu = buf.getIU(iuUid);
+            handleFunctor.handle(iu, type, local);
+        }
+    }
+}