If not already created, a new <code>filter-mapping</code> element will be created and returned.
Otherwise, the first existing <code>filter-mapping</code> element will be returned.
@return the instance defined for the element <code>filter-mapping</code>
344858
public FilterMappingType<WebAppType<T>> getOrCreateFilterMapping()
   {
      List<Node> nodeList = childNode.get("filter-mapping");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FilterMappingTypeImpl<WebAppType<T>>(this, "filter-mapping", childNode, nodeList.get(0));
      }
      return createFilterMapping();
   }
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;
	}
251161
public static WebElementFinder create() {
		return new WebElementFinder(null, null, 0L, 0L, null, null, null, null, false);
	}
121652
@SuppressWarnings("unchecked")
    static <S extends Storable> Factory<S> getFactory(Filter<S> filter) {
        if (filter == null) {
            throw new IllegalArgumentException();
        }
        synchronized (cCache) {
            Factory<S> factory = (Factory<S>) cCache.get(filter);
            if (factory != null) {
                return factory;
            }
            Class<Cursor<S>> clazz = generateClass(filter);
            factory = QuickConstructorGenerator.getInstance(clazz, Factory.class);
            cCache.put(filter, factory);
            return factory;
        }
    }
1297168
public static SOAPElementFactory newInstance() throws SOAPException {
        try {
            return new SOAPElementFactory(SOAPFactory.newInstance());
        } catch (Exception ex) {
            throw new SOAPException(
                "Unable to create SOAP Element Factory: " + ex.getMessage());
        }
    }
387090
NodeIterator<T> getNodeIterator(Filter<T> filter) {
        return new NodeIterator<T>(root, filter, true);
    }
1063423
public static <K, V> Map<K, V> newFilteredMap(Map<K, V> map,
            Predicate<? super Entry<K, V>> filter) {
        return getEntryStreamWithFilter(map, filter)
                .collect(toMap(Entry::getKey, Entry::getValue));
    }
236601
public NamedQuery<OrmDescriptor> getOrCreateNamedQuery()
   {
      List<Node> nodeList = model.get("named-query");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new NamedQueryImpl<OrmDescriptor>(this, "named-query", model, nodeList.get(0));
      }
      return createNamedQuery();
   }
478431
public static <T extends ParameterDescription> ElementMatcher.Junction<T> definedParameter(ElementMatcher<? super ParameterDescription.InDefinedShape> matcher) {
        return new DefinedShapeMatcher<T, ParameterDescription.InDefinedShape>(matcher);
    }
835168
public FilterChain create() throws FilterConfigurationException {
        Preconditions.checkState(filters != null, "list of filters must be set");
        Preconditions.checkState(inputType != null, "inputType must be set");
        Preconditions.checkState(outputType != null, "outputType must be set");

        Preconditions.checkState(filters.size() > 0, "need at least one filter");
        validateFiltersList();

        Iterator<Object> iterator = filters.iterator();

        FilterChainElement firstInstance = getInstanceFromListElement(iterator.next());
        if (!firstInstance.getSupportedInputType().isAssignableFrom(inputType)
                || !firstInstance.getSupportedOutputType().isAssignableFrom(outputType)) {
            throw new FilterConfigurationException(String.format(
                "incompatible Filtertype (%s) should be (%s->%s) - is (%s->%s)",
                firstInstance.getClass(), inputType, outputType, firstInstance.getSupportedInputType(),
                firstInstance.getSupportedOutputType()));
        }
        FilterChainElement current = firstInstance;
        while (iterator.hasNext()) {
            Object next = iterator.next();
            FilterChainElement nextFilterElement = getInstanceFromListElement(next);
            if (nextFilterElement == null) {
                current.setNext((FilterAction) next);
                break;
            }
            current.setNext(nextFilterElement);
            current = nextFilterElement;
        }
        return new FilterChain(firstInstance);
    }
227925
public Embeddable<EntityMappings<T>> getOrCreateEmbeddable()
   {
      List<Node> nodeList = childNode.get("embeddable");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new EmbeddableImpl<EntityMappings<T>>(this, "embeddable", childNode, nodeList.get(0));
      }
      return createEmbeddable();
   }
495168
@Override
    public FilterMutableType getOrCreateFilter() {
        final List<Node> nodeList = this.getRootNode().get("filter");
        if (nodeList.size() > 0) {
            return createNewFilterViewForModel(nodeList.get(0));
        }
        return createFilter();
    }
124266
public MongoDeepJobConfig<T> filterQuery(Filter[] filters) {

        if (filters.length > 0) {
            List<BasicDBObject> list = new ArrayList<>();

            QueryBuilder queryBuilder = QueryBuilder.start();
            for (int i = 0; i < filters.length; i++) {
                BasicDBObject bsonObject = new BasicDBObject();

                Filter filter = filters[i];
                if (filter.getFilterType().equals(FilterType.EQ)) {
                    bsonObject.put(filter.getField(), filter.getValue());
                } else {
                    bsonObject.put(filter.getField(),
                            new BasicDBObject("$".concat(filter.getFilterType().getFilterTypeId().toLowerCase()),
                                    filter.getValue()));
                }

                list.add(bsonObject);
            }
            queryBuilder.and(list.toArray(new BasicDBObject[list.size()]));

            filterQuery(queryBuilder);
        }
        return this;

    }
857032
function() {
        var filters = [];        
        for(var i=0, len=this.filters.length; i<len; ++i) {
            filters.push(this.filters[i].clone());
        }
        return new OpenLayers.Filter.Logical({
            type: this.type,
            filters: filters
        });
    }
686548
@Override
    public List<FILTERTYPE> getAllFilter() {

        final List<FILTERTYPE> list = new ArrayList<FILTERTYPE>();
        final List<Node> nodeList = model.get("filter");
        for (final Node node : nodeList) {
            final FILTERTYPE filter = this.createNewFilterViewForModel(node);
            list.add(filter);
        }

        return list;
    }
1348406
public Convert<ElementCollection<T>> getOrCreateMapKeyConvert()
   {
      List<Node> nodeList = childNode.get("map-key-convert");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ConvertImpl<ElementCollection<T>>(this, "map-key-convert", childNode, nodeList.get(0));
      }
      return createMapKeyConvert();
   }
290529
@XmlElementDecl(namespace = "", name = "filter")
    public JAXBElement<Filter> createFilter(Filter value) {
        return new JAXBElement<Filter>(_Filter_QNAME, Filter.class, null, value);
    }