remove NSIndex1a

src/borg/hashindex.pyx

@@ -239,80 +239,6 @@ cdef class NSKeyIterator:
                 NSIndexEntry(segment, _le32toh(value[1]), _le32toh(value[2])))
 
 
-cdef class NSIndex1a(IndexBase):  # legacy borg 1.x
-
-    legacy = 1
-    value_size = 8
-
-    def __getitem__(self, key):
-        assert len(key) == self.key_size
-        data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
-        if not data:
-            raise KeyError(key)
-        cdef uint32_t segment = _le32toh(data[0])
-        assert segment <= _MAX_VALUE, "maximum number of segments reached"
-        return segment, _le32toh(data[1])
-
-    def __setitem__(self, key, value):
-        assert len(key) == self.key_size
-        cdef uint32_t[2] data
-        cdef uint32_t segment = value[0]
-        assert segment <= _MAX_VALUE, "maximum number of segments reached"
-        data[0] = _htole32(segment)
-        data[1] = _htole32(value[1])
-        if not hashindex_set(self.index, <unsigned char *>key, data):
-            raise Exception('hashindex_set failed')
-
-    def __contains__(self, key):
-        cdef uint32_t segment
-        assert len(key) == self.key_size
-        data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
-        if data != NULL:
-            segment = _le32toh(data[0])
-            assert segment <= _MAX_VALUE, "maximum number of segments reached"
-        return data != NULL
-
-    def iteritems(self, marker=None):
-        cdef const unsigned char *key
-        iter = NSKeyIterator1(self.key_size)
-        iter.idx = self
-        iter.index = self.index
-        if marker:
-            key = hashindex_get(self.index, <unsigned char *>marker)
-            if marker is None:
-                raise IndexError
-            iter.key = key - self.key_size
-        return iter
-
-
-cdef class NSKeyIterator1:  # legacy borg 1.x
-    cdef NSIndex1a idx
-    cdef HashIndex *index
-    cdef const unsigned char *key
-    cdef int key_size
-    cdef int exhausted
-
-    def __cinit__(self, key_size):
-        self.key = NULL
-        self.key_size = key_size
-        self.exhausted = 0
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self.exhausted:
-            raise StopIteration
-        self.key = hashindex_next_key(self.index, <unsigned char *>self.key)
-        if not self.key:
-            self.exhausted = 1
-            raise StopIteration
-        cdef uint32_t *value = <uint32_t *>(self.key + self.key_size)
-        cdef uint32_t segment = _le32toh(value[0])
-        assert segment <= _MAX_VALUE, "maximum number of segments reached"
-        return (<char *>self.key)[:self.key_size], (segment, _le32toh(value[1]))
-
-
 ChunkIndexEntry = namedtuple('ChunkIndexEntry', 'refcount size')