This allows the filters to be used at the end of a long chain of calls that ends
 at a service.  It forwards the message and the parameters to the target of this
 method (presumably a Service instance)
778583
def method_missing(method_name, *args, &block)
    puts "SoftLayer::APIParameterFilter#method_missing called #{method_name}, #{args.inspect}" if $DEBUG

    if(!block && method_name.to_s.match(/[[:alnum:]]+/))
      @target.call_softlayer_api_with_params(method_name, self, args)
    else
      super
    end
  end
21962
@Override
    public BlobContract withFilter(ServiceFilter filter) {
        ClientFilter[] currentFilters = getFilters();
        ClientFilter[] newFilters = Arrays.copyOf(currentFilters,
                currentFilters.length + 1);
        newFilters[currentFilters.length] = new ClientFilterAdapter(filter);
        return new MediaBlobRestProxy(getChannel(), newFilters,
                getAccountName(), getUrl(), this.tokenFilter, getDateMapper());
    }
107892
function (e) {
    var self = this;
    if (e) {
      self.stopPropagation(e);
    }

    // Get current filter
    var currentFilter = self.filterStateModel.getActiveFilter();
    if (currentFilter !== self.filter) {
      self.filterStateModel.setActiveFilter(self.filter);
      self.filterStateModel.trigger("filter:loaded");
    }
  }
835429
@Override
    public void end() {
        final EntityManager em = entityManager.get();

        // Let's not penalize users for calling end() multiple times.
        if (null == em) {
          return;
        }

        final EntityTransaction tx = em.getTransaction();

        if(tx.isActive()) {
            LOG.warn("There was an active transaction at the end of a request");
            tx.commit();
        }

        em.close();
        entityManager.remove();
    }
1217362
private IMessageFilter[] getFilter(Method method, Handler subscription) {
        Filter[] filterDefinitions = collectFilters(method, subscription);
        if (filterDefinitions.length == 0) {
            return null;
        }
        IMessageFilter[] filters = new IMessageFilter[filterDefinitions.length];
        int i = 0;
        for (Filter filterDef : filterDefinitions) {
            IMessageFilter filter = filterCache.get(filterDef.value());
            if (filter == null) {
                try {
                    filter = filterDef.value().newInstance();
                    filterCache.put(filterDef.value(), filter);
                } catch (Exception e) {
                    throw new RuntimeException(e);// propagate as runtime exception
                }
            }
            filters[i] = filter;
            i++;
        }
        return filters;
    }
1249145
private void decideTypeFilterToAdd(Filter filter) {
        Filter step = filter;

        if (Operator.MATCH == step.getRelation().getOperator() ||
                step.getRelation().getRightTerm() instanceof FunctionSelector) {
            if (matchList.isEmpty()) {
                matchList = new ArrayList<>();
            }
            matchList.add(filter);
        } else {
            if (filterList.isEmpty()) {
                filterList = new ArrayList<>();
            }
            filterList.add(filter);
        }
    }
341942
public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain)
	throws IOException, ServletException
    {
        String path=((HttpServletRequest)request).getServletPath();
        if (welcome!=null && path.endsWith("/"))
            request.getRequestDispatcher(path+welcome).forward(request,response);
        else
            chain.doFilter(request, response);
    }
640534
function (args) {
                var filters = args.filters;
                for (var i = 0, l = args.nbFilters; i < l; i++) {
                    var curFilter = filters[i];
                    // not that filterClasspath can be null if the filter was removed in the meantime.
                    if (curFilter.filterClasspath != null && curFilter.obj == null) {
                        curFilter.obj = Aria.getClassInstance(curFilter.filterClasspath, curFilter.initArgs);
                        this._filtersToBeLoaded--;
                    }
                }
                this.$callback(args.cb);
            }
910804
def add_filter(self, methods=None, endpoints=None):
        
        if not methods and not endpoints:
            raise ValueError('Filter cannot be added with no criteria.')

        filter = TraceFilter(methods, endpoints)
        self.filters.append(filter)
        return filter
119673
def applyFilters(self, endpoint):
        """"""
        for filter_function in self.filter_functions:
            e = filter_function(endpoint)
            if e is not None:
                # Once one of the filters has returned an
                # endpoint, do not apply any more.
                return e

        return None
453007
public Result proceed() throws Exception {
        if (iterator == null) {
            iterator = chain.listIterator();
        }
        if (!iterator.hasNext()) {
            throw new IllegalStateException("Reached the end of the chain without result.");
        }
        Filter filter = iterator.next();
        return filter.call(route, this);
    }
1286481
@Override
    public void onPreRemove(final IoFilterChain chain, final String name,
            final NextFilter nextFilter) {
        IoSession session = chain.getSession();
        session.removeAttribute(ProxyIoSession.PROXY_SESSION);
    }
169176
public void afterAfter(String path, Filter filter) {
        addFilter(HttpMethod.afterafter, FilterImpl.create(path, filter));
    }
1375038
public boolean removeRemoteMessageFilter(BaseMessageFilter messageFilter, boolean bFreeFilter) throws RemoteException
    {
        BaseTransport transport = this.createProxyTransport(REMOVE_REMOTE_MESSAGE_FILTER);
        transport.addParam(FILTER, messageFilter);   // Don't use COMMAND
        transport.addParam(FREE, bFreeFilter);
        Object strReturn = transport.sendMessageAndGetReply();
        Object objReturn = transport.convertReturnObject(strReturn);
        if (objReturn instanceof Boolean)
            return ((Boolean)objReturn).booleanValue();
        return true;
    }
891465
public void addMessageFilter(MessageFilter messageFilter)
    {
        boolean bThinTarget = ((BaseMessageFilter)messageFilter).isThinTarget();
        ((BaseMessageFilter)messageFilter).setThinTarget(false);  // If this is replicated to a server, the server needs to know that I am thick.
        super.addMessageFilter(messageFilter);
        ((BaseMessageFilter)messageFilter).setThinTarget(bThinTarget);
    }
342700
def object_filter(filter)
    raise ArgumentError, "object_filter expects an instance of SoftLayer::ObjectFilter" if filter.nil? || !filter.kind_of?(SoftLayer::ObjectFilter)

    # we create a new object in case the user wants to store off the
    # filter chain and reuse it later
    APIParameterFilter.new(self.target, @parameters.merge({:object_filter => filter}));
  end
980351
protected void cleanup() {

        final String methodName = "cleanup";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        super.cleanup();

        if (_successfulMessages.size() > 0) {

            try {

                deleteMessages(getMessageHandles(_successfulMessages), null);

            } catch (final ResourceException exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_1, this);
                if (TRACE.isEventEnabled()) {
                    SibTr.exception(this, TRACE, exception);
                }

            } finally {

                _successfulMessages.clear();

            }

        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }