Delete filtered load balancers

@param filter load balancer filter
@return OperationFuture wrapper for load balancer list
428708
public OperationFuture<List<LoadBalancer>> delete(LoadBalancerFilter filter) {
        List<LoadBalancer> loadBalancerList = findLazy(filter)
                .map(metadata -> LoadBalancer.refById(
                    metadata.getId(),
                    DataCenter.refById(metadata.getDataCenterId()))
                )
                .collect(toList());

        return delete(loadBalancerList);
    }
471172
public OperationFuture<AntiAffinityPolicy> delete(AntiAffinityPolicy policyRef) {
        client.deleteAntiAffinityPolicy(findByRef(policyRef).getId());

        return new OperationFuture<>(
            policyRef,
            new NoWaitingJobFuture()
        );
    }
999511
public OperationFuture<List<Server>> addSecondaryNetwork(ServerFilter filter, AddNetworkConfig config) {
        return addSecondaryNetwork(Arrays.asList(getRefsFromFilter(filter)), config);
    }
951422
public static cachepolicylabel[] get_filtered(nitro_service service, String filter) throws Exception{
		cachepolicylabel obj = new cachepolicylabel();
		options option = new options();
		option.set_filter(filter);
		cachepolicylabel[] response = (cachepolicylabel[]) obj.getfiltered(service, option);
		return response;
	}
590252
public static <E> Filter<E> notFilter(Filter<E> filter) {
    return (new NegatedFilter<E>(filter));
  }
545244
public void deleteRelationsFromResource(CmsResource resource, CmsRelationFilter filter) throws CmsException {

        m_securityManager.deleteRelationsForResource(m_context, resource, filter);
    }
250054
public static service[] get_filtered(nitro_service service, String filter) throws Exception{
		service obj = new service();
		options option = new options();
		option.set_filter(filter);
		service[] response = (service[]) obj.getfiltered(service, option);
		return response;
	}
51883
public void dispose() {
        LOGGER.debug("dispose all Filters for FilterFactory {}...", factory.getClass().getName());
        synchronized (filterCache) {
            if (maintainLifeCycle) {
                Collection<Filter> values = filterCache.values();
                for (Filter filter : values) {
                    try {
                        filter.destroy();
                    } catch (RuntimeException e) {
                        LOGGER.warn("RuntimeException while calling destroy() of filter {}", filter.getClass()
                            .getName(), e);
                    }
                }
            }
            filterCache.clear();
        }
    }
424025
public void removeFilter(String filterName)
   {
      Filter filter = getFilterByName(filterName);
      if (filter != null)
      {
         if (filter.isTaskFilter())
         {
            m_taskFilters.remove(filter);
         }

         if (filter.isResourceFilter())
         {
            m_resourceFilters.remove(filter);
         }
         m_filtersByName.remove(filterName);
         m_filtersByID.remove(filter.getID());
      }
   }
843484
public NetworkFilter where(Predicate<NetworkMetadata> filter) {
        checkNotNull(filter, "Filter predicate must be not a null");

        this.predicate = this.predicate.and(filter);

        return this;
    }
1013751
public Task<DocumentT> findOneAndDelete(final Bson filter) {
    return dispatcher.dispatchTask(new Callable<DocumentT>() {
      @Override
      public DocumentT call() {
        return proxy.findOneAndDelete(filter);
      }
    });
  }
997240
public static <T> Collection<T> filter(Collection<T> collection, Filter<T> filter) {
		if (null == collection || null == filter) {
			return collection;
		}

		Collection<T> collection2 = ObjectUtil.clone(collection);
		try {
			collection2.clear();
		} catch (UnsupportedOperationException e) {
			// 克隆后的对象不支持清空，说明为不可变集合对象，使用默认的ArrayList保存结果
			collection2 = new ArrayList<>();
		}

		for (T t : collection) {
			if (filter.accept(t)) {
				collection2.add(t);
			}
		}
		return collection2;
	}
1180858
public static <T> List<T> filtered(Collection<T> data, Filter<T> filter) {
        List<T> list = new ArrayList<>();
        if (!Utils.isEmpty(data)) {
            for (T item : data) {
                if (filter.accept(item)) {
                    list.add(item);
                }
            }
        }
        return list;
    }
422167
public OperationFuture<List<Server>> delete(Server... servers) {
        List<JobFuture> futures = Arrays.asList(servers).stream()
            .map(serverRef -> delete(serverRef).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            Arrays.asList(servers),
            new ParallelJobsFuture(futures)
        );
    }
31158
public OperationFuture<List<Server>> shutDown(GroupFilter groupFilter) {
        return serverService().shutDown(
            getServerSearchCriteria(groupFilter)
        );
    }
431884
public static cacheglobal_cachepolicy_binding[] get_filtered(nitro_service service, String filter) throws Exception{
		cacheglobal_cachepolicy_binding obj = new cacheglobal_cachepolicy_binding();
		options option = new options();
		option.set_filter(filter);
		cacheglobal_cachepolicy_binding[] response = (cacheglobal_cachepolicy_binding[]) obj.getfiltered(service, option);
		return response;
	}
944264
public static <T> Iterator<T> filter(Iterator<T> it, Predicate<T> filter) {
        return new Iterator<T>() {

            private T cached = null;

            @Override
            public boolean hasNext() {
                if (this.cached != null) {
                    return true;
                }

                boolean test = false;
                while (it.hasNext() && !test) {
                    this.cached = it.next();
                    test = filter.test(this.cached);
                }
                return test;
            }

            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                final T result = this.cached;
                this.cached = null;
                return result;
            }

            @Override
            public void remove() {
                it.remove();
            }
        };
    }