Python IndexedContainer.addItem方法代码示例

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def testIndedexContainerItemIds(self):
     ic = IndexedContainer()
     ic.addContainerProperty('prop1', str, None)
     idd = ic.addItem()
     ic.getItem(idd).getItemProperty('prop1').setValue('1')
     item2 = ic.addItem('item2')
     item2.getItemProperty('prop1').setValue('2')
     self.serializeAndDeserialize(ic)

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def rebuild_editor ( self ):
     """ Rebuilds the editor after its definition is modified.
     """
     control = self.control
     c = IndexedContainer()
     for name in self.names:
         c.addItem(name)
     control.setContainerDataSource(c)
     self.update_editor()

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def testAddItemPerformance(self):
     times = list()
     for _ in range(self._REPEATS):
         c = IndexedContainer()
         start = 1000 * time.time()
         for _ in range(self._ITEMS):
             c.addItem()
         times.append((1000 * time.time()) - start)
     self.checkMedian(self._ITEMS, times, "IndexedContainer.addItem()", self._ADD_ITEM_FAIL_THRESHOLD)

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def testAddItemAfterPerformance(self):
     initialId = "Item0"
     times = list()
     for _ in range(self._REPEATS):
         c = IndexedContainer()
         c.addItem(initialId)
         start = 1000 * time.time()
         for _ in range(self._ITEMS):
             c.addItemAfter(initialId)
         times.append((1000 * time.time()) - start)
     self.checkMedian(self._ITEMS, times, "IndexedContainer.addItemAfter()", self._ADD_ITEM_AFTER_FAIL_THRESHOLD)

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def testAddItemAfterLastPerformance(self):
     # TODO running with less items because slow otherwise
     times = list()
     for _ in range(self._REPEATS):
         c = IndexedContainer()
         c.addItem()
         start = 1000 * time.time()
         for _ in range(self._ITEMS):
             c.addItemAfter(c.lastItemId())
         times.append((1000 * time.time()) - start)
     self.checkMedian(self._ITEMS / 3, times,
             'IndexedContainer.addItemAfter(lastId)',
             self._ADD_ITEM_AFTER_LAST_FAIL_THRESHOLD)

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def getLocaleContainer(cls):
     localeContainer = IndexedContainer()
     localeContainer.addContainerProperty(cls.locale_PROPERTY_LOCALE, Locale, None)
     localeContainer.addContainerProperty(cls.locale_PROPERTY_NAME, str, None)
     for i in range(len(cls._locales)):
         idd = cls._locales[i][2]
         item = localeContainer.addItem(idd)
         v = Locale(cls._locales[i][0], cls._locales[i][1])
         item.getItemProperty(cls.locale_PROPERTY_LOCALE).setValue(v)
         v = cls._locales[i][2]
         item.getItemProperty(cls.locale_PROPERTY_NAME).setValue(v)
     return localeContainer

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
    def getResolutionContainer(self):
        resolutionContainer = IndexedContainer()
        resolutionContainer.addContainerProperty(
                self.resolution_PROPERTY_NAME, str, None)

        for i, res in enumerate(self._resolutions):
            added = resolutionContainer.addItem(res)
            added.getItemProperty(
                    self.resolution_PROPERTY_NAME).setValue(
                            self._resolutionNames[i])

        return resolutionContainer

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
 def getNameContainer(cls):
     contactContainer = IndexedContainer()
     contactContainer.addContainerProperty(cls.PERSON_PROPERTY_NAME, str, "")
     i = 0
     while i < 50:
         fn = cls._firstnames[int(random() * len(cls._firstnames))]
         ln = cls._lastnames[int(random() * len(cls._lastnames))]
         idd = fn + ln
         item = contactContainer.addItem(idd)
         if item is not None:
             i += 1
             v = fn + " " + ln
             item.getItemProperty(cls.PERSON_PROPERTY_NAME).setValue(v)
     return contactContainer

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
    def createContainer(cls):
        """Creates a container with three properties "col1,col2,col3"
        with 100 items

        @return: Returns the created table
        """
        container = IndexedContainer()
        container.addContainerProperty('col1', str, '')
        container.addContainerProperty('col2', str, '')
        container.addContainerProperty('col3', str, '')

        for i in range(100):
            item = container.addItem('item %d' % i)
            item.getItemProperty('col1').setValue('first%d' % i)
            item.getItemProperty('col2').setValue('middle%d' % i)
            item.getItemProperty('col3').setValue('last%d' % i)

        return container

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
    def createDummyData(cls):
        fnames = ['Peter', 'Alice', 'Joshua', 'Mike', 'Olivia', 'Nina', 'Alex',
                'Rita', 'Dan', 'Umberto', 'Henrik', 'Rene', 'Lisa', 'Marge']
        lnames = ['Smith', 'Gordon', 'Simpson', 'Brown', 'Clavel', 'Simons',
                'Verne', 'Scott', 'Allison', 'Gates', 'Rowling', 'Barks',
                'Ross', 'Schneider', 'Tate']

        ic = IndexedContainer()

        for p in cls._fields:
            ic.addContainerProperty(p, str, '')

        for _ in range(1000):
            idd = ic.addItem()
            fname = fnames[int( len(fnames) * random() )]
            ic.getContainerProperty(idd, 'First Name').setValue(fname)
            lname = lnames[int( len(lnames) * random() )]
            ic.getContainerProperty(idd, 'Last Name').setValue(lname)

        return ic

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
    def testItemSetChangeListeners(self):
        container = IndexedContainer()
        counter = ItemSetChangeCounter()
        container.addListener(counter)

        id1 = 'id1'
        id2 = 'id2'
        id3 = 'id3'

        self.initializeContainer(container)
        counter.reset()
        container.addItem()
        counter.assertOnce()
        container.addItem(id1)
        counter.assertOnce()

        self.initializeContainer(container)
        counter.reset()
        container.addItemAt(0)
        counter.assertOnce()
        container.addItemAt(0, id1)
        counter.assertOnce()
        container.addItemAt(0, id2)
        counter.assertOnce()
        container.addItemAt(len(container), id3)
        counter.assertOnce()
        # no notification if already in container
        container.addItemAt(0, id1)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        container.addItemAfter(None)
        counter.assertOnce()
        container.addItemAfter(None, id1)
        counter.assertOnce()
        container.addItemAfter(id1)
        counter.assertOnce()
        container.addItemAfter(id1, id2)
        counter.assertOnce()
        container.addItemAfter(container.firstItemId())
        counter.assertOnce()
        container.addItemAfter(container.lastItemId())
        counter.assertOnce()
        container.addItemAfter(container.lastItemId(), id3)
        counter.assertOnce()
        # no notification if already in container
        container.addItemAfter(0, id1)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        container.removeItem(self.sampleData[0])
        counter.assertOnce()

        self.initializeContainer(container)
        counter.reset()
        # no notification for removing a non-existing item
        container.removeItem(id1)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        container.removeAllItems()
        counter.assertOnce()
        # already empty
        container.removeAllItems()
        counter.assertNone()

# 需要导入模块: from muntjac.data.util.indexed_container import IndexedContainer [as 别名]
# 或者: from muntjac.data.util.indexed_container.IndexedContainer import addItem [as 别名]
    def testItemSetChangeListenersFiltering(self):
        container = IndexedContainer()
        counter = ItemSetChangeCounter()
        container.addListener(counter)

        counter.reset()
        container.addContainerFilter(self.FULLY_QUALIFIED_NAME, 'Test', True, False)
        # no real change, so no notification required
        counter.assertNone()

        id1 = 'com.example.Test1'
        id2 = 'com.example.Test2'
        id3 = 'com.example.Other'

        # perform operations while filtering container

        self.initializeContainer(container)
        counter.reset()
        # passes filter
        item = container.addItem(id1)
        # no event if filtered out
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id1)
        counter.assertOnce()
        # passes filter but already in the container
        item = container.addItem(id1)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        # passes filter after change
        item = container.addItemAt(0, id1)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id1)
        counter.assertOnce()
        item = container.addItemAt(len(container), id2)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id2)
        counter.assertOnce()
        # passes filter but already in the container
        item = container.addItemAt(0, id1)
        counter.assertNone()
        item = container.addItemAt(len(container), id2)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        # passes filter
        item = container.addItemAfter(None, id1)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id1)
        counter.assertOnce()
        item = container.addItemAfter(container.lastItemId(), id2)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id2)
        counter.assertOnce()
        # passes filter but already in the container
        item = container.addItemAfter(None, id1)
        counter.assertNone()
        item = container.addItemAfter(container.lastItemId(), id2)
        counter.assertNone()

        # does not pass filter

        # TODO implement rest

        self.initializeContainer(container)
        counter.reset()
        item = container.addItemAfter(None, id3)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id3)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        item = container.addItemAfter(container.firstItemId(), id3)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id3)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        item = container.addItemAfter(container.lastItemId(), id3)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id3)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        item = container.addItemAt(0, id3)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id3)
        counter.assertNone()

        self.initializeContainer(container)
        counter.reset()
        item = container.addItemAt(1, id3)
        counter.assertNone()
        item.getItemProperty(self.FULLY_QUALIFIED_NAME).setValue(id3)
        counter.assertNone()
#.........这里部分代码省略.........