def __init__(self, name, searcher, parent, other_tags, tag_path):
self.name = name
self.__name__ = name.encode('utf-8')
self.__parent__ = parent
self.searcher = searcher
self.other_tags = difference(other_tags, OOTreeSet([self.__name__]))
self.tag_path = tag_path + [name]
def logstorage(self):
""" This is an annotation OOTreeSet where we can store log entries
"""
annotations = IAnnotations(self.context)
if self.logstorage_key not in annotations:
annotations[self.logstorage_key] = OOTreeSet()
return annotations[self.logstorage_key]
def convertListToOOTreeSet(self):
"conver the list object to an OOTreeSet"
if len(self.entry) and isinstance(self.entry, types.ListType):
temp = OOTreeSet()
for i in self.entry:
temp.insert(i)
self.setObject('entry', temp)
def _insert(self, entry):
if entry.main not in self._index:
self._index[entry.main] = OOBTree()
if entry.sub not in self._index[entry.main]:
self._index[entry.main][entry.sub] = OOTreeSet()
self._index[entry.main][entry.sub].insert(entry)
def index(self, conf, element):
self._indexCheck()
# self.get is equivalent to root['indexByConf']
if not self.get().has_key(conf):
self.get()[conf] = OOTreeSet()
self.get()[conf].insert(element)
def categoryConfDictToTreeSet(dbi, withRBDB, prevVersion):
"""
Replacing the conference dictionary in the Category objects by a OOTreeSet.
"""
for categ in CategoryManager()._getIdx().itervalues():
categ.conferencesBackup = categ.conferences.values()
categ.conferences = OOTreeSet(categ.conferences.itervalues())
if len(categ.conferences) != len(categ.conferencesBackup):
print "Problem migrating conf dict to tree set: %s" % categ.getId()
def __init__(self, sessionId):
self._sessionId = sessionId
self._questionId = OOBTree()
self._answer = OOBTree()
self._nav = OOBTree()
self._context = OOBTree()
self._loginStatus = OOBTree()
self._page = OOBTree()
self._query = OOBTree()
self._qstPage = OOTreeSet()
def clear(self):
'''clear the index.'''
l = self.__len__
if isinstance(l, Length): l.set(0)
else: self.__len__ = Length()
try:
self.numObjects.set(0)
except AttributeError:
self.numObjects = Length()
if self.ReverseOrder: self._reverseOrder = OOTreeSet()
self._setup()
def insert(self, parent, child):
# Establish a new path to child_id for each path that leads to
# parent_id.
child_id = child._p_oid
new_paths = []
for parent_path in self.get_paths(parent):
new_paths.append(parent_path + (child_id, ))
if not self.paths.has_key(child_id):
self.paths[child_id] = OOTreeSet()
for path in new_paths:
self.paths[child_id].insert(path)
return new_paths
def enqueue(self, t, obj):
"""
Add an element to the queue
"""
if t not in self._container:
self._container[t] = OOTreeSet()
if obj in self._container[t]:
raise DuplicateElementException(obj)
self._container[t].add(obj)
self._elem_counter.change(1)
def index(self, element):
self._indexCheck()
# self.get is equivalent to root['IndexByCRName']
if self.get().has_key(element.getTitle()):
for cr in self.get()[element.getTitle()]:
#if there is a chat room repeated in the server (either ours or an external one) we have a problem
if cr.getTitle() == element.getTitle() and cr.getHost() == element.getHost():
raise NoReportError( _('There is already a chat room in that server with that name, please choose another one'))
else:
self.get()[element.getTitle()] = OOTreeSet()
self.get()[element.getTitle()].insert(element)
def _get_persistent_class_keys(cls):
index_key = cls.full_name + "-keys"
keys = datastore.root.get(index_key)
if keys is None:
if isinstance(cls.primary_member, schema.Integer):
keys = IOTreeSet()
else:
keys = OOTreeSet()
datastore.root[index_key] = keys
return keys
def set_exported_content_tags(self, item, language, tags):
entry = (item.id, language)
prev_tags = self._entry_tags.get(entry)
self._entry_tags[entry] = tags
if prev_tags:
for tag in prev_tags:
tag_entries = self._entries_by_tag.get(tag)
if tag_entries:
tag_entries.remove(entry)
for tag in tags:
tag_entries = self._entries_by_tag.get(tag)
if tag_entries is None:
tag_entries = OOTreeSet()
self._entries_by_tag[tag] = tag_entries
tag_entries.insert(entry)
def __init__(self, pairs = None):
self.__items = OOTreeSet()
self.__descending_items = OOTreeSet()
Index.__init__(self, pairs)
def __or__(self, other):
return QuerySet(union(OOTreeSet(self), OOTreeSet(other)))
def __xor__(self, other):
return QuerySet(difference(OOTreeSet(self), OOTreeSet(other)))
def __init__(self):
self._brands = OOTreeSet()
def __and__(self, other):
return QuerySet(intersection(OOTreeSet(self), OOTreeSet(other)))
def __init__(self):
self.comments = OOTreeSet()
def test_comparison(sheraf_connection, m0, m1, m2):
assert QuerySet() is not None
assert QuerySet([m0]) == QuerySet([m0])
assert QuerySet([m0]) == QuerySet(m for m in [m0])
assert QuerySet([m0]) == QuerySet(OOTreeSet([m0]))
def getTree(self):
"Return all the entries as the native format"
if self.entry is not None:
return self.entry
return OOTreeSet()
def getEntries(self):
"Return all the entries as a list"
if self.entry is not None:
return self.entry.keys()
return OOTreeSet()
def replaceEntries(self, items):
"replace all the entries with these ones"
self.entry = OOTreeSet()
for item in items:
self.entry.insert(item)
def __init__(self, uids):
self.archived = False
self.uids = OOTreeSet()
self.uids.update(uids)
def addEntry(self, item):
"Add an entry to the list"
if self.entry is None:
self.entry = OOTreeSet()
self.entry.insert(item)
def __init__(self):
self.subscribers = OOTreeSet()
def insert(self, key, value):
"Insert value under key."
if not self._index.has_key(key):
self._index[key] = OOTreeSet()
self._index[key].insert(value)
def _items(self):
res = {}
tag_set = OOTreeSet(self.tags)
for i in self.tags:
res[i] = Tag(i, self.__parent__, self, tag_set, [])
return res
def setUp(self):
self.t = OOTreeSet()
