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 _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 _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)
