def readValue(self, itemReader, offset, data, withSchema, view, name,
afterLoadHooks):
if data[offset] == '\0':
return offset+1, None
return offset+17, SingleRef(UUID(data[offset+1:offset+17]))
def _makeValidValues(self):
""" create valid values of appropriate types"""
class myStruct(object):
__slots__ = ('name', 'rank')
self.uuid = self.attrKind.itsUUID
self.uuidString = str(self.uuid)
self.pathString = '//Schema/Core/Item'
self.path = Path(self.pathString)
self.singleRef = SingleRef(self.uuid)
self.itemClass = eval('repository.item.Item.Item')
self.dateTimeString = '2004-01-08 12:34:56 US/Mountain'
self.dateTime = datetime(2004, 1, 8, 12, 34, 56,
tzinfo=ICUtzinfo.getInstance('US/Mountain'))
self.timeDeltaString= '-8+45.000012'
self.timeDelta = timedelta(-8, 45, 12)
self.enum = self.types['Enumeration'].newItem('myEnum', self.rep)
self.enum.values = ['red', 'green', 'blue']
self.structType = self.types['Struct'].newItem('myStruct', self.rep)
self.structType.fields=['name','rank']
self.structType.implementationTypes = {'python': myStruct }
self.struct = myStruct()
self.lob = self.types['Lob'].makeValue("aba;dsjfa;jfdl;ajru87z.vncxyt89q47654", encoding='utf-8', mimetype='text/plain')
def prepareValue(cls, item, attribute, value, setDirty=True):
if isinstance(value, ItemValue):
if value._item is not None:
value = value._copy(item, attribute, 'copy')
else:
value._setOwner(item, attribute)
elif isinstance(value, list):
value = PersistentList(item, attribute, value, setDirty)
elif isinstance(value, dict):
value = PersistentDict(item, attribute, value, setDirty)
elif isinstance(value, tuple):
value = PersistentTuple(item, attribute, value, setDirty)
elif isinstance(value, set):
value = PersistentSet(item, attribute, value, setDirty)
elif isinstance(value, CItem):
value = SingleRef(value._uuid)
return value
def _useValue(self, value):
if isinstance(value, PersistentCollection):
return value
if isinstance(value, CItem):
return SingleRef(value._uuid)
elif isinstance(value, list):
return [self._useValue(v) for v in value]
elif isinstance(value, set):
return set([self._useValue(v) for v in value])
elif isinstance(value, tuple):
return tuple([self._useValue(v) for v in value])
elif isinstance(value, dict):
d = {}
for k, v in value.itervalues():
d[k] = self._useValue(v)
return d
else:
return value
def filterItem(self, item, level=0, key=0, _remove=True):
sup = super(PersistentTuple, self)
if level == 0:
if sup.__getitem__(key) == SingleRef(item.itsUUID):
if _remove:
raise TypeError, 'tuple is immutable'
return True
else:
count = len(self)
values = [
value for value in sup.__iter__()
if not value.filterItem(item, level - 1, key, False)
]
if len(values) < count:
raise TypeError, 'tuple is immutable'
return False
def filterItem(self, item, level=0, key=0, _remove=True):
sup = super(PersistentDict, self)
if level == 0:
if sup.__getitem__(key) == SingleRef(item.itsUUID):
if _remove:
self.__delitem__(key)
return True
else:
dirty = False
for k, value in sup.items():
if value.filterItem(item, level - 1, key, False):
sup.__delitem__(k)
dirty = True
if dirty:
self._setDirty()
return False
def filterItem(self, item, level=0, key=0, _remove=True):
sup = super(PersistentList, self)
if level == 0:
if sup.__getitem__(key) == SingleRef(item.itsUUID):
if _remove:
self.__delitem__(key)
return True
else:
count = len(self)
values = [
value for value in sup.__iter__()
if not value.filterItem(item, level - 1, key, False)
]
if len(values) < count:
sup.__setslice__(0, count, values)
self._setDirty()
return False
def filterItem(self, item, level=0, key=0, _remove=True):
sup = super(PersistentSet, self)
if level == 0:
if sup.__contains__(SingleRef(item.itsUUID)):
if _remove:
self.remove(item)
return True
else:
count = len(self)
values = [
value for value in sup.__iter__()
if not value.filterItem(item, level - 1, key, False)
]
if len(values) < count:
sup.clear()
sup.update(values)
self._setDirty()
return False
def _copy(self, orig, copyPolicy, copyFn):
item = self._item
for name, value in orig.iteritems():
if isinstance(value, ItemValue):
value = value._copy(item, name, copyPolicy, copyFn)
value._setOwner(item, name)
self[name] = value
elif isinstance(value, SingleRef):
policy = (copyPolicy or item.getAttributeAspect(
name, 'copyPolicy', False, None, 'copy'))
other = item.find(value.itsUUID)
if other is None:
self[name] = value
else:
copyOther = copyFn(item, other, policy)
if copyOther is not Nil:
self[name] = SingleRef(copyOther.itsUUID)
else:
self[name] = value
self._copyFlags(orig, name)
class TypeHandler(object):
def typeHandler(cls, view, value):
try:
for t in cls.typeHandlers[view][type(value)]:
if t.recognizes(value):
return t
except KeyError:
pass
from repository.item.Item import Item
if isinstance(value, Item):
return cls.typeHandlers[view][SingleRef][0]
try:
typeKind = cls.typeHandlers[view][None]
except KeyError:
print type(value), value
raise
types = typeKind.findTypes(value)
if types:
return types[0]
raise TypeError, 'No handler for values of type %s' %(type(value))
def makeString(cls, view, value):
return cls.typeHandler(view, value).makeString(value)
def makeValue(cls, typeName, data):
try:
return cls.typeDispatch[typeName](data)
except KeyError:
raise ValueError, "Unknown type %s for data: %s" %(typeName, data)
def hashValue(cls, view, value):
return cls.typeHandler(view, value).hashValue(value)
def clear(cls, view):
try:
cls.typeHandlers[view].clear()
except KeyError:
pass
typeHandler = classmethod(typeHandler)
makeString = classmethod(makeString)
makeValue = classmethod(makeValue)
hashValue = classmethod(hashValue)
clear = classmethod(clear)
typeHandlers = {}
typeDispatch = {
'str': str,
'unicode': unicode,
'uuid': UUID,
'path': Path,
'ref': lambda(data): SingleRef(UUID(data)),
'bool': lambda(data): data != 'False',
'int': int,
'long': long,
'float': float,
'complex': complex,
'class': lambda(data): ClassLoader.loadClass(data),
'none': lambda(data): None,
}
def hashValue(self, value):
if value is None:
return 0
return TypeHandler.hashValue(self.itsView, SingleRef(value.itsUUID))
def makeString(self, data):
if data is None:
return Kind.NoneString
return SingleRef(UUID(data))
def makeValue(self, data):
if data == Kind.NoneString:
return None
return SingleRef(UUID(data))