diff --git a/Core/Code/Controllers/mitkCoreActivator.cpp b/Core/Code/Controllers/mitkCoreActivator.cpp
index 22a996b3ef..b3b8e165de 100644
--- a/Core/Code/Controllers/mitkCoreActivator.cpp
+++ b/Core/Code/Controllers/mitkCoreActivator.cpp
@@ -1,58 +1,80 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRenderingManager.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkCoreDataNodeReader.h"
 
 #include <mitkModuleActivator.h>
 
+void HandleMicroServicesMessages(mitk::MsgType type, const char* msg)
+{
+  switch (type)
+  {
+  case mitk::DebugMsg:
+    MITK_DEBUG << msg;
+    break;
+  case mitk::InfoMsg:
+    MITK_INFO << msg;
+    break;
+  case mitk::WarningMsg:
+    MITK_WARN << msg;
+    break;
+  case mitk::ErrorMsg:
+    MITK_ERROR << msg;
+    break;
+  }
+}
+
 /*
  * This is the module activator for the "Mitk" module. It registers core services
  * like ...
  */
 class MitkCoreActivator : public mitk::ModuleActivator
 {
 public:
 
   void Load(mitk::ModuleContext* context)
   {
+    // Handle messages from CppMicroServices
+    mitk::installMsgHandler(HandleMicroServicesMessages);
+
     //m_RenderingManager = mitk::RenderingManager::New();
     //context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
     m_PlanePositionManager = mitk::PlanePositionManagerService::New();
     context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager);
 
     m_CoreDataNodeReader = mitk::CoreDataNodeReader::New();
     context->RegisterService<mitk::IDataNodeReader>(m_CoreDataNodeReader);
   }
 
   void Unload(mitk::ModuleContext* )
   {
     // The mitk::ModuleContext* argument of the Unload() method
     // will always be 0 for the Mitk library. It makes no sense
     // to use it at this stage anyway, since all libraries which
     // know about the module system have already been unloaded.
   }
 
 private:
 
   //mitk::RenderingManager::Pointer m_RenderingManager;
   mitk::PlanePositionManagerService::Pointer m_PlanePositionManager;
   mitk::CoreDataNodeReader::Pointer m_CoreDataNodeReader;
 };
 
 US_EXPORT_MODULE_ACTIVATOR(Mitk, MitkCoreActivator)
 
diff --git a/Core/Code/CppMicroServices/src/module/usModuleUtils.cpp b/Core/Code/CppMicroServices/src/module/usModuleUtils.cpp
index 4cea854204..cc5ff30c76 100644
--- a/Core/Code/CppMicroServices/src/module/usModuleUtils.cpp
+++ b/Core/Code/CppMicroServices/src/module/usModuleUtils.cpp
@@ -1,155 +1,166 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #include "usModuleUtils_p.h"
 #include <usUtils_p.h>
 
 US_BEGIN_NAMESPACE
 
 #ifdef __GNUC__
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
 #include <dlfcn.h>
 
 std::string GetLibraryPath_impl(const std::string& /*libName*/, void* symbol)
 {
   Dl_info info;
   if (dladdr(symbol, &info))
   {
     return info.dli_fname;
   }
   else
   {
-    US_DEBUG << GetLastErrorStr();
+    US_DEBUG << "GetLibraryPath_impl() dladdr() failed: " << dlerror();
   }
   return "";
 }
 
 void* GetSymbol_impl(const std::string& libName, const char* symbol)
 {
+  // Clear the last error message
+  dlerror();
+
   void* selfHandle = 0;
   if (libName.empty())
   {
     // Get the handle of the executable
     selfHandle = dlopen(0, RTLD_LAZY);
   }
   else
   {
     selfHandle = dlopen(libName.c_str(), RTLD_LAZY);
   }
 
   if (selfHandle)
   {
     void* addr = dlsym(selfHandle, symbol);
+    if (!addr)
+    {
+      const char* dlerrorMsg = dlerror();
+      if (dlerrorMsg)
+      {
+        US_DEBUG << "GetSymbol_impl() failed: " << dlerrorMsg;
+      }
+    }
     dlclose(selfHandle);
     return addr;
   }
   else
   {
-    US_DEBUG << GetLastErrorStr();
+    US_DEBUG << "GetSymbol_impl() dlopen() failed: " << dlerror();
   }
   return 0;
 }
 
 #elif _WIN32
 
 #include <windows.h>
 
 std::string GetLibraryPath_impl(const std::string& libName, void *symbol)
 {
   HMODULE handle = 0;
   if (libName.empty())
   {
     // get the handle for the executable
     handle = GetModuleHandle(0);
   }
   else
   {
     handle = GetModuleHandle(libName.c_str());
   }
   if (!handle)
   {
     US_DEBUG << "GetLibraryPath_impl():GetModuleHandle() " << GetLastErrorStr();
     return "";
   }
 
   char modulePath[512];
   if (GetModuleFileName(handle, modulePath, 512))
   {
     return modulePath;
   }
 
   US_DEBUG << "GetLibraryPath_impl():GetModuleFileName() " << GetLastErrorStr();
   return "";
 }
 
 void* GetSymbol_impl(const std::string& libName, const char* symbol)
 {
   HMODULE handle = NULL;
   if (libName.empty())
   {
     handle = GetModuleHandle(NULL);
   }
   else
   {
     handle = GetModuleHandle(libName.c_str());
   }
 
   if (!handle)
   {
     US_DEBUG << "GetSymbol_impl():GetModuleHandle() " << GetLastErrorStr();
     return 0;
   }
 
   void* addr = (void*)GetProcAddress(handle, symbol);
   if (!addr)
   {
     US_DEBUG << "GetSymbol_impl():GetProcAddress(handle," << symbol << ") " << GetLastErrorStr();
   }
   return addr;
 }
 #else
 std::string GetLibraryPath_impl(const std::string& libName, void* symbol)
 {
   return "";
 }
 
 void* GetSymbol_impl(const std::string& libName, const char* symbol)
 {
   return 0;
 }
 #endif
 
 std::string ModuleUtils::GetLibraryPath(const std::string& libName, void* symbol)
 {
   return GetLibraryPath_impl(libName, symbol);
 }
 
 void* ModuleUtils::GetSymbol(const std::string& libName, const char* symbol)
 {
   return GetSymbol_impl(libName, symbol);
 }
 
 US_END_NAMESPACE
diff --git a/Core/Code/CppMicroServices/src/util/usUtils_p.h b/Core/Code/CppMicroServices/src/util/usUtils_p.h
index 1e5b5d2065..25a4a2d0e4 100644
--- a/Core/Code/CppMicroServices/src/util/usUtils_p.h
+++ b/Core/Code/CppMicroServices/src/util/usUtils_p.h
@@ -1,207 +1,210 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USUTILS_H
 #define USUTILS_H
 
 #include <usConfig.h>
 
 #include <iostream>
 #include <sstream>
 #include <algorithm>
 
 
 //-------------------------------------------------------------------
 // Logging
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 US_EXPORT void message_output(MsgType, const char* buf);
 
 struct LogMsg {
 
-  LogMsg(int t) : type(static_cast<MsgType>(t)), enabled(true), buffer() {}
+  LogMsg(int t, const char* file, int ln, const char* func)
+    : type(static_cast<MsgType>(t)), enabled(true), buffer()
+  { buffer << "In " << func << " at " << file << ":" << ln << " : "; }
+
   ~LogMsg() { if(enabled) message_output(type, buffer.str().c_str()); }
 
   template<typename T>
   LogMsg& operator<<(T t)
   {
     if (enabled) buffer << t;
     return *this;
   }
 
   LogMsg& operator()(bool flag)
   {
     this->enabled = flag;
     return *this;
   }
 
 private:
 
   MsgType type;
   bool enabled;
   std::stringstream buffer;
 };
 
 struct NoLogMsg {
 
   template<typename T>
   NoLogMsg& operator<<(T)
   {
     return *this;
   }
 
   NoLogMsg& operator()(bool)
   {
     return *this;
   }
 
 };
 
 US_END_NAMESPACE
 
 #if !defined(US_NO_DEBUG_OUTPUT)
-  #define US_DEBUG US_PREPEND_NAMESPACE(LogMsg)(0)
+  #define US_DEBUG US_PREPEND_NAMESPACE(LogMsg)(0, __FILE__, __LINE__, __FUNCTION__)
 #else
-  #define US_DEBUG US_PREPEND_NAMESPACE(NoLogMsg)()
+  #define US_DEBUG true ? US_PREPEND_NAMESPACE(NoLogMsg)() : US_PREPEND_NAMESPACE(NoLogMsg)()
 #endif
 
 #if !defined(US_NO_INFO_OUTPUT)
-  #define US_INFO US_PREPEND_NAMESPACE(LogMsg)(1)
+  #define US_INFO US_PREPEND_NAMESPACE(LogMsg)(1, __FILE__, __LINE__, __FUNCTION__)
 #else
-  #define US_INFO US_PREPEND_NAMESPACE(NoLogMsg)()
+  #define US_INFO  true ? US_PREPEND_NAMESPACE(NoLogMsg)() : US_PREPEND_NAMESPACE(NoLogMsg)()
 #endif
 
 #if !defined(US_NO_WARNING_OUTPUT)
-  #define US_WARN US_PREPEND_NAMESPACE(LogMsg)(2)
+  #define US_WARN US_PREPEND_NAMESPACE(LogMsg)(2, __FILE__, __LINE__, __FUNCTION__)
 #else
-  #define US_WARN US_PREPEND_NAMESPACE(LogMsg)()
+  #define US_WARN true ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)()
 #endif
 
-#define US_ERROR US_PREPEND_NAMESPACE(LogMsg)(3)
+#define US_ERROR US_PREPEND_NAMESPACE(LogMsg)(3, __FILE__, __LINE__, __FUNCTION__)
 
 //-------------------------------------------------------------------
 // Error handling
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 US_EXPORT std::string GetLastErrorStr();
 
 US_END_NAMESPACE
 
 
 //-------------------------------------------------------------------
 // Functors
 //-------------------------------------------------------------------
 
 #include <usServiceEvent.h>
 #include <usModuleEvent.h>
 
 #if defined(US_USE_CXX11) || defined(__GNUC__)
 
   #ifdef US_USE_CXX11
     #include <functional>
     #define US_MODULE_LISTENER_FUNCTOR std::function<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
     #define US_SERVICE_LISTENER_FUNCTOR std::function<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
   #else
     #include <tr1/functional>
     #define US_MODULE_LISTENER_FUNCTOR std::tr1::function<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
     #define US_SERVICE_LISTENER_FUNCTOR std::tr1::function<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
   #endif
 
   US_BEGIN_NAMESPACE
     template<class X>
     US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ModuleEvent)))
     { return std::bind1st(std::mem_fun(memFn), x); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ModuleListenerCompare : std::binary_function<US_MODULE_LISTENER_FUNCTOR, US_MODULE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_MODULE_LISTENER_FUNCTOR& f1,
                       const US_MODULE_LISTENER_FUNCTOR& f2) const
       {
         return f1.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>();
       }
     };
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     template<class X>
     US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ServiceEvent)))
     { return std::bind1st(std::mem_fun(memFn), x); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ServiceListenerCompare : std::binary_function<US_SERVICE_LISTENER_FUNCTOR, US_SERVICE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                       const US_SERVICE_LISTENER_FUNCTOR& f2) const
       {
         return f1.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
       }
     };
   US_END_NAMESPACE
 
 #else
 
   #include <usFunctor_p.h>
 
   #define US_MODULE_LISTENER_FUNCTOR US_PREPEND_NAMESPACE(Functor)<const US_PREPEND_NAMESPACE(ModuleEvent)&>
 
   US_BEGIN_NAMESPACE
     template<class X, typename MemFn>
     US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, MemFn memFn)
     { return Functor<const ModuleEvent&>(x, memFn); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ModuleListenerCompare : std::binary_function<US_MODULE_LISTENER_FUNCTOR, US_MODULE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_MODULE_LISTENER_FUNCTOR& f1,
                       const US_MODULE_LISTENER_FUNCTOR& f2) const
       { return f1 == f2; }
     };
   US_END_NAMESPACE
 
   #define US_SERVICE_LISTENER_FUNCTOR US_PREPEND_NAMESPACE(Functor)<const US_PREPEND_NAMESPACE(ServiceEvent)&>
 
   US_BEGIN_NAMESPACE
     template<class X, typename MemFn>
     US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, MemFn memFn)
     { return Functor<const ServiceEvent&>(x, memFn); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ServiceListenerCompare : std::binary_function<US_SERVICE_LISTENER_FUNCTOR, US_SERVICE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                       const US_SERVICE_LISTENER_FUNCTOR& f2) const
       { return f1 == f2; }
     };
   US_END_NAMESPACE
 
 #endif
 
 #endif // USUTILS_H
diff --git a/Core/Code/CppMicroServices/test/usDebugOutputTest.cpp b/Core/Code/CppMicroServices/test/usDebugOutputTest.cpp
index c93de8c554..721ad6e351 100644
--- a/Core/Code/CppMicroServices/test/usDebugOutputTest.cpp
+++ b/Core/Code/CppMicroServices/test/usDebugOutputTest.cpp
@@ -1,100 +1,100 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include <usUtils_p.h>
 
 #include "usTestingMacros.h"
 
 US_USE_NAMESPACE
 
 static int lastMsgType = -1;
 static std::string lastMsg;
 
 void handleMessages(MsgType type, const char* msg)
 {
   lastMsgType = type;
   lastMsg.assign(msg);
 }
 
 void resetLastMsg()
 {
   lastMsgType = -1;
   lastMsg.clear();
 }
 
 int usDebugOutputTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("DebugOutputTest");
 
   // Use the default message handler
   {
     US_DEBUG << "Msg";
     US_DEBUG(false) << "Msg";
     US_INFO << "Msg";
     US_INFO(false) << "Msg";
     US_WARN << "Msg";
     US_WARN(false) << "Msg";
   }
   US_TEST_CONDITION(lastMsg.empty(), "Testing default message handler");
 
   resetLastMsg();
 
   installMsgHandler(handleMessages);
   {
     US_DEBUG << "Msg";
   }
 #ifdef NDEBUG
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing suppressed debug message")
 #else
-  US_TEST_CONDITION(lastMsgType == 0 && lastMsg == "Msg", "Testing debug message")
+  US_TEST_CONDITION(lastMsgType == 0 && lastMsg.find("Msg") != std::string::npos, "Testing debug message")
 #endif
   resetLastMsg();
 
   {
     US_DEBUG(false) << "No msg";
   }
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing disabled debug message")
   resetLastMsg();
 
   {
     US_INFO << "Info msg";
   }
-  US_TEST_CONDITION(lastMsgType == 1 && lastMsg == "Info msg", "Testing informational message")
+  US_TEST_CONDITION(lastMsgType == 1 && lastMsg.find("Info msg") != std::string::npos, "Testing informational message")
   resetLastMsg();
 
   {
     US_WARN << "Warn msg";
   }
-  US_TEST_CONDITION(lastMsgType == 2 && lastMsg == "Warn msg", "Testing warning message")
+  US_TEST_CONDITION(lastMsgType == 2 && lastMsg.find("Warn msg") != std::string::npos, "Testing warning message")
   resetLastMsg();
 
   // We cannot test US_ERROR since it will call abort().
 
   installMsgHandler(0);
 
   {
     US_INFO << "Info msg";
   }
   US_TEST_CONDITION(lastMsgType == -1 && lastMsg.empty(), "Testing message handler reset")
 
   US_TEST_END()
 }
 
diff --git a/Core/Code/CppMicroServices/usConfig.h.in b/Core/Code/CppMicroServices/usConfig.h.in
index 5107bb38bd..e6ce942560 100644
--- a/Core/Code/CppMicroServices/usConfig.h.in
+++ b/Core/Code/CppMicroServices/usConfig.h.in
@@ -1,224 +1,224 @@
 /*
   USCONFIG.h
   this file is generated. Do not change!
 */
 
 #ifndef USCONFIG_H
 #define USCONFIG_H
 
 #cmakedefine US_BUILD_SHARED_LIBS
 #cmakedefine CppMicroServices_EXPORTS
 #cmakedefine US_ENABLE_THREADING_SUPPORT
 #cmakedefine US_ENABLE_SERVICE_FACTORY_SUPPORT
 #cmakedefine US_USE_CXX11
 
 ///-------------------------------------------------------------------
 // Version information
 //-------------------------------------------------------------------
 
 #define CppMicroServices_VERSION_MAJOR @CppMicroServices_VERSION_MAJOR@
 #define CppMicroServices_VERSION_MINOR @CppMicroServices_VERSION_MINOR@
 #define CppMicroServices_VERSION_PATH @CppMicroServices_VERSION_PATCH@
-#define CppMicroServices_VERSION_VERSION @CppMicroServices_VERSION@
-#define CppMicroServices_VERSION_VERSION_STR "@CppMicroServices_VERSION@"
+#define CppMicroServices_VERSION @CppMicroServices_VERSION@
+#define CppMicroServices_VERSION_STR "@CppMicroServices_VERSION@"
 
 ///-------------------------------------------------------------------
 // Macros for import/export declarations
 //-------------------------------------------------------------------
 
 #if defined(WIN32)
   #define US_ABI_EXPORT __declspec(dllexport)
   #define US_ABI_IMPORT __declspec(dllimport)
   #define US_ABI_LOCAL
 #else
   #if __GNUC__ >= 4
     #define US_ABI_EXPORT __attribute__ ((visibility ("default")))
     #define US_ABI_IMPORT __attribute__ ((visibility ("default")))
     #define US_ABI_LOCAL  __attribute__ ((visibility ("hidden")))
   #else
     #define US_ABI_EXPORT
     #define US_ABI_IMPORT
     #define US_ABI_LOCAL
   #endif
 #endif
 
 #ifdef US_BUILD_SHARED_LIBS
   // We are building a shared lib
   #ifdef CppMicroServices_EXPORTS
     #define US_EXPORT US_ABI_EXPORT
   #else
     #define US_EXPORT US_ABI_IMPORT
   #endif
 #else
   // We are building a static lib
   #if __GNUC__ >= 4
     // Don't hide RTTI symbols of definitions in the C++ Micro Services
     // headers that are included in DSOs with hidden visibility
     #define US_EXPORT US_ABI_EXPORT
   #else
     #define US_EXPORT
   #endif
 #endif
 
 //-------------------------------------------------------------------
 // Namespace customization
 //-------------------------------------------------------------------
 
 #define US_NAMESPACE @US_NAMESPACE@
 
 #ifndef US_NAMESPACE /* user namespace */
 
   # define US_PREPEND_NAMESPACE(name) ::name
   # define US_USE_NAMESPACE
   # define US_BEGIN_NAMESPACE
   # define US_END_NAMESPACE
   # define US_FORWARD_DECLARE_CLASS(name) class name;
   # define US_FORWARD_DECLARE_STRUCT(name) struct name;
 
 #else /* user namespace */
 
   # define US_PREPEND_NAMESPACE(name) ::US_NAMESPACE::name
   # define US_USE_NAMESPACE using namespace ::US_NAMESPACE;
   # define US_BEGIN_NAMESPACE namespace US_NAMESPACE {
   # define US_END_NAMESPACE }
   # define US_FORWARD_DECLARE_CLASS(name) \
     US_BEGIN_NAMESPACE class name; US_END_NAMESPACE
 
   # define US_FORWARD_DECLARE_STRUCT(name) \
     US_BEGIN_NAMESPACE struct name; US_END_NAMESPACE
 
   namespace US_NAMESPACE {}
 
 #endif /* user namespace */
 
 #define US_BASECLASS_NAME @US_BASECLASS_NAME@
 #define US_BASECLASS_HEADER <@US_BASECLASS_HEADER@>
 
 // base class forward declaration
 @US_BASECLASS_FORWARD_DECLARATION@
 
 //-------------------------------------------------------------------
 // Platform defines
 //-------------------------------------------------------------------
 
 #if defined(__APPLE__)
   #define US_PLATFORM_APPLE
 #endif
 
 #if defined(_WIN32) || defined(_WIN64)
   #define US_PLATFORM_WINDOWS
 #else
   #define US_PLATFORM_POSIX
 #endif
 
 //-------------------------------------------------------------------
 // Compiler defines
 //-------------------------------------------------------------------
 
 #if defined(_MSC_VER) && !defined(_SCL_SECURE_NO_WARNINGS)
   #define _SCL_SECURE_NO_WARNINGS
 #endif
 
 //-------------------------------------------------------------------
 // Debuging & Logging
 //-------------------------------------------------------------------
 
 #if defined(NDEBUG) && !defined(US_NO_DEBUG_OUTPUT)
   #define US_NO_DEBUG_OUTPUT
 #endif
 
 US_BEGIN_NAMESPACE
   enum MsgType { DebugMsg = 0, InfoMsg = 1, WarningMsg = 2, ErrorMsg = 3 };
   typedef void (*MsgHandler)(MsgType, const char *);
   US_EXPORT MsgHandler installMsgHandler(MsgHandler);
 US_END_NAMESPACE
 
 //-------------------------------------------------------------------
 // Hash Container
 //-------------------------------------------------------------------
 
 #ifdef US_USE_CXX11
 
   #include <unordered_map>
   #include <unordered_set>
 
   #define US_HASH_FUNCTION_BEGIN(type) \
   template<> \
   struct hash<type> : std::unary_function<type, std::size_t> { \
   std::size_t operator()(const type& arg) const {
 
   #define US_HASH_FUNCTION_END } };
 
   #define US_HASH_FUNCTION(type, arg) hash<type>()(arg)
   
   #ifdef US_PLATFORM_WINDOWS
     #define US_HASH_FUNCTION_FRIEND(type) friend class ::std::hash<type>
   #else
     #define US_HASH_FUNCTION_FRIEND(type) friend struct ::std::hash<type>
   #endif
 
   #define US_UNORDERED_MAP_TYPE ::std::unordered_map
   #define US_UNORDERED_SET_TYPE ::std::unordered_set
 
   #define US_HASH_FUNCTION_NAMESPACE ::std
   #define US_HASH_FUNCTION_NAMESPACE_BEGIN namespace std {
   #define US_HASH_FUNCTION_NAMESPACE_END }
 
 #elif defined(__GNUC__)
 
   #include <tr1/unordered_map>
   #include <tr1/unordered_set>
   
   #define US_HASH_FUNCTION_BEGIN(type) \
   template<> \
   struct hash<type> : std::unary_function<type, std::size_t> { \
   std::size_t operator()(const type& arg) const { 
   
   #define US_HASH_FUNCTION_END } };
   
   #define US_HASH_FUNCTION(type, arg) hash<type>()(arg)
   #define US_HASH_FUNCTION_FRIEND(type) friend struct ::std::tr1::hash<type>
 
   #define US_UNORDERED_MAP_TYPE ::std::tr1::unordered_map
   #define US_UNORDERED_SET_TYPE ::std::tr1::unordered_set
 
   #define US_HASH_FUNCTION_NAMESPACE ::std::tr1
   #define US_HASH_FUNCTION_NAMESPACE_BEGIN namespace std { namespace tr1 {
   #define US_HASH_FUNCTION_NAMESPACE_END }}
 
 #elif _MSC_VER <= 1500 // Visual Studio 2008 and lower
 
   #include <hash_map>
   #include <hash_set>
   
   #define US_HASH_FUNCTION_BEGIN(type) \
   template<> \
   inline std::size_t hash_value<type>(const type& arg) { 
   
   #define US_HASH_FUNCTION_END }
   
   #define US_HASH_FUNCTION(type, arg) hash_value(arg)
   #define US_HASH_FUNCTION_FRIEND(type) friend std::size_t stdext::hash_value<type>(const type&)
 
   #define US_UNORDERED_MAP_TYPE ::stdext::hash_map
   #define US_UNORDERED_SET_TYPE ::stdext::hash_set
 
   #define US_HASH_FUNCTION_NAMESPACE ::stdext
   #define US_HASH_FUNCTION_NAMESPACE_BEGIN namespace stdext {
   #define US_HASH_FUNCTION_NAMESPACE_END }
 
 #endif
 
 
 //-------------------------------------------------------------------
 // Threading Configuration
 //-------------------------------------------------------------------
 
 #ifdef US_ENABLE_THREADING_SUPPORT
   #define US_DEFAULT_THREADING US_PREPEND_NAMESPACE(MultiThreaded)
 #else
   #define US_DEFAULT_THREADING US_PREPEND_NAMESPACE(SingleThreaded)
 #endif
 
 
 #endif // USCONFIG_H