introduce indexes in shared data

synergine2/share.py

 from synergine2.exceptions import UnknownSharedData
 
 
+class SharedDataIndex(object):
+    def __init__(
+        self,
+        shared_data_manager: 'SharedDataManager',
+        key: str,
+    ) -> None:
+        self.shared_data_manager = shared_data_manager
+        self.key = key
+
+    def add(self, value: typing.Any) -> None:
+        raise NotImplementedError()
+
+    def remove(self, value: typing.Any) -> None:
+        raise NotImplementedError()
+
+
 class SharedDataManager(object):
     """
     This object is designed to own shared memory between processes. It must be feed (with set method) before
     def refresh(self) -> None:
         self._data = {}
 
+    def make_index(
+        self,
+        shared_data_index_class: typing.Type[SharedDataIndex],
+        key: str,
+        *args: typing.Any,
+        **kwargs: typing.Any
+    ) -> SharedDataIndex:
+        return shared_data_index_class(self, key, *args, **kwargs)
+
     def create(
         self,
         key: str,
         value,
-        indexes=None,
+        indexes: typing.List[SharedDataIndex]=None,
     ):
+        indexes = indexes or []
+
         def get_key(obj):
             return key
 
             return self.get(key)
 
         def fset(self_, value_):
+            try:
+                previous_value = self.get(key_formatter(self_))
+                for index in indexes:
+                    index.remove(previous_value)
+            except UnknownSharedData:
+                pass  # If no shared data, no previous value to remove
+
             self.set(key_formatter(self_), value_)
 
+            for index in indexes:
+                index.add(value_)
+
         def fdel(self_):
             raise SynergineException('You cannot delete a shared data')
 

tests/test_share.py

 
 from synergine2.exceptions import UnknownSharedData
 from synergine2.share import SharedDataManager
+from synergine2.share import SharedDataIndex
 from tests import BaseTest
 
 
         class Foo(object):
             counter = shared.create(
                 '{id}_counter',
-                (0, 0, 0),
+                0,
                 indexes=[],
             )
 
 
         assert shared.get('{}_counter'.format(foo.id)) == 48
 
+    def test_multiple_uses(self):
+        shared = SharedDataManager()
+
+        class Foo(object):
+            position = shared.create(
+                '{id}_position',
+                (0, 0, 0),
+                indexes=[],
+            )
+
+            @property
+            def id(self):
+                return id(self)
+
+        foo = Foo()
+        foo.position = (0, 1, 2)
+
+        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
+
+        foo2 = Foo()
+        foo2.position = (3, 4, 5)
+
+        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
+        assert shared.get('{}_position'.format(foo2.id)) == (3, 4, 5)
+
     def test_update_dict_with_pointer(self):
         shared = SharedDataManager()
 
         shared.refresh()
         assert shared.get('counter') == 42
 
-    def test_indexes(self):
-        pass
+    def test_position_index(self):
+        class ListIndex(SharedDataIndex):
+            def add(self, value):
+                try:
+                    values = self.shared_data_manager.get(self.key)
+                except UnknownSharedData:
+                    values = []
+
+                values.append(value)
+                self.shared_data_manager.set(self.key, values)
+
+            def remove(self, value):
+                values = self.shared_data_manager.get(self.key)
+                values.remove(value)
+                self.shared_data_manager.set(self.key, values)
+
+        shared = SharedDataManager()
+
+        class Foo(object):
+            position = shared.create(
+                '{id}_position',
+                (0, 0, 0),
+                indexes=[shared.make_index(ListIndex, 'positions')],
+            )
+
+            @property
+            def id(self):
+                return id(self)
+
+        with pytest.raises(UnknownSharedData):
+            shared.get('positions')
+
+        foo = Foo()
+        foo.position = (0, 1, 2)
+
+        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
+        assert shared.get('positions') == [(0, 1, 2)]
+
+        foo2 = Foo()
+        foo2.position = (3, 4, 5)
+
+        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
+        assert shared.get('{}_position'.format(foo2.id)) == (3, 4, 5)
+        assert shared.get('positions') == [(0, 1, 2), (3, 4, 5)]
+
+        foo2.position = (6, 7, 8)
+        assert shared.get('{}_position'.format(foo2.id)) == (6, 7, 8)
+        assert shared.get('positions') == [(0, 1, 2), (6, 7, 8)]