Get all vector layers with the specified server layer id.

@param serverLayerId
The layer's server layer ID.
@return Returns list of layers with the specified server layer id.
558034
public List<VectorLayer> getVectorLayersByServerId(String serverLayerId) {
		List<VectorLayer> l = new ArrayList<VectorLayer>();
		if (layers != null) {
			for (VectorLayer layer : getVectorLayers()) {
				if (layer.getServerLayerId().equals(serverLayerId)) {
					l.add(layer);
				}
			}
		}
		return l;
	}
783314
@Override
  public void getServers(
      GetServersRequest request, StreamObserver<GetServersResponse> responseObserver) {
    ServerList servers = channelz.getServers(request.getStartServerId(), maxPageSize);

    GetServersResponse resp;
    try {
      resp = ChannelzProtoUtil.toGetServersResponse(servers);
    } catch (StatusRuntimeException e) {
      responseObserver.onError(e);
      return;
    }

    responseObserver.onNext(resp);
    responseObserver.onCompleted();
  }
417195
def _read_layers(self, layers, image_id):
        

        for layer in self.docker.history(image_id):
            layers.append(layer['Id'])
780287
private String[] getServerLayerIds(MapModel mapModel) {
		List<String> layerIds = new ArrayList<String>();
		for (Layer<?> layer : mapModel.getLayers()) {
			if (layer.isShowing()) {
				layerIds.add(layer.getServerLayerId());
			}
		}
		return layerIds.toArray(new String[layerIds.size()]);
	}
285901
public List<RESTLayer> getAllImportedLayers(Integer importJobId, List<RESTImportTask> tasks) throws Exception {
        ArrayList<RESTLayer> layers = new ArrayList<RESTLayer>();
        for (RESTImportTask task : tasks) {

            RESTImportTask refreshedTask = this.getRESTImportTask(importJobId, task.getId());
            if (refreshedTask.getState().equalsIgnoreCase("COMPLETE")) {
                Response httpResponse = HttpUtil.get(
                    this.addEndPoint(importJobId + "/tasks/" + task.getId() + "/layer"),
                    this.username,
                    this.password
                );
                RESTLayer layer = (RESTLayer) this.asEntity(httpResponse.getBody(), RESTLayer.class);

                if (layer != null) {
                    layers.add(layer);
                }
            } else if ((tasks.size() == 1) && refreshedTask.getState().equalsIgnoreCase("ERROR")) {
                throw new GeoServerRESTImporterException(refreshedTask.getErrorMessage());
            }
        }
        return layers;
    }
93959
public static String getServerId(String clientId) {

        String serverId = clientId;
        if (clientId.contains(CLIENT_ID_SEPERATOR)) {
            serverId = clientId.substring(0, clientId.lastIndexOf(CLIENT_ID_SEPERATOR));
        }
        return serverId;
    }
95269
@SuppressWarnings("unchecked")
    @PreAuthorize("hasRole(@configHolder.getSuperAdminRoleName()) or hasPermission(#mapModuleId, 'de.terrestris.shoguncore.model.module.Map', 'UPDATE')")
    public List<Layer> setLayersForMap(Integer mapModuleId, List<Integer> layerIds) throws Exception {
        E module = this.findById(mapModuleId);
        List<Layer> layers = new ArrayList<Layer>();

        if (module instanceof Map) {
            Map mapModule = (Map) module;
            for (Integer id : layerIds) {
                PersistentObject entity = this.layerService.findById(id);
                if (entity instanceof Layer) {
                    Layer layer = (Layer) entity;
                    if (layer != null) {
                        layers.add(layer);
                    }
                }
            }
            mapModule.setMapLayers(layers);
            this.saveOrUpdate((E) mapModule);
            return layers;
        } else {
            throw new Exception("Can't find mapModule with id " + mapModuleId.toString());
        }

    }
97363
private VectorServerLayer searchLayer(MapPresenter mapPresenter, String layerId) {
		if (layerId != null) {
			for (int i = 0; i < mapPresenter.getLayersModel().getLayerCount(); i++) {
				Layer layer = mapPresenter.getLayersModel().getLayer(i);
				if (layer instanceof VectorServerLayer) {
					VectorServerLayer serverLayer = (VectorServerLayer) layer;
					if (layerId.equals(serverLayer.getServerLayerId())) {
						return (VectorServerLayer) layer;
					}
				}
			}
		}
		return null;
	}
1212583
public List<ThriftServerInfo> getThriftServers() {
		List<ThriftServerInfo> servers = new ArrayList<>();
		servers.addAll(thriftServers);
		return servers;
	}
1091599
public List<ServerRedirect> tableServers(int clientId) {
        List<ServerRedirect> servers = new ArrayList<>();

        try {
            Client client = ClientService.getInstance().getClient(clientId);
            servers = tableServers(client.getProfile().getId(), client.getActiveServerGroup());
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return servers;
    }
101860
public static List<String> getInboundLayerNamesFromConfig(Map<String, Object> layerConfig, KerasLayerConfiguration conf) {
        List<String> inboundLayerNames = new ArrayList<>();
        if (layerConfig.containsKey(conf.getLAYER_FIELD_INBOUND_NODES())) {
            List<Object> inboundNodes = (List<Object>) layerConfig.get(conf.getLAYER_FIELD_INBOUND_NODES());
            if (!inboundNodes.isEmpty()) {
                inboundNodes = (List<Object>) inboundNodes.get(0);
                for (Object o : inboundNodes) {
                    String nodeName = (String) ((List<Object>) o).get(0);
                    inboundLayerNames.add(nodeName);
                }
            }
        }
        return inboundLayerNames;
    }
712295
private Collection<Displayable> getLayer(Integer layer)
    {
        final Collection<Displayable> displayables;
        if (!layers.containsKey(layer))
        {
            displayables = new HashSet<>();
            layers.put(layer, displayables);
        }
        else
        {
            displayables = layers.get(layer);
        }
        return displayables;
    }
191873
public java.util.List<String> getEgressOnlyInternetGatewayIds() {
        if (egressOnlyInternetGatewayIds == null) {
            egressOnlyInternetGatewayIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return egressOnlyInternetGatewayIds;
    }
124352
private String[] getMappedServers(final ServerInformationCatalog serverInformationCatalog,
            final Map<String, String> mappedServers) {

        if (serverInformationCatalog.containsServer(HadoopResource.DEFAULT_CLUSTERREFERENCE)) {
            mappedServers.put("(default)", HadoopResource.DEFAULT_CLUSTERREFERENCE);
        }

        final String[] serverNames = serverInformationCatalog.getServerNames();
        for (int i = 0; i < serverNames.length; i++) {
            final String serverName = serverNames[i];
            if (!serverName.equals(HadoopResource.DEFAULT_CLUSTERREFERENCE)) {
                mappedServers.put(serverName, serverName);
            }
        }
        return mappedServers.keySet().toArray(new String[serverNames.length]);
    }
199488
function(layersContext) {
        var layers = [];
        for (var i=0, len=layersContext.length; i<len; i++) {
            var layer = this.getLayerFromContext(layersContext[i]);
            if (layer !== null) {
                layers.push(layer);
            }
        }
        return layers;
    }
1168423
@Nullable
  public ServerSocketsList getServerSockets(long serverId, long fromId, int maxPageSize) {
    ServerSocketMap serverSockets = perServerSockets.get(serverId);
    if (serverSockets == null) {
      return null;
    }
    List<InternalWithLogId> socketList = new ArrayList<>(maxPageSize);
    Iterator<InternalInstrumented<SocketStats>> iterator
        = serverSockets.tailMap(fromId).values().iterator();
    while (socketList.size() < maxPageSize && iterator.hasNext()) {
      socketList.add(iterator.next());
    }
    return new ServerSocketsList(socketList, !iterator.hasNext());
  }
763204
public List<Server> getEligibleServers(List<Server> servers, Object loadBalancerKey) {
        if (loadBalancerKey == null) {
            return ImmutableList.copyOf(Iterables.filter(servers, this.getServerOnlyPredicate()));            
        } else {
            List<Server> results = Lists.newArrayList();
            for (Server server: servers) {
                if (this.apply(new PredicateKey(loadBalancerKey, server))) {
                    results.add(server);
                }
            }
            return results;            
        }
    }