Update the network

@param filter network filter
@param config update config
@return OperationFuture wrapper for network list
169832
public OperationFuture<List<Network>> update(NetworkFilter filter, UpdateNetworkConfig config) {
        checkFilter(filter);

        List<Network> networkList = findLazy(filter)
            .map(metadata -> Network.refById(metadata.getId()))
            .collect(toList());

        return update(networkList, config);
    }
486714
@Override
    public Filter createFilter(FilterConfig filterConfig) {
        Binding binding = new Binding();
        SecurityComponents sc = this.createSecurityComponents();
        binding.setVariable("securityComponents", sc);
        binding.setVariable("securityRealm",this);
        BeanBuilder builder = new BeanBuilder();
        builder.parse(filterConfig.getServletContext().getResourceAsStream("/WEB-INF/security/SecurityFilters.groovy"),binding);
        
        WebApplicationContext context = builder.createApplicationContext();
        
        return (Filter) context.getBean("legacy");
    }
651183
public void updateFilter(String filter) {
    if (isInitialized) {
      LynxConfig lynxConfig = lynx.getConfig();
      lynxConfig.setFilter(filter);
      lynx.setConfig(lynxConfig);
      clearView();
      restartLynx();
    }
  }
1151041
public OperationFuture<List<Server>> delete(ServerFilter filter) {
        List<Server> serverRefs = find(filter)
            .stream()
            .map(ServerMetadata::asRefById)
            .collect(toList());

        return delete(serverRefs.toArray(new Server[serverRefs.size()]));
    }
824151
public OperationFuture<LoadBalancer> update(
        LoadBalancer loadBalancer, List<LoadBalancerPoolConfig> configs) {

        List<LoadBalancerPoolMetadata> poolsForGroup = find(
            new LoadBalancerPoolFilter().loadBalancers(loadBalancer)
        );

        return new OperationFuture<>(
            loadBalancer,
            new ParallelJobsFuture(
                configs.stream()
                    .map(poolConfig -> createOrUpdate(poolConfig, loadBalancer, poolsForGroup))
                    .map(OperationFuture::jobFuture)
                    .collect(toList())
            )
        );
    }
739602
public OperationFuture<List<Server>> startMaintenance(GroupFilter groupFilter) {
        return serverService().startMaintenance(
            getServerSearchCriteria(groupFilter)
        );
    }
313376
public void addMappingFilter(String mapping, com.ibm.websphere.servlet.filter.IFilterConfig config){
        	context.addMappingFilter(mapping, config);
        }
634820
public OperationFuture<List<Server>> reboot(ServerFilter serverFilter) {
        List<Server> serverList = findServers(serverFilter);

        return powerOperationResponse(
            serverList,
            "Reboot",
            client.reboot(ids(serverList))
        );
    }
1359234
public OperationFuture<List<Server>> addPublicIp(ServerFilter serverFilter,  CreatePublicIpConfig publicIpConfig) {
        return addPublicIp(Arrays.asList(getRefsFromFilter(serverFilter)), publicIpConfig);
    }
1179799
public OperationFuture<List<Server>> modifyPublicIp(ServerFilter filter, ModifyPublicIpConfig config) {
        return modifyPublicIp(Arrays.asList(getRefsFromFilter(filter)), config);
    }
1070429
public OperationFuture<List<Server>> modify(List<Server> serverList, ModifyServerConfig modifyServerConfig) {
        List<JobFuture> futures = serverList.stream()
            .map(
                server ->
                    modify(server, modifyServerConfig).jobFuture()
            )
            .collect(toList());

        return new OperationFuture<>(
            serverList,
            new ParallelJobsFuture(futures)
        );
    }
1049775
public void updateRemoteFilterProperties(BaseMessageFilter messageFilter, Object[][] properties, Map<String,Object> propFilter) throws RemoteException
    {
        BaseTransport transport = this.createProxyTransport(REMOVE_REMOTE_MESSAGE_FILTER);
        transport.addParam(FILTER, messageFilter);   // Don't use COMMAND
        transport.addParam(PROPERTIES, properties);
        transport.addParam(MAP, propFilter);
        transport.sendMessageAndGetReply();
    }
756348
public UpdateResponse updateFlowConfig(FlowId flowId, FlowConfig flowConfig) throws FlowConfigLoggedException {
    return updateFlowConfig(flowId, flowConfig, true);
  }
373439
public static snmpmanager[] get_filtered(nitro_service service, String filter) throws Exception{
		snmpmanager obj = new snmpmanager();
		options option = new options();
		option.set_filter(filter);
		snmpmanager[] response = (snmpmanager[]) obj.getfiltered(service, option);
		return response;
	}
990109
public OperationFuture<List<Server>> reboot(GroupFilter groupFilter) {
        return serverService().reboot(
            getServerSearchCriteria(groupFilter)
        );
    }
12395
public DocumentT findOneAndUpdate(final Bson filter,
                                    final Bson update,
                                    final RemoteFindOneAndModifyOptions options) {
    return proxy.findOneAndUpdate(filter, update, options);
  }
569641
public OperationFuture<List<LoadBalancer>> update(
            LoadBalancerFilter loadBalancerFilter,
            LoadBalancerConfig config
    ) {
        checkNotNull(loadBalancerFilter, "Load balancer filter must be not null");

        List<LoadBalancer> loadBalancerList = findLazy(loadBalancerFilter)
                .map(metadata -> LoadBalancer.refById(
                    metadata.getId(),
                    DataCenter.refById(metadata.getDataCenterId())
                ))
                .collect(toList());

        return update(loadBalancerList, config);
    }