Determines if this analyzer is enabled.

@return <code>true</code> if the analyzer is enabled; otherwise
<code>false</code>
492419
private boolean checkEnabled() {
        boolean retVal = false;

        try {
            if (getSettings().getBoolean(Settings.KEYS.ANALYZER_CENTRAL_ENABLED)) {
                if (!getSettings().getBoolean(Settings.KEYS.ANALYZER_NEXUS_ENABLED)
                        || NexusAnalyzer.DEFAULT_URL.equals(getSettings().getString(Settings.KEYS.ANALYZER_NEXUS_URL))) {
                    LOGGER.debug("Enabling the Central analyzer");
                    retVal = true;
                } else {
                    LOGGER.info("Nexus analyzer is enabled, disabling the Central Analyzer");
                }
            } else {
                LOGGER.info("Central analyzer disabled");
            }
        } catch (InvalidSettingException ise) {
            LOGGER.warn("Invalid setting. Disabling the Central analyzer");
        }
        return retVal;
    }
531392
public static boolean getCurrentSecurityEnabled()
  {
      boolean enabled = false;
      ICollaboratorHelper instance = getCurrentInstance();
      if (instance != null)
          enabled = ((CollaboratorHelperImpl)instance).isSecurityEnabled();
      return enabled;
  }
65373
public boolean isEnabledSaslMechanism(String saslMechanism) {
        // If enabledSaslMechanisms is not set, then all mechanisms which are not blacklisted are enabled per default.
        if (enabledSaslMechanisms == null) {
            return !SASLAuthentication.getBlacklistedSASLMechanisms().contains(saslMechanism);
        }
        return enabledSaslMechanisms.contains(saslMechanism);
    }
717595
public boolean isEnabledFor( final Priority priority )
    {
        if ( priority == null )
        {
            return false;
        }

        switch ( priority.level )
        {
            case Level.FATAL_INT:
                return m_delegate.isFatalEnabled();
            case Level.ERROR_INT:
                return m_delegate.isErrorEnabled();
            case Level.WARN_INT:
                return m_delegate.isWarnEnabled();
            case Level.INFO_INT:
                return m_delegate.isInfoEnabled();
            case Level.DEBUG_INT:
                return m_delegate.isDebugEnabled();
            case Level.TRACE_INT:
            case Level.ALL_INT:
                return m_delegate.isTraceEnabled();
            default:
                return false;
        }
    }
1053354
public static boolean isDetectorEnabled(IFindBugsEngine findBugs, DetectorFactory factory, int rankThreshold) {

        if (!findBugs.getUserPreferences().isDetectorEnabled(factory)) {
            return false;
        }

        if (!factory.isEnabledForCurrentJRE()) {
            return false;
        }

        // Slow first pass detectors are usually disabled, but may be explicitly
        // enabled
        if (!AnalysisContext.currentAnalysisContext().getBoolProperty(FindBugsAnalysisFeatures.INTERPROCEDURAL_ANALYSIS)
                && factory.isDetectorClassSubtypeOf(InterproceduralFirstPassDetector.class)) {
            return false;
        }

        int maxRank = Integer.MAX_VALUE;
        Set<BugPattern> reportedBugPatterns = factory.getReportedBugPatterns();
        boolean isNonReportingDetector = factory.isDetectorClassSubtypeOf(FirstPassDetector.class);
        if (!isNonReportingDetector && !reportedBugPatterns.isEmpty()) {
            for (BugPattern b : reportedBugPatterns) {
                int rank = BugRanker.findRank(b, factory);
                if (maxRank > rank) {
                    maxRank = rank;
                }
            }
            if (maxRank > rankThreshold) {
                return false;
            }
        }

        // Training detectors are enabled if, and only if, we are emitting
        // training output
        boolean isTrainingDetector = factory.isDetectorClassSubtypeOf(TrainingDetector.class);
        if (findBugs.emitTrainingOutput()) {
            return isTrainingDetector || isNonReportingDetector;
        }

        return !isTrainingDetector;
    }
549720
public boolean isDisabled(FaceletContext ctx) {
        return disabled != null && Boolean.TRUE.equals(disabled.getBoolean(ctx));
    }
1044292
public boolean isEnabled(String path) {
        if (path.startsWith("/")) {
            // start after the leading slash
            int roomSlashPos = path.indexOf('/', 1);
            if (roomSlashPos == -1) {
                // check application level scope
                path = path.substring(1);
            } else {
                // check room level scope
                path = path.substring(1, roomSlashPos);
            }
        }
        boolean enabled = activeRooms.contains(path);
        log.debug("Enabled check on path: {} enabled: {}", path, enabled);
        return enabled;
    }
960216
public boolean isInfoEnabled() {
        if (repository.isDisabled(Level.INFO_INT))
            return false;
        return Level.INFO.isGreaterOrEqual(this.getEffectiveLevel());
    }
252534
public function isAnalyticsEnabled()
    {
        $enabled = SiteConfig::current_site_config()->GoogleAnalyticsEnabled;
        
        if (!$enabled) {
            $enabled = self::config()->analytics_enabled;
        }
        
        return (boolean) $enabled;
    }
82891
public void analyze(Analyzer analyzer, boolean allowFlow)
    throws Exception
  {
    analyzeImpl(analyzer, allowFlow, new IntArray(), new IntArray());
  }
583415
public synchronized boolean isClientAuthenticationEnabled() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "isClientAuthenticationEnabled");
        boolean auth = false;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "isClientAuthenticationEnabled", Boolean.valueOf(auth));
        return auth;
    }
225674
public boolean isEnabled()
    {
        if ((this.getMasterSlaveFlag() & FileListener.RUN_IN_SLAVE) == 0) // Is NOT enabled in a SERVER only environment
            if (this.getOwner() != null)
                if ((this.getOwner().getMasterSlave() & RecordOwner.MASTER) == 0) // Is not a client environment
            return false;   // Don't run this listener in a server-only environment
        if ((this.getMasterSlaveFlag() & FileListener.RUN_IN_MASTER) == 0) // Is NOT enabled in a CLIENT only environment
            if (this.getOwner() != null)
                if ((this.getOwner().getMasterSlave() & RecordOwner.SLAVE) == 0) // Is not a server environment
            return false;   // Don't run this listener in a client-only environment
        return super.isEnabled();
    }
357626
public boolean isDetectorEnabled(DetectorFactory factory) {
        String detectorName = factory.getShortName();
        Boolean enabled = detectorEnablementMap.get(detectorName);
        if (enabled == null) {
            // No explicit preference has been specified for this detector,
            // so use the default enablement specified by the
            // DetectorFactory.
            enabled = factory.isDefaultEnabled();
            detectorEnablementMap.put(detectorName, enabled);
        }
        return enabled;
    }
1208494
private static boolean acquireAnalysisPermitUnlessCancelled(IProgressMonitor monitor) throws InterruptedException {
        do {
            if (analysisSem.tryAcquire(1, TimeUnit.SECONDS)) {
                return true;
            }
        } while (!monitor.isCanceled());

        return false;
    }
165825
final boolean isMaster() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "isMaster");

        if (master == compatibilityWrapperOrSelf) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                JmfTr.exit(this, tc, "isMaster", Boolean.TRUE);
            return Boolean.TRUE;
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                JmfTr.exit(this, tc, "isMaster", Boolean.FALSE);
            return Boolean.FALSE;
        }
    }
740868
private boolean isTraceEnabled(boolean debug) // d581579
    {
        if (debug ? tc.isDebugEnabled() : tc.isEntryEnabled())
        {
            return true;
        }

        if (ivCache.numSweeps % NUM_SWEEPS_PER_OOMTRACE == 1 &&
            (debug ? tcOOM.isDebugEnabled() : tcOOM.isEntryEnabled()))
        {
            return true;
        }

        return false;
    }
1192443
public boolean isFeatureEnabled(com.ibm.websphere.servlet.container.WebContainer.Feature feature) {
        return this.features.contains(feature);
    }