From bd14729f305c077e65963fba4aeaab3baf8ee653 Mon Sep 17 00:00:00 2001
From: Fredrik Tolf <fredrik@dolda2000.com>
Date: Sat, 21 Mar 2015 08:09:52 +0100
Subject: [PATCH] Added support for compound indices.

---
 didex/index.py  | 39 +++++++++++++++++++++++++++++++++++++++
 didex/values.py | 48 ++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 77 insertions(+), 10 deletions(-)

diff --git a/didex/index.py b/didex/index.py
index a2828ce..cdd4069 100644
--- a/didex/index.py
+++ b/didex/index.py
@@ -49,6 +49,45 @@ class maybe(object):
         else:
             return self.bk.compare(a[1:], b[1:])
 
+class compound(object):
+    def __init__(self, *parts):
+        self.parts = parts
+
+    def encode(self, obs):
+        if len(obs) != len(self.parts):
+            raise ValueError("invalid length of compound data: " + str(len(obs)) + ", rather than " + len(self.parts))
+        buf = bytearray()
+        for ob, part in zip(obs, self.parts):
+            dat = part.encode(ob)
+            if len(dat) < 128:
+                buf.append(0x80 | len(dat))
+                buf.extend(dat)
+            else:
+                buf.extend(struct.pack(">i", len(dat)))
+                buf.extend(dat)
+        return bytes(buf)
+    def decode(self, dat):
+        ret = []
+        off = 0
+        for part in self.parts:
+            if dat[off] & 0x80:
+                ln = dat[off] & 0x7f
+                off += 1
+            else:
+                ln = struct.unpack(">i", dat[off:off + 4])[0]
+                off += 4
+            ret.append(part.decode(dat[off:off + len]))
+            off += len
+        return tuple(ret)
+    def compare(self, al, bl):
+        if (len(al) != len(self.parts)) or (len(bl) != len(self.parts)):
+            raise ValueError("invalid length of compound data: " + str(len(al)) + ", " + str(len(bl)) + ", rather than " + len(self.parts))
+        for a, b, part in zip(al, bl, self.parts):
+            c = part.compare(a, b)
+            if c != 0:
+                return c
+        return 0
+
 def floatcmp(a, b):
     if math.isnan(a) and math.isnan(b):
         return 0
diff --git a/didex/values.py b/didex/values.py
index 090edd4..9a501eb 100644
--- a/didex/values.py
+++ b/didex/values.py
@@ -1,5 +1,5 @@
 import threading
-from . import store, lib
+from . import store, lib, index
 from .store import storedesc
 
 __all__ = ["simple", "multi"]
@@ -23,16 +23,13 @@ class cursor(lib.closable):
         self.bk.skip(n)
 
 class base(storedesc):
-    def __init__(self, store, indextype, name, datatype, default):
+    def __init__(self, store, indextype, name, datatype):
         self.store = store
         self.indextype = indextype
         self.name = name
         self.typ = datatype
-        self.default = default
         self.idx = None
         self.lk = threading.Lock()
-        self.mattr = "__idx_%s_new" % name
-        self.iattr = "__idx_%s_cur" % name
 
     def index(self):
         with self.lk:
@@ -40,6 +37,16 @@ class base(storedesc):
                 self.idx = self.indextype(self.store.db(), self.name, self.typ)
             return self.idx
 
+    def get(self, **kwargs):
+        return cursor(self.index().get(**kwargs), self.store)
+
+class descbase(base):
+    def __init__(self, store, indextype, name, datatype, default):
+        super().__init__(store, indextype, name, datatype)
+        self.default = default
+        self.mattr = "__idx_%s_new" % name
+        self.iattr = "__idx_%s_cur" % name
+
     def __get__(self, obj, cls):
         if obj is None: return self
         return getattr(obj, self.mattr, self.default)
@@ -50,10 +57,7 @@ class base(storedesc):
     def __delete__(self, obj):
         delattr(obj, self.mattr)
 
-    def get(self, **kwargs):
-        return cursor(self.index().get(**kwargs), self.store)
-
-class simple(base):
+class simple(descbase):
     def __init__(self, store, indextype, name, datatype, default=None):
         super().__init__(store, indextype, name, datatype, default)
 
@@ -75,7 +79,7 @@ class simple(base):
             idx.put(val, id, tx=tx)
             tx.postcommit(lambda: setattr(obj, self.iattr, val))
 
-class multi(base):
+class multi(descbase):
     def __init__(self, store, indextype, name, datatype):
         super().__init__(store, indextype, name, datatype, ())
 
@@ -102,3 +106,27 @@ class multi(base):
             for val in vals - ivals:
                 idx.put(val, id, tx=tx)
             tx.postcommit(lambda: setattr(obj, self.iattr, vals))
+
+class compound(base):
+    def __init__(self, indextype, name, *parts):
+        super().__init__(parts[0].store, indextype, name, index.compound(*(part.typ for part in parts)))
+        self.parts = parts
+        self.iattr = "__idx_%s_cur" % name
+
+    def register(self, id, obj, tx):
+        val = tuple(part.__get__(obj, None) for part in self.parts)
+        self.index().put(val, id, tx=tx)
+        tx.postcommit(lambda: setattr(obj, self.iattr, val))
+
+    def unregister(self, id, obj, tx):
+        self.index().remove(getattr(obj, self.iattr), id, tx=tx)
+        tx.postcommit(lambda: delattr(obj, self.iattr))
+
+    def update(self, id, obj, tx):
+        val = tuple(part.__get__(obj, None) for part in self.parts)
+        ival = getattr(obj, self.iattr)
+        if val != ival:
+            idx = self.index()
+            idx.remove(ival, id, tx=tx)
+            idx.put(val, id, tx=tx)
+            tx.postcommit(lambda: setattr(obj, self.iattr, val))
-- 
2.11.0