diff --git a/ipaacalib/cpp/CMakeLists.txt b/ipaacalib/cpp/CMakeLists.txt
index e792a9edfc366c1259f93a8b3d92134622003010..ab6d3fd71a68f06f0d360d6a8df3fb7246baf972 100644
--- a/ipaacalib/cpp/CMakeLists.txt
+++ b/ipaacalib/cpp/CMakeLists.txt
@@ -7,56 +7,87 @@ project (ipaaca_cpp)
 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")
 
 # 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})
-#set(BOOSTLIBS boost_regex-mt boost_date_time-mt boost_program_options-mt boost_thread-mt boost_filesystem-mt boost_signals-mt boost_system-mt)
-
-find_package(Protobuf REQUIRED)
-link_directories(${PROTOBUF_LIBRARY_DIRS})
-include_directories(${PROTOBUF_INCLUDE_DIRS})
-
-##set(PROTOLIBS protobuf)
-#set(RSBLIBS rsc rsbcore)
-
-# add for for each new rsb version
-include_directories( ${PROJECT_SOURCE_DIR}/../../deps/include/rsc0.10 )
-include_directories( ${PROJECT_SOURCE_DIR}/../../deps/include/rsb0.10 )
-# change for each new rsb version
-if (DEFINED APPLE)
-set(RSBLIBS rsc0.10 rsb.0.10)
-else(DEFINED APPLE)
-set(RSBLIBS ${PROJECT_SOURCE_DIR}/../../deps/lib/librsc0.10.so ${PROJECT_SOURCE_DIR}/../../deps/lib/librsb.so.0.10 )
-endif(DEFINED APPLE)
-
-#set(LIBS ${LIBS} ${BOOSTLIBS} ${PROTOLIBS} ${RSBLIBS})
-#set(LIBS ${LIBS} ${PROTOLIBS} ${RSBLIBS})
-set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES} ${RSBLIBS})
-
-if (NOT DEFINED APPLE)
-	set(LIBS ${LIBS} uuid)
-endif(NOT DEFINED APPLE)
+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)
+		#
+		#   set BOOST_ROOT=%YOURREPODIR%\rsx\boost
+		#   set PROTOBUF_INCLUDE_DIR=%YOURREPODIR%\rsx\protobuf\include
+		#
+		#
+		#find_package(Boost COMPONENTS date_time program_options system filesystem thread signals regex REQUIRED)
+		#link_directories(${Boost_LIBRARY_DIRS})
+		#include_directories(${Boost_INCLUDE_DIRS})
+		# overriding the determined libs to remove boost_thread (causes multiple-definition issues)
+		
+		set(Boost_LIBRARIES boost_regex-vc100-mt-gd-1_54 boost_date_time-vc100-mt-gd-1_54 boost_program_options-vc100-mt-gd-1_54 boost_filesystem-vc100-mt-gd-1_54 boost_signals-vc100-mt-gd-1_54 boost_system-vc100-mt-gd-1_54)
+		
+		include_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/boost/include/boost-1_54 )
+		link_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/boost/lib )
+		
+		include_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/RSC-0.11.0-win32/include/rsc0.11 )
+		include_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/RSB-0.11.0-win32/include/rsb0.11 )
+		include_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/protobuf/include )
+		link_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/RSC-0.11.0-win32/lib )
+		link_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/RSB-0.11.0-win32/lib )
+		link_directories( ${PROJECT_SOURCE_DIR}/../../../rsx/protobuf/bin )
+		
+		set(RSBLIBS rsc0.11 rsb)
+		set(PROTOBUF_LIBRARY libprotobuf)
+		set(LIBS ${LIBS} rpcrt4)
+		# boost_regex-vc100-mt-gd-1_54.lib;boost_date_time-vc100-mt-gd-1_54.lib;boost_program_options-vc100-mt-gd-1_54.lib;boost_filesystem-vc100-mt-gd-1_54.lib;boost_signals-vc100-mt-gd-1_54.lib;boost_system-vc100-mt-gd-1_54.lib
+		
+		#	boost_regex-mt boost_date_time-mt boost_program_options-mt boost_thread-mt boost_filesystem-mt boost_signals-mt boost_system-mt
+	else()
+		message(SEND_ERROR "Unsupported compiler! Please build with MSVC (2010).")
+	endif()
+else()
+	#
+	# Setup section for Linux or OS X (using 'rsb' soa project)
+	#
+	find_package(Boost COMPONENTS system filesystem thread regex REQUIRED)
+	link_directories(${Boost_LIBRARY_DIRS})
+	include_directories(${Boost_INCLUDE_DIRS})
+	#set(BOOSTLIBS boost_regex-mt boost_date_time-mt boost_program_options-mt boost_thread-mt boost_filesystem-mt boost_signals-mt boost_system-mt)
+
+	find_package(Protobuf REQUIRED)
+	link_directories(${PROTOBUF_LIBRARY_DIRS})
+	include_directories(${PROTOBUF_INCLUDE_DIRS})
+
+	# add for for each new rsb version
+	include_directories( ${PROJECT_SOURCE_DIR}/../../deps/include/rsc0.10 )
+	include_directories( ${PROJECT_SOURCE_DIR}/../../deps/include/rsb0.10 )
+	# change for each new rsb version
+	if (DEFINED APPLE)
+		set(RSBLIBS rsc0.10 rsb.0.10)
+	else(DEFINED APPLE)
+		set(RSBLIBS ${PROJECT_SOURCE_DIR}/../../deps/lib/librsc0.10.so ${PROJECT_SOURCE_DIR}/../../deps/lib/librsb.so.0.10 )
+		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)
 
-# enhance the default search paths (headers, libs ...)
-set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}:/opt/local:${CMAKE_PREFIX_PATH})
 
-## Ace2 uses deprecated style (non-template friend functions and non-const char*s)
-##  We just hide the warnings here
-#set(CXX_OLD_CODE_CONVENIENCE_FLAGS "-Wno-non-template-friend -Wno-write-strings")
+set(LIBS ${LIBS} ${PROTOBUF_LIBRARY} ${Boost_LIBRARIES} ${RSBLIBS})
 
 # 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}")
diff --git a/ipaacalib/cpp/include/ipaaca/ipaaca.h b/ipaacalib/cpp/include/ipaaca/ipaaca.h
index 057ff191995fcbc14cd4033ba729be485ad828ba..1ed2f2b2700657aeb3f7baace44643699c705d9a 100644
--- a/ipaacalib/cpp/include/ipaaca/ipaaca.h
+++ b/ipaacalib/cpp/include/ipaaca/ipaaca.h
@@ -39,15 +39,43 @@
 #define IPAACA_PROTOCOL_VERSION_MINOR         0
 
 /// running release number of ipaaca-c++
-#define IPAACA_CPP_RELEASE_NUMBER             1
+#define IPAACA_CPP_RELEASE_NUMBER             11
 /// date of last release number increment
-#define IPAACA_CPP_RELEASE_DATE     "2012-09-08"
+#define IPAACA_CPP_RELEASE_DATE     "2014-02-10"
+
+#ifndef __FUNCTION_NAME__
+	#ifdef WIN32   // Windows
+		#define __FUNCTION_NAME__   __FUNCTION__
+	#else          // POSIX
+		#define __FUNCTION_NAME__   __func__
+	#endif
+#endif
+
+#if defined (_WIN32)
+	#if defined(ipaaca_EXPORTS)
+		#define  IPAACA_EXPORT
+// __declspec(dllexport)
+		#define  IPAACA_HEADER_EXPORT __declspec(dllexport)
+		#define  IPAACA_MEMBER_VAR_EXPORT
+// __declspec(dllexport)
+	#else
+		#define  IPAACA_EXPORT
+// __declspec(dllimport)
+		#define  IPAACA_HEADER_EXPORT __declspec(dllimport)
+		#define  IPAACA_MEMBER_VAR_EXPORT
+// __declspec(dllimport)
+	#endif
+#else
+	#define IPAACA_EXPORT
+	#define IPAACA_HEADER_EXPORT
+	#define IPAACA_MEMBER_VAR_EXPORT
+#endif
 
 #ifdef IPAACA_DEBUG_MESSAGES
-#define IPAACA_INFO(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __func__ << "() -- " << i << std::endl;
-#define IPAACA_WARNING(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __func__ << "() -- WARNING: " << i << std::endl;
-#define IPAACA_IMPLEMENT_ME std::cout << __FILE__ << ":" << __LINE__ << ": " << __func__ << "() -- IMPLEMENT ME" << std::endl;
-#define IPAACA_TODO(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __func__ << "() -- TODO: " << i << std::endl;
+#define IPAACA_INFO(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __FUNCTION_NAME__ << "() -- " << i << std::endl;
+#define IPAACA_WARNING(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __FUNCTION_NAME__ << "() -- WARNING: " << i << std::endl;
+#define IPAACA_IMPLEMENT_ME std::cout << __FILE__ << ":" << __LINE__ << ": " << __FUNCTION_NAME__ << "() -- IMPLEMENT ME" << std::endl;
+#define IPAACA_TODO(i) std::cout << __FILE__ << ":" << __LINE__ << ": " << __FUNCTION_NAME__ << "() -- TODO: " << i << std::endl;
 #else
 #define IPAACA_INFO(i) ;
 #define IPAACA_WARNING(i) ;
@@ -60,6 +88,7 @@
 #include <rsb/Factory.h>
 #include <rsb/Handler.h>
 #include <rsb/Event.h>
+#include <rsb/ParticipantConfig.h>
 #include <rsb/converter/Repository.h>
 #include <rsb/converter/ProtocolBufferConverter.h>
 #include <rsb/converter/Converter.h>
@@ -81,7 +110,14 @@
 
 // for logger
 #include <iomanip>
+
+#ifdef WIN32
+// for Windows
+#include <time.h>
+#else
+// for Linux and OS X
 #include <sys/time.h>
+#endif
 
 #ifndef Q_MOC_RUN
 #include <boost/bind.hpp>
@@ -94,9 +130,6 @@
 
 #include <ipaaca/ipaaca.pb.h>
 
-#include <pthread.h>
-#include <uuid/uuid.h>
-
 #include <set>
 
 namespace ipaaca {
@@ -116,7 +149,7 @@ typedef uint32_t IUEventType;
 #define IU_ALL_EVENTS  127
 
 /// Convert an int event type to a human-readable string
-inline std::string iu_event_type_to_str(IUEventType type)
+IPAACA_HEADER_EXPORT inline std::string iu_event_type_to_str(IUEventType type)
 {
 	switch(type) {
 		case IU_ADDED: return "ADDED";
@@ -131,7 +164,7 @@ inline std::string iu_event_type_to_str(IUEventType type)
 }
 
 /// IU access mode: PUSH means that updates are broadcast; REMOTE means that reads are RPC calls; MESSAGE means a fire-and-forget message
-enum IUAccessMode {
+IPAACA_HEADER_EXPORT enum IUAccessMode {
 	IU_ACCESS_PUSH,
 	IU_ACCESS_REMOTE,
 	IU_ACCESS_MESSAGE
@@ -166,144 +199,169 @@ class IULinkUpdateConverter;
 class IntConverter;
 
 /// generate a UUID as an ASCII string
-std::string generate_uuid_string();
+IPAACA_HEADER_EXPORT std::string generate_uuid_string();
 
 /// store for (local) IUs. TODO Stores need to be unified more
-class IUStore: public std::map<std::string, boost::shared_ptr<IU> >
+IPAACA_HEADER_EXPORT class IUStore: public std::map<std::string, boost::shared_ptr<IU> >
 {
 };
 /// store for RemotePushIUs. TODO Stores need to be unified more
-class RemotePushIUStore: public std::map<std::string, boost::shared_ptr<RemotePushIU> > // TODO genericize to all remote IU types
+IPAACA_HEADER_EXPORT class RemotePushIUStore: public std::map<std::string, boost::shared_ptr<RemotePushIU> > // TODO genericize to all remote IU types
 {
 };
 
-class Exception: public std::exception//{{{
+IPAACA_HEADER_EXPORT class Exception: public std::exception//{{{
 {
 	protected:
-		std::string _description;
+		IPAACA_MEMBER_VAR_EXPORT std::string _description;
 	public:
-		inline Exception(const std::string& description=""): _description(description) { }
-		inline ~Exception() throw() { }
-		const char* what() const throw() {
+		IPAACA_HEADER_EXPORT inline Exception(const std::string& description=""): _description(description) { }
+		IPAACA_HEADER_EXPORT inline ~Exception() throw() { }
+		IPAACA_HEADER_EXPORT const char* what() const throw() {
 			return _description.c_str();
 		}
 };//}}}
-class Abort: public std::exception//{{{
+IPAACA_HEADER_EXPORT class Abort: public std::exception//{{{
 {
 	protected:
-		std::string _description;
+		IPAACA_MEMBER_VAR_EXPORT std::string _description;
 	public:
-		inline Abort(const std::string& description=""): _description(description) { }
-		inline ~Abort() throw() { }
-		const char* what() const throw() {
+		IPAACA_HEADER_EXPORT inline Abort(const std::string& description=""): _description(description) { }
+		IPAACA_HEADER_EXPORT inline ~Abort() throw() { }
+		IPAACA_HEADER_EXPORT const char* what() const throw() {
 			return _description.c_str();
 		}
 };//}}}
 
 /// a reentrant lock/mutex
-class Lock
+#ifdef WIN32
+#include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/thread.hpp>
+IPAACA_HEADER_EXPORT class Lock
 {
 	protected:
-		pthread_mutexattr_t _attrs;
-		pthread_mutex_t _mutex;
+		IPAACA_MEMBER_VAR_EXPORT boost::recursive_mutex _mutex;
 	public:
-		inline Lock() {
+		IPAACA_HEADER_EXPORT inline Lock() {
+		}
+		IPAACA_HEADER_EXPORT inline ~Lock() {
+		}
+		IPAACA_HEADER_EXPORT inline void lock() {
+			_mutex.lock();
+		}
+		IPAACA_HEADER_EXPORT inline void unlock() {
+			_mutex.unlock();
+		}
+};
+#else
+#include <pthread.h>
+IPAACA_HEADER_EXPORT class Lock
+{
+	protected:
+		IPAACA_MEMBER_VAR_EXPORT pthread_mutexattr_t _attrs;
+		IPAACA_MEMBER_VAR_EXPORT pthread_mutex_t _mutex;
+	public:
+		IPAACA_HEADER_EXPORT inline Lock() {
 			pthread_mutexattr_init(&_attrs);
 			pthread_mutexattr_settype(&_attrs, PTHREAD_MUTEX_RECURSIVE);
 			pthread_mutex_init(&_mutex, &_attrs);
 		}
-		inline ~Lock() {
+		IPAACA_HEADER_EXPORT inline ~Lock() {
 			pthread_mutex_destroy(&_mutex);
 			pthread_mutexattr_destroy(&_attrs);
 		}
-		inline void lock() {
+		IPAACA_HEADER_EXPORT inline void lock() {
 			pthread_mutex_lock(&_mutex);
 		}
-		inline void unlock() {
+		IPAACA_HEADER_EXPORT inline void unlock() {
 			pthread_mutex_unlock(&_mutex);
 		}
 };
+#endif
 
 /// Stack-based lock holder. Create in a new stack frame
 ///  (i.e.  {}-block) and it will obtain the lock and
 ///  auto-release in on exiting the stack frame.
-class Locker
+IPAACA_HEADER_EXPORT class Locker
 {
 	protected:
-		Lock* _lock;
+		IPAACA_MEMBER_VAR_EXPORT Lock* _lock;
 	private:
-		inline Locker(): _lock(NULL) { } // not available
+		IPAACA_HEADER_EXPORT inline Locker(): _lock(NULL) { } // not available
 	public:
-		inline Locker(Lock& lock): _lock(&lock) {
+		IPAACA_HEADER_EXPORT inline Locker(Lock& lock): _lock(&lock) {
 			//std::cout << "-- Locker: lock" << std::endl;
 			_lock->lock();
 		}
-		inline ~Locker() {
+		IPAACA_HEADER_EXPORT inline ~Locker() {
 			//std::cout << "-- Locker: unlock" << std::endl;
 			_lock->unlock();
 		}
 };
-class PthreadMutexLocker
+
+#ifndef WIN32
+IPAACA_HEADER_EXPORT class PthreadMutexLocker
 {
 	protected:
-		pthread_mutex_t* _lock;
+		IPAACA_MEMBER_VAR_EXPORT pthread_mutex_t* _lock;
 	private:
-		inline PthreadMutexLocker(): _lock(NULL) { } // not available
+		IPAACA_HEADER_EXPORT inline PthreadMutexLocker(): _lock(NULL) { } // not available
 	public:
-		inline PthreadMutexLocker(pthread_mutex_t* lock): _lock(lock) {
+		IPAACA_HEADER_EXPORT inline PthreadMutexLocker(pthread_mutex_t* lock): _lock(lock) {
 			if (!lock) throw Exception("PthreadMutexLocker got a NULL mutex!");
 			pthread_mutex_lock(_lock);
 		}
-		inline ~PthreadMutexLocker() {
+		IPAACA_HEADER_EXPORT inline ~PthreadMutexLocker() {
 			pthread_mutex_unlock(_lock);
 		}
 };
+#endif
 
 typedef std::set<std::string> LinkSet;
 typedef std::map<std::string, LinkSet> LinkMap;
-class SmartLinkMap {
+IPAACA_HEADER_EXPORT class SmartLinkMap {
 	friend std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj);
 	friend class IUInterface;
 	friend class IU;
 	friend class IUConverter;
 	friend class MessageConverter;
 	public:
-		const LinkSet& get_links(const std::string& key);
-		const LinkMap& get_all_links();
+		IPAACA_HEADER_EXPORT const LinkSet& get_links(const std::string& key);
+		IPAACA_HEADER_EXPORT const LinkMap& get_all_links();
 	
 	protected:
-		LinkMap _links;
-		static LinkSet empty_link_set;
-		void _add_and_remove_links(const LinkMap& add, const LinkMap& remove);
-		void _replace_links(const LinkMap& links);
+		IPAACA_MEMBER_VAR_EXPORT LinkMap _links;
+		IPAACA_MEMBER_VAR_EXPORT static LinkSet empty_link_set;
+		IPAACA_HEADER_EXPORT void _add_and_remove_links(const LinkMap& add, const LinkMap& remove);
+		IPAACA_HEADER_EXPORT void _replace_links(const LinkMap& links);
 };
 
-const LinkSet EMPTY_LINK_SET;
+IPAACA_MEMBER_VAR_EXPORT const LinkSet EMPTY_LINK_SET;
 //const std::set<std::string> EMPTY_LINK_SET;
 
 //typedef boost::function<void (const std::string&, bool, IUEventType, const std::string&)> IUEventHandlerFunction;
-typedef boost::function<void (boost::shared_ptr<IUInterface>, IUEventType, bool)> IUEventHandlerFunction;
+IPAACA_HEADER_EXPORT typedef boost::function<void (boost::shared_ptr<IUInterface>, IUEventType, bool)> IUEventHandlerFunction;
 
-class IUEventHandler {
+IPAACA_HEADER_EXPORT class IUEventHandler {
 	protected:
-		IUEventHandlerFunction _function;
-		IUEventType _event_mask;
-		bool _for_all_categories;
-		std::set<std::string> _categories;
+		IPAACA_MEMBER_VAR_EXPORT IUEventHandlerFunction _function;
+		IPAACA_MEMBER_VAR_EXPORT IUEventType _event_mask;
+		IPAACA_MEMBER_VAR_EXPORT bool _for_all_categories;
+		IPAACA_MEMBER_VAR_EXPORT std::set<std::string> _categories;
 	protected:
-		inline bool _condition_met(IUEventType event_type, const std::string& category)
+		IPAACA_HEADER_EXPORT inline bool _condition_met(IUEventType event_type, const std::string& category)
 		{
 			return ((_event_mask&event_type)!=0) && (_for_all_categories || (_categories.count(category)>0));
 		}
 	public:
-		IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category);
-		IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
+		IPAACA_HEADER_EXPORT IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category);
+		IPAACA_HEADER_EXPORT IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
 		//void call(Buffer* buffer, const std::string& uid, bool local, IUEventType event_type, const std::string& category);
-		void call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
+		IPAACA_HEADER_EXPORT void call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
 	typedef boost::shared_ptr<IUEventHandler> ptr;
 };
 
-class Buffer { //: public boost::enable_shared_from_this<Buffer> {//{{{
+IPAACA_HEADER_EXPORT class Buffer { //: public boost::enable_shared_from_this<Buffer> {//{{{
 	friend class IU;
 	friend class RemotePushIU;
 	friend class CallbackIUPayloadUpdate;
@@ -311,183 +369,184 @@ class Buffer { //: public boost::enable_shared_from_this<Buffer> {//{{{
 	friend class CallbackIUCommission;
 	protected:
 		//Lock _handler_lock;
-		std::string _uuid;
-		std::string _basename;
-		std::string _unique_name;
-		std::string _id_prefix;
-		std::vector<IUEventHandler::ptr> _event_handlers;
-	protected:
-		_IPAACA_ABSTRACT_ virtual void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef") = 0;
-		_IPAACA_ABSTRACT_ virtual void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef") = 0;
-		_IPAACA_ABSTRACT_ virtual void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef") = 0;
-		void _allocate_unique_name(const std::string& basename, const std::string& function);
-		inline Buffer(const std::string& basename, const std::string& function) {
+		IPAACA_MEMBER_VAR_EXPORT std::string _uuid;
+		IPAACA_MEMBER_VAR_EXPORT std::string _basename;
+		IPAACA_MEMBER_VAR_EXPORT std::string _unique_name;
+		IPAACA_MEMBER_VAR_EXPORT std::string _id_prefix;
+		IPAACA_MEMBER_VAR_EXPORT std::vector<IUEventHandler::ptr> _event_handlers;
+	protected:
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef") = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef") = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef") = 0;
+		IPAACA_HEADER_EXPORT void _allocate_unique_name(const std::string& basename, const std::string& function);
+		IPAACA_HEADER_EXPORT inline Buffer(const std::string& basename, const std::string& function) {
 			_allocate_unique_name(basename, function);
 		}
-		void call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
+		IPAACA_HEADER_EXPORT void call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category);
 	public:
-		virtual inline ~Buffer() { }
-		inline const std::string& unique_name() { return _unique_name; }
-		void register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
-		void register_handler(IUEventHandlerFunction function, IUEventType event_mask = IU_ALL_EVENTS, const std::string& category="");
+		IPAACA_HEADER_EXPORT virtual inline ~Buffer() { }
+		IPAACA_HEADER_EXPORT inline const std::string& unique_name() { return _unique_name; }
+		IPAACA_HEADER_EXPORT void register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories);
+		IPAACA_HEADER_EXPORT void register_handler(IUEventHandlerFunction function, IUEventType event_mask = IU_ALL_EVENTS, const std::string& category="");
 		//_IPAACA_ABSTRACT_ virtual void add(boost::shared_ptr<IUInterface> iu) = 0;
-		_IPAACA_ABSTRACT_ virtual boost::shared_ptr<IUInterface> get(const std::string& iu_uid) = 0;
-		_IPAACA_ABSTRACT_ virtual std::set<boost::shared_ptr<IUInterface> > get_ius() = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual boost::shared_ptr<IUInterface> get(const std::string& iu_uid) = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual std::set<boost::shared_ptr<IUInterface> > get_ius() = 0;
 };
 //}}}
 
-class OutputBuffer: public Buffer { //, public boost::enable_shared_from_this<OutputBuffer>  {//{{{
+IPAACA_HEADER_EXPORT class OutputBuffer: public Buffer { //, public boost::enable_shared_from_this<OutputBuffer>  {//{{{
 	friend class IU;
 	friend class RemotePushIU;
 	friend class OutputBufferRsbAdaptor;
 	protected:
 	protected:
 		//OutputBufferRsbAdaptor _rsb;
-		IUStore _iu_store;
-		Lock _iu_id_counter_lock;
+		IPAACA_MEMBER_VAR_EXPORT IUStore _iu_store;
+		IPAACA_MEMBER_VAR_EXPORT Lock _iu_id_counter_lock;
 #ifdef IPAACA_EXPOSE_FULL_RSB_API
 	protected:
-		std::map<std::string, rsb::Informer<rsb::AnyType>::Ptr> _informer_store;
-		rsb::patterns::ServerPtr _server;
-		rsb::Informer<rsb::AnyType>::Ptr _get_informer(const std::string& category);
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, rsb::Informer<rsb::AnyType>::Ptr> _informer_store;
+		IPAACA_MEMBER_VAR_EXPORT rsb::patterns::ServerPtr _server;
+		IPAACA_HEADER_EXPORT rsb::Informer<rsb::AnyType>::Ptr _get_informer(const std::string& category);
 #endif
 	protected:
 		// informing functions
-		void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef");
-		void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef");
-		void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name);
+		IPAACA_HEADER_EXPORT void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef");
+		IPAACA_HEADER_EXPORT void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef");
+		IPAACA_HEADER_EXPORT void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name);
 		// remote access functions
 		// _remote_update_links(IULinkUpdate)
 		// _remote_update_payload(IUPayloadUpdate)
 		// _remote_commit(protobuf::IUCommission)
-		void _publish_iu(boost::shared_ptr<IU> iu);
-		void _retract_iu(boost::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT void _publish_iu(boost::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT void _retract_iu(boost::shared_ptr<IU> iu);
 	protected:
-		OutputBuffer(const std::string& basename);
-		void _initialize_server();
+		IPAACA_HEADER_EXPORT OutputBuffer(const std::string& basename);
+		IPAACA_HEADER_EXPORT void _initialize_server();
 	public:
-		static boost::shared_ptr<OutputBuffer> create(const std::string& basename);
-		~OutputBuffer() {
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<OutputBuffer> create(const std::string& basename);
+		IPAACA_HEADER_EXPORT ~OutputBuffer() {
 			IPAACA_IMPLEMENT_ME
 		}
-		void add(boost::shared_ptr<IU> iu);
-		boost::shared_ptr<IU> remove(const std::string& iu_uid);
-		boost::shared_ptr<IU> remove(boost::shared_ptr<IU> iu);
-		boost::shared_ptr<IUInterface> get(const std::string& iu_uid);
-		std::set<boost::shared_ptr<IUInterface> > get_ius();
+		IPAACA_HEADER_EXPORT void add(boost::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<IU> remove(const std::string& iu_uid);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<IU> remove(boost::shared_ptr<IU> iu);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<IUInterface> get(const std::string& iu_uid);
+		IPAACA_HEADER_EXPORT std::set<boost::shared_ptr<IUInterface> > get_ius();
 	typedef boost::shared_ptr<OutputBuffer> ptr;
 };
 //}}}
 
-class InputBuffer: public Buffer { //, public boost::enable_shared_from_this<InputBuffer>  {//{{{
+IPAACA_HEADER_EXPORT class InputBuffer: public Buffer { //, public boost::enable_shared_from_this<InputBuffer>  {//{{{
 	friend class IU;
 	friend class RemotePushIU;
 	friend class InputBufferRsbAdaptor;
 		//InputBufferRsbAdaptor _rsb;
 #ifdef IPAACA_EXPOSE_FULL_RSB_API
 	protected:
-		std::map<std::string, rsb::ListenerPtr> _listener_store;
-		std::map<std::string, rsb::patterns::RemoteServerPtr> _remote_server_store;
-		RemotePushIUStore _iu_store;  // TODO genericize
-		rsb::patterns::RemoteServerPtr _get_remote_server(const std::string& unique_server_name);
-		rsb::ListenerPtr _create_category_listener_if_needed(const std::string& category);
-		void _handle_iu_events(rsb::EventPtr event);
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, rsb::ListenerPtr> _listener_store;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, rsb::patterns::RemoteServerPtr> _remote_server_store;
+		IPAACA_MEMBER_VAR_EXPORT RemotePushIUStore _iu_store;  // TODO genericize
+		IPAACA_HEADER_EXPORT rsb::patterns::RemoteServerPtr _get_remote_server(const std::string& unique_server_name);
+		IPAACA_HEADER_EXPORT rsb::ListenerPtr _create_category_listener_if_needed(const std::string& category);
+		IPAACA_HEADER_EXPORT void _handle_iu_events(rsb::EventPtr event);
 #endif
 	protected:
-		inline void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef")
+		IPAACA_HEADER_EXPORT inline void _send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name="undef")
 		{
 			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_link_update() should never be invoked")
 		}
-		inline void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef")
+		IPAACA_HEADER_EXPORT inline void _send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name="undef")
 		{
 			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_payload_update() should never be invoked")
 		}
-		inline void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef")
+		IPAACA_HEADER_EXPORT inline void _send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name="undef")
 		{
 			IPAACA_WARNING("(ERROR) InputBuffer::_send_iu_commission() should never be invoked")
 		}
 	protected:
-		InputBuffer(const std::string& basename, const std::set<std::string>& category_interests);
-		InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests);
-		InputBuffer(const std::string& basename, const std::string& category_interest1);
-		InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
-		InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
-		InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4);
-	public:
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::set<std::string>& category_interests);
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::vector<std::string>& category_interests);
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1);
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
-		static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4);
-		~InputBuffer() {
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::set<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
+		IPAACA_HEADER_EXPORT InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4);
+	public:
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::set<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::vector<std::string>& category_interests);
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1);
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2);
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3);
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<InputBuffer> create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4);
+		IPAACA_HEADER_EXPORT ~InputBuffer() {
 			IPAACA_IMPLEMENT_ME
 		}
-		boost::shared_ptr<IUInterface> get(const std::string& iu_uid);
-		std::set<boost::shared_ptr<IUInterface> > get_ius();
+		IPAACA_HEADER_EXPORT boost::shared_ptr<IUInterface> get(const std::string& iu_uid);
+		IPAACA_HEADER_EXPORT std::set<boost::shared_ptr<IUInterface> > get_ius();
 	typedef boost::shared_ptr<InputBuffer> ptr;
 };
 //}}}
 
-class IUPayloadUpdate {//{{{
+IPAACA_HEADER_EXPORT class IUPayloadUpdate {//{{{
 	public:
-		std::string uid;
-		revision_t revision;
-		std::string writer_name;
-		bool is_delta;
-		std::map<std::string, std::string> new_items;
-		std::vector<std::string> keys_to_remove;
+		IPAACA_MEMBER_VAR_EXPORT std::string uid;
+		IPAACA_MEMBER_VAR_EXPORT revision_t revision;
+		IPAACA_MEMBER_VAR_EXPORT std::string writer_name;
+		IPAACA_MEMBER_VAR_EXPORT bool is_delta;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> new_items;
+		IPAACA_MEMBER_VAR_EXPORT std::vector<std::string> keys_to_remove;
 	friend std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj);
 	typedef boost::shared_ptr<IUPayloadUpdate> ptr;
 };//}}}
 
-class IULinkUpdate {//{{{
+IPAACA_HEADER_EXPORT class IULinkUpdate {//{{{
 	public:
-		std::string uid;
-		revision_t revision;
-		std::string writer_name;
-		bool is_delta;
-		std::map<std::string, std::set<std::string> > new_links;
-		std::map<std::string, std::set<std::string> > links_to_remove;
+		IPAACA_MEMBER_VAR_EXPORT std::string uid;
+		IPAACA_MEMBER_VAR_EXPORT revision_t revision;
+		IPAACA_MEMBER_VAR_EXPORT std::string writer_name;
+		IPAACA_MEMBER_VAR_EXPORT bool is_delta;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::set<std::string> > new_links;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::set<std::string> > links_to_remove;
 	friend std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj);
 	typedef boost::shared_ptr<IULinkUpdate> ptr;
 };//}}}
 
 
 
-class Initializer
+IPAACA_HEADER_EXPORT class Initializer
 {
 	public:
-		static void initialize_ipaaca_rsb_if_needed();
-		static void initialize_updated_default_config();
-		static bool initialized();
+		IPAACA_HEADER_EXPORT static void initialize_ipaaca_rsb_if_needed();
+		IPAACA_HEADER_EXPORT static void initialize_updated_default_config();
+		IPAACA_HEADER_EXPORT static bool initialized();
+		IPAACA_HEADER_EXPORT static void dump_current_default_config();
 	protected:
-		static bool _initialized;
+		IPAACA_MEMBER_VAR_EXPORT static bool _initialized;
 };
 
-class PayloadEntryProxy//{{{
+IPAACA_HEADER_EXPORT class PayloadEntryProxy//{{{
 {
 	protected:
-		Payload* _payload;
-		std::string _key;
-	public:
-		PayloadEntryProxy(Payload* payload, const std::string& key);
-		PayloadEntryProxy& operator=(const std::string& value);
-		PayloadEntryProxy& operator=(const char* value);
-		PayloadEntryProxy& operator=(double value);
-		PayloadEntryProxy& operator=(bool value);
-		operator std::string();
-		operator long();
-		operator double();
-		operator bool();
-		inline std::string to_str() { return operator std::string(); }
+		IPAACA_MEMBER_VAR_EXPORT Payload* _payload;
+		IPAACA_MEMBER_VAR_EXPORT std::string _key;
+	public:
+		IPAACA_HEADER_EXPORT PayloadEntryProxy(Payload* payload, const std::string& key);
+		IPAACA_HEADER_EXPORT PayloadEntryProxy& operator=(const std::string& value);
+		IPAACA_HEADER_EXPORT PayloadEntryProxy& operator=(const char* value);
+		IPAACA_HEADER_EXPORT PayloadEntryProxy& operator=(double value);
+		IPAACA_HEADER_EXPORT PayloadEntryProxy& operator=(bool value);
+		IPAACA_HEADER_EXPORT operator std::string();
+		IPAACA_HEADER_EXPORT operator long();
+		IPAACA_HEADER_EXPORT operator double();
+		IPAACA_HEADER_EXPORT operator bool();
+		IPAACA_HEADER_EXPORT inline std::string to_str() { return operator std::string(); }
 		//inline long to_int() { return operator long(); }
-		inline long to_long() { return operator long(); }
-		inline double to_float() { return operator double(); }
-		inline bool to_bool() { return operator bool(); }
+		IPAACA_HEADER_EXPORT inline long to_long() { return operator long(); }
+		IPAACA_HEADER_EXPORT inline double to_float() { return operator double(); }
+		IPAACA_HEADER_EXPORT inline bool to_bool() { return operator bool(); }
 };//}}}
 
-class Payload//{{{
+IPAACA_HEADER_EXPORT class Payload//{{{
 {
 	friend std::ostream& operator<<(std::ostream& os, const Payload& obj);
 	friend class IUInterface;
@@ -499,99 +558,99 @@ class Payload//{{{
 	friend class MessageConverter;
 	friend class CallbackIUPayloadUpdate;
 	protected:
-		std::string _owner_name;
-		std::map<std::string, std::string> _store;
-		boost::weak_ptr<IUInterface> _iu;
-	protected:
-		void initialize(boost::shared_ptr<IUInterface> iu);
-		inline void _set_owner_name(const std::string& name) { _owner_name = name; }
-		void _remotely_enforced_wipe();
-		void _remotely_enforced_delitem(const std::string& k);
-		void _remotely_enforced_setitem(const std::string& k, const std::string& v);
-		void _internal_replace_all(const std::map<std::string, std::string>& new_contents, const std::string& writer_name="");
-		void _internal_merge(const std::map<std::string, std::string>& contents_to_merge, const std::string& writer_name="");
-		void _internal_set(const std::string& k, const std::string& v, const std::string& writer_name="");
-		void _internal_remove(const std::string& k, const std::string& writer_name="");
-	public:
-		inline const std::string& owner_name() { return _owner_name; }
+		IPAACA_MEMBER_VAR_EXPORT std::string _owner_name;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> _store;
+		IPAACA_MEMBER_VAR_EXPORT boost::weak_ptr<IUInterface> _iu;
+	protected:
+		IPAACA_HEADER_EXPORT void initialize(boost::shared_ptr<IUInterface> iu);
+		IPAACA_HEADER_EXPORT inline void _set_owner_name(const std::string& name) { _owner_name = name; }
+		IPAACA_HEADER_EXPORT void _remotely_enforced_wipe();
+		IPAACA_HEADER_EXPORT void _remotely_enforced_delitem(const std::string& k);
+		IPAACA_HEADER_EXPORT void _remotely_enforced_setitem(const std::string& k, const std::string& v);
+		IPAACA_HEADER_EXPORT void _internal_replace_all(const std::map<std::string, std::string>& new_contents, const std::string& writer_name="");
+		IPAACA_HEADER_EXPORT void _internal_merge(const std::map<std::string, std::string>& contents_to_merge, const std::string& writer_name="");
+		IPAACA_HEADER_EXPORT void _internal_set(const std::string& k, const std::string& v, const std::string& writer_name="");
+		IPAACA_HEADER_EXPORT void _internal_remove(const std::string& k, const std::string& writer_name="");
+	public:
+		IPAACA_HEADER_EXPORT inline const std::string& owner_name() { return _owner_name; }
 		// access
-		PayloadEntryProxy operator[](const std::string& key);
-		operator std::map<std::string, std::string>();
-		inline void set(const std::map<std::string, std::string>& all_elems) { _internal_replace_all(all_elems); }
-		inline void set(const std::string& k, const std::string& v) { _internal_set(k, v); }
-		inline void merge(const std::map<std::string, std::string>& elems_to_merge) { _internal_merge(elems_to_merge); }
-		inline void remove(const std::string& k) { _internal_remove(k); }
-		std::string get(const std::string& k);
+		IPAACA_HEADER_EXPORT PayloadEntryProxy operator[](const std::string& key);
+		IPAACA_HEADER_EXPORT operator std::map<std::string, std::string>();
+		IPAACA_HEADER_EXPORT inline void set(const std::map<std::string, std::string>& all_elems) { _internal_replace_all(all_elems); }
+		IPAACA_HEADER_EXPORT inline void set(const std::string& k, const std::string& v) { _internal_set(k, v); }
+		IPAACA_HEADER_EXPORT inline void merge(const std::map<std::string, std::string>& elems_to_merge) { _internal_merge(elems_to_merge); }
+		IPAACA_HEADER_EXPORT inline void remove(const std::string& k) { _internal_remove(k); }
+		IPAACA_HEADER_EXPORT std::string get(const std::string& k);
 	typedef boost::shared_ptr<Payload> ptr;
 };//}}}
 
-class IUInterface {//{{{
+IPAACA_HEADER_EXPORT class IUInterface {//{{{
 	friend class IUConverter;
 	friend class MessageConverter;
 	friend std::ostream& operator<<(std::ostream& os, const IUInterface& obj);
 	protected:
-		IUInterface();
+		IPAACA_HEADER_EXPORT IUInterface();
 	public:
-		inline virtual ~IUInterface() { }
+		IPAACA_HEADER_EXPORT inline virtual ~IUInterface() { }
 	protected:
-		std::string _uid;
-		revision_t _revision;
-		std::string _category;
-		std::string _payload_type; // default is "MAP"
-		std::string _owner_name;
-		bool _committed;
-		bool _retracted;
-		IUAccessMode _access_mode;
-		bool _read_only;
+		IPAACA_MEMBER_VAR_EXPORT std::string _uid;
+		IPAACA_MEMBER_VAR_EXPORT revision_t _revision;
+		IPAACA_MEMBER_VAR_EXPORT std::string _category;
+		IPAACA_MEMBER_VAR_EXPORT std::string _payload_type; // default is "MAP"
+		IPAACA_MEMBER_VAR_EXPORT std::string _owner_name;
+		IPAACA_MEMBER_VAR_EXPORT bool _committed;
+		IPAACA_MEMBER_VAR_EXPORT bool _retracted;
+		IPAACA_MEMBER_VAR_EXPORT IUAccessMode _access_mode;
+		IPAACA_MEMBER_VAR_EXPORT bool _read_only;
 		//boost::shared_ptr<Buffer> _buffer;
-		Buffer* _buffer;
-		SmartLinkMap _links;
+		IPAACA_MEMBER_VAR_EXPORT Buffer* _buffer;
+		IPAACA_MEMBER_VAR_EXPORT SmartLinkMap _links;
 	protected:
 		friend class Payload;
 		// Internal functions that perform the update logic,
 		//  e.g. sending a notification across the network
-		_IPAACA_ABSTRACT_ virtual void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name) = 0;
-		_IPAACA_ABSTRACT_ virtual void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name) = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name) = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name) = 0;
 		//void _set_buffer(boost::shared_ptr<Buffer> buffer);
-		void _associate_with_buffer(Buffer* buffer);
-		void _set_buffer(Buffer* buffer);
-		void _set_uid(const std::string& uid);
-		void _set_owner_name(const std::string& owner_name);
+		IPAACA_HEADER_EXPORT void _associate_with_buffer(Buffer* buffer);
+		IPAACA_HEADER_EXPORT void _set_buffer(Buffer* buffer);
+		IPAACA_HEADER_EXPORT void _set_uid(const std::string& uid);
+		IPAACA_HEADER_EXPORT void _set_owner_name(const std::string& owner_name);
 	protected:
 		// internal functions that do not emit update events
-		inline void _add_and_remove_links(const LinkMap& add, const LinkMap& remove) { _links._add_and_remove_links(add, remove); }
-		inline void _replace_links(const LinkMap& links) { _links._replace_links(links); }
-	public:
-		inline bool is_published() { return (_buffer != 0); }
-		inline const std::string& uid() const { return _uid; }
-		inline revision_t revision() const { return _revision; }
-		inline const std::string& category() const { return _category; }
-		inline const std::string& payload_type() const { return _payload_type; }
-		inline const std::string& owner_name() const { return _owner_name; }
-		inline bool committed() const { return _committed; }
-		inline IUAccessMode access_mode() const { return _access_mode; }
-		inline bool read_only() const { return _read_only; }
+		IPAACA_HEADER_EXPORT inline void _add_and_remove_links(const LinkMap& add, const LinkMap& remove) { _links._add_and_remove_links(add, remove); }
+		IPAACA_HEADER_EXPORT inline void _replace_links(const LinkMap& links) { _links._replace_links(links); }
+	public:
+		IPAACA_HEADER_EXPORT inline bool is_published() { return (_buffer != 0); }
+		IPAACA_HEADER_EXPORT inline const std::string& uid() const { return _uid; }
+		IPAACA_HEADER_EXPORT inline revision_t revision() const { return _revision; }
+		IPAACA_HEADER_EXPORT inline const std::string& category() const { return _category; }
+		IPAACA_HEADER_EXPORT inline const std::string& payload_type() const { return _payload_type; }
+		IPAACA_HEADER_EXPORT inline const std::string& owner_name() const { return _owner_name; }
+		IPAACA_HEADER_EXPORT inline bool committed() const { return _committed; }
+		IPAACA_HEADER_EXPORT inline IUAccessMode access_mode() const { return _access_mode; }
+		IPAACA_HEADER_EXPORT inline bool read_only() const { return _read_only; }
 		//inline boost::shared_ptr<Buffer> buffer() { return _buffer; }
-		inline Buffer* buffer() const { return _buffer; }
-		inline const LinkSet& get_links(std::string type) { return _links.get_links(type); }
-		inline const LinkMap& get_all_links() { return _links.get_all_links(); }
+		IPAACA_HEADER_EXPORT inline Buffer* buffer() const { return _buffer; }
+		IPAACA_HEADER_EXPORT inline const LinkSet& get_links(std::string type) { return _links.get_links(type); }
+		IPAACA_HEADER_EXPORT inline const LinkMap& get_all_links() { return _links.get_all_links(); }
 		// Payload
-		_IPAACA_ABSTRACT_ virtual Payload& payload() = 0;
-		_IPAACA_ABSTRACT_ virtual const Payload& const_payload() const = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual Payload& payload() = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual const Payload& const_payload() const = 0;
 		// setters
-		_IPAACA_ABSTRACT_ virtual void commit() = 0;
+		IPAACA_HEADER_EXPORT _IPAACA_ABSTRACT_ virtual void commit() = 0;
 		// functions to modify and update links:
-		void add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name = "");
-		void remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name = "");
-		void modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name = "");
-		void set_links(const LinkMap& links, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void set_links(const LinkMap& links, const std::string& writer_name = "");
 		//    (with cpp specific convenience functions:)
-		void add_link(const std::string& type, const std::string& target, const std::string& writer_name = "");
-		void remove_link(const std::string& type, const std::string& target, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void add_link(const std::string& type, const std::string& target, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void remove_link(const std::string& type, const std::string& target, const std::string& writer_name = "");
 	typedef boost::shared_ptr<IUInterface> ptr;
 };//}}}
 
-class IU: public IUInterface {//{{{
+IPAACA_HEADER_EXPORT class IU: public IUInterface {//{{{
 	friend class Buffer;
 	friend class InputBuffer;
 	friend class OutputBuffer;
@@ -599,29 +658,29 @@ class IU: public IUInterface {//{{{
 	friend class CallbackIULinkUpdate;
 	friend class CallbackIUCommission;
 	public:
-		Payload _payload;
+		IPAACA_MEMBER_VAR_EXPORT Payload _payload;
 	protected:
-		Lock _revision_lock;
+	   IPAACA_MEMBER_VAR_EXPORT  Lock _revision_lock;
 	protected:
-		inline void _increase_revision_number() { _revision++; }
-		IU(const std::string& category, IUAccessMode access_mode=IU_ACCESS_PUSH, bool read_only=false, const std::string& payload_type="MAP" );
+		IPAACA_HEADER_EXPORT inline void _increase_revision_number() { _revision++; }
+		IPAACA_HEADER_EXPORT IU(const std::string& category, IUAccessMode access_mode=IU_ACCESS_PUSH, bool read_only=false, const std::string& payload_type="MAP" );
 	public:
-		inline ~IU() {
+		IPAACA_HEADER_EXPORT inline ~IU() {
 			//IPAACA_IMPLEMENT_ME
 		}
-		static boost::shared_ptr<IU> create(const std::string& category, IUAccessMode access_mode=IU_ACCESS_PUSH, bool read_only=false, const std::string& payload_type="MAP" );
-		inline Payload& payload() { return _payload; }
-		inline const Payload& const_payload() const { return _payload; }
-		void commit();
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<IU> create(const std::string& category, IUAccessMode access_mode=IU_ACCESS_PUSH, bool read_only=false, const std::string& payload_type="MAP" );
+		IPAACA_HEADER_EXPORT inline Payload& payload() { return _payload; }
+		IPAACA_HEADER_EXPORT inline const Payload& const_payload() const { return _payload; }
+		IPAACA_HEADER_EXPORT void commit();
 	protected:
-		virtual void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
-		virtual void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT virtual void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT virtual void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
 	protected:
-		virtual void _internal_commit(const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT virtual void _internal_commit(const std::string& writer_name = "");
 	public:
 	typedef boost::shared_ptr<IU> ptr;
 };//}}}
-class Message: public IU {//{{{
+IPAACA_HEADER_EXPORT class Message: public IU {//{{{
 	friend class Buffer;
 	friend class InputBuffer;
 	friend class OutputBuffer;
@@ -629,259 +688,267 @@ class Message: public IU {//{{{
 	friend class CallbackIULinkUpdate;
 	friend class CallbackIUCommission;
 	protected:
-		Message(const std::string& category, IUAccessMode access_mode=IU_ACCESS_MESSAGE, bool read_only=true, const std::string& payload_type="MAP" );
+		IPAACA_HEADER_EXPORT Message(const std::string& category, IUAccessMode access_mode=IU_ACCESS_MESSAGE, bool read_only=true, const std::string& payload_type="MAP" );
 	public:
-		inline ~Message() {
+		IPAACA_HEADER_EXPORT inline ~Message() {
 			//IPAACA_IMPLEMENT_ME
 		}
-		static boost::shared_ptr<Message> create(const std::string& category, IUAccessMode access_mode=IU_ACCESS_MESSAGE, bool read_only=true, const std::string& payload_type="MAP" );
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<Message> create(const std::string& category, IUAccessMode access_mode=IU_ACCESS_MESSAGE, bool read_only=true, const std::string& payload_type="MAP" );
 	protected:
-		void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
-		void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
 	protected:
-		void _internal_commit(const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _internal_commit(const std::string& writer_name = "");
 	public:
 	typedef boost::shared_ptr<Message> ptr;
 };//}}}
 
-class RemotePushIU: public IUInterface {//{{{
+IPAACA_HEADER_EXPORT class RemotePushIU: public IUInterface {//{{{
 	friend class Buffer;
 	friend class InputBuffer;
 	friend class OutputBuffer;
 	friend class IUConverter;
 	friend class MessageConverter;
 	public:
-		Payload _payload;
+		IPAACA_MEMBER_VAR_EXPORT Payload _payload;
 	protected:
-		RemotePushIU();
-		static boost::shared_ptr<RemotePushIU> create();
+		IPAACA_HEADER_EXPORT RemotePushIU();
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<RemotePushIU> create();
 	public:
-		inline ~RemotePushIU() {
+		IPAACA_HEADER_EXPORT inline ~RemotePushIU() {
 			//IPAACA_IMPLEMENT_ME
 		}
-		inline Payload& payload() { return _payload; }
-		inline const Payload& const_payload() const { return _payload; }
-		void commit();
+		IPAACA_HEADER_EXPORT inline Payload& payload() { return _payload; }
+		IPAACA_HEADER_EXPORT inline const Payload& const_payload() const { return _payload; }
+		IPAACA_HEADER_EXPORT void commit();
 	protected:
-		void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
-		void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
 	protected:
-		void _apply_update(IUPayloadUpdate::ptr update);
-		void _apply_link_update(IULinkUpdate::ptr update);
-		void _apply_commission();
-		void _apply_retraction();
+		IPAACA_HEADER_EXPORT void _apply_update(IUPayloadUpdate::ptr update);
+		IPAACA_HEADER_EXPORT void _apply_link_update(IULinkUpdate::ptr update);
+		IPAACA_HEADER_EXPORT void _apply_commission();
+		IPAACA_HEADER_EXPORT void _apply_retraction();
 	typedef boost::shared_ptr<RemotePushIU> ptr;
 };//}}}
-class RemoteMessage: public IUInterface {//{{{
+IPAACA_HEADER_EXPORT class RemoteMessage: public IUInterface {//{{{
 	friend class Buffer;
 	friend class InputBuffer;
 	friend class OutputBuffer;
 	friend class IUConverter;
 	friend class MessageConverter;
 	public:
-		Payload _payload;
+		IPAACA_MEMBER_VAR_EXPORT Payload _payload;
 	protected:
-		RemoteMessage();
-		static boost::shared_ptr<RemoteMessage> create();
+		IPAACA_HEADER_EXPORT RemoteMessage();
+		IPAACA_HEADER_EXPORT static boost::shared_ptr<RemoteMessage> create();
 	public:
-		inline ~RemoteMessage() {
+		IPAACA_HEADER_EXPORT inline ~RemoteMessage() {
 			//IPAACA_IMPLEMENT_ME
 		}
-		inline Payload& payload() { return _payload; }
-		inline const Payload& const_payload() const { return _payload; }
-		void commit();
+		IPAACA_HEADER_EXPORT inline Payload& payload() { return _payload; }
+		IPAACA_HEADER_EXPORT inline const Payload& const_payload() const { return _payload; }
+		IPAACA_HEADER_EXPORT void commit();
 	protected:
-		void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
-		void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name = "");
+		IPAACA_HEADER_EXPORT void _modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name = "");
 	protected:
-		void _apply_update(IUPayloadUpdate::ptr update);
-		void _apply_link_update(IULinkUpdate::ptr update);
-		void _apply_commission();
-		void _apply_retraction();
+		IPAACA_HEADER_EXPORT void _apply_update(IUPayloadUpdate::ptr update);
+		IPAACA_HEADER_EXPORT void _apply_link_update(IULinkUpdate::ptr update);
+		IPAACA_HEADER_EXPORT void _apply_commission();
+		IPAACA_HEADER_EXPORT void _apply_retraction();
 	typedef boost::shared_ptr<RemoteMessage> ptr;
 };//}}}
 
-class IUNotFoundError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUNotFoundError: public Exception//{{{
 {
 	public:
-		inline ~IUNotFoundError() throw() { }
-		inline IUNotFoundError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUNotFoundError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUNotFoundError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUNotFoundError";
 		}
 };//}}}
-class IUPublishedError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUPublishedError: public Exception//{{{
 {
 	public:
-		inline ~IUPublishedError() throw() { }
-		inline IUPublishedError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUPublishedError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUPublishedError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUPublishedError";
 		}
 };//}}}
-class IUCommittedError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUCommittedError: public Exception//{{{
 {
 	public:
-		inline ~IUCommittedError() throw() { }
-		inline IUCommittedError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUCommittedError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUCommittedError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUCommittedError";
 		}
 };//}}}
-class IUUpdateFailedError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUUpdateFailedError: public Exception//{{{
 {
 	public:
-		inline ~IUUpdateFailedError() throw() { }
-		inline IUUpdateFailedError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUUpdateFailedError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUUpdateFailedError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUUpdateFailedError";
 		}
 };//}}}
-class IUReadOnlyError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUReadOnlyError: public Exception//{{{
 {
 	public:
-		inline ~IUReadOnlyError() throw() { }
-		inline IUReadOnlyError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUReadOnlyError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUReadOnlyError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUReadOnlyError";
 		}
 };//}}}
-class IUAlreadyInABufferError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUAlreadyInABufferError: public Exception//{{{
 {
 	public:
-		inline ~IUAlreadyInABufferError() throw() { }
-		inline IUAlreadyInABufferError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUAlreadyInABufferError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUAlreadyInABufferError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUAlreadyInABufferError";
 		}
 };//}}}
-class IUAlreadyHasAnUIDError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUAlreadyHasAnUIDError: public Exception//{{{
 {
 	public:
-		inline ~IUAlreadyHasAnUIDError() throw() { }
-		inline IUAlreadyHasAnUIDError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUAlreadyHasAnUIDError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUAlreadyHasAnUIDError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUAlreadyHasAnUIDError";
 		}
 };//}}}
-class IUAlreadyHasAnOwnerNameError: public Exception//{{{
+IPAACA_HEADER_EXPORT class IUAlreadyHasAnOwnerNameError: public Exception//{{{
 {
 	public:
-		inline ~IUAlreadyHasAnOwnerNameError() throw() { }
-		inline IUAlreadyHasAnOwnerNameError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~IUAlreadyHasAnOwnerNameError() throw() { }
+		IPAACA_HEADER_EXPORT inline IUAlreadyHasAnOwnerNameError() { //boost::shared_ptr<IU> iu) {
 			_description = "IUAlreadyHasAnOwnerNameError";
 		}
 };//}}}
-class NotImplementedError: public Exception//{{{
+IPAACA_HEADER_EXPORT class UUIDGenerationError: public Exception//{{{
+{
+	public:
+		IPAACA_HEADER_EXPORT inline ~UUIDGenerationError() throw() { }
+		IPAACA_HEADER_EXPORT inline UUIDGenerationError() { //boost::shared_ptr<IU> iu) {
+			_description = "UUIDGenerationError";
+		}
+};//}}}
+IPAACA_HEADER_EXPORT class NotImplementedError: public Exception//{{{
 {
 	public:
-		inline ~NotImplementedError() throw() { }
-		inline NotImplementedError() { //boost::shared_ptr<IU> iu) {
+		IPAACA_HEADER_EXPORT inline ~NotImplementedError() throw() { }
+		IPAACA_HEADER_EXPORT inline NotImplementedError() { //boost::shared_ptr<IU> iu) {
 			_description = "NotImplementedError";
 		}
 };//}}}
 
 #ifdef IPAACA_EXPOSE_FULL_RSB_API
-class CallbackIUPayloadUpdate: public rsb::patterns::Server::Callback<IUPayloadUpdate, int> {//{{{
+IPAACA_HEADER_EXPORT class CallbackIUPayloadUpdate: public rsb::patterns::Server::Callback<IUPayloadUpdate, int> {//{{{
 	protected:
-		Buffer* _buffer;
+		IPAACA_MEMBER_VAR_EXPORT Buffer* _buffer;
 	public:
-		CallbackIUPayloadUpdate(Buffer* buffer);
-		boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<IUPayloadUpdate> update);
+		IPAACA_HEADER_EXPORT CallbackIUPayloadUpdate(Buffer* buffer);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<IUPayloadUpdate> update);
 };//}}}
-class CallbackIULinkUpdate: public rsb::patterns::Server::Callback<IULinkUpdate, int> {//{{{
+IPAACA_HEADER_EXPORT class CallbackIULinkUpdate: public rsb::patterns::Server::Callback<IULinkUpdate, int> {//{{{
 	protected:
-		Buffer* _buffer;
+		IPAACA_MEMBER_VAR_EXPORT Buffer* _buffer;
 	public:
-		CallbackIULinkUpdate(Buffer* buffer);
+		IPAACA_HEADER_EXPORT CallbackIULinkUpdate(Buffer* buffer);
 	public:
-		boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<IULinkUpdate> update);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<IULinkUpdate> update);
 };//}}}
-class CallbackIUCommission: public rsb::patterns::Server::Callback<protobuf::IUCommission, int> {//{{{
+IPAACA_HEADER_EXPORT class CallbackIUCommission: public rsb::patterns::Server::Callback<protobuf::IUCommission, int> {//{{{
 	protected:
-		Buffer* _buffer;
+		IPAACA_MEMBER_VAR_EXPORT Buffer* _buffer;
 	public:
-		CallbackIUCommission(Buffer* buffer);
+		IPAACA_HEADER_EXPORT CallbackIUCommission(Buffer* buffer);
 	public:
-		boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<protobuf::IUCommission> update);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<protobuf::IUCommission> update);
 };//}}}
-class CallbackIURetraction: public rsb::patterns::Server::Callback<protobuf::IURetraction, int> {//{{{
+IPAACA_HEADER_EXPORT class CallbackIURetraction: public rsb::patterns::Server::Callback<protobuf::IURetraction, int> {//{{{
 	protected:
-		Buffer* _buffer;
+		IPAACA_MEMBER_VAR_EXPORT Buffer* _buffer;
 	public:
-		CallbackIURetraction(Buffer* buffer);
+		IPAACA_HEADER_EXPORT CallbackIURetraction(Buffer* buffer);
 	public:
-		boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<protobuf::IURetraction> update);
+		IPAACA_HEADER_EXPORT boost::shared_ptr<int> call(const std::string& methodName, boost::shared_ptr<protobuf::IURetraction> update);
 };//}}}
 
-class IUConverter: public rsb::converter::Converter<std::string> {//{{{
+IPAACA_HEADER_EXPORT class IUConverter: public rsb::converter::Converter<std::string> {//{{{
 	public:
-		IUConverter();
-		std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
-		rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
+		IPAACA_HEADER_EXPORT IUConverter();
+		IPAACA_HEADER_EXPORT std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
+		IPAACA_HEADER_EXPORT rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
 };//}}}
-class MessageConverter: public rsb::converter::Converter<std::string> {//{{{
+IPAACA_HEADER_EXPORT class MessageConverter: public rsb::converter::Converter<std::string> {//{{{
 	public:
-		MessageConverter();
-		std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
-		rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
+		IPAACA_HEADER_EXPORT MessageConverter();
+		IPAACA_HEADER_EXPORT std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
+		IPAACA_HEADER_EXPORT rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
 };//}}}
-class IUPayloadUpdateConverter: public rsb::converter::Converter<std::string> {//{{{
+IPAACA_HEADER_EXPORT class IUPayloadUpdateConverter: public rsb::converter::Converter<std::string> {//{{{
 	public:
-		IUPayloadUpdateConverter();
-		std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
-		rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
+		IPAACA_HEADER_EXPORT IUPayloadUpdateConverter();
+		IPAACA_HEADER_EXPORT std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
+		IPAACA_HEADER_EXPORT rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
 };//}}}
-class IULinkUpdateConverter: public rsb::converter::Converter<std::string> {//{{{
+IPAACA_HEADER_EXPORT class IULinkUpdateConverter: public rsb::converter::Converter<std::string> {//{{{
 	public:
-		IULinkUpdateConverter();
-		std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
-		rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
+		IPAACA_HEADER_EXPORT IULinkUpdateConverter();
+		IPAACA_HEADER_EXPORT std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
+		IPAACA_HEADER_EXPORT rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
 };//}}}
-class IntConverter: public rsb::converter::Converter<std::string> {//{{{
+IPAACA_HEADER_EXPORT class IntConverter: public rsb::converter::Converter<std::string> {//{{{
 	public:
-		IntConverter();
-		std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
-		rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
+		IPAACA_HEADER_EXPORT IntConverter();
+		IPAACA_HEADER_EXPORT std::string serialize(const rsb::AnnotatedData& data, std::string& wire);
+		IPAACA_HEADER_EXPORT rsb::AnnotatedData deserialize(const std::string& wireSchema, const std::string& wire);
 };//}}}
 #endif
 
 
 // additional misc classes ( Command line options )//{{{
-class CommandLineOptions {
+IPAACA_HEADER_EXPORT class CommandLineOptions {
 	public:
-		inline CommandLineOptions() { }
-		std::map<std::string, std::string> param_opts;
-		std::map<std::string, bool> param_set;
+		IPAACA_HEADER_EXPORT inline CommandLineOptions() { }
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> param_opts;
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, bool> param_set;
 	public:
-		void set_option(const std::string& name, bool expect, const char* optarg);
-		std::string get_param(const std::string& o);
-		bool is_set(const std::string& o);
-		void dump();
+		IPAACA_HEADER_EXPORT void set_option(const std::string& name, bool expect, const char* optarg);
+		IPAACA_HEADER_EXPORT std::string get_param(const std::string& o);
+		IPAACA_HEADER_EXPORT bool is_set(const std::string& o);
+		IPAACA_HEADER_EXPORT void dump();
 	typedef boost::shared_ptr<CommandLineOptions> ptr;
 };
 
 class CommandLineParser {
 	protected:
-		std::map<char, std::string> longopt; // letter->name
-		std::map<std::string, char> shortopt; // letter->name
-		std::map<std::string, bool> options; //  name / expect_param
-		std::map<std::string, std::string> defaults; // for opt params
-		std::map<std::string, int> set_flag; // for paramless opts
+		IPAACA_MEMBER_VAR_EXPORT std::map<char, std::string> longopt; // letter->name
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, char> shortopt; // letter->name
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, bool> options; //  name / expect_param
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, std::string> defaults; // for opt params
+		IPAACA_MEMBER_VAR_EXPORT std::map<std::string, int> set_flag; // for paramless opts
 	protected:
-		CommandLineParser();
+		IPAACA_HEADER_EXPORT CommandLineParser();
 	public:
-		inline ~CommandLineParser() { }
-		static inline boost::shared_ptr<CommandLineParser> create() {
+		IPAACA_HEADER_EXPORT inline ~CommandLineParser() { }
+		IPAACA_HEADER_EXPORT static inline boost::shared_ptr<CommandLineParser> create() {
 			return boost::shared_ptr<CommandLineParser>(new CommandLineParser());
 		}
-		void initialize_parser_defaults();
-		void dump_options();
-		void add_option(const std::string& optname, char shortn, bool expect_param, const std::string& defaultv);
-		void ensure_defaults_in( CommandLineOptions::ptr clo );
-		CommandLineOptions::ptr parse(int argc, char* const* argv);
+		IPAACA_HEADER_EXPORT void initialize_parser_defaults();
+		IPAACA_HEADER_EXPORT void dump_options();
+		IPAACA_HEADER_EXPORT void add_option(const std::string& optname, char shortn, bool expect_param, const std::string& defaultv);
+		IPAACA_HEADER_EXPORT void ensure_defaults_in( CommandLineOptions::ptr clo );
+		IPAACA_HEADER_EXPORT CommandLineOptions::ptr parse(int argc, char* const* argv);
 	typedef boost::shared_ptr<CommandLineParser> ptr;
 };
 //}}}
 
 // additional misc functions ( String splitting / joining )//{{{
-std::string str_join(const std::set<std::string>& set,const std::string& sep);
-std::string str_join(const std::vector<std::string>& vec,const std::string& sep);
-void str_split_wipe(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters );
-void str_split_append(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters );
+IPAACA_HEADER_EXPORT std::string str_join(const std::set<std::string>& set,const std::string& sep);
+IPAACA_HEADER_EXPORT std::string str_join(const std::vector<std::string>& vec,const std::string& sep);
+IPAACA_HEADER_EXPORT void str_split_wipe(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters );
+IPAACA_HEADER_EXPORT void str_split_append(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters );
 //}}}
 
 // (snippets) //{{{
@@ -896,8 +963,15 @@ class IUEventFunctionHandler: public rsb::EventFunctionHandler {
 */
 //}}}
 
-Lock& logger_lock();
+IPAACA_MEMBER_VAR_EXPORT Lock& logger_lock();
+
+#ifdef WIN32
+#define LOG_IPAACA_CONSOLE(msg) { ipaaca::Locker logging_locker(ipaaca::logger_lock()); std::time_t result = std::time(NULL); std::cout << "[LOG] " << std::asctime(std::localtime(&result)) << " : " << msg << std::endl; }
+#else
+// use normal gettimeofday() on POSIX
 #define LOG_IPAACA_CONSOLE(msg) { ipaaca::Locker logging_locker(ipaaca::logger_lock()); timeval logging_tim; gettimeofday(&logging_tim, NULL); double logging_t1=logging_tim.tv_sec+(logging_tim.tv_usec/1000000.0); std::cout << "[LOG] " << std::setprecision(15) << logging_t1 << " : " << msg << std::endl; }
+#endif
+
 
 } // of namespace ipaaca
 
diff --git a/ipaacalib/cpp/src/ipaaca-cmdline-parser.cc b/ipaacalib/cpp/src/ipaaca-cmdline-parser.cc
index 6430d28e21a26880a7d0960a73db9d6117c69c3b..18035dc409e7166a03bceb08d4d96341044f941c 100644
--- a/ipaacalib/cpp/src/ipaaca-cmdline-parser.cc
+++ b/ipaacalib/cpp/src/ipaaca-cmdline-parser.cc
@@ -31,7 +31,10 @@
  */
 
 #include <ipaaca/ipaaca.h>
+
+#ifndef WIN32
 #include <getopt.h>
+#endif
 
 namespace ipaaca {
 
@@ -114,6 +117,10 @@ void CommandLineParser::add_option(const std::string& optname, char shortoptn, b
 
 CommandLineOptions::ptr CommandLineParser::parse(int argc, char* const* argv)
 {
+#ifdef WIN32
+	LOG_IPAACA_CONSOLE("IMPLEMENT ME: command line parsing for Windows. (req'd: getopt)")
+	throw NotImplementedError();
+#else
 	int len = options.size();
 	struct option long_options[len+1];
 	int i=0;
@@ -177,6 +184,7 @@ CommandLineOptions::ptr CommandLineParser::parse(int argc, char* const* argv)
 	}
 	ensure_defaults_in( clo );
 	return clo;
+#endif
 }
 
 void CommandLineParser::ensure_defaults_in( CommandLineOptions::ptr clo )
diff --git a/ipaacalib/cpp/src/ipaaca.cc b/ipaacalib/cpp/src/ipaaca.cc
index 32264161d4abf28389ad35163d07530e1e019916..3f9ee57f34b2d7f54bb676651cdb8d3e72d5805f 100644
--- a/ipaacalib/cpp/src/ipaaca.cc
+++ b/ipaacalib/cpp/src/ipaaca.cc
@@ -32,7 +32,13 @@
 
 #include <ipaaca/ipaaca.h>
 #include <cstdlib>
+
+#ifdef WIN32
+#include <rpc.h>
+#else
+#include <uuid/uuid.h>
 #include <glob.h>
+#endif
 
 namespace ipaaca {
 
@@ -50,21 +56,23 @@ Lock& logger_lock() {
 
 // util and init//{{{
 
-bool Initializer::_initialized = false;
+IPAACA_EXPORT bool Initializer::_initialized = false;
 
 //const LinkSet EMPTY_LINK_SET = LinkSet();
 //const std::set<std::string> EMPTY_LINK_SET();
-bool Initializer::initialized() { return _initialized; }
-void Initializer::initialize_ipaaca_rsb_if_needed()
+IPAACA_EXPORT bool Initializer::initialized() { return _initialized; }
+IPAACA_EXPORT void Initializer::initialize_ipaaca_rsb_if_needed()
 {
 	if (_initialized) return;
-
+	
+	IPAACA_INFO("Calling initialize_updated_default_config()")
 	initialize_updated_default_config();
 
 	// RYT FIXME This configuration stuff has been simply removed in rsb!
 	//ParticipantConfig config = ParticipantConfig::fromConfiguration();
 	//getFactory().setDefaultParticipantConfig(config);
 	
+	IPAACA_INFO("Creating and registering Converters")
 	boost::shared_ptr<IUConverter> iu_converter(new IUConverter());
 	converterRepository<std::string>()->registerConverter(iu_converter);
 	
@@ -86,11 +94,26 @@ void Initializer::initialize_ipaaca_rsb_if_needed()
 	boost::shared_ptr<IntConverter> int_converter(new IntConverter());
 	converterRepository<std::string>()->registerConverter(int_converter);
 	
+	IPAACA_INFO("Initialization complete.")
 	_initialized = true;
 	//IPAACA_TODO("initialize all converters")
 }
 
-void Initializer::initialize_updated_default_config()
+IPAACA_EXPORT void Initializer::dump_current_default_config()
+{
+	IPAACA_INFO("--- Dumping current default participant configuration ---")
+	rsb::ParticipantConfig config = getFactory().getDefaultParticipantConfig();
+	std::set<rsb::ParticipantConfig::Transport> transports = config.getTransports();
+	for (std::set<rsb::ParticipantConfig::Transport>::const_iterator it=transports.begin(); it!=transports.end(); ++it) {
+		IPAACA_INFO( "Active transport: " << it->getName() )
+	}
+	IPAACA_INFO("--- End of configuration dump ---")
+	//ParticipantConfig::Transport inprocess = config.getTransport("inprocess");
+	//inprocess.setEnabled(true);
+	//config.addTransport(inprocess);
+}
+
+IPAACA_EXPORT void Initializer::initialize_updated_default_config()
 {
 	// quick hack to iterate through the pwd parents
 	// and find the closest rsb plugin dir
@@ -98,6 +121,10 @@ void Initializer::initialize_updated_default_config()
 	// but only if not yet defined
 	const char* plugin_path = getenv("RSB_PLUGINS_CPP_PATH");
 	if (!plugin_path) {
+#ifdef WIN32
+		LOG_IPAACA_CONSOLE("WARNING: RSB_PLUGINS_CPP_PATH not set - in Windows it has to be specified.")
+		//throw NotImplementedError();
+#else
 		LOG_IPAACA_CONSOLE("RSB_PLUGINS_CPP_PATH not set; looking here and up to 7 dirs up.")
 		std::string pathstr = "./";
 		for (int i=0; i<   8 /* depth EIGHT (totally arbitrary..) */  ; i++) {
@@ -114,24 +141,46 @@ void Initializer::initialize_updated_default_config()
 			globfree(&g);
 			pathstr += "../";
 		}
+#endif
 	} else {
 		LOG_IPAACA_CONSOLE("RSB_PLUGINS_CPP_PATH already defined: " << plugin_path)
 	}
 }
 
-std::string generate_uuid_string()
+IPAACA_EXPORT std::string generate_uuid_string()
 {
+#ifdef WIN32
+	// Windows
+	UUID uuid;
+	RPC_STATUS stat;
+	stat = UuidCreate(&uuid);
+	if (stat == RPC_S_OK) {
+		unsigned char* uuid_str = NULL;
+		stat = UuidToString(&uuid, &uuid_str);
+		if (stat == RPC_S_OK) {
+			std::string result((const char*) uuid_str, 16);
+			RpcStringFree(&uuid_str);
+			return result;
+		}
+	} else {
+		throw UUIDGenerationError();
+	}
+#else
+	// POSIX
 	uuid_t uuidt;
 	uuid_generate(uuidt);
 #ifdef __MACOSX__
+	//   (Mac)
 	uuid_string_t uuidstr;
 	uuid_unparse_lower(uuidt, uuidstr);
 	return uuidstr;
 #else
+	//   (Linux)
 	char result_c[37];
 	uuid_unparse_lower(uuidt, result_c);
 	return result_c;
 #endif
+#endif
 }
 
 /*
@@ -146,7 +195,7 @@ void init_inprocess_too() {
 */
 //}}}
 
-std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj)//{{{
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj)//{{{
 {
 	os << "{";
 	bool first = true;
@@ -164,7 +213,7 @@ std::ostream& operator<<(std::ostream& os, const SmartLinkMap& obj)//{{{
 	return os;
 }
 //}}}
-std::ostream& operator<<(std::ostream& os, const Payload& obj)//{{{
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const Payload& obj)//{{{
 {
 	os << "{";
 	bool first = true;
@@ -176,7 +225,7 @@ std::ostream& operator<<(std::ostream& os, const Payload& obj)//{{{
 	return os;
 }
 //}}}
-std::ostream& operator<<(std::ostream& os, const IUInterface& obj)//{{{
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IUInterface& obj)//{{{
 {
 	os << "IUInterface(uid='" << obj.uid() << "'";
 	os << ", category='" << obj.category() << "'";
@@ -191,7 +240,7 @@ std::ostream& operator<<(std::ostream& os, const IUInterface& obj)//{{{
 	return os;
 }
 //}}}
-std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj)//{{{
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj)//{{{
 {
 	os << "PayloadUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
 	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
@@ -211,7 +260,7 @@ std::ostream& operator<<(std::ostream& os, const IUPayloadUpdate& obj)//{{{
 	return os;
 }
 //}}}
-std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj)//{{{
+IPAACA_EXPORT std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj)//{{{
 {
 	os << "LinkUpdate(uid=" << obj.uid << ", revision=" << obj.revision;
 	os << ", writer_name=" << obj.writer_name << ", is_delta=" << (obj.is_delta?"True":"False");
@@ -246,8 +295,8 @@ std::ostream& operator<<(std::ostream& os, const IULinkUpdate& obj)//{{{
 
 // SmartLinkMap//{{{
 
-LinkSet SmartLinkMap::empty_link_set;
-void SmartLinkMap::_add_and_remove_links(const LinkMap& add, const LinkMap& remove)
+IPAACA_EXPORT LinkSet SmartLinkMap::empty_link_set;
+IPAACA_EXPORT void SmartLinkMap::_add_and_remove_links(const LinkMap& add, const LinkMap& remove)
 {
 	// remove specified links
 	for (LinkMap::const_iterator it = remove.begin(); it != remove.end(); ++it ) {
@@ -270,25 +319,25 @@ void SmartLinkMap::_add_and_remove_links(const LinkMap& add, const LinkMap& remo
 		}
 	}
 }
-void SmartLinkMap::_replace_links(const LinkMap& links)
+IPAACA_EXPORT void SmartLinkMap::_replace_links(const LinkMap& links)
 {
 	//_links.clear();
 	_links=links;
 }
-const LinkSet& SmartLinkMap::get_links(const std::string& key)
+IPAACA_EXPORT const LinkSet& SmartLinkMap::get_links(const std::string& key)
 {
 	LinkMap::const_iterator it = _links.find(key);
 	if (it==_links.end()) return empty_link_set;
 	return it->second;
 }
-const LinkMap& SmartLinkMap::get_all_links()
+IPAACA_EXPORT const LinkMap& SmartLinkMap::get_all_links()
 {
 	return _links;
 }
 //}}}
 
 // IUEventHandler//{{{
-IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
+IPAACA_EXPORT IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
 : _function(function), _event_mask(event_mask), _for_all_categories(false)
 {
 	if (category=="") {
@@ -297,7 +346,7 @@ IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType even
 		_categories.insert(category);
 	}
 }
-IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
+IPAACA_EXPORT IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
 : _function(function), _event_mask(event_mask), _for_all_categories(false)
 {
 	if (categories.size()==0) {
@@ -306,7 +355,7 @@ IUEventHandler::IUEventHandler(IUEventHandlerFunction function, IUEventType even
 		_categories = categories;
 	}
 }
-void IUEventHandler::call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
+IPAACA_EXPORT void IUEventHandler::call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
 {
 	if (_condition_met(event_type, category)) {
 		//IUInterface::ptr iu = buffer->get(uid);
@@ -324,23 +373,23 @@ void IUEventHandler::call(Buffer* buffer, boost::shared_ptr<IUInterface> iu, boo
 //}}}
 
 // Buffer//{{{
-void Buffer::_allocate_unique_name(const std::string& basename, const std::string& function) {
+IPAACA_EXPORT void Buffer::_allocate_unique_name(const std::string& basename, const std::string& function) {
 	std::string uuid = ipaaca::generate_uuid_string();
 	_basename = basename;
 	_uuid = uuid.substr(0,8);
 	_unique_name = "/ipaaca/component/" + _basename + "ID" + _uuid + "/" + function;
 }
-void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
+IPAACA_EXPORT void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::set<std::string>& categories)
 {
 	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, categories));
 	_event_handlers.push_back(handler);
 }
-void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
+IPAACA_EXPORT void Buffer::register_handler(IUEventHandlerFunction function, IUEventType event_mask, const std::string& category)
 {
 	IUEventHandler::ptr handler = IUEventHandler::ptr(new IUEventHandler(function, event_mask, category));
 	_event_handlers.push_back(handler);
 }
-void Buffer::call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
+IPAACA_EXPORT void Buffer::call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool local, IUEventType event_type, const std::string& category)
 {
 	//IPAACA_INFO("handling an event " << ipaaca::iu_event_type_to_str(event_type) << " for IU " << iu->uid())
 	for (std::vector<IUEventHandler::ptr>::iterator it = _event_handlers.begin(); it != _event_handlers.end(); ++it) {
@@ -350,11 +399,11 @@ void Buffer::call_iu_event_handlers(boost::shared_ptr<IUInterface> iu, bool loca
 //}}}
 
 // Callbacks for OutputBuffer//{{{
-CallbackIUPayloadUpdate::CallbackIUPayloadUpdate(Buffer* buffer): _buffer(buffer) { }
-CallbackIULinkUpdate::CallbackIULinkUpdate(Buffer* buffer): _buffer(buffer) { }
-CallbackIUCommission::CallbackIUCommission(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIUPayloadUpdate::CallbackIUPayloadUpdate(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIULinkUpdate::CallbackIULinkUpdate(Buffer* buffer): _buffer(buffer) { }
+IPAACA_EXPORT CallbackIUCommission::CallbackIUCommission(Buffer* buffer): _buffer(buffer) { }
 
-boost::shared_ptr<int> CallbackIUPayloadUpdate::call(const std::string& methodName, boost::shared_ptr<IUPayloadUpdate> update)
+IPAACA_EXPORT boost::shared_ptr<int> CallbackIUPayloadUpdate::call(const std::string& methodName, boost::shared_ptr<IUPayloadUpdate> update)
 {
 	//std::cout << "-- Received a modify_payload with " << update->new_items.size() << " keys to merge." << std::endl;
 	IUInterface::ptr iui = _buffer->get(update->uid);
@@ -387,7 +436,7 @@ boost::shared_ptr<int> CallbackIUPayloadUpdate::call(const std::string& methodNa
 	return boost::shared_ptr<int>(new int(revision));
 }
 
-boost::shared_ptr<int> CallbackIULinkUpdate::call(const std::string& methodName, boost::shared_ptr<IULinkUpdate> update)
+IPAACA_EXPORT boost::shared_ptr<int> CallbackIULinkUpdate::call(const std::string& methodName, boost::shared_ptr<IULinkUpdate> update)
 {
 	IUInterface::ptr iui = _buffer->get(update->uid);
 	if (! iui) {
@@ -411,7 +460,7 @@ boost::shared_ptr<int> CallbackIULinkUpdate::call(const std::string& methodName,
 	iu->_revision_lock.unlock();
 	return boost::shared_ptr<int>(new int(revision));
 }
-boost::shared_ptr<int> CallbackIUCommission::call(const std::string& methodName, boost::shared_ptr<protobuf::IUCommission> update)
+IPAACA_EXPORT boost::shared_ptr<int> CallbackIUCommission::call(const std::string& methodName, boost::shared_ptr<protobuf::IUCommission> update)
 {
 	IUInterface::ptr iui = _buffer->get(update->uid());
 	if (! iui) {
@@ -440,38 +489,44 @@ boost::shared_ptr<int> CallbackIUCommission::call(const std::string& methodName,
 
 // OutputBuffer//{{{
 
-OutputBuffer::OutputBuffer(const std::string& basename)
+IPAACA_EXPORT OutputBuffer::OutputBuffer(const std::string& basename)
 :Buffer(basename, "OB")
 {
+	IPAACA_INFO("Entering ...")
 	_id_prefix = _basename + "-" + _uuid + "-IU-";
 	_initialize_server();
+	IPAACA_INFO("... exiting.")
 }
-void OutputBuffer::_initialize_server()
+IPAACA_EXPORT void OutputBuffer::_initialize_server()
 {
+	IPAACA_INFO("Entering ...")
+	IPAACA_INFO("Calling createServer(\"" << _unique_name << "\")")
 	_server = getFactory().createServer( Scope( _unique_name ) );
+	IPAACA_INFO("Registering methods")
 	_server->registerMethod("updatePayload", Server::CallbackPtr(new CallbackIUPayloadUpdate(this)));
 	_server->registerMethod("updateLinks", Server::CallbackPtr(new CallbackIULinkUpdate(this)));
 	_server->registerMethod("commit", Server::CallbackPtr(new CallbackIUCommission(this)));
+	IPAACA_INFO("... exiting.")
 }
-OutputBuffer::ptr OutputBuffer::create(const std::string& basename)
+IPAACA_EXPORT OutputBuffer::ptr OutputBuffer::create(const std::string& basename)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return OutputBuffer::ptr(new OutputBuffer(basename));
 }
-IUInterface::ptr OutputBuffer::get(const std::string& iu_uid)
+IPAACA_EXPORT IUInterface::ptr OutputBuffer::get(const std::string& iu_uid)
 {
 	IUStore::iterator it = _iu_store.find(iu_uid);
 	if (it==_iu_store.end()) return IUInterface::ptr();
 	return it->second;
 }
-std::set<IUInterface::ptr> OutputBuffer::get_ius()
+IPAACA_EXPORT std::set<IUInterface::ptr> OutputBuffer::get_ius()
 {
 	std::set<IUInterface::ptr> set;
 	for (IUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second);
 	return set;
 }
 
-void OutputBuffer::_send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void OutputBuffer::_send_iu_link_update(IUInterface* iu, bool is_delta, revision_t revision, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
 {
 	IULinkUpdate* lup = new ipaaca::IULinkUpdate();
 	Informer<ipaaca::IULinkUpdate>::DataPtr ldata(lup);
@@ -487,7 +542,7 @@ void OutputBuffer::_send_iu_link_update(IUInterface* iu, bool is_delta, revision
 	informer->publish(ldata);
 }
 
-void OutputBuffer::_send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void OutputBuffer::_send_iu_payload_update(IUInterface* iu, bool is_delta, revision_t revision, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
 {
 	IUPayloadUpdate* pup = new ipaaca::IUPayloadUpdate();
 	Informer<ipaaca::IUPayloadUpdate>::DataPtr pdata(pup);
@@ -502,7 +557,7 @@ void OutputBuffer::_send_iu_payload_update(IUInterface* iu, bool is_delta, revis
 	informer->publish(pdata);
 }
 
-void OutputBuffer::_send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name)
+IPAACA_EXPORT void OutputBuffer::_send_iu_commission(IUInterface* iu, revision_t revision, const std::string& writer_name)
 {
 	Informer<protobuf::IUCommission>::DataPtr data(new protobuf::IUCommission());
 	data->set_uid(iu->uid());
@@ -514,7 +569,7 @@ void OutputBuffer::_send_iu_commission(IUInterface* iu, revision_t revision, con
 	informer->publish(data);
 }
 
-void OutputBuffer::add(IU::ptr iu)
+IPAACA_EXPORT void OutputBuffer::add(IU::ptr iu)
 {
 	if (_iu_store.count(iu->uid()) > 0) {
 		throw IUPublishedError();
@@ -530,14 +585,14 @@ void OutputBuffer::add(IU::ptr iu)
 	_publish_iu(iu);
 }
 
-void OutputBuffer::_publish_iu(IU::ptr iu)
+IPAACA_EXPORT void OutputBuffer::_publish_iu(IU::ptr iu)
 {
 	Informer<AnyType>::Ptr informer = _get_informer(iu->_category);
 	Informer<ipaaca::IU>::DataPtr iu_data(iu);
 	informer->publish(iu_data);
 }
 
-Informer<AnyType>::Ptr OutputBuffer::_get_informer(const std::string& category)
+IPAACA_EXPORT Informer<AnyType>::Ptr OutputBuffer::_get_informer(const std::string& category)
 {
 	if (_informer_store.count(category) > 0) {
 		return _informer_store[category];
@@ -549,7 +604,7 @@ Informer<AnyType>::Ptr OutputBuffer::_get_informer(const std::string& category)
 		return informer;
 	}
 }
-boost::shared_ptr<IU> OutputBuffer::remove(const std::string& iu_uid)
+IPAACA_EXPORT boost::shared_ptr<IU> OutputBuffer::remove(const std::string& iu_uid)
 {
 	IUStore::iterator it = _iu_store.find(iu_uid);
 	if (it == _iu_store.end()) {
@@ -561,12 +616,12 @@ boost::shared_ptr<IU> OutputBuffer::remove(const std::string& iu_uid)
 	_iu_store.erase(iu_uid);
 	return iu;
 }
-boost::shared_ptr<IU> OutputBuffer::remove(IU::ptr iu)
+IPAACA_EXPORT boost::shared_ptr<IU> OutputBuffer::remove(IU::ptr iu)
 {
 	return remove(iu->uid()); // to make sure it is in the store
 }
 
-void OutputBuffer::_retract_iu(IU::ptr iu)
+IPAACA_EXPORT void OutputBuffer::_retract_iu(IU::ptr iu)
 {
 	Informer<protobuf::IURetraction>::DataPtr data(new protobuf::IURetraction());
 	data->set_uid(iu->uid());
@@ -579,39 +634,39 @@ void OutputBuffer::_retract_iu(IU::ptr iu)
 //}}}
 
 // InputBuffer//{{{
-InputBuffer::InputBuffer(const std::string& basename, const std::set<std::string>& category_interests)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::set<std::string>& category_interests)
 :Buffer(basename, "IB")
 {
 	for (std::set<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
 		_create_category_listener_if_needed(*it);
 	}
 }
-InputBuffer::InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::vector<std::string>& category_interests)
 :Buffer(basename, "IB")
 {
 	for (std::vector<std::string>::const_iterator it=category_interests.begin(); it!=category_interests.end(); ++it) {
 		_create_category_listener_if_needed(*it);
 	}
 }
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1)
 :Buffer(basename, "IB")
 {
 	_create_category_listener_if_needed(category_interest1);
 }
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
 :Buffer(basename, "IB")
 {
 	_create_category_listener_if_needed(category_interest1);
 	_create_category_listener_if_needed(category_interest2);
 }
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
 :Buffer(basename, "IB")
 {
 	_create_category_listener_if_needed(category_interest1);
 	_create_category_listener_if_needed(category_interest2);
 	_create_category_listener_if_needed(category_interest3);
 }
-InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
+IPAACA_EXPORT InputBuffer::InputBuffer(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
 :Buffer(basename, "IB")
 {
 	_create_category_listener_if_needed(category_interest1);
@@ -621,44 +676,44 @@ InputBuffer::InputBuffer(const std::string& basename, const std::string& categor
 }
 
 
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::set<std::string>& category_interests)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::set<std::string>& category_interests)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
 }
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::vector<std::string>& category_interests)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::vector<std::string>& category_interests)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interests));
 }
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interest1));
 }
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2));
 }
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3));
 }
-InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
+IPAACA_EXPORT InputBuffer::ptr InputBuffer::create(const std::string& basename, const std::string& category_interest1, const std::string& category_interest2, const std::string& category_interest3, const std::string& category_interest4)
 {
 	Initializer::initialize_ipaaca_rsb_if_needed();
 	return InputBuffer::ptr(new InputBuffer(basename, category_interest1, category_interest2, category_interest3, category_interest4));
 }
 
-IUInterface::ptr InputBuffer::get(const std::string& iu_uid)
+IPAACA_EXPORT IUInterface::ptr InputBuffer::get(const std::string& iu_uid)
 {
 	RemotePushIUStore::iterator it = _iu_store.find(iu_uid); // TODO genericize
 	if (it==_iu_store.end()) return IUInterface::ptr();
 	return it->second;
 }
-std::set<IUInterface::ptr> InputBuffer::get_ius()
+IPAACA_EXPORT std::set<IUInterface::ptr> InputBuffer::get_ius()
 {
 	std::set<IUInterface::ptr> set;
 	for (RemotePushIUStore::iterator it=_iu_store.begin(); it!=_iu_store.end(); ++it) set.insert(it->second); // TODO genericize
@@ -666,7 +721,7 @@ std::set<IUInterface::ptr> InputBuffer::get_ius()
 }
 
 
-RemoteServerPtr InputBuffer::_get_remote_server(const std::string& unique_server_name)
+IPAACA_EXPORT RemoteServerPtr InputBuffer::_get_remote_server(const std::string& unique_server_name)
 {
 	std::map<std::string, RemoteServerPtr>::iterator it = _remote_server_store.find(unique_server_name);
 	if (it!=_remote_server_store.end()) return it->second;
@@ -675,13 +730,18 @@ RemoteServerPtr InputBuffer::_get_remote_server(const std::string& unique_server
 	return remote_server;
 }
 
-ListenerPtr InputBuffer::_create_category_listener_if_needed(const std::string& category)
+IPAACA_EXPORT ListenerPtr InputBuffer::_create_category_listener_if_needed(const std::string& category)
 {
+	IPAACA_INFO("Entering ...")
 	std::map<std::string, ListenerPtr>::iterator it = _listener_store.find(category);
-	if (it!=_listener_store.end()) return it->second;
-	//IPAACA_INFO("Creating a new listener for category " << category)
+	if (it!=_listener_store.end()) {
+		IPAACA_INFO("... exiting.")
+		return it->second;
+	}
+	IPAACA_INFO("Creating a new listener for category " << category)
 	std::string scope_string = "/ipaaca/category/" + category;
 	ListenerPtr listener = getFactory().createListener( Scope(scope_string) );
+	IPAACA_INFO("Adding handler")
 	HandlerPtr event_handler = HandlerPtr(
 			new EventFunctionHandler(
 				boost::bind(&InputBuffer::_handle_iu_events, this, _1)
@@ -689,19 +749,10 @@ ListenerPtr InputBuffer::_create_category_listener_if_needed(const std::string&
 		);
 	listener->addHandler(event_handler);
 	_listener_store[category] = listener;
+	IPAACA_INFO("... exiting.")
 	return listener;
-	/*
-		'''Return (or create, store and return) a category listener.'''
-		if iu_category in self._listener_store: return self._informer_store[iu_category]
-		cat_listener = rsb.createListener(rsb.Scope("/ipaaca/category/"+str(iu_category)), config=self._participant_config)
-		cat_listener.addHandler(self._handle_iu_events)
-		self._listener_store[iu_category] = cat_listener
-		self._category_interests.append(iu_category)
-		logger.info("Added listener in scope "+"/ipaaca/category/"+iu_category)
-		return cat_listener
-	*/
-}
-void InputBuffer::_handle_iu_events(EventPtr event)
+}
+IPAACA_EXPORT void InputBuffer::_handle_iu_events(EventPtr event)
 {
 	std::string type = event->getType();
 	if (type == "ipaaca::RemotePushIU") {
@@ -799,19 +850,19 @@ void InputBuffer::_handle_iu_events(EventPtr event)
 
 // IUInterface//{{{
 
-IUInterface::IUInterface()
+IPAACA_EXPORT IUInterface::IUInterface()
 : _buffer(NULL), _committed(false), _retracted(false)
 {
 }
 
-void IUInterface::_set_uid(const std::string& uid) {
+IPAACA_EXPORT void IUInterface::_set_uid(const std::string& uid) {
 	if (_uid != "") {
 		throw IUAlreadyHasAnUIDError();
 	}
 	_uid = uid;
 }
 
-void IUInterface::_set_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
+IPAACA_EXPORT void IUInterface::_set_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
 	if (_buffer) {
 		throw IUAlreadyInABufferError();
 	}
@@ -819,7 +870,7 @@ void IUInterface::_set_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buff
 	
 }
 
-void IUInterface::_set_owner_name(const std::string& owner_name) {
+IPAACA_EXPORT void IUInterface::_set_owner_name(const std::string& owner_name) {
 	if (_owner_name != "") {
 		throw IUAlreadyHasAnOwnerNameError();
 	}
@@ -827,14 +878,14 @@ void IUInterface::_set_owner_name(const std::string& owner_name) {
 }
 
 /// set the buffer pointer and the owner names of IU and Payload
-void IUInterface::_associate_with_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
+IPAACA_EXPORT void IUInterface::_associate_with_buffer(Buffer* buffer) { //boost::shared_ptr<Buffer> buffer) {
 	_set_buffer(buffer); // will throw if already set
 	_set_owner_name(buffer->unique_name());
 	payload()._set_owner_name(buffer->unique_name());
 }
 
 /// C++-specific convenience function to add one single link
-void IUInterface::add_link(const std::string& type, const std::string& target, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::add_link(const std::string& type, const std::string& target, const std::string& writer_name)
 {
 	LinkMap none;
 	LinkMap add;
@@ -843,7 +894,7 @@ void IUInterface::add_link(const std::string& type, const std::string& target, c
 	_add_and_remove_links(add, none);
 }
 /// C++-specific convenience function to remove one single link
-void IUInterface::remove_link(const std::string& type, const std::string& target, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::remove_link(const std::string& type, const std::string& target, const std::string& writer_name)
 {
 	LinkMap none;
 	LinkMap remove;
@@ -852,7 +903,7 @@ void IUInterface::remove_link(const std::string& type, const std::string& target
 	_add_and_remove_links(none, remove);
 }
 
-void IUInterface::add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::add_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
 {
 	LinkMap none;
 	LinkMap add;
@@ -861,7 +912,7 @@ void IUInterface::add_links(const std::string& type, const LinkSet& targets, con
 	_add_and_remove_links(add, none);
 }
 
-void IUInterface::remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::remove_links(const std::string& type, const LinkSet& targets, const std::string& writer_name)
 {
 	LinkMap none;
 	LinkMap remove;
@@ -870,13 +921,13 @@ void IUInterface::remove_links(const std::string& type, const LinkSet& targets,
 	_add_and_remove_links(none, remove);
 }
 
-void IUInterface::modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::modify_links(const LinkMap& add, const LinkMap& remove, const std::string& writer_name)
 {
 	_modify_links(true, add, remove, writer_name);
 	_add_and_remove_links(add, remove);
 }
 
-void IUInterface::set_links(const LinkMap& links, const std::string& writer_name)
+IPAACA_EXPORT void IUInterface::set_links(const LinkMap& links, const std::string& writer_name)
 {
 	LinkMap none;
 	_modify_links(false, links, none, writer_name);
@@ -886,14 +937,14 @@ void IUInterface::set_links(const LinkMap& links, const std::string& writer_name
 //}}}
 
 // IU//{{{
-IU::ptr IU::create(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+IPAACA_EXPORT IU::ptr IU::create(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
 {
 	IU::ptr iu = IU::ptr(new IU(category, access_mode, read_only, payload_type)); /* params */ //));
 	iu->_payload.initialize(iu);
 	return iu;
 }
 
-IU::IU(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
+IPAACA_EXPORT IU::IU(const std::string& category, IUAccessMode access_mode, bool read_only, const std::string& payload_type)
 {
 	_revision = 1;
 	_uid = ipaaca::generate_uuid_string();
@@ -905,7 +956,7 @@ IU::IU(const std::string& category, IUAccessMode access_mode, bool read_only, co
 	_committed = false;
 }
 
-void IU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void IU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
 {
 	_revision_lock.lock();
 	if (_committed) {
@@ -918,7 +969,7 @@ void IU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& l
 	}
 	_revision_lock.unlock();
 }
-void IU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void IU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
 {
 	_revision_lock.lock();
 	if (_committed) {
@@ -933,12 +984,12 @@ void IU::_modify_payload(bool is_delta, const std::map<std::string, std::string>
 	_revision_lock.unlock();
 }
 
-void IU::commit()
+IPAACA_EXPORT void IU::commit()
 {
 	_internal_commit();
 }
 
-void IU::_internal_commit(const std::string& writer_name)
+IPAACA_EXPORT void IU::_internal_commit(const std::string& writer_name)
 {
 	_revision_lock.lock();
 	if (_committed) {
@@ -990,17 +1041,17 @@ void Message::_internal_commit(const std::string& writer_name)
 
 // RemotePushIU//{{{
 
-RemotePushIU::ptr RemotePushIU::create()
+IPAACA_EXPORT RemotePushIU::ptr RemotePushIU::create()
 {
 	RemotePushIU::ptr iu = RemotePushIU::ptr(new RemotePushIU(/* params */));
 	iu->_payload.initialize(iu);
 	return iu;
 }
-RemotePushIU::RemotePushIU()
+IPAACA_EXPORT RemotePushIU::RemotePushIU()
 {
 	// nothing
 }
-void RemotePushIU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void RemotePushIU::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
 {
 	if (_committed) {
 		throw IUCommittedError();
@@ -1023,7 +1074,7 @@ void RemotePushIU::_modify_links(bool is_delta, const LinkMap& new_links, const
 		_revision = *result;
 	}
 }
-void RemotePushIU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void RemotePushIU::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
 {
 	//std::cout << "-- Sending a modify_payload with " << new_items.size() << " keys to merge." << std::endl;
 	if (_committed) {
@@ -1048,7 +1099,7 @@ void RemotePushIU::_modify_payload(bool is_delta, const std::map<std::string, st
 	}
 }
 
-void RemotePushIU::commit()
+IPAACA_EXPORT void RemotePushIU::commit()
 {
 	if (_read_only) {
 		throw IUReadOnlyError();
@@ -1070,7 +1121,7 @@ void RemotePushIU::commit()
 	}
 }
 
-void RemotePushIU::_apply_link_update(IULinkUpdate::ptr update)
+IPAACA_EXPORT void RemotePushIU::_apply_link_update(IULinkUpdate::ptr update)
 {
 	_revision = update->revision;
 	if (update->is_delta) {
@@ -1079,7 +1130,7 @@ void RemotePushIU::_apply_link_update(IULinkUpdate::ptr update)
 		_replace_links(update->new_links);
 	}
 }
-void RemotePushIU::_apply_update(IUPayloadUpdate::ptr update)
+IPAACA_EXPORT void RemotePushIU::_apply_update(IUPayloadUpdate::ptr update)
 {
 	_revision = update->revision;
 	if (update->is_delta) {
@@ -1096,11 +1147,11 @@ void RemotePushIU::_apply_update(IUPayloadUpdate::ptr update)
 		}
 	}
 }
-void RemotePushIU::_apply_commission()
+IPAACA_EXPORT void RemotePushIU::_apply_commission()
 {
 	_committed = true;
 }
-void RemotePushIU::_apply_retraction()
+IPAACA_EXPORT void RemotePushIU::_apply_retraction()
 {
 	_retracted = true;
 }
@@ -1108,30 +1159,30 @@ void RemotePushIU::_apply_retraction()
 
 // RemoteMessage//{{{
 
-RemoteMessage::ptr RemoteMessage::create()
+IPAACA_EXPORT RemoteMessage::ptr RemoteMessage::create()
 {
 	RemoteMessage::ptr iu = RemoteMessage::ptr(new RemoteMessage(/* params */));
 	iu->_payload.initialize(iu);
 	return iu;
 }
-RemoteMessage::RemoteMessage()
+IPAACA_EXPORT RemoteMessage::RemoteMessage()
 {
 	// nothing
 }
-void RemoteMessage::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void RemoteMessage::_modify_links(bool is_delta, const LinkMap& new_links, const LinkMap& links_to_remove, const std::string& writer_name)
 {
 	IPAACA_INFO("Info: modifying a RemoteMessage only has local effects")
 }
-void RemoteMessage::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
+IPAACA_EXPORT void RemoteMessage::_modify_payload(bool is_delta, const std::map<std::string, std::string>& new_items, const std::vector<std::string>& keys_to_remove, const std::string& writer_name)
 {
 	IPAACA_INFO("Info: modifying a RemoteMessage only has local effects")
 }
-void RemoteMessage::commit()
+IPAACA_EXPORT void RemoteMessage::commit()
 {
 	IPAACA_INFO("Info: committing to a RemoteMessage only has local effects")
 }
 
-void RemoteMessage::_apply_link_update(IULinkUpdate::ptr update)
+IPAACA_EXPORT void RemoteMessage::_apply_link_update(IULinkUpdate::ptr update)
 {
 	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_link_update")
 	_revision = update->revision;
@@ -1141,7 +1192,7 @@ void RemoteMessage::_apply_link_update(IULinkUpdate::ptr update)
 		_replace_links(update->new_links);
 	}
 }
-void RemoteMessage::_apply_update(IUPayloadUpdate::ptr update)
+IPAACA_EXPORT void RemoteMessage::_apply_update(IUPayloadUpdate::ptr update)
 {
 	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_update")
 	_revision = update->revision;
@@ -1159,12 +1210,12 @@ void RemoteMessage::_apply_update(IUPayloadUpdate::ptr update)
 		}
 	}
 }
-void RemoteMessage::_apply_commission()
+IPAACA_EXPORT void RemoteMessage::_apply_commission()
 {
 	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_commission")
 	_committed = true;
 }
-void RemoteMessage::_apply_retraction()
+IPAACA_EXPORT void RemoteMessage::_apply_retraction()
 {
 	IPAACA_WARNING("Warning: should never be called: RemoteMessage::_apply_retraction")
 	_retracted = true;
@@ -1176,49 +1227,49 @@ void RemoteMessage::_apply_retraction()
 
 // PayloadEntryProxy//{{{
 
-PayloadEntryProxy::PayloadEntryProxy(Payload* payload, const std::string& key)
+IPAACA_EXPORT PayloadEntryProxy::PayloadEntryProxy(Payload* payload, const std::string& key)
 : _payload(payload), _key(key)
 {
 }
-PayloadEntryProxy& PayloadEntryProxy::operator=(const std::string& value)
+IPAACA_EXPORT PayloadEntryProxy& PayloadEntryProxy::operator=(const std::string& value)
 {
 	//std::cout << "operator=(string)" << std::endl;
 	_payload->set(_key, value);
 	return *this;
 }
-PayloadEntryProxy& PayloadEntryProxy::operator=(const char* value)
+IPAACA_EXPORT PayloadEntryProxy& PayloadEntryProxy::operator=(const char* value)
 {
 	//std::cout << "operator=(const char*)" << std::endl;
 	_payload->set(_key, value);
 	return *this;
 }
-PayloadEntryProxy& PayloadEntryProxy::operator=(double value)
+IPAACA_EXPORT PayloadEntryProxy& PayloadEntryProxy::operator=(double value)
 {
 	//std::cout << "operator=(double)" << std::endl;
 	_payload->set(_key, boost::lexical_cast<std::string>(value));
 	return *this;
 }
-PayloadEntryProxy& PayloadEntryProxy::operator=(bool value)
+IPAACA_EXPORT PayloadEntryProxy& PayloadEntryProxy::operator=(bool value)
 {
 	//std::cout << "operator=(bool)" << std::endl;
 	_payload->set(_key, boost::lexical_cast<std::string>(value));
 	return *this;
 }
-PayloadEntryProxy::operator std::string()
+IPAACA_EXPORT PayloadEntryProxy::operator std::string()
 {
 	return _payload->get(_key);
 }
-PayloadEntryProxy::operator bool()
+IPAACA_EXPORT PayloadEntryProxy::operator bool()
 {
 	std::string s = operator std::string();
 	return ((s=="1")||(s=="true")||(s=="True"));
 }
-PayloadEntryProxy::operator long()
+IPAACA_EXPORT PayloadEntryProxy::operator long()
 {
 	//return boost::lexical_cast<long>(operator std::string().c_str());
 	return atof(operator std::string().c_str());
 }
-PayloadEntryProxy::operator double()
+IPAACA_EXPORT PayloadEntryProxy::operator double()
 {
 	//return boost::lexical_cast<double>(operator std::string().c_str());
 	return atol(operator std::string().c_str());
@@ -1227,42 +1278,42 @@ PayloadEntryProxy::operator double()
 
 // Payload//{{{
 
-void Payload::initialize(boost::shared_ptr<IUInterface> iu)
+IPAACA_EXPORT void Payload::initialize(boost::shared_ptr<IUInterface> iu)
 {
 	_iu = boost::weak_ptr<IUInterface>(iu);
 }
 
-PayloadEntryProxy Payload::operator[](const std::string& key)
+IPAACA_EXPORT PayloadEntryProxy Payload::operator[](const std::string& key)
 {
 	//boost::shared_ptr<PayloadEntryProxy> p(new PayloadEntryProxy(this, key));
 	return PayloadEntryProxy(this, key);
 }
-Payload::operator std::map<std::string, std::string>()
+IPAACA_EXPORT Payload::operator std::map<std::string, std::string>()
 {
 	return _store;
 }
 
-inline void Payload::_internal_set(const std::string& k, const std::string& v, const std::string& writer_name) {
+IPAACA_EXPORT inline void Payload::_internal_set(const std::string& k, const std::string& v, const std::string& writer_name) {
 	std::map<std::string, std::string> _new;
 	std::vector<std::string> _remove;
 	_new[k]=v;
 	_iu.lock()->_modify_payload(true, _new, _remove, writer_name );
 	_store[k] = v;
 }
-inline void Payload::_internal_remove(const std::string& k, const std::string& writer_name) {
+IPAACA_EXPORT inline void Payload::_internal_remove(const std::string& k, const std::string& writer_name) {
 	std::map<std::string, std::string> _new;
 	std::vector<std::string> _remove;
 	_remove.push_back(k);
 	_iu.lock()->_modify_payload(true, _new, _remove, writer_name );
 	_store.erase(k);
 }
-void Payload::_internal_replace_all(const std::map<std::string, std::string>& new_contents, const std::string& writer_name)
+IPAACA_EXPORT void Payload::_internal_replace_all(const std::map<std::string, std::string>& new_contents, const std::string& writer_name)
 {
 	std::vector<std::string> _remove;
 	_iu.lock()->_modify_payload(false, new_contents, _remove, writer_name );
 	_store = new_contents;
 }
-void Payload::_internal_merge(const std::map<std::string, std::string>& contents_to_merge, const std::string& writer_name)
+IPAACA_EXPORT void Payload::_internal_merge(const std::map<std::string, std::string>& contents_to_merge, const std::string& writer_name)
 {
 	std::vector<std::string> _remove;
 	_iu.lock()->_modify_payload(true, contents_to_merge, _remove, writer_name );
@@ -1271,19 +1322,19 @@ void Payload::_internal_merge(const std::map<std::string, std::string>& contents
 	//	_store[it->first] = it->second;
 	//}
 }
-inline std::string Payload::get(const std::string& k) {
+IPAACA_EXPORT inline std::string Payload::get(const std::string& k) {
 	if (_store.count(k)>0) return _store[k];
 	else return IPAACA_PAYLOAD_DEFAULT_STRING_VALUE;
 }
-void Payload::_remotely_enforced_wipe()
+IPAACA_EXPORT void Payload::_remotely_enforced_wipe()
 {
 	_store.clear();
 }
-void Payload::_remotely_enforced_delitem(const std::string& k)
+IPAACA_EXPORT void Payload::_remotely_enforced_delitem(const std::string& k)
 {
 	_store.erase(k);
 }
-void Payload::_remotely_enforced_setitem(const std::string& k, const std::string& v)
+IPAACA_EXPORT void Payload::_remotely_enforced_setitem(const std::string& k, const std::string& v)
 {
 	_store[k] = v;
 }
@@ -1292,12 +1343,12 @@ void Payload::_remotely_enforced_setitem(const std::string& k, const std::string
 
 // IUConverter//{{{
 
-IUConverter::IUConverter()
-: Converter<std::string> ("ipaaca::IU", "ipaaca-iu", true)
+IPAACA_EXPORT IUConverter::IUConverter()
+: Converter<std::string> ("class ipaaca::IU", "ipaaca-iu", true)
 {
 }
 
-std::string IUConverter::serialize(const AnnotatedData& data, std::string& wire)
+IPAACA_EXPORT std::string IUConverter::serialize(const AnnotatedData& data, std::string& wire)
 {
 	//std::cout << "serialize" << std::endl;
 	// Ensure that DATA actually holds a datum of the data-type we expect.
@@ -1354,7 +1405,7 @@ std::string IUConverter::serialize(const AnnotatedData& data, std::string& wire)
 
 }
 
-AnnotatedData IUConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
+IPAACA_EXPORT AnnotatedData IUConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
 	//std::cout << "deserialize" << std::endl;
 	assert(wireSchema == getWireSchema()); // "ipaaca-iu"
 	boost::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
@@ -1428,12 +1479,12 @@ AnnotatedData IUConverter::deserialize(const std::string& wireSchema, const std:
 
 // MessageConverter//{{{
 
-MessageConverter::MessageConverter()
-: Converter<std::string> ("ipaaca::Message", "ipaaca-messageiu", true)
+IPAACA_EXPORT MessageConverter::MessageConverter()
+: Converter<std::string> ("class ipaaca::Message", "ipaaca-messageiu", true)
 {
 }
 
-std::string MessageConverter::serialize(const AnnotatedData& data, std::string& wire)
+IPAACA_EXPORT std::string MessageConverter::serialize(const AnnotatedData& data, std::string& wire)
 {
 	// Ensure that DATA actually holds a datum of the data-type we expect.
 	assert(data.first == getDataType()); // "ipaaca::Message"
@@ -1487,7 +1538,7 @@ std::string MessageConverter::serialize(const AnnotatedData& data, std::string&
 
 }
 
-AnnotatedData MessageConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
+IPAACA_EXPORT AnnotatedData MessageConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
 	assert(wireSchema == getWireSchema()); // "ipaaca-iu"
 	boost::shared_ptr<protobuf::IU> pbo(new protobuf::IU());
 	pbo->ParseFromString(wire);
@@ -1559,12 +1610,12 @@ AnnotatedData MessageConverter::deserialize(const std::string& wireSchema, const
 
 // IUPayloadUpdateConverter//{{{
 
-IUPayloadUpdateConverter::IUPayloadUpdateConverter()
-: Converter<std::string> ("ipaaca::IUPayloadUpdate", "ipaaca-iu-payload-update", true)
+IPAACA_EXPORT IUPayloadUpdateConverter::IUPayloadUpdateConverter()
+: Converter<std::string> ("class ipaaca::IUPayloadUpdate", "ipaaca-iu-payload-update", true)
 {
 }
 
-std::string IUPayloadUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
+IPAACA_EXPORT std::string IUPayloadUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
 {
 	assert(data.first == getDataType()); // "ipaaca::IUPayloadUpdate"
 	boost::shared_ptr<const IUPayloadUpdate> obj = boost::static_pointer_cast<const IUPayloadUpdate> (data.second);
@@ -1612,12 +1663,12 @@ AnnotatedData IUPayloadUpdateConverter::deserialize(const std::string& wireSchem
 
 // IULinkUpdateConverter//{{{
 
-IULinkUpdateConverter::IULinkUpdateConverter()
-: Converter<std::string> ("ipaaca::IULinkUpdate", "ipaaca-iu-link-update", true)
+IPAACA_EXPORT IULinkUpdateConverter::IULinkUpdateConverter()
+: Converter<std::string> ("class ipaaca::IULinkUpdate", "ipaaca-iu-link-update", true)
 {
 }
 
-std::string IULinkUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
+IPAACA_EXPORT std::string IULinkUpdateConverter::serialize(const AnnotatedData& data, std::string& wire)
 {
 	assert(data.first == getDataType()); // "ipaaca::IULinkUpdate"
 	boost::shared_ptr<const IULinkUpdate> obj = boost::static_pointer_cast<const IULinkUpdate> (data.second);
@@ -1675,12 +1726,12 @@ AnnotatedData IULinkUpdateConverter::deserialize(const std::string& wireSchema,
 
 // IntConverter//{{{
 
-IntConverter::IntConverter()
+IPAACA_EXPORT IntConverter::IntConverter()
 : Converter<std::string> ("int", "int32", true)
 {
 }
 
-std::string IntConverter::serialize(const AnnotatedData& data, std::string& wire)
+IPAACA_EXPORT std::string IntConverter::serialize(const AnnotatedData& data, std::string& wire)
 {
 	// Ensure that DATA actually holds a datum of the data-type we expect.
 	assert(data.first == getDataType()); // "int"
@@ -1694,7 +1745,7 @@ std::string IntConverter::serialize(const AnnotatedData& data, std::string& wire
 
 }
 
-AnnotatedData IntConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
+IPAACA_EXPORT AnnotatedData IntConverter::deserialize(const std::string& wireSchema, const std::string& wire) {
 	assert(wireSchema == getWireSchema()); // "int"
 	boost::shared_ptr<protobuf::IntMessage> pbo(new protobuf::IntMessage());
 	pbo->ParseFromString(wire);