Whether or not the Rule firings are being watched.
496959
def watch_firings(self, flag):
        """"""
        lib.EnvSetDefruleWatchFirings(self._env, int(flag), self._rule)
1212948
public boolean hasPolicy(String sec, String ptype, List<String> rule) {
        for (List<String> r : model.get(sec).get(ptype).policy) {
            if (Util.arrayEquals(rule, r)) {
                return true;
            }
        }

        return false;
    }
61986
def watch_activations(self, flag):
        """"""
        lib.EnvSetDefruleWatchActivations(self._env, int(flag), self._rule)
1049407
public static List<Action> getActions(MonitoringRule rule) {
        List<Action> result;

        if (rule.getActions() != null && rule.getActions().getActions() != null) {
            result = rule.getActions().getActions();
        } else {
            result = Collections.<Action> emptyList();
        }
        return result;
    }
1342140
public boolean isPolicyExceeded() {
    boolean withinMaxRetries = maxAttempts == -1 || attemptCount < maxAttempts;
    boolean withinMaxDuration = maxDuration == -1 || System.nanoTime() - startTime < maxDuration;
    return !withinMaxRetries || !withinMaxDuration;
  }
1040542
protected Boolean isAllowed(CmsPermissionSet p, int value) {

        if ((p.getAllowedPermissions() & value) > 0) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }
1348491
def check(self):
        
        for character, followers in self.items():
            for follower in followers:
                if follower not in self:
                    return False
        return True
502465
boolean containsRule( Rule rule ) {
        for( int i = state.stackIdx - 1; i >= 0; i-- ) {
            if( rule == state.stack.get( i ).mixin ) {
                return true;
            }
        }
        return false;
    }
402147
function(rule) {
      var state = this.bt.current_state();
      try { return rule.call(this); } 
      catch(f) {
        this.bt.catch_mismatch(f);
        this.bt.restore(state);
      }
    }
86745
def qualify(change_or_pattern)
      return true unless self.defined?
      rules = get_rule(change_or_pattern)

      # define behaviors for when there are no rules applying to a given pattern
      if rules.empty?

        if change_or_pattern.respond_to?(:text) or
            change_or_pattern.respond_to?(:value) or
            change_or_pattern.subject.is_a?(Doc)
          return true
        end
        report(:ValidateError, change_or_pattern)
        return false
      end
      results = rules.collect do |rule|
        rule.qualify change_or_pattern
      end
      !results.any? do |qualified| !qualified end
    end
160722
def match(self, rule):
        
        if len(self.filters) == 0:
            return True

        for filter in self.filters:
            if filter.match(rule):
                return True
        return False
578898
function _rule_check($rule, $str) {
        if (($rule['flag'] & PSCWS4_ZRULE_INCLUDE) && !$this->_rule_checkbit($str, $rule['bit']))
            return false;
        if (($rule['flag'] & PSCWS4_ZRULE_EXCLUDE) && $this->_rule_checkbit($str, $rule['bit']))
            return false;
        return true;
    }
1085704
private boolean isWhitelisted(RoleSensitive subject, Collection<Role> expected) {
        for (CallableWhitelist w : CallableWhitelist.all()) {
            if (w.isWhitelisted(subject, expected, context))
                return true;
        }
        return false;
    }
469719
def _has_actions(self, event):
        """"""
        event_actions = self._aconfig.get(event)
        return event_actions is None or bool(event_actions)
289186
def watch(self, flag):
        """"""
        lib.EnvSetDeffunctionWatch(self._env, int(flag), self._fnc)
24126
@Override
    public boolean isCorruptOrIndoubt()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isCorruptOrIndoubt");

        boolean isCorruptOrIndoubt = _targetDestinationHandler.isCorruptOrIndoubt();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isCorruptOrIndoubt", Boolean.valueOf(isCorruptOrIndoubt));

        return isCorruptOrIndoubt;
    }
829802
def on_rule(self, *args):
        """"""
        if self.rule is None:
            return
        self.rule.connect(self._listen_to_rule)