builds the unique filter_id key
@param application_name
@param filter_type
@param filter_name
@return key is application_name:filter_name:filter_type
964811
public static String buildFilterID(String application_name, FilterType filter_type, String filter_name) {
        return application_name + ":" + filter_name + ":" + filter_type.toString();
    }
49682
public static appfwconfidfield[] get_filtered(nitro_service service, String filter) throws Exception{
		appfwconfidfield obj = new appfwconfidfield();
		options option = new options();
		option.set_filter(filter);
		appfwconfidfield[] response = (appfwconfidfield[]) obj.getfiltered(service, option);
		return response;
	}
1307966
def _get_filter(sdk_filter, attr_map):
    
    if not isinstance(sdk_filter, dict):
        raise CloudValueError('filter value must be a dictionary, was %r' % (sdk_filter,))
    custom = sdk_filter.pop('custom_attributes', {})
    new_filter = _normalise_key_values(filter_obj=sdk_filter, attr_map=attr_map)
    new_filter.update({
        'custom_attributes__%s' % k: v for k, v in _normalise_key_values(filter_obj=custom).items()
    })
    return new_filter
522616
function setDKeyEnumOnITCArgs(resolver, baseTC: DiscriminatorTypeComposer<any, any>) {
  // setDKeyEnum for filter types, and on record types
  if (resolver) {
    const argNames = resolver.getArgNames();

    for (const argName of argNames) {
      if (argName === 'filter' || argName === 'record' || argName === 'records') {
        const filterArgTC = resolver.getArgITC(argName);

        if (filterArgTC) {
          filterArgTC.extendField(baseTC.getDKey(), {
            type: baseTC.getDKeyETC(),
          });
        }
      }
    }
  }
}
1072584
public static appfwjsoncontenttype[] get_filtered(nitro_service service, String filter) throws Exception{
		appfwjsoncontenttype obj = new appfwjsoncontenttype();
		options option = new options();
		option.set_filter(filter);
		appfwjsoncontenttype[] response = (appfwjsoncontenttype[]) obj.getfiltered(service, option);
		return response;
	}
408203
public static filterpolicy[] get(nitro_service service, String name[]) throws Exception{
		if (name !=null && name.length>0) {
			filterpolicy response[] = new filterpolicy[name.length];
			filterpolicy obj[] = new filterpolicy[name.length];
			for (int i=0;i<name.length;i++) {
				obj[i] = new filterpolicy();
				obj[i].set_name(name[i]);
				response[i] = (filterpolicy) obj[i].get_resource(service);
			}
			return response;
		}
		return null;
	}
1096625
@SuppressWarnings("unchecked")
    private static Filter<ArchivePath> getFilterInstance(final String filterClassName, final Class<?>[] ctorTypes,
        final Object[] ctorArguments) {
        // Precondition checks
        assert filterClassName != null && filterClassName.length() > 0 : "Filter class name must be specified";
        assert ctorTypes != null : "Construction types must be specified";
        assert ctorArguments != null : "Construction arguments must be specified";
        assert ctorTypes.length == ctorArguments.length : "The number of ctor arguments and their types must match";

        // Find the filter impl class in the configured CLs
        final Class<Filter<ArchivePath>> filterClass;
        try {
            filterClass = (Class<Filter<ArchivePath>>) ClassLoaderSearchUtil.findClassFromClassLoaders(filterClassName,
                ShrinkWrap.getDefaultDomain().getConfiguration().getClassLoaders());
        } catch (final ClassNotFoundException cnfe) {
            throw new IllegalStateException("Could not find filter implementation class " + filterClassName
                + " in any of the configured CLs", cnfe);
        }

        // Make the new instance
        return SecurityActions.newInstance(filterClass, ctorTypes, ctorArguments, Filter.class);
    }
962093
public static QueryFilter getIdentityFilter(DecoratedKey key, String cfName, long timestamp)
    {
        return new QueryFilter(key, cfName, new IdentityQueryFilter(), timestamp);
    }
1124088
public static FilterAdapter buildAdapter() {
    FilterAdapter adapter = new FilterAdapter();
    adapter.addFilterAdapter(
        ColumnPrefixFilter.class, new ColumnPrefixFilterAdapter());
    adapter.addFilterAdapter(
        ColumnRangeFilter.class, new ColumnRangeFilterAdapter());
    adapter.addFilterAdapter(
        KeyOnlyFilter.class, new KeyOnlyFilterAdapter());
    adapter.addFilterAdapter(
        MultipleColumnPrefixFilter.class, new MultipleColumnPrefixFilterAdapter());
    adapter.addFilterAdapter(
        TimestampsFilter.class, new TimestampsFilterAdapter());
    adapter.addFilterAdapter(
      TimestampRangeFilter.class, new TimestampRangeFilterAdapter());
    ValueFilterAdapter valueFilterAdapter = new ValueFilterAdapter();
    adapter.addFilterAdapter(
        ValueFilter.class, valueFilterAdapter);
    SingleColumnValueFilterAdapter scvfa =
        new SingleColumnValueFilterAdapter(valueFilterAdapter);
    adapter.addFilterAdapter(
        SingleColumnValueFilter.class, scvfa);
    adapter.addFilterAdapter(
        SingleColumnValueExcludeFilter.class,
        new SingleColumnValueExcludeFilterAdapter(scvfa));
    adapter.addFilterAdapter(
        ColumnPaginationFilter.class, new ColumnPaginationFilterAdapter());
    adapter.addFilterAdapter(
        FirstKeyOnlyFilter.class, new FirstKeyOnlyFilterAdapter());
    adapter.addFilterAdapter(
        ColumnCountGetFilter.class, new ColumnCountGetFilterAdapter());
    adapter.addFilterAdapter(
        RandomRowFilter.class, new RandomRowFilterAdapter());
    adapter.addFilterAdapter(
        PrefixFilter.class, new PrefixFilterAdapter());
    adapter.addFilterAdapter(
        QualifierFilter.class, new QualifierFilterAdapter());
    adapter.addFilterAdapter(
        PageFilter.class, new PageFilterAdapter());
    adapter.addFilterAdapter(
      WhileMatchFilter.class, new WhileMatchFilterAdapter(adapter));
    adapter.addFilterAdapter(
        org.apache.hadoop.hbase.filter.RowFilter.class, new RowFilterAdapter());
    adapter.addFilterAdapter(FuzzyRowFilter.class, new FuzzyRowFilterAdapter());
    adapter.addFilterAdapter(FamilyFilter.class, new FamilyFilterAdapter());
    adapter.addFilterAdapter(BigtableFilter.class, new BigtableFilterAdapter());

    // MultiRowRangeFilter only exists in hbase >= 1.1
    try {
      adapter.addFilterAdapter(
          org.apache.hadoop.hbase.filter.MultiRowRangeFilter.class,
          new MultiRowRangeFilterAdapter()
      );
    } catch (NoClassDefFoundError ignored) {
    }

    // Passing the FilterAdapter in to the FilterListAdapter is a bit
    // unfortunate, but makes adapting the FilterList's subfilters simpler.
    FilterListAdapter filterListAdapter = new FilterListAdapter(adapter);
    // FilterList implements UnsupportedStatusCollector so it should
    // be used when possible (third parameter to addFilterAdapter()).
    adapter.addFilterAdapter(
        FilterList.class, filterListAdapter, filterListAdapter);

    return adapter;
  }
1262933
def add(type, filter=nil, &block)
      if((filter.nil? && !block_given?) || (filter && !filter.is_a?(Filter)))
        raise ArgumentError.new('Filter or proc must be provided for filter')
      end
      const = Splib.find_const(type)
      type = const unless const.nil?
      @lock.synchronize do
        @filters[type] ||= {}
      end
      if(block_given?)
        unless(block.arity == 1 || block.arity < 0)
          raise ArgumentError.new('Block must accept a parameter')
        end
        @lock.synchronize do
          @filters[type][:procs] ||= []
          unless(@filters[type][:procs].include?(block))
            @filters[type][:procs] << block
          end
        end
      end
      if(filter)
        @lock.synchronize do
          unless(@filters[type].include?(filter))
            @filters[type][:filters] ||= []
            unless(@filters[type][:filters].include?(filter))
              @filters[type][:filters] << filter
            end
          end
        end
      end
      filter ? block_given? ? [filter, block] : filter : block
    end
357339
public org.osgi.framework.Filter createOsgiFilter()
        throws IllegalArgumentException {
        org.osgi.framework.Filter filter;
        try {
            String filterString = String.format("(&(%s=%s)(%s=%s))", APPLICATION_NAME, applicationName,
                OBJECTCLASS, FilterFactory.class.getName());
            LOGGER.debug("createOsgiFilter={} for application {}", filterString, applicationName);
            filter = bundleContext.createFilter(filterString);
        } catch (InvalidSyntaxException e) {
            throw new IllegalArgumentException("applicationName can not contain '*', '(' or ')' : " + applicationName,
                e);
        }
        return filter;
    }
623779
public static function addFilter(array $filters, array $filterArray, string $key, string $name): array
    {
        if (isset($filterArray[$name][$key])) {
            unset($filterArray[$name][$key]);
        }
        if (sizeof($filterArray[$name]) > 0) {
            $filters['filter']['bool']['must'][] = $filterArray;
        }

        return $filters;
    }
922013
public function create($filterTypeAlias, $name = null, array $options = [])
    {
        $alias = strtolower($filterTypeAlias);

        if (!$this->filterChain->hasType($alias)) {
            throw new FilterCreatorException(sprintf('Given filter type alias "%s" does not exist.', $alias));
        }


        /** @var FilterInterface $filter */
        $filter = clone $this->filterChain->getType($alias);

        if (!($filter instanceof FilterInterface)) {
            // The filter must implement the bundles FilterInterface.
            throw new FilterCreatorException(sprintf(
                'Filter "%s" must implement Da2e\FiltrationBundle\Filter\Filter\FilterInterface interface.',
                get_class($filter)
            ));
        }

        $filter->setName($name === null ? $this->generateUniqueName($alias) : $name);

        if (count($options) > 0) {
            // Handle filter options if there are such.
            $this->filterOptionHandler->handle($filter, $options);
        }

        return $filter;
    }
276309
static Element buildFilterElement(String filterName, String filterGUID)
	{
		Element filter = new Element(filterName);
		Element module = new Element("Module_0");
		filter.addContent(module);

		module.setAttribute("PresetGUID", filterGUID);

		return filter;
	}
890735
public CmsRelationFilter filterType(CmsRelationType type) {

        CmsRelationFilter filter = (CmsRelationFilter)clone();
        filter.m_types.add(type);
        return filter;
    }
17268
public static filteraction get(nitro_service service, String name) throws Exception{
		filteraction obj = new filteraction();
		obj.set_name(name);
		filteraction response = (filteraction) obj.get_resource(service);
		return response;
	}
270356
function (filterContainer) {
			this.writeDebug('getFilterKey',arguments);
			for (var key in this.settings.taxonomyFilters) {
				if (this.settings.taxonomyFilters.hasOwnProperty(key)) {
					for (var i = 0; i < this.settings.taxonomyFilters[key].length; i++) {
						if (this.settings.taxonomyFilters[key] === filterContainer) {
							return key;
						}
					}
				}
			}
		}