Switch from boost::signal to embedded Simple::Signal.

14 files changed, 796 insertions, 55 deletions

diff --git a/.travis.yml b/.travis.yml
index 3bd2e8e..5b5024f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,7 +9,6 @@ before_install:
   - sudo apt-add-repository -y ppa:jkeiren/ppa
   - if test $CC = gcc; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi
   - sudo apt-get update -qq
-  - sudo apt-get upgrade -y
   - sudo apt-get install -y boost1.48 python-dev
   - if test $CC = gcc; then sudo apt-get install gcc-4.7 g++-4.7; fi
   - if test $CC = gcc; then sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.7 20; fi
diff --git a/CHANGELOG.md b/CHANGES.md
index acc0008..67759c4 100644
--- a/CHANGELOG.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # Change Log
 
+## 2013-08-22 - Remove `boost::signal` and switch to `Simple::Signal`.
+
+According to the [benchmarks](http://timj.testbit.eu/2013/cpp11-signal-system-performance/) Simple::Signal is an order of magnitude faster than `boost::signal`. Additionally, `boost::signal` is now deprecated in favor of `boost::signal2`, which is not supported on versions of Boost on a number of platforms.
+
+This is an implementation detail and should not affect EntityX users at all.
+
 ## 2013-08-18 - Destroying an entity invalidates all other references
 
 Previously, `Entity::Id` was a simple integer index (slot) into vectors in the `EntityManager`. EntityX also maintains a list of deleted entity slots that are reused when new entities are created. This reduces the size and frequency of vector reallocation. The downside though, was that if a slot was reused, entity IDs referencing the entity before reallocation would be invalidated on reuse.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e53de9a..667549f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,10 +11,11 @@ include_directories(${CMAKE_CURRENT_LIST_DIR})
 set(ENTITYX_BUILD_TESTING false CACHE BOOL "Enable building of tests.")
 set(ENTITYX_RUN_BENCHMARKS false CACHE BOOL "Run benchmarks (in conjunction with -DENTITYX_BUILD_TESTING=1).")
 set(ENTITYX_MAX_COMPONENTS 64 CACHE STRING "Set the maximum number of components.")
-set(ENTITYX_USE_CPP11_STDLIB false CACHE BOOL "Use the C++11 stdlib (-stdlib=libc++).")
+set(ENTITYX_USE_CPP11_STDLIB false CACHE BOOL "For Clang, specify whether to use libc++ (-stdlib=libc++).")
 # Check for which shared_ptr implementation to use.
 set(ENTITYX_USE_STD_SHARED_PTR false CACHE BOOL "Use std::shared_ptr<T> rather than boost::shared_ptr<T>?")
 set(ENTITYX_BUILD_SHARED true CACHE BOOL "Build shared libraries?")
+set(ENTITYX_BUILD_PYTHON true CACHE BOOL "Build entityx::python?")
 
 include(${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
 include(CheckCXXSourceCompiles)
@@ -76,8 +77,12 @@ require(HAVE_STDINT_H "stdint.h")
 set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
-find_package(Boost 1.48.0 REQUIRED COMPONENTS signals)
-find_package(Boost 1.48.0 COMPONENTS python)
+if (ENTITYX_BUILD_PYTHON)
+    message("-- Building with Python support (-DENTITYX_BUILD_PYTHON=0 to disable)")
+    find_package(Boost 1.48.0 COMPONENTS python)
+else (ENTITYX_BUILD_PYTHON)
+    message("-- Python support disabled")
+endif (ENTITYX_BUILD_PYTHON)
 
 include_directories(${Boost_INCLUDE_DIR})
 set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
@@ -106,7 +111,7 @@ endif (ENTITYX_BUILD_SHARED)
 
 include_directories(${Boost_INCLUDE_DIR})
 
-if (Boost_PYTHON_LIBRARY)
+if (ENTITYX_BUILD_PYTHON AND Boost_PYTHON_LIBRARY)
     message("-- Found boost::python, building entityx/python")
     find_package(PythonLibs REQUIRED)
     include_directories(${PYTHON_INCLUDE_DIRS})
@@ -132,10 +137,12 @@ if (Boost_PYTHON_LIBRARY)
         set_target_properties(entityx_python_shared PROPERTIES OUTPUT_NAME entityx_python)
         list(APPEND install_libs entityx_python_shared)
     endif (ENTITYX_BUILD_SHARED)
-endif (Boost_PYTHON_LIBRARY)
+    set(CMAKE_REQUIRED_FLAGS ${CMAKE_CXX_FLAGS})
+    include(CheckNeedGetPointer.cmake)
+endif (ENTITYX_BUILD_PYTHON AND Boost_PYTHON_LIBRARY)
 
 if (ENTITYX_BUILD_TESTING)
-    find_package(Boost 1.48.0 REQUIRED COMPONENTS signals timer system)
+    find_package(Boost 1.48.0 REQUIRED COMPONENTS timer system)
     add_subdirectory(gtest-1.6.0)
     include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
     enable_testing()
diff --git a/CheckCXX11Features.cmake b/CheckCXX11Features.cmake
index 80e684d..3102f4d 100644
--- a/CheckCXX11Features.cmake
+++ b/CheckCXX11Features.cmake
@@ -21,7 +21,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8.3)
 SET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})

 IF(CMAKE_COMPILER_IS_GNUCXX)

 	SET(CMAKE_CXX_FLAGS "-std=c++0x")

-ELSE("${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" MATCHES ".*clang")

+ELSE("${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" MATCHES ".*clang.*")

 	SET(CMAKE_CXX_FLAGS "-std=c++11")

 ENDIF()

 

diff --git a/CheckNeedGetPointer.cmake b/CheckNeedGetPointer.cmake
new file mode 100644
index 0000000..2e53ac3
--- /dev/null
+++ b/CheckNeedGetPointer.cmake
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+check_cxx_source_compiles(
+"
+#include <boost/get_pointer.hpp>
+
+namespace boost {
+template <class T> inline T * get_pointer(const std::shared_ptr<T> &p) {
+  return p.get();
+}
+}
+
+int main() {
+  return 0;
+}
+"
+ENTITYX_NEED_GET_POINTER_SHARED_PTR_SPECIALIZATION
+)
diff --git a/README.md b/README.md
index 0df1d74..49b03c6 100644
--- a/README.md
+++ b/README.md
@@ -15,10 +15,11 @@ You can also contact me directly via [email](mailto:alec@swapoff.org) or [Twitte
 
 ## Recent Notable Changes
 
+- 2013-08-21 - Remove dependency on `boost::signal` and switch to embedded [Simple::Signal](http://timj.testbit.eu/2013/cpp11-signal-system-performance/).
 - 2013-08-18 - Destroying an entity invalidates all other references
 - 2013-08-17 - Python scripting, and a more robust build system
 
-See the [ChangeLog](https://github.com/alecthomas/entityx/blob/master/CHANGELOG.md) for details.
+See the [ChangeLog](https://github.com/alecthomas/entityx/blob/master/CHANGES.md) for details.
 
 ## Overview
 
@@ -253,16 +254,70 @@ class GameManager : public Manager {
 
 EntityX has the following build and runtime requirements:
 
-- A C++ compiler that supports a basic set of C++11 features (ie. recent clang, recent gcc, and maybe (untested) VC++ with the [Nov 2012 CTP](http://www.microsoft.com/en-us/download/details.aspx?id=35515)).
+- A C++ compiler that supports a basic set of C++11 features (ie. Clang >= 3.1, GCC >= 4.7, and maybe (untested) VC++ with the [Nov 2012 CTP](http://www.microsoft.com/en-us/download/details.aspx?id=35515)).
 - [CMake](http://cmake.org/)
-- [Boost](http://boost.org) `1.48.0` or higher (links against `boost::signals`).
+- [Boost](http://boost.org) `1.48.0` (headers only unless using boost::python).
+
+### C++11 compiler and library support
+
+C++11 support is quite...raw. To make life more interesting, C++ support really means two things: language features supported by the compiler, and library features.
+
+### Installing on OSX Mountain Lion
+
+On OSX you must use Clang as the GCC version is practically prehistoric.
+
+EntityX can build against libstdc++ (GCC with no C++11 library support) or libc++ (Clang with C++11 library support), though you will need to ensure that Boost is built with the same standard library.
+
+I use Homebrew, and the following works for me:
+
+For libstdc++:
+
+```bash
+brew install boost
+cmake -DENTITYX_BUILD_SHARED=0 -DENTITYX_BUILD_TESTING=1 -DENTITYX_USE_STD_SHARED_PTR=1 -DENTITYX_USE_CPP11_STDLIB=0 ..
+```
+
+For libc++ (with C++11 support):
+
+```bash
+brew install boost --with-c++11
+cmake -DENTITYX_BUILD_SHARED=0 -DENTITYX_BUILD_TESTING=1 -DENTITYX_USE_STD_SHARED_PTR=1 -DENTITYX_USE_CPP11_STDLIB=1 ..
+```
+
+### Installing on Ubuntu 12.04
+
+On Ubuntu LTS (12.04, Precise) you will need to add some PPAs to get either clang-3.1 or gcc-4.7. Respective versions prior to these do not work.
+
+For gcc-4.7:
+
+```bash
+sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+sudo apt-get update -qq
+sudo apt-get install gcc-4.7 g++4.7
+CC=gcc-4.7 CXX=g++4.7 cmake ...
+```
+
+For clang-3.1 (or 3.2 or 3.3):
+
+```bash
+sudo apt-add-repository ppa:h-rayflood/llvm
+sudo apt-get update -qq
+sudo apt-get install clang-3.1
+CC=clang-3.1 CXX=clang++3.1 cmake ...
+```
+
+### Options
 
 Once these dependencies are installed you should be able to build and install EntityX as below. The following options can be passed to cmake to modify how EntityX is built:
 
+- `-DENTITYX_BUILD_PYTHON=1` - Build Python scripting integration.
 - `-DENTITYX_BUILD_TESTING=1` - Build tests (run with `make test`).
 - `-DENTITYX_RUN_BENCHMARKS=1` - In conjunction with `-DENTITYX_BUILD_TESTING=1`, also build benchmarks.
 - `-DENTITYX_USE_CPP11_STDLIB=1` - For Clang, specify whether to use `-stdlib=libc++`.
 - `-DENTITYX_USE_STD_SHARED_PTR=1` - Use `std::shared_ptr<T>` (and friends) rather than the Boost equivalents. This does not eliminate the need for Boost, but is useful if the rest of your application uses `std::shared_ptr<T>`.
+- `-DENTITYX_MAX_COMPONENTS=64` - Override the maximum number of components that can be assigned to each entity.
+- `-DENTITYX_BUILD_SHARED=1` - Whether to build shared libraries (defaults to 1).
+- `-DENTITYX_BUILD_TESTING=0` - Whether to build tests (defaults to 0). Run with "make && make test".
 
 For a production build, you'll typically only need the `-DENTITYX_USE_STD_SHARED_PTR=1` flag, if any.
 
@@ -271,9 +326,9 @@ Once you have selected your flags, build and install with:
 ```sh
 mkdir build
 cd build
-cmake [-DENTITYX_BUILD_TESTING=1] [-DENTITYX_RUN_BENCHMARKS=1] [-DENTITYX_USE_CPP11_STDLIB=1] [-DENTITYX_USE_STD_SHARED_PTR=1] ..
+cmake <flags> ..
 make
 make install
 ```
 
-EntityX has currently only been tested on Mac OSX (Lion and Mountain Lion), and Linux Debian. Reports and patches for builds on other platforms are welcome.
+EntityX has currently only been tested on Mac OSX (Lion and Mountain Lion), and Linux Debian 12.04. Reports and patches for builds on other platforms are welcome.
diff --git a/entityx/3rdparty/simplesignal.h b/entityx/3rdparty/simplesignal.h
new file mode 100644
index 0000000..eaca148
--- /dev/null
+++ b/entityx/3rdparty/simplesignal.h
@@ -0,0 +1,585 @@
+// CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/
+#ifndef SIMPLE_SIGNAL_H__
+#define SIMPLE_SIGNAL_H__
+
+#include <unistd.h>
+#include <assert.h>
+#include <stdint.h>
+#include <vector>
+#include <boost/function.hpp>
+
+namespace Simple {
+
+namespace Lib {
+
+/// ProtoSignal is the template implementation for callback list.
+template<typename,typename> class ProtoSignal;   // undefined
+
+/// CollectorInvocation invokes signal handlers differently depending on return type.
+template<typename,typename> struct CollectorInvocation;
+
+/// CollectorLast returns the result of the last signal handler from a signal emission.
+template<typename Result>
+struct CollectorLast {
+  typedef Result CollectorResult;
+  explicit        CollectorLast ()              : last_() {}
+  inline bool     operator()    (Result r)      { last_ = r; return true; }
+  CollectorResult result        ()              { return last_; }
+private:
+  Result last_;
+};
+
+/// CollectorDefault implements the default signal handler collection behaviour.
+template<typename Result>
+struct CollectorDefault : CollectorLast<Result>
+{};
+
+/// CollectorDefault specialisation for signals with void return type.
+template<>
+struct CollectorDefault<void> {
+  typedef void CollectorResult;
+  void                  result     ()           {}
+  inline bool           operator() (void)       { return true; }
+};
+
+/// CollectorInvocation specialisation for regular signals.
+template<class Collector, class R, class... Args>
+struct CollectorInvocation<Collector, R (Args...)> {
+  inline bool
+  invoke (Collector &collector, const boost::function<R (Args...)> &cbf, Args... args)
+  {
+    return collector (cbf (args...));
+  }
+};
+
+/// CollectorInvocation specialisation for signals with void return type.
+template<class Collector, class... Args>
+struct CollectorInvocation<Collector, void (Args...)> {
+  inline bool
+  invoke (Collector &collector, const boost::function<void (Args...)> &cbf, Args... args)
+  {
+    cbf (args...); return collector();
+  }
+};
+
+/// ProtoSignal template specialised for the callback signature and collector.
+template<class Collector, class R, class... Args>
+class ProtoSignal<R (Args...), Collector> : private CollectorInvocation<Collector, R (Args...)> {
+protected:
+  typedef boost::function<R (Args...)> CbFunction;
+  typedef typename CbFunction::result_type Result;
+  typedef typename Collector::CollectorResult CollectorResult;
+private:
+  /// SignalLink implements a doubly-linked ring with ref-counted nodes containing the signal handlers.
+  struct SignalLink {
+    SignalLink *next, *prev;
+    CbFunction  function;
+    int         ref_count;
+    explicit    SignalLink (const CbFunction &cbf) : next (0), prev (0), function (cbf), ref_count (1) {}
+    /*dtor*/   ~SignalLink ()           { assert (ref_count == 0); }
+    void        incref     ()           { ref_count += 1; assert (ref_count > 0); }
+    void        decref     ()           { ref_count -= 1; if (!ref_count) delete this; else assert (ref_count > 0); }
+    void
+    unlink ()
+    {
+      function = 0;
+      if (next)
+        next->prev = prev;
+      if (prev)
+        prev->next = next;
+      decref();
+      // leave intact ->next, ->prev for stale iterators
+    }
+    size_t
+    add_before (const CbFunction &cb)
+    {
+      SignalLink *link = new SignalLink (cb);
+      link->prev = prev; // link to last
+      link->next = this;
+      prev->next = link; // link from last
+      prev = link;
+      static_assert (sizeof (link) == sizeof (size_t), "sizeof size_t");
+      return size_t (link);
+    }
+    bool
+    deactivate (const CbFunction &cbf)
+    {
+      if (cbf == function)
+        {
+          function = 0;      // deactivate static head
+          return true;
+        }
+      for (SignalLink *link = this->next ? this->next : this; link != this; link = link->next)
+        if (cbf == link->function)
+          {
+            link->unlink();     // deactivate and unlink sibling
+            return true;
+          }
+      return false;
+    }
+    bool
+    remove_sibling (size_t id)
+    {
+      for (SignalLink *link = this->next ? this->next : this; link != this; link = link->next)
+        if (id == size_t (link))
+          {
+            link->unlink();     // deactivate and unlink sibling
+            return true;
+          }
+      return false;
+    }
+  };
+  SignalLink   *callback_ring_; // linked ring of callback nodes
+  /*copy-ctor*/ ProtoSignal (const ProtoSignal&) = delete;
+  ProtoSignal&  operator=   (const ProtoSignal&) = delete;
+  void
+  ensure_ring ()
+  {
+    if (!callback_ring_)
+      {
+        callback_ring_ = new SignalLink (CbFunction()); // ref_count = 1
+        callback_ring_->incref(); // ref_count = 2, head of ring, can be deactivated but not removed
+        callback_ring_->next = callback_ring_; // ring head initialization
+        callback_ring_->prev = callback_ring_; // ring tail initialization
+      }
+  }
+public:
+  /// ProtoSignal constructor, connects default callback if non-0.
+  ProtoSignal (const CbFunction &method) :
+    callback_ring_ (0)
+  {
+    if (method != 0)
+      {
+        ensure_ring();
+        callback_ring_->function = method;
+      }
+  }
+  /// ProtoSignal destructor releases all resources associated with this signal.
+  ~ProtoSignal ()
+  {
+    if (callback_ring_)
+      {
+        while (callback_ring_->next != callback_ring_)
+          callback_ring_->next->unlink();
+        assert (callback_ring_->ref_count >= 2);
+        callback_ring_->decref();
+        callback_ring_->decref();
+      }
+  }
+  /// Operator to add a new function or lambda as signal handler, returns a handler connection ID.
+  size_t connect (const CbFunction &cb)      { ensure_ring(); return callback_ring_->add_before (cb); }
+  /// Operator to remove a signal handler through it connection ID, returns if a handler was removed.
+  bool   disconnect (size_t connection)         { return callback_ring_ ? callback_ring_->remove_sibling (connection) : false; }
+  /// Emit a signal, i.e. invoke all its callbacks and collect return types with the Collector.
+  CollectorResult
+  emit (Args... args)
+  {
+    Collector collector;
+    if (!callback_ring_)
+      return collector.result();
+    SignalLink *link = callback_ring_;
+    link->incref();
+    do
+      {
+        if (link->function != 0)
+          {
+            const bool continue_emission = this->invoke (collector, link->function, args...);
+            if (!continue_emission)
+              break;
+          }
+        SignalLink *old = link;
+        link = old->next;
+        link->incref();
+        old->decref();
+      }
+    while (link != callback_ring_);
+    link->decref();
+    return collector.result();
+  }
+  // Number of connected slots.
+  int
+  size ()
+  {
+    int size = 0;
+    SignalLink *link = callback_ring_;
+    link->incref();
+    do
+      {
+        if (link->function != 0)
+          {
+            size++;
+          }
+        SignalLink *old = link;
+        link = old->next;
+        link->incref();
+        old->decref();
+      }
+    while (link != callback_ring_);
+    return size;
+  }
+};
+
+} // Lib
+// namespace Simple
+
+/**
+ * Signal is a template type providing an interface for arbitrary callback lists.
+ * A signal type needs to be declared with the function signature of its callbacks,
+ * and optionally a return result collector class type.
+ * Signal callbacks can be added with operator+= to a signal and removed with operator-=, using
+ * a callback connection ID return by operator+= as argument.
+ * The callbacks of a signal are invoked with the emit() method and arguments according to the signature.
+ * The result returned by emit() depends on the signal collector class. By default, the result of
+ * the last callback is returned from emit(). Collectors can be implemented to accumulate callback
+ * results or to halt a running emissions in correspondance to callback results.
+ * The signal implementation is safe against recursion, so callbacks may be removed and
+ * added during a signal emission and recursive emit() calls are also safe.
+ * The overhead of an unused signal is intentionally kept very low, around the size of a single pointer.
+ * Note that the Signal template types is non-copyable.
+ */
+template <typename SignalSignature, class Collector = Lib::CollectorDefault<typename boost::function<SignalSignature>::result_type> >
+struct Signal /*final*/ :
+    Lib::ProtoSignal<SignalSignature, Collector>
+{
+  typedef Lib::ProtoSignal<SignalSignature, Collector> ProtoSignal;
+  typedef typename ProtoSignal::CbFunction             CbFunction;
+  /// Signal constructor, supports a default callback as argument.
+  Signal (const CbFunction &method = CbFunction()) : ProtoSignal (method) {}
+};
+
+/// This function creates a boost::function by binding @a object to the member function pointer @a method.
+template<class Instance, class Class, class R, class... Args> boost::function<R (Args...)>
+slot (Instance &object, R (Class::*method) (Args...))
+{
+  return [&object, method] (Args... args) { return (object .* method) (args...); };
+}
+
+/// This function creates a boost::function by binding @a object to the member function pointer @a method.
+template<class Class, class R, class... Args> boost::function<R (Args...)>
+slot (Class *object, R (Class::*method) (Args...))
+{
+  return [object, method] (Args... args) { return (object ->* method) (args...); };
+}
+
+/// Keep signal emissions going while all handlers return !0 (true).
+template<typename Result>
+struct CollectorUntil0 {
+  typedef Result CollectorResult;
+  explicit                      CollectorUntil0 ()      : result_() {}
+  const CollectorResult&        result          ()      { return result_; }
+  inline bool
+  operator() (Result r)
+  {
+    result_ = r;
+    return result_ ? true : false;
+  }
+private:
+  CollectorResult result_;
+};
+
+/// Keep signal emissions going while all handlers return 0 (false).
+template<typename Result>
+struct CollectorWhile0 {
+  typedef Result CollectorResult;
+  explicit                      CollectorWhile0 ()      : result_() {}
+  const CollectorResult&        result          ()      { return result_; }
+  inline bool
+  operator() (Result r)
+  {
+    result_ = r;
+    return result_ ? false : true;
+  }
+private:
+  CollectorResult result_;
+};
+
+/// CollectorVector returns the result of the all signal handlers from a signal emission in a std::vector.
+template<typename Result>
+struct CollectorVector {
+  typedef std::vector<Result> CollectorResult;
+  const CollectorResult&        result ()       { return result_; }
+  inline bool
+  operator() (Result r)
+  {
+    result_.push_back (r);
+    return true;
+  }
+private:
+  CollectorResult result_;
+};
+
+} // Simple
+
+
+#endif  // SIMPLE_SIGNAL_H__
+
+
+#ifdef ENABLE_SIMPLE_SIGNAL_TESTS
+
+#include <string>
+#include <stdarg.h>
+#include <time.h>
+#include <sys/time.h>
+
+#ifdef __MACH__
+#include <mach/clock.h>
+#include <mach/mach.h>
+#endif
+
+
+
+
+
+static std::string string_printf (const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
+static std::string
+string_printf (const char *format, ...)
+{
+  std::string result;
+  char *str = 0;
+  va_list args;
+  va_start (args, format);
+  if (vasprintf (&str, format, args) >= 0)
+    result = str;
+  va_end (args);
+  if (str)
+    free (str);
+  return result;
+}
+
+static uint64_t
+timestamp_benchmark ()
+{
+  struct timespec tp = { 0, 0 };
+
+#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
+  clock_serv_t cclock;
+  mach_timespec_t mts;
+  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+  clock_get_time(cclock, &mts);
+  mach_port_deallocate(mach_task_self(), cclock);
+  tp.tv_sec = mts.tv_sec;
+  tp.tv_nsec = mts.tv_nsec;
+#else
+  clock_gettime(CLOCK_REALTIME, &tp);
+#endif
+  uint64_t stamp = tp.tv_sec * 1000000000ULL + tp.tv_nsec;
+  return stamp;
+}
+
+struct TestCounter {
+  static uint64_t get     ();
+  static void     set     (uint64_t);
+  static void     add2    (void*, uint64_t);
+};
+
+namespace { // Anon
+void        (*test_counter_add2) (void*, uint64_t) = TestCounter::add2; // external symbol to prevent easy inlining
+static uint64_t test_counter_var = 0;
+} // Anon
+
+class BasicSignalTests {
+  static std::string accu;
+  struct Foo {
+    char
+    foo_bool (float f, int i, std::string s)
+    {
+      accu += string_printf ("Foo: %.2f\n", f + i + s.size());
+      return true;
+    }
+  };
+  static char
+  float_callback (float f, int, std::string)
+  {
+    accu += string_printf ("float: %.2f\n", f);
+    return 0;
+  }
+public:
+  static void
+  run()
+  {
+    accu = "";
+    Simple::Signal<char (float, int, std::string)> sig1;
+    size_t id1 = sig1.connect(float_callback);
+    size_t id2 = sig1.connect([] (float, int i, std::string) { accu += string_printf ("int: %d\n", i); return 0; });
+    size_t id3 = sig1.connect([] (float, int, const std::string &s) { accu += string_printf ("string: %s\n", s.c_str()); return 0; });
+    sig1.emit (.3, 4, "huhu");
+    bool success;
+    success = sig1.disconnect(id1); assert (success == true);  success = sig1.disconnect(id1); assert (success == false);
+    success = sig1.disconnect(id2); assert (success == true);  success = sig1.disconnect(id3); assert (success == true);
+    success = sig1.disconnect(id3); assert (success == false); success = sig1.disconnect(id2); assert (success == false);
+    Foo foo;
+    sig1.connect(Simple::slot (foo, &Foo::foo_bool));
+    sig1.connect(Simple::slot (&foo, &Foo::foo_bool));
+    sig1.emit (.5, 1, "12");
+
+    Simple::Signal<void (std::string, int)> sig2;
+    sig2.connect([] (std::string msg, int) { accu += string_printf ("msg: %s", msg.c_str()); });
+    sig2.connect([] (std::string, int d)   { accu += string_printf (" *%d*\n", d); });
+    sig2.emit ("in sig2", 17);
+
+    accu += "DONE";
+
+    const char *expected =
+      "float: 0.30\n"
+      "int: 4\n"
+      "string: huhu\n"
+      "Foo: 3.50\n"
+      "Foo: 3.50\n"
+      "msg: in sig2 *17*\n"
+      "DONE";
+    assert (accu == expected);
+  }
+};
+std::string BasicSignalTests::accu;
+
+
+class TestCollectorVector {
+  static int handler1   ()  { return 1; }
+  static int handler42  ()  { return 42; }
+  static int handler777 ()  { return 777; }
+  public:
+  static void
+  run ()
+  {
+    Simple::Signal<int (), Simple::CollectorVector<int>> sig_vector;
+    sig_vector.connect(handler777);
+    sig_vector.connect(handler42);
+    sig_vector.connect(handler1);
+    sig_vector.connect(handler42);
+    sig_vector.connect(handler777);
+    std::vector<int> results = sig_vector.emit();
+    const std::vector<int> reference = { 777, 42, 1, 42, 777, };
+    assert (results == reference);
+  }
+};
+
+class TestCollectorUntil0 {
+  bool check1, check2;
+  TestCollectorUntil0() : check1 (0), check2 (0) {}
+  bool handler_true  ()  { check1 = true; return true; }
+  bool handler_false ()  { check2 = true; return false; }
+  bool handler_abort ()  { abort(); }
+  public:
+  static void
+  run ()
+  {
+    TestCollectorUntil0 self;
+    Simple::Signal<bool (), Simple::CollectorUntil0<bool>> sig_until0;
+    sig_until0.connect(Simple::slot (self, &TestCollectorUntil0::handler_true));
+    sig_until0.connect(Simple::slot (self, &TestCollectorUntil0::handler_false));
+    sig_until0.connect(Simple::slot (self, &TestCollectorUntil0::handler_abort));
+    assert (!self.check1 && !self.check2);
+    const bool result = sig_until0.emit();
+    assert (!result && self.check1 && self.check2);
+  }
+};
+
+class TestCollectorWhile0 {
+  bool check1, check2;
+  TestCollectorWhile0() : check1 (0), check2 (0) {}
+  bool handler_0     ()  { check1 = true; return false; }
+  bool handler_1     ()  { check2 = true; return true; }
+  bool handler_abort ()  { abort(); }
+  public:
+  static void
+  run ()
+  {
+    TestCollectorWhile0 self;
+    Simple::Signal<bool (), Simple::CollectorWhile0<bool>> sig_while0;
+    sig_while0.connect(Simple::slot (self, &TestCollectorWhile0::handler_0));
+    sig_while0.connect(Simple::slot (self, &TestCollectorWhile0::handler_1));
+    sig_while0.connect(Simple::slot (self, &TestCollectorWhile0::handler_abort));
+    assert (!self.check1 && !self.check2);
+    const bool result = sig_while0.emit();
+    assert (result == true && self.check1 && self.check2);
+  }
+};
+
+static void
+bench_simple_signal()
+{
+  Simple::Signal<void (void*, uint64_t)> sig_increment;
+  sig_increment.connect(test_counter_add2);
+  const uint64_t start_counter = TestCounter::get();
+  const uint64_t benchstart = timestamp_benchmark();
+  uint64_t i;
+  for (i = 0; i < 999999; i++)
+    {
+      sig_increment.emit (0, 1);
+    }
+  const uint64_t benchdone = timestamp_benchmark();
+  const uint64_t end_counter = TestCounter::get();
+  assert (end_counter - start_counter == i);
+  printf ("OK\n  Benchmark: Simple::Signal: %fns per emission (size=%zu): ", size_t (benchdone - benchstart) * 1.0 / size_t (i),
+          sizeof (sig_increment));
+}
+
+static void
+bench_callback_loop()
+{
+  void (*counter_increment) (void*, uint64_t) = test_counter_add2;
+  const uint64_t start_counter = TestCounter::get();
+  const uint64_t benchstart = timestamp_benchmark();
+  uint64_t i;
+  for (i = 0; i < 999999; i++)
+    {
+      counter_increment (0, 1);
+    }
+  const uint64_t benchdone = timestamp_benchmark();
+  const uint64_t end_counter = TestCounter::get();
+  assert (end_counter - start_counter == i);
+  printf ("OK\n  Benchmark: callback loop: %fns per round: ", size_t (benchdone - benchstart) * 1.0 / size_t (i));
+}
+
+uint64_t
+TestCounter::get ()
+{
+  return test_counter_var;
+}
+
+void
+TestCounter::set (uint64_t v)
+{
+  test_counter_var = v;
+}
+
+void
+TestCounter::add2 (void*, uint64_t v)
+{
+  test_counter_var += v;
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  printf ("Signal/Basic Tests: ");
+  BasicSignalTests::run();
+  printf ("OK\n");
+
+  printf ("Signal/CollectorVector: ");
+  TestCollectorVector::run();
+  printf ("OK\n");
+
+  printf ("Signal/CollectorUntil0: ");
+  TestCollectorUntil0::run();
+  printf ("OK\n");
+
+  printf ("Signal/CollectorWhile0: ");
+  TestCollectorWhile0::run();
+  printf ("OK\n");
+
+  printf ("Signal/Benchmark: Simple::Signal: ");
+  bench_simple_signal();
+  printf ("OK\n");
+
+  printf ("Signal/Benchmark: callback loop: ");
+  bench_callback_loop();
+  printf ("OK\n");
+
+  return 0;
+}
+
+#endif // DISABLE_TESTS
+
+// g++ -Wall -O2 -std=gnu++0x -pthread simplesignal.cc -lrt && ./a.out
diff --git a/entityx/Entity.h b/entityx/Entity.h
index 3296e34..535b395 100644
--- a/entityx/Entity.h
+++ b/entityx/Entity.h
@@ -11,6 +11,7 @@
 #pragma once
 
 
+#include <stdint.h>
 #include <algorithm>
 #include <bitset>
 #include <cassert>
@@ -18,7 +19,6 @@
 #include <iterator>
 #include <list>
 #include <set>
-#include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ -73,7 +73,7 @@ public:
   /**
    * Check if Entity handle is invalid.
    */
-  bool operator ! () const {
+  bool operator !() const {
     return !valid();
   }
 
@@ -189,7 +189,7 @@ struct Component : public BaseComponent {
  * Emitted when an entity is added to the system.
  */
 struct EntityCreatedEvent : public Event<EntityCreatedEvent> {
-  EntityCreatedEvent(Entity entity) : entity(entity) {}
+  explicit EntityCreatedEvent(Entity entity) : entity(entity) {}
 
   Entity entity;
 };
@@ -199,7 +199,7 @@ struct EntityCreatedEvent : public Event<EntityCreatedEvent> {
  * Called just prior to an entity being destroyed.
  */
 struct EntityDestroyedEvent : public Event<EntityDestroyedEvent> {
-  EntityDestroyedEvent(Entity entity) : entity(entity) {}
+  explicit EntityDestroyedEvent(Entity entity) : entity(entity) {}
 
   Entity entity;
 };
@@ -238,7 +238,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
      public:
       ComponentMaskPredicate(const std::vector<ComponentMask> &entity_id, ComponentMask mask) : entity_id_(entity_id), mask_(mask) {}
 
-      bool operator () (entityx::shared_ptr<EntityManager> entities, Entity::Id entity) {
+      bool operator()(entityx::shared_ptr<EntityManager> entities, Entity::Id entity) {
         return entities->entity_version_.at(entity.index()) == entity.version()
             && (entity_id_.at(entity.index()) & mask_) == mask_;
       }
@@ -251,7 +251,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
     /// An iterator over a view of the entities in an EntityManager.
     class Iterator : public std::iterator<std::input_iterator_tag, Entity::Id> {
      public:
-      Iterator &operator ++ () {
+      Iterator &operator ++() {
         ++i_;
         next();
         return *this;
@@ -267,7 +267,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
       Iterator() {}
 
       Iterator(entityx::shared_ptr<EntityManager> manager, const std::vector<Predicate> &predicates,
-               const std::vector<boost::function<void (Entity::Id)>> &unpackers, uint32_t index)
+               const std::vector<boost::function<void(Entity::Id)>> &unpackers, uint32_t index)
           : manager_(manager), predicates_(predicates), unpackers_(unpackers), i_(index) {
         next();
       }
@@ -296,7 +296,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
 
       entityx::shared_ptr<EntityManager> manager_;
       const std::vector<Predicate> predicates_;
-      std::vector<boost::function<void (Entity::Id)>> unpackers_;
+      std::vector<boost::function<void(Entity::Id)>> unpackers_;
       uint32_t i_;
     };
 
@@ -325,6 +325,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
       unpack_to<A>(a);
       return unpack_to<B, Args ...>(b, args ...);
     }
+
    private:
     friend class EntityManager;
 
@@ -332,7 +333,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
     struct Unpacker {
       Unpacker(entityx::shared_ptr<EntityManager> manager, entityx::shared_ptr<T> &c) : manager_(manager), c(c) {}
 
-      void operator () (Entity::Id id) {
+      void operator()(Entity::Id id) {
         c = manager_->component<T>(id);
       }
 
@@ -347,7 +348,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
 
     entityx::shared_ptr<EntityManager> manager_;
     std::vector<Predicate> predicates_;
-    std::vector<boost::function<void (Entity::Id)>> unpackers_;
+    std::vector<boost::function<void(Entity::Id)>> unpackers_;
   };
 
   /**
@@ -522,7 +523,7 @@ class EntityManager : public entityx::enable_shared_from_this<EntityManager>, bo
   void destroy_all();
 
  private:
-  EntityManager(entityx::shared_ptr<EventManager> event_manager) : event_manager_(event_manager) {}
+  explicit EntityManager(entityx::shared_ptr<EventManager> event_manager) : event_manager_(event_manager) {}
 
 
   template <typename C>
@@ -616,4 +617,4 @@ void Entity::unpack(entityx::shared_ptr<A> &a, entityx::shared_ptr<B> &b, Args &
   manager_.lock()->unpack(id_, a, b, args ...);
 }
 
-}
+}  // namespace entityx
diff --git a/entityx/Event.h b/entityx/Event.h
index 8d3de61..e6f8fbe 100644
--- a/entityx/Event.h
+++ b/entityx/Event.h
@@ -14,9 +14,11 @@
 #include <boost/bind.hpp>
 #include <boost/function.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/signal.hpp>
 #include <boost/unordered_map.hpp>
+#include <list>
+#include <utility>
 #include "entityx/config.h"
+#include "entityx/3rdparty/simplesignal.h"
 
 
 namespace entityx {
@@ -35,6 +37,11 @@ class BaseEvent {
 };
 
 
+typedef Simple::Signal<void (const BaseEvent*)> EventSignal;
+typedef entityx::shared_ptr<EventSignal> EventSignalPtr;
+typedef entityx::weak_ptr<EventSignal> EventSignalWeakPtr;
+
+
 /**
  * Event types should subclass from this.
  *
@@ -60,13 +67,27 @@ class BaseReceiver {
  public:
   virtual ~BaseReceiver() {
     for (auto connection : connections_) {
-      connection.disconnect();
+      auto &ptr = connection.first;
+      if (!ptr.expired()) {
+        ptr.lock()->disconnect(connection.second);
+      }
+    }
+  }
+
+  // Return number of signals connected to this receiver.
+  int connected_signals() const {
+    size_t size = 0;
+    for (auto connection : connections_) {
+      if (!connection.first.expired()) {
+        size++;
+      }
     }
+    return size;
   }
 
  private:
   friend class EventManager;
-  std::list<boost::signals::connection> connections_;
+  std::list<std::pair<EventSignalWeakPtr, size_t>> connections_;
 };
 
 
@@ -84,7 +105,6 @@ class Receiver : public BaseReceiver {
  */
 class EventManager : public entityx::enable_shared_from_this<EventManager>, boost::noncopyable {
  public:
-
   static entityx::shared_ptr<EventManager> make() {
     return entityx::shared_ptr<EventManager>(new EventManager());
   }
@@ -105,11 +125,13 @@ class EventManager : public entityx::enable_shared_from_this<EventManager>, boos
    * em.subscribe<Explosion>(receiver);
    */
   template <typename E, typename Receiver>
-  void subscribe(Receiver &receiver) {
-    void (Receiver::*receive) (const E &) = &Receiver::receive;
+  void subscribe(Receiver &receiver) {  //NOLINT
+    void (Receiver::*receive)(const E &) = &Receiver::receive;
     auto sig = signal_for(E::family());
     auto wrapper = EventCallbackWrapper<E>(boost::bind(receive, &receiver, _1));
-    static_cast<BaseReceiver&>(receiver).connections_.push_back(sig->connect(wrapper));
+    auto connection = sig->connect(wrapper);
+    static_cast<BaseReceiver&>(receiver).connections_.push_back(
+      std::make_pair(EventSignalWeakPtr(sig), connection));
   }
 
   /**
@@ -127,20 +149,25 @@ class EventManager : public entityx::enable_shared_from_this<EventManager>, boos
   void emit(Args && ... args) {
     E event(args ...);
     auto sig = signal_for(E::family());
-    (*sig)(static_cast<BaseEvent*>(&event));
+    sig->emit(static_cast<BaseEvent*>(&event));
   }
 
- private:
-  typedef boost::signal<void (const BaseEvent*)> EventSignal;
-  typedef entityx::shared_ptr<EventSignal> EventSignalPtr;
+  int connected_receivers() const {
+    int size = 0;
+    for (auto pair : handlers_) {
+      size += pair.second->size();
+    }
+    return size;
+  }
 
+ private:
   EventManager() {}
 
-   EventSignalPtr signal_for(int id) {
+  EventSignalPtr signal_for(int id) {
     auto it = handlers_.find(id);
     if (it == handlers_.end()) {
       EventSignalPtr sig(entityx::make_shared<EventSignal>());
-      handlers_.insert(make_pair(id, sig));
+      handlers_.insert(std::make_pair(id, sig));
       return sig;
     }
     return it->second;
@@ -149,12 +176,12 @@ class EventManager : public entityx::enable_shared_from_this<EventManager>, boos
   // Functor used as an event signal callback that casts to E.
   template <typename E>
   struct EventCallbackWrapper {
-    EventCallbackWrapper(boost::function<void (const E &)> callback) : callback(callback) {}
-    void operator () (const BaseEvent* event) { callback(*(static_cast<const E*>(event))); }
-    boost::function<void (const E &)> callback;
+    EventCallbackWrapper(boost::function<void(const E &)> callback) : callback(callback) {}
+    void operator()(const BaseEvent* event) { callback(*(static_cast<const E*>(event))); }
+    boost::function<void(const E &)> callback;
   };
 
   boost::unordered_map<int, EventSignalPtr> handlers_;
 };
 
-}
+}  // namespace entityx
diff --git a/entityx/Event_test.cc b/entityx/Event_test.cc
index a797ad7..2e6528c 100644
--- a/entityx/Event_test.cc
+++ b/entityx/Event_test.cc
@@ -8,16 +8,19 @@
  * Author: Alec Thomas <alec@swapoff.org>
  */
 
+#include <gtest/gtest.h>
 #include <string>
 #include <vector>
-#include <gtest/gtest.h>
 #include "entityx/Event.h"
 
-using namespace entityx;
-using namespace boost;
+
+using entityx::EventManager;
+using entityx::Event;
+using entityx::Receiver;
+
 
 struct Explosion : public Event<Explosion> {
-  Explosion(int damage) : damage(damage) {}
+  explicit Explosion(int damage) : damage(damage) {}
   int damage;
 };
 
@@ -37,3 +40,31 @@ TEST(EventManagerTest, TestEmitReceive) {
   em->emit<Explosion>(10);
   ASSERT_EQ(10, explosion_system.damage_received);
 }
+
+
+TEST(EventManagerTest, TestReceiverExpired) {
+  auto em = EventManager::make();
+  {
+    ExplosionSystem explosion_system;
+    em->subscribe<Explosion>(explosion_system);
+    em->emit<Explosion>(10);
+    ASSERT_EQ(10, explosion_system.damage_received);
+    ASSERT_EQ(1, explosion_system.connected_signals());
+    ASSERT_EQ(1, em->connected_receivers());
+  }
+  ASSERT_EQ(0, em->connected_receivers());
+}
+
+
+TEST(EventManagerTest, TestSenderExpired) {
+  ExplosionSystem explosion_system;
+  {
+    auto em = EventManager::make();
+    em->subscribe<Explosion>(explosion_system);
+    em->emit<Explosion>(10);
+    ASSERT_EQ(10, explosion_system.damage_received);
+    ASSERT_EQ(1, explosion_system.connected_signals());
+    ASSERT_EQ(1, em->connected_receivers());
+  }
+  ASSERT_EQ(0, explosion_system.connected_signals());
+}
diff --git a/entityx/config.h.in b/entityx/config.h.in
index e1e4d67..9722cf4 100644
--- a/entityx/config.h.in
+++ b/entityx/config.h.in
@@ -6,6 +6,9 @@
 #cmakedefine ENTITYX_MAX_COMPONENTS @ENTITYX_MAX_COMPONENTS@
 #cmakedefine ENTITYX_HAVE_BOOST_PYTHON 1
 #cmakedefine ENTITYX_INSTALLED_PYTHON_PACKAGE_DIR "@ENTITYX_INSTALLED_PYTHON_PACKAGE_DIR@"
+#cmakedefine ENTITYX_NEED_GET_POINTER_SHARED_PTR_SPECIALIZATION "@ENTITYX_NEED_GET_POINTER_SHARED_PTR_SPECIALIZATION@"
+
+#include <stdint.h>
 
 // Which shared_ptr implementation should we use?
 #if (ENTITYX_HAVE_STD_SHARED_PTR && ENTITYX_USE_STD_SHARED_PTR)
@@ -22,6 +25,7 @@ using std::enable_shared_from_this;
 
 #elif ENTITYX_HAVE_BOOST_SHARED_PTR
 
+#include <boost/enable_shared_from_this.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/make_shared.hpp>
@@ -37,5 +41,5 @@ using boost::enable_shared_from_this;
 #endif
 
 namespace entityx {
-static const int MAX_COMPONENTS = ENTITYX_MAX_COMPONENTS;
+static const uint64_t MAX_COMPONENTS = ENTITYX_MAX_COMPONENTS;
 }
diff --git a/entityx/python/PythonSystem.cc b/entityx/python/PythonSystem.cc
index c313e50..0abdde6 100644
--- a/entityx/python/PythonSystem.cc
+++ b/entityx/python/PythonSystem.cc
@@ -40,7 +40,7 @@ struct EntityIdToPythonInteger {
 class PythonEntityXLogger {
 public:
   PythonEntityXLogger() {}
-  PythonEntityXLogger(PythonSystem::LoggerFunction logger) : logger_(logger) {}
+  explicit PythonEntityXLogger(PythonSystem::LoggerFunction logger) : logger_(logger) {}
 
   void write(const std::string &text) {
     logger_(text);
@@ -51,7 +51,7 @@ private:
 
 
 struct PythonEntity {
-  PythonEntity(Entity entity) : _entity(entity) {}
+  explicit PythonEntity(Entity entity) : _entity(entity) {}
 
   void destroy() {
     _entity.destroy();
@@ -164,7 +164,7 @@ void PythonSystem::configure(entityx::shared_ptr<EventManager> event_manager) {
     py::object entityx = py::import("_entityx");
     entityx.attr("_entity_manager") = entity_manager_;
     // entityx.attr("event_manager") = boost::ref(event_manager);
-  } catch (...) {
+  } catch(...) {
     PyErr_Print();
     PyErr_Clear();
     throw;
@@ -177,7 +177,7 @@ void PythonSystem::update(entityx::shared_ptr<EntityManager> entity_manager, ent
 
     try {
       python->object.attr("update")(dt);
-    } catch (...) {
+    } catch(...) {
       PyErr_Print();
       PyErr_Clear();
       throw;
@@ -220,5 +220,5 @@ void PythonSystem::receive(const ComponentAddedEvent<PythonComponent> &event) {
   }
 }
 
-}
-}
+}  // namespace python
+}  // namespace entityx
diff --git a/entityx/python/PythonSystem.h b/entityx/python/PythonSystem.h
index 7001f23..1d2926b 100644
--- a/entityx/python/PythonSystem.h
+++ b/entityx/python/PythonSystem.h
@@ -12,6 +12,7 @@
 
 // http://docs.python.org/2/extending/extending.html
 #include <Python.h>
+
 #include "entityx/config.h"
 
 // boost::python smart pointer adapter for std::shared_ptr<T>
@@ -20,6 +21,8 @@
 #include <boost/python.hpp>
 #include <memory>
 
+#ifdef ENTITYX_NEED_GET_POINTER_SHARED_PTR_SPECIALIZATION
+
 namespace std {
 
 // This may or may not work... it definitely does not work on OSX.
@@ -29,6 +32,8 @@ template <class T> inline T * get_pointer(const std::shared_ptr<T> &p) {
 
 }
 
+#endif
+
 namespace boost {
 namespace python {
 
@@ -41,6 +46,7 @@ template <typename T> struct pointee<std::shared_ptr<T> > {
 
 #endif
 
+#include <list>
 #include <vector>
 #include <string>
 #include <boost/python.hpp>
@@ -107,7 +113,7 @@ public:
    * @param handler_name The default implementation of can_send() tests for
    *     the existence of this attribute on an Entity.
    */
-  PythonEventProxy(const std::string &handler_name) : handler_name(handler_name) {}
+  explicit PythonEventProxy(const std::string &handler_name) : handler_name(handler_name) {}
   virtual ~PythonEventProxy() {}
 
   /**
diff --git a/entityx/python/entityx/tests/deep_subclass_test.py b/entityx/python/entityx/tests/deep_subclass_test.py
index 9c576b2..801b487 100644
--- a/entityx/python/entityx/tests/deep_subclass_test.py
+++ b/entityx/python/entityx/tests/deep_subclass_test.py
@@ -21,4 +21,6 @@ class DeepSubclassTest2(DeepSubclassTest):
         assert self.direction
         assert self.position
         assert self.position2
-        assert self.position is self.position2
+        assert self.position.x == self.position2.x and self.position.y == self.position2.y
+        self.position.x += 1
+        assert self.position.x == self.position2.x and self.position.y == self.position2.y