Is this the remote version of a filter?
(It is a remote filter if the listener is a remote session).
@return true if this is the remote version of a filter.
505602
public boolean isRemoteFilter()
    {
        for (int i = 0; (this.getMessageListener(i) != null); i++)
        {
            if (this.getMessageListener(i) instanceof Remote)
                return true;
        }
        return false;
    }
1312864
protected boolean isDirectory(String remoteFilePath) throws IOException {
        if (!ftpClient.changeWorkingDirectory(remoteFilePath)) { // not a directory or not accessible

            switch (ftpClient.listFiles(remoteFilePath).length) {
                case 0:
                    throw new CitrusRuntimeException("Remote file path does not exist or is not accessible: " + remoteFilePath);
                case 1:
                    return false;
                default:
                    throw new CitrusRuntimeException("Unexpected file type result for file path: " + remoteFilePath);
            }
        } else {
            return true;
        }
    }
1295967
private boolean isHandledByFilter(Method method) {
        // "Resource classes are POJOs that have at least one method annotated
        // with @Path or a request method designator. [...]
        //
        // Resource methods are methods of a resource class annotated with a
        // request method designator. [...] A request method designator is a
        // runtime annotation that is annotated with the @HttpMethod
        // annotation."
        for (Annotation annotation : method.getAnnotations()) {
            if (HttpMethod.class.isAssignableFrom(annotation.annotationType())) {
                return true;
            }
        }

        if (method.isAnnotationPresent(Path.class)) {
            return true;
        }

        return false;
    }
1187516
protected function _isFilterEnabled()
    {
        if (!isset($this->controller->filterFields)) {
            return false;
        }

        foreach ($this->controller->filterFields as $field) {
            if (isset($field['actions']) &&
                is_array($field['actions']) &&
                in_array($this->action, $field['actions'])
            ) {
                return true;
            }
        }

        return false;
    }
544705
function () {
				var oBinding = this.byId("tree").getBinding("items");
				if (this._sFilter) {
					oBinding.filter(new Filter({
						path: "name",
						operator: FilterOperator.Contains,
						value1: this._sFilter
					}));
					return true;
				} else {
					oBinding.filter();
					return false;
				}
			}
1029248
public boolean verifySender(InetAddress remoteAddr) {
        boolean returnValue = true;

        if (alists != null) {
            returnValue = !alists.accessDenied(remoteAddr);
        }
        return returnValue;
    }
634707
def checkIfRemoteIsNewer(self, localfile):
        
        is_remote_newer = False
        if localfile.exists() and localfile.stat().st_size > 0:
            LOG.info("File exists locally, using cache")
        else:
            is_remote_newer = True
            LOG.info("No cache file, fetching entries")
        return is_remote_newer
337278
public synchronized boolean hasMoreElementsR()
                    throws RemoteException, EnumeratorException
    {
        if (elements != null && index < elements.length) {
            return true;

        } else if (!exhausted) {

            // Reset our local cache and attempt to fetch the next batch
            // from the server

            try {
                elements = null;
                index = 0;
                elements = fetchElements(PREFETCH_COUNT);
                return true;
            } catch (NoMoreElementsException ex) {
                // We've exhausted the remote result set
                // FFDCFilter.processException(ex, CLASS_NAME + ".hasMoreElementsR",
                //                             "172", this);
                return false;
            }

        }

        // Exhausted!
        return false;

    }
843484
public NetworkFilter where(Predicate<NetworkMetadata> filter) {
        checkNotNull(filter, "Filter predicate must be not a null");

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

        return this;
    }
51909
@Override
    protected boolean isLocalOnly() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isLocalOnly");
        boolean ret = false;

        String scopeToLocalQP = (String) properties.get(SCOPE_TO_LOCAL_QP);
        if (ApiJmsConstants.SCOPE_TO_LOCAL_QP_ON.equals(scopeToLocalQP)) {
            ret = true;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isLocalOnly", ret);
        return ret;
    }
263559
public boolean isSendRemoteMessage(BaseMessage message)
    {
        Iterator<BaseMessageFilter> iterator = this.getMessageFilterList().getFilterList(null);    // ALL The filters (not just matches).
        while (iterator.hasNext())
        {
            BaseMessageFilter filter = iterator.next();
            if (!filter.isRemoteFilter())   // Always send down when filter is a remote copy
                if (filter.isSendRemoteMessage(message) == false)
                    return false;      // Don't send this message down
        }
        return true;
    }
476179
protected final InetSocketAddress remoteAddress() {
        if (remoteAddress == null) {
            if (server) {
                remoteAddress = new InetSocketAddress(NetUtil.LOCALHOST, randomClientPort());
            } else {
                remoteAddress = new InetSocketAddress(NetUtil.LOCALHOST,
                                                      guessServerPort(sessionProtocol, authority));
            }
        }
        return remoteAddress;
    }
816330
public static boolean isXForwardedAllowed(String remoteAddr) {
        return isXForwardedAllowed() && (S.eq("all", xForwardedAllowed) || xForwardedAllowed.contains(remoteAddr));
    }
1016340
public boolean isUnary() {
		Variable oneVar = this.scope[0];
		for (int i = 1; i < this.scope.length; i++) {
			if (!this.scope[i].equals(oneVar)) return false;
		}
		return true;
	}
1067874
static boolean passesFilter(SAMRecord record, Filter filter,
      String referenceName) {
    // If we are looking for only mapped or only unmapped reads then we will use
    // the UnmappedFlag to decide if this read should be rejected.
    if (filter == Filter.UNMAPPED_ONLY && !record.getReadUnmappedFlag()) {
      return false;
    }

    if (filter == Filter.MAPPED_ONLY && record.getReadUnmappedFlag()) {
      return false;
    }

    // If we are looking for mapped reads, then we check the reference name
    // of the read matches the one we are looking for.
    final boolean referenceNameMismatch = referenceName != null &&
        !referenceName.isEmpty() &&
        !referenceName.equals(record.getReferenceName());

    // Note that unmapped mate pair of mapped read will have a reference
    // name set to the reference of its mapped mate.
    if ((filter == Filter.MAPPED_ONLY || filter == Filter.MAPPED_AND_UNMAPPED)
        && referenceNameMismatch) {
      return false;
    }

    return true;
  }
811113
public T filter(@NonNull SerializablePredicate<? super HString> filter) {
      this.filter = filter;
      return Cast.as(this);
   }
556960
public boolean matchRemoteEvent(final TenantAwareEvent tenantAwareEvent) {
        if (!(tenantAwareEvent instanceof RemoteIdEvent) || entityClass == null || entityIds == null) {
            return false;
        }
        final RemoteIdEvent remoteIdEvent = (RemoteIdEvent) tenantAwareEvent;
        try {
            final Class<?> remoteEntityClass = Class.forName(remoteIdEvent.getEntityClass());
            return entityClass.isAssignableFrom(remoteEntityClass) && entityIds.contains(remoteIdEvent.getEntityId());
        } catch (final ClassNotFoundException e) {
            LOG.error("Entity Class of remoteIdEvent cannot be found", e);
            return false;
        }

    }