def _hashValues(self): item = self._item kind = item._kind view = item.itsView hash = 0 names = self.keys() names.sort() for name in names: attribute = kind.getAttribute(name, False, item) if attribute.getAspect('persisted', True): hash = _combine(hash, _hash(name)) value = self[name] if value is None: hash = _combine(hash, 0) elif value._isUUID(): hash = _combine(hash, value._hash) elif value._isItem(): hash = _combine(hash, value._uuid._hash) elif value._isRefList(): hash = _combine(hash, value._hashValues()) return hash
def hashValue(self, value): view = self.itsView hash = _hash(str(self.itsPath)) for v in value: hash = _combine(hash, TypeHandler.hashValue(view, v)) return hash
def _unchangedValue(self, item, name): try: self.values.append((name, self.oldValues[_hash(name)])) except KeyError: raise AssertionError, "unchanged value for '%s' not found" % (name) return 0
def _unchangedValue(self, item, name): try: self.values.append((name, self.oldValues[_hash(name)])) except KeyError: raise AssertionError, "unchanged value for '%s' not found" %(name) return 0
def hashValue(self, value): view = self.itsView hash = _hash(str(self.itsPath)) for k, v in value.iteritems(): hash = _combine(hash, TypeHandler.hashValue(view, k)) hash = _combine(hash, TypeHandler.hashValue(view, v)) return hash
def _hashItem(self): hash = 0 isMixin = self.isMixin() if not isMixin: hash = _combine(hash, _hash(str(self.itsPath))) for superKind in self.getAttributeValue('superKinds', self._references): hash = _combine(hash, superKind.hashItem()) if not isMixin: attributes = list(self.iterAttributes(False)) attributes.sort() for name, attribute, kind in attributes: hash = _combine(hash, _hash(name)) hash = _combine(hash, attribute.hashItem()) return hash
def _hashValues(self): hash = 0 for key in self.iterkeys(): link = self._get(key) hash = _combine(hash, key._hash) if link._alias is not None: hash = _combine(hash, _hash(link._alias)) return hash
def hashItem(self): """ Compute a hash value from this type's schema. The hash value is computed from the type's path. @return: an integer """ return _hash(str(self.itsPath))
def readName(self, version, key, name): if name is None: raise ValueError, 'name is None' if isinstance(name, unicode): name = name.encode('utf-8') cursorKey = pack('>16sl', key._uuid, _hash(name)) store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor() try: value = cursor.set_range(cursorKey, self._flags) except DBNotFoundError: return None except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(8) continue else: raise try: while value is not None and value[0].startswith(cursorKey): nameVer = ~unpack('>l', value[0][-4:])[0] if nameVer <= version: if value[1] == value[0][0:16]: # deleted name return None return UUID(value[1]) else: value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(9) continue else: raise return None finally: self.closeCursor(cursor) store.abortTransaction(txnStatus)
def _hashItem(self): hash = 0 view = self.itsView item = self.getAttributeValue('superAttribute', self._references, None, None) if item is not None: hash = _combine(hash, item.hashItem()) def hashValue(hash, type, value): if type is not None: return _combine(hash, type.hashValue(value)) else: return _combine(hash, TypeHandler.hashValue(view, value)) for aspect in Attribute.valueAspects: value = self.getAttributeValue(aspect, self._values, None, Nil) if value is not Nil: hash = _combine(hash, _hash(aspect)) type = self.getAttributeAspect(aspect, 'type', False, None, None) card = self.getAttributeAspect(aspect, 'cardinality', False, None, 'single') if card == 'single': hash = hashValue(hash, type, value) elif card == 'list': for v in value: hash = hashValue(hash, type, v) else: raise NotImplementedError, card item = self.getAttributeValue('type', self._references, None, None) if item is not None: if isinstance(item, Kind): hash = _combine(hash, _hash(str(item.itsPath))) else: hash = _combine(hash, item.hashItem()) return hash
def hashValue(self, value): view = self.itsView hash = _hash(str(self.itsPath)) fields = self.getAttributeValue('fields', self._values, None, None) if fields: for fieldName, field in fields.iteritems(): default = self.getDefaultValue(fieldName) fieldValue = self.getFieldValue(value, fieldName, default) if fieldValue == default: continue fieldType = field.get('type', None) hash = _combine(hash, _hash(fieldName)) if fieldType is not None: hash = _combine(hash, fieldType.hashValue(fieldValue)) else: hash = _combine(hash, TypeHandler.hashValue(view, fieldValue)) return hash
def writeName(self, version, key, name, uuid): if name is None: raise ValueError, 'name is None' if isinstance(name, unicode): name = name.encode('utf-8') if uuid is None: uuid = key return self.put(pack('>16sll', key._uuid, _hash(name), ~version), uuid._uuid)
def hashItem(self): """ Compute a hash value from this aliase's schema. The hash value is computed from the aliase's path and types. @return: an integer """ hash = _hash(str(self.itsPath)) if 'types' in self._references: for t in self.types: hash = _combine(hash, t.hashItem()) return hash
def writeACL(self, version, key, name, acl): if name is None: key = pack('>16sll', key._uuid, 0, ~version) else: if isinstance(name, unicode): name = name.encode('utf-8') key = pack('>16sll', key._uuid, _hash(name), ~version) if acl is None: # deleted acl value = pack('>l', 0) else: value = "".join([pack('>16sl', ace.pid._uuid, ace.perms) for ace in acl]) self.put(key, value)
def getItemClass(self): """ Return the class used to create items of this Kind. If this Kind has superKinds and C{self.classes['python']} is not set a composite class is generated and cached from the superKinds. The L{Item<repository.item.Item.Item>} class is returned by default. """ try: return self._values['classes']['python'] except KeyError: pass except TypeError: pass superClasses = [] for superKind in self.getAttributeValue('superKinds', self._references): c = superKind.getItemClass() if c is not Item and c not in superClasses: superClasses.append(c) count = len(superClasses) if count == 0: c = Item elif count == 1: c = superClasses[0] else: hash = 0 for c in superClasses: hash = _combine(hash, _hash('.'.join((c.__module__, c.__name__)))) if hash < 0: hash = ~hash name = "class_%08x" %(hash) c = classobj(name, tuple(superClasses), {}) self._values['classes'] = { 'python': c } self._values._setTransient('classes') self._setupClass(c) return c
def findValue(self, version, uuid, name): version, item = self._findItem(version, uuid) if item is not None: if isinstance(name, unicode): name = name.encode('utf-8') hash = _hash(name) vCount, dCount = unpack('>ll', item[-8:]) pos = -(dCount + 2) * 4 - vCount * 20 for i in xrange(vCount): h, uValue = unpack('>l16s', item[pos:pos+20]) if h == hash: return UUID(uValue) pos += 20 return None
def _hashValues(self): item = self._item kind = item._kind view = item.itsView hash = 0 names = self.keys() names.sort() for name in names: if kind is not None: attribute = kind.getAttribute(name, False, item) else: attribute = None if attribute is not None: persisted = attribute.getAspect('persisted', True) else: persisted = True if persisted: persisted = self._getFlags(name) & Values.TRANSIENT == 0 if persisted: hash = _combine(hash, _hash(name)) value = self[name] if attribute is not None: attrType = attribute.getAspect('type') else: attrType = None if attrType is not None: hash = _combine(hash, attrType.hashValue(value)) else: hash = _combine(hash, TypeHandler.hashValue(view, value)) return hash
def writeName(name): if isinstance(name, unicode): name = name.encode('utf-8') buffer.write(pack('>l', _hash(name)))
def hashValue(self, value): return _hash(pack('>d', value))
def readACL(self, version, key, name): if name is None: cursorKey = pack('>16sl', key._uuid, 0) else: if isinstance(name, unicode): name = name.encode('utf-8') cursorKey = pack('>16sl', key._uuid, _hash(name)) store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor() try: value = cursor.set_range(cursorKey, self._flags) except DBNotFoundError: return None except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(10) continue else: raise try: while value is not None and value[0].startswith(cursorKey): key, aces = value aclVer = ~unpack('>l', key[-4:])[0] if aclVer <= version: if len(aces) == 4: # deleted acl return None acl = ACL() for i in xrange(0, len(aces), 20): pid = UUID(aces[i:i+16]) perms = unpack('>l', aces[i+16:i+20])[0] acl.append(ACE(pid, perms)) return acl else: value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(11) continue else: raise return None finally: self.closeCursor(cursor) store.abortTransaction(txnStatus)
def hashValue(self, value): if value == True: return _hash('True') else: return _hash('False')
def hashValue(self, value): return _combine(_hash(pack('>d', value.real)), _hash(pack('>d', value.imag)))
def __contains__(self, name): if isinstance(name, unicode): name = name.encode('utf-8') return super(HashTuple, self).__contains__(_hash(name))
def hash(self, name): return _hash(name)
def hashValue(self, value): if value is None: return 0 return _combine(_hash(str(self.itsPath)), _hash(str(value)))
def hashValue(self, value): return _combine(_hash(str(self.itsPath)), _hash(self.makeString(value)))
def hashValue(self, value): return _hash(self.makeString(value))
def hashValue(self, value): return _hash(value.encode('utf-8'))
def hashValue(self, value): if value is None: return 0 return _hash(repr(value))
def hashValue(self, value): if type(value) is unicode: value = value.encode('utf-8') return _hash(value)
def hashValue(self, value): return _hash(value)