Of course! I've attached the full source code to the initial post for reference, but here are the relevant lines:
- This is the function with which I create the wrapper layers, using the inner layers. In this function the inner layers have already been loaded.
// Returns a layer promise which has all of the important characteristics of the passed layer, and which carries a reference to the original layer in the property 'subordinate'
function createWrapperLayer( featLayer ){
console.log( 'Creating wrapper layer for ', featLayer.title );
// Grab the features in the featLayer which are visible to the initial extent of the view. Assign those as the source.
// Wait for the results of the query to return, then pass it into the next function to be used as the resultant layer's source.
// Here we read out all of the important information from the original layer
var subTitle = featLayer.title;
var subID = featLayer.id;
var subFields = featLayer.fields;
var subObjID = featLayer.objectIdField;
var subSpRef = featLayer.spatialReference;
var subGeoType = featLayer.geometryType;
var subRender = featLayer.renderer;
// We have to wait for the query to finish execution to create the wrapper layer
visibleFeats.then(
function(visibleFeats) {
// Now we create the actual layer
visiLayer = new FeatureLayer({
title: subTitle,
id: subID,
objectIdField: subObjID,
source: findFeaturesInCameraExtent( featLayer ), // In order to execute this function, featLayers must already be loaded.
fields: subFields,
visible: true,
spatialReference: subSpRef,
geometryType: subGeoType,
renderer: subRender
});
// Here we add a prototype attribute 'subordinate' to the visiLayer so that we can access the feature layer again later
visiLayer.subordinate = featLayer;
// And return it
visiLayer.then(
function( vLayer ) {
console.log( vLayer );
}
);
visiLayer.load();
map.add( visiLayer );
});
}
- This is the function which initiates the querying of the inner layers, and sets the source of the wrapper layer to the query's result(s)
// This is the function that will be called each time the camera changes.
// It
function updateVisibleFeatures() {
map.layers.forEach(function(layer) {
if ( layer.visible == true && layer.id != layerBounds.id ) { // Cycle through every layer except for the bounds
// layer.subordinate is a reference to the internal layer that the wrapper layer is wrapped around
// it is the layer that is built from the REST service, and contains all available features.
visibleFeats = findFeaturesInCameraExtent( layer.subordinate );
visibleFeats.then(
function( visibleFeats ) {
layer.source = visibleFeats.features;
console.log( layer );
},
// Function that is called in case the promise fails
function( reason ) {
console.log( 'Updating visible features failed: ', reason );
});
}
});
}
And this is the subroutine that actually executes the query
// Function which, given a layer, will return the features of that layer that are contained within the camera extent.
// Function returns a promise, and the resultant featureSet should be accessed with the '.then()' function
function findFeaturesInCameraExtent( layer ) {
var query = layer.createQuery(); // Create a blank query
query.geometry = view.extent
query.spatialRelationship = "contains";
var results = layer.queryFeatures( query ) // Apply the spatial query to the layer, return a promise of the result
// Returns a promise which, once resolved, will contain all of the features returned by the query
return results;
}
