Extract {@link Group} from {@link GroupFilter}
@param groupFilter group search criteria
@return array of groups
429464
private Group[] getRefsFromFilter(GroupFilter groupFilter) {
        checkNotNull(groupFilter, "Group filter must be not null");

        List<Group> groupList = findLazy(groupFilter)
            .map(metadata -> Group.refById(metadata.getId()))
            .collect(toList());

        return groupList.toArray(new Group[groupList.size()]);
    }
410636
@Override
	public List<CPTaxCategory> findByGroupId(long groupId) {
		return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
1293391
private List<CmsCategoryBean> getFilteredCategories(String filter) {

        List<CmsCategoryBean> result;
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(filter)) {
            result = new ArrayList<CmsCategoryBean>();
            for (CmsCategoryBean category : getCategoryList()) {
                if (category.matchesFilter(filter)) {
                    result.add(category);
                }
            }
        } else {
            result = getCategoryList();
        }
        return result;
    }
817357
public List<Method> getMethodsFromGroupId(int groupId, String[] filters) throws Exception {
        ArrayList<Method> methods = new ArrayList<Method>();
        PreparedStatement statement = null;
        ResultSet results = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "SELECT * FROM " + Constants.DB_TABLE_OVERRIDE +
                    " WHERE " + Constants.OVERRIDE_GROUP_ID + " = ?"
            );
            statement.setInt(1, groupId);
            results = statement.executeQuery();
            while (results.next()) {
                Method method = PathOverrideService.getInstance().getMethodForOverrideId(results.getInt("id"));
                if (method == null) {
                    continue;
                }

                // decide whether or not to add this method based on the filters
                boolean add = true;
                if (filters != null) {
                    add = false;
                    for (String filter : filters) {
                        if (method.getMethodType().endsWith(filter)) {
                            add = true;
                            break;
                        }
                    }
                }

                if (add && !methods.contains(method)) {
                    methods.add(method);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (results != null) {
                    results.close();
                }
            } catch (Exception e) {
            }
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }

        return methods;
    }
123615
function(filterGroup) {
    const filters = filterGroup.filters.map((filterDef) => {
      const condition = filterDef.condition;
      if (Array.isArray(condition)) {
        return WfsPermalinkService.or_(condition.map(cond => equalTo(filterDef.property, cond)));
      } else {
        return equalTo(filterDef.property, condition);
      }
    });
    return WfsPermalinkService.and_(filters);
  }
773979
public java.util.List<GroupIdentifier> getGroups() {
        if (groups == null) {
            groups = new com.amazonaws.internal.SdkInternalList<GroupIdentifier>();
        }
        return groups;
    }
421029
public List<ZuulFilter> getFiltersByType(FilterType filterType) {

        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        list = new ArrayList<ZuulFilter>();

        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                list.add(filter);
            }
        }

        // Sort by filterOrder.
        Collections.sort(list, new Comparator<ZuulFilter>() {
            @Override
            public int compare(ZuulFilter o1, ZuulFilter o2) {
                return o1.filterOrder() - o2.filterOrder();
            }
        });

        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }
1135569
public Collection<Theme> getThemes(ThemeFilter filter) {
        filter = (filter != null) ? filter : new ThemeFilter();

        filter.goals.clear();
        filter.goals.add(this);
        return getInstance().get().themes(filter);
    }
125003
public function serverGroupList(array $filter = array())
  {
    if($this->sgroupList === null)
    {
      $this->sgroupList = $this->request("servergrouplist")->toAssocArray("sgid");

      foreach($this->sgroupList as $sgid => $group)
      {
        $this->sgroupList[$sgid] = new TeamSpeak3_Node_Servergroup($this, $group);
      }

      uasort($this->sgroupList, array(__CLASS__, "sortGroupList"));
    }

    return $this->filterList($this->sgroupList, $filter);
  }
1116866
public function getGroupMembers($groupId,  array $filters = [])
	{
		return $this->sendRequest(
			$this->createRequest('GET', sprintf('groups/%d/members', $groupId), [
				'query' => $filters
			])
		);
	}
31158
public OperationFuture<List<Server>> shutDown(GroupFilter groupFilter) {
        return serverService().shutDown(
            getServerSearchCriteria(groupFilter)
        );
    }
370028
@Override
	public List<CommerceDiscount> filterFindByGroupId(long groupId) {
		return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
			QueryUtil.ALL_POS, null);
	}
380276
public Map<Group, List<ServerMonitoringStatistics>> getMonitoringStatsAsMap(List<Group> groups, ServerMonitoringFilter config) {
        Map<Group, List<ServerMonitoringStatistics>> result = new HashMap<>(groups.size());
        groups.stream()
            .forEach(group -> result.put(group, getMonitoringStats(group, config)));

        return result;
    }
853135
public List<String> findObjectsInGroup(String groupName) {
        if (getObjectGroups().containsKey(groupName)) {
            return getObjectGroups().get(groupName);
        } else {
            return Collections.emptyList();
        }
    }
811667
public static systemgroup[] get_filtered(nitro_service service, String filter) throws Exception{
		systemgroup obj = new systemgroup();
		options option = new options();
		option.set_filter(filter);
		systemgroup[] response = (systemgroup[]) obj.getfiltered(service, option);
		return response;
	}
997291
public static clusternodegroup[] get_filtered(nitro_service service, String filter) throws Exception{
		clusternodegroup obj = new clusternodegroup();
		options option = new options();
		option.set_filter(filter);
		clusternodegroup[] response = (clusternodegroup[]) obj.getfiltered(service, option);
		return response;
	}
1308111
protected List<CmsTreeItem> getFilteredCategories(String filter) {

        List<CmsTreeItem> result = new ArrayList<CmsTreeItem>();
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(filter)) {
            result = new ArrayList<CmsTreeItem>();
            for (CmsTreeItem category : m_categories.values()) {
                if (((CmsDataValue)category.getMainWidget()).matchesFilter(filter, 0, 1)) {
                    result.add(category);
                }
            }
        } else {
            Iterator<CmsTreeItem> it = m_categories.values().iterator();
            while (it.hasNext()) {
                result.add(it.next());
            }

        }
        return result;
    }