Python QgsMapLayerStore.count方法代码示例

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_removeMapLayersByLayer(self):
        """ test removing map layers by layer"""
        store = QgsMapLayerStore()

        # test no crash with empty store
        store.removeMapLayers([None])

        l1 = createLayer('test')
        l2 = createLayer('test2')
        l3 = createLayer('test3')

        store.addMapLayers([l1, l2, l3])
        self.assertEqual(store.count(), 3)

        #remove bad layers
        store.removeMapLayers([None])
        self.assertEqual(store.count(), 3)

        # remove valid layers
        store.removeMapLayers([l1])
        self.assertEqual(store.count(), 2)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove multiple
        store.removeMapLayers([l2, l3])
        self.assertEqual(store.count(), 0)
        self.assertTrue(sip.isdeleted(l2))
        self.assertTrue(sip.isdeleted(l3))

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addMapLayersAlreadyAdded(self):
        """ test that already added layers can't be readded to store """
        store = QgsMapLayerStore()

        l1 = createLayer('test')
        self.assertEqual(store.addMapLayers([l1]), [l1])
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(store.addMapLayers([l1]), [])
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_removeAllMapLayers(self):
        """ test removing all map layers from store """
        store = QgsMapLayerStore()
        l1 = createLayer('test')
        l2 = createLayer('test2')

        store.addMapLayers([l1, l2])
        self.assertEqual(store.count(), 2)
        store.removeAllMapLayers()
        self.assertEqual(store.count(), 0)
        self.assertEqual(store.mapLayersByName('test'), [])
        self.assertEqual(store.mapLayersByName('test2'), [])

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addMapLayerInvalid(self):
        """ test that invalid map layers can't be added to store """
        store = QgsMapLayerStore()

        self.assertEqual(store.addMapLayer(QgsVectorLayer("Point?field=x:string", 'test', "xxx")), None)
        self.assertEqual(len(store.mapLayersByName('test')), 0)
        self.assertEqual(store.count(), 0)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addMapLayer(self):
        """ test adding individual map layers to store"""
        store = QgsMapLayerStore()

        l1 = createLayer('test')
        self.assertEqual(store.addMapLayer(l1), l1)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(len(store), 1)

        # adding a second layer should leave existing layers intact
        l2 = createLayer('test2')
        self.assertEqual(store.addMapLayer(l2), l2)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(len(store.mapLayersByName('test2')), 1)
        self.assertEqual(store.count(), 2)
        self.assertEqual(len(store), 2)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addMapLayersInvalid(self):
        """ test that invalid map layers can be added to store """
        store = QgsMapLayerStore()

        vl = QgsVectorLayer("Point?field=x:string", 'test', "xxx")
        self.assertEqual(store.addMapLayers([vl]), [vl])
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(store.validCount(), 0)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addMapLayers(self):
        """ test adding multiple map layers to store """
        store = QgsMapLayerStore()

        l1 = createLayer('test')
        l2 = createLayer('test2')
        self.assertEqual(set(store.addMapLayers([l1, l2])), {l1, l2})
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(len(store.mapLayersByName('test2')), 1)
        self.assertEqual(store.count(), 2)

        # adding more layers should leave existing layers intact
        l3 = createLayer('test3')
        l4 = createLayer('test4')
        self.assertEqual(set(store.addMapLayers([l3, l4])), {l3, l4})
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(len(store.mapLayersByName('test2')), 1)
        self.assertEqual(len(store.mapLayersByName('test3')), 1)
        self.assertEqual(len(store.mapLayersByName('test4')), 1)
        self.assertEqual(store.count(), 4)

        store.removeAllMapLayers()

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_removeMapLayerByLayer(self):
        """ test removing a map layer by layer """
        store = QgsMapLayerStore()

        # test no crash with empty store
        store.removeMapLayer('bad')
        store.removeMapLayer(None)

        l1 = createLayer('test')
        l2 = createLayer('test2')

        store.addMapLayers([l1, l2])
        self.assertEqual(store.count(), 2)

        #remove bad layers
        store.removeMapLayer(None)
        self.assertEqual(store.count(), 2)
        l3 = createLayer('test3')
        store.removeMapLayer(l3)
        self.assertEqual(store.count(), 2)

        # remove valid layers
        store.removeMapLayer(l1)
        self.assertEqual(store.count(), 1)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove second layer
        store.removeMapLayer(l2)
        self.assertEqual(store.count(), 0)
        self.assertTrue(sip.isdeleted(l2))

        # try removing a layer not in the store
        l3 = createLayer('test3')
        store.removeMapLayer(l3)
        self.assertFalse(sip.isdeleted(l3))

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_removeMapLayersById(self):
        """ test removing map layers by ID """
        store = QgsMapLayerStore()

        # test no crash with empty store
        store.removeMapLayersById(['bad'])
        store.removeMapLayersById([None])

        l1 = createLayer('test')
        l2 = createLayer('test2')
        l3 = createLayer('test3')

        store.addMapLayers([l1, l2, l3])
        self.assertEqual(store.count(), 3)

        #remove bad layers
        store.removeMapLayersById(['bad'])
        self.assertEqual(store.count(), 3)
        store.removeMapLayersById([None])
        self.assertEqual(store.count(), 3)

        # remove valid layers
        l1_id = l1.id()
        store.removeMapLayersById([l1_id])
        self.assertEqual(store.count(), 2)
        # double remove
        store.removeMapLayersById([l1_id])
        self.assertEqual(store.count(), 2)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove multiple
        store.removeMapLayersById([l2.id(), l3.id()])
        self.assertEqual(store.count(), 0)
        self.assertTrue(sip.isdeleted(l2))

        # try removing a layer not in the store
        l4 = createLayer('test4')
        store.removeMapLayersById([l4.id()])
        self.assertFalse(sip.isdeleted(l4))

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import count [as 别名]
    def test_addRemoveLayersSignals(self):
        """ test that signals are correctly emitted when removing map layers"""
        store = QgsMapLayerStore()

        layers_will_be_removed_spy = QSignalSpy(store.layersWillBeRemoved)
        layer_will_be_removed_spy_str = QSignalSpy(store.layerWillBeRemoved[str])
        layer_will_be_removed_spy_layer = QSignalSpy(store.layerWillBeRemoved[QgsMapLayer])
        layers_removed_spy = QSignalSpy(store.layersRemoved)
        layer_removed_spy = QSignalSpy(store.layerRemoved)
        remove_all_spy = QSignalSpy(store.allLayersRemoved)

        l1 = createLayer('l1')
        l2 = createLayer('l2')
        l3 = createLayer('l3')
        l4 = createLayer('l4')
        store.addMapLayers([l1, l2, l3, l4])

        # remove 1 layer
        store.removeMapLayer(l1)
        # can't seem to actually test the data which was emitted, so best we can do is test
        # the signal count
        self.assertEqual(len(layers_will_be_removed_spy), 1)
        self.assertEqual(len(layer_will_be_removed_spy_str), 1)
        self.assertEqual(len(layer_will_be_removed_spy_layer), 1)
        self.assertEqual(len(layers_removed_spy), 1)
        self.assertEqual(len(layer_removed_spy), 1)
        self.assertEqual(len(remove_all_spy), 0)
        self.assertEqual(store.count(), 3)

        # remove 2 layers at once
        store.removeMapLayersById([l2.id(), l3.id()])
        self.assertEqual(len(layers_will_be_removed_spy), 2)
        self.assertEqual(len(layer_will_be_removed_spy_str), 3)
        self.assertEqual(len(layer_will_be_removed_spy_layer), 3)
        self.assertEqual(len(layers_removed_spy), 2)
        self.assertEqual(len(layer_removed_spy), 3)
        self.assertEqual(len(remove_all_spy), 0)
        self.assertEqual(store.count(), 1)

        # remove all
        store.removeAllMapLayers()
        self.assertEqual(len(layers_will_be_removed_spy), 3)
        self.assertEqual(len(layer_will_be_removed_spy_str), 4)
        self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
        self.assertEqual(len(layers_removed_spy), 3)
        self.assertEqual(len(layer_removed_spy), 4)
        self.assertEqual(len(remove_all_spy), 1)

        #remove some layers which aren't in the store
        store.removeMapLayersById(['asdasd'])
        self.assertEqual(len(layers_will_be_removed_spy), 3)
        self.assertEqual(len(layer_will_be_removed_spy_str), 4)
        self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
        self.assertEqual(len(layers_removed_spy), 3)
        self.assertEqual(len(layer_removed_spy), 4)
        self.assertEqual(len(remove_all_spy), 1)

        l5 = createLayer('test5')
        store.removeMapLayer(l5)
        self.assertEqual(len(layers_will_be_removed_spy), 3)
        self.assertEqual(len(layer_will_be_removed_spy_str), 4)
        self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
        self.assertEqual(len(layers_removed_spy), 3)
        self.assertEqual(len(layer_removed_spy), 4)
        self.assertEqual(len(remove_all_spy), 1)