Sets the match rule to filter for the given _signal_ and the
 given interface _intf_.
190005
def from_signal(intf, signal)
      signal = signal.name unless signal.is_a?(String)
      self.type = "signal"
      self.interface = intf.name
      self.member = signal
      self.path = intf.object.path
      self
    end
630155
public void setNoMatchReturnValue(String filterReturnValue) {
    if (filterReturnValue.equalsIgnoreCase("accept")) {
      noMatchReturnValue = ACCEPT;
    } else if (filterReturnValue.equalsIgnoreCase("deny")) {
      noMatchReturnValue = DENY;
    } else if (filterReturnValue.equalsIgnoreCase("neutral")) {
      noMatchReturnValue = NEUTRAL;
    } else {
      LogLog.error("invalid noMatchReturnValue: " + filterReturnValue);
    }
  }
459558
public Set<SIFInteraction> createSIFInteraction(Match m, IDFetcher fetcher)
	{
		BioPAXElement sourceBpe = m.get(((SIFMiner) this).getSourceLabel(), getPattern());
		BioPAXElement targetBpe = m.get(((SIFMiner) this).getTargetLabel(), getPattern());

		Set<String> sources = fetchIDs(sourceBpe, fetcher);
		Set<String> targets = fetchIDs(targetBpe, fetcher);

		SIFType sifType = ((SIFMiner) this).getSIFType();

		Set<SIFInteraction> set = new HashSet<SIFInteraction>();

		for (String source : sources)
		{
			for (String target : targets)
			{
				if (source.equals(target)) continue;
				else if (sifType.isDirected() || source.compareTo(target) < 0)
				{
					set.add(new SIFInteraction(source, target, sourceBpe, targetBpe, sifType,
						new HashSet<BioPAXElement>(m.get(getMediatorLabels(), getPattern())),
						new HashSet<BioPAXElement>(m.get(getSourcePELabels(), getPattern())),
						new HashSet<BioPAXElement>(m.get(getTargetPELabels(), getPattern()))));
				}
				else
				{
					set.add(new SIFInteraction(target, source, targetBpe, sourceBpe, sifType,
						new HashSet<BioPAXElement>(m.get(getMediatorLabels(), getPattern())),
						new HashSet<BioPAXElement>(m.get(getTargetPELabels(), getPattern())),
						new HashSet<BioPAXElement>(m.get(getSourcePELabels(), getPattern()))));
				}
			}
		}
		return set;
	}
528196
def block(self, signals=None, isBlocked=True):
        
        if signals:
            try:
                if isinstance(signals, basestring):
                    signals = [signals]
            except NameError:
                if isinstance(signals, str):
                    signals = [signals]

        signals = signals or self.keys()

        for signal in signals:
            if signal not in self:
                raise RuntimeError("Could not find signal matching %s" % signal)
            self[signal].block(isBlocked)
420010
def get_interface_by_instance_name(self, name):
        ''''''
        with self._mutex:
            for intf in self.interfaces:
                if intf.instance_name == name:
                    return intf
            return None
710699
def Filter(self, match=None, **_):
    """"""
    arg = self.stack.pop(-1)

    # Filters can be specified as a comma separated list.
    for filter_name in match.group(1).split(","):
      filter_object = ConfigFilter.classes_by_name.get(filter_name)
      if filter_object is None:
        raise FilterError("Unknown filter function %r" % filter_name)

      if not filter_object.sensitive_arg:
        logging.debug("Applying filter %s for %s.", filter_name, arg)
      arg = filter_object().Filter(arg)
      precondition.AssertType(arg, Text)

    self.stack[-1] += arg
939084
def InterfaceMatcher(clazz, subclass, protocol):
    """"""
    interface = (clazz, subclass, protocol)

    def Matcher(device):
        for setting in device.iterSettings():
            if GetInterface(setting) == interface:
                return setting

    return Matcher
715875
def set_bind(self):
        
        IntegerEntry.set_bind(self)
        self.bind('<Next>', lambda e: self.set(self.imin))
        self.bind('<Prior>', lambda e: self.set(self.imax))
710072
def filter(self, table, idps, filter_string):
        """"""
        q = filter_string.lower()
        return [idp for idp in idps
                if q in idp.ud.lower()]
34102
private boolean doesPortMatch(String connectionObjPort, String remotePort) {
        boolean match = false;

        if (remotePort.equalsIgnoreCase(connectionObjPort))
            match = true;

        return match;
    }
1272958
public static void setIndex(Matcher matcher, int idx) {
        int count = getCount(matcher);
        if (idx < -count || idx >= count) {
            throw new IndexOutOfBoundsException("index is out of range " + (-count) + ".." + (count - 1) + " (index = " + idx + ")");
        }
        if (idx == 0) {
            matcher.reset();
        } else if (idx > 0) {
            matcher.reset();
            for (int i = 0; i < idx; i++) {
                matcher.find();
            }
        } else if (idx < 0) {
            matcher.reset();
            idx += getCount(matcher);
            for (int i = 0; i < idx; i++) {
                matcher.find();
            }
        }
    }
1236095
def simxSetIntegerSignal(clientID, signalName, signalValue, operationMode):
    '''
    
    '''

    if (sys.version_info[0] == 3) and (type(signalName) is str):
        signalName=signalName.encode('utf-8')
    return c_SetIntegerSignal(clientID, signalName, signalValue, operationMode)
747613
def ILIKE(pattern):
    """"""
    return P(lambda x: fnmatch.fnmatch(x.lower(), pattern.lower()))
1041734
private Optional<Data<Input, Output>> match_(Input input) {
        return Optional.ofNullable(recent_.get())
                .filter((Data<Input, Output> data) -> equality_.test(data.getInput(), input));
    }
796473
public void setMatchReturnValue(String filterReturnValue) {
    if (filterReturnValue.equalsIgnoreCase("accept")) {
      matchReturnValue = ACCEPT;
    } else if (filterReturnValue.equalsIgnoreCase("deny")) {
      matchReturnValue = DENY;
    } else if (filterReturnValue.equalsIgnoreCase("neutral")) {
      matchReturnValue = NEUTRAL;
    } else {
      LogLog.error("invalid matchReturnValue: " + filterReturnValue);
    }
  }
961923
private static Set<Interaction> getInter(Match match)
	{
		Set<Interaction> set = new HashSet<Interaction>();
		for (BioPAXElement ele : match.getVariables())
		{
			if (ele instanceof Interaction) 
			{
				set.add((Interaction) ele);
				addControlsRecursive((Interaction) ele, set);
			}
		}
		return set;
	}
527661
private boolean ignoreScan(String intf)
    {
        for (String ignored : ignoredPackages)
        {
            if (intf.startsWith(ignored + "."))
            {
                return true;
            }
        }
        return false;
    }