Check whether groovydoc enabled
@return the result
425482
public boolean isGroovydocEnabled() {
        Boolean groovydocEnabled = this.getOptimizationOptions().get(GROOVYDOC);

        if (null == groovydocEnabled) {
            return false;
        }

        return groovydocEnabled;
    }
865087
public boolean isEnabledForCurrentJRE() {
        if ("".equals(requireJRE)) {
            return true;
        }
        try {
            JavaVersion requiredVersion = new JavaVersion(requireJRE);
            JavaVersion runtimeVersion = JavaVersion.getRuntimeVersion();

            if (DEBUG_JAVA_VERSION) {
                System.out.println("Checking JRE version for " + getShortName() + " (requires " + requiredVersion
                        + ", running on " + runtimeVersion + ")");
            }

            boolean enabledForCurrentJRE = runtimeVersion.isSameOrNewerThan(requiredVersion);
            if (DEBUG_JAVA_VERSION) {
                System.out.println("\t==> " + enabledForCurrentJRE);
            }
            return enabledForCurrentJRE;
        } catch (JavaVersionException e) {
            if (DEBUG_JAVA_VERSION) {
                System.out.println("Couldn't check Java version: " + e.toString());
                e.printStackTrace(System.out);
            }
            return false;
        }
    }
531392
public static boolean getCurrentSecurityEnabled()
  {
      boolean enabled = false;
      ICollaboratorHelper instance = getCurrentInstance();
      if (instance != null)
          enabled = ((CollaboratorHelperImpl)instance).isSecurityEnabled();
      return enabled;
  }
912580
def is_enabled(self):
        
        if self.name in settings.exclude_rules:
            return False
        elif self.name in settings.rules:
            return True
        elif self.enabled_by_default and ALL_ENABLED in settings.rules:
            return True
        else:
            return False
990750
static function isMethodDebugEnabled()
    {
        if ( !isset( $GLOBALS['eZTemplateDebugMethodEnabled'] ) )
        {
            $ini = eZINI::instance();
            $GLOBALS['eZTemplateDebugMethodEnabled'] = $ini->variable( 'TemplateSettings', 'ShowMethodDebug' ) == 'enabled';
        }
        return $GLOBALS['eZTemplateDebugMethodEnabled'];
    }
967417
static function isExecutionEnabled()
    {
        if ( isset( $GLOBALS['eZTemplateCompilerSettings']['execution'] ) and
             $GLOBALS['eZTemplateCompilerSettings']['execution'] !== null )
        {
            return $GLOBALS['eZTemplateCompilerSettings']['execution'];
        }

        $ini = eZINI::instance();
        $execution = $ini->variable( 'TemplateSettings', 'CompileExecution' ) == 'enabled';
        return $execution;
    }
819755
public function isEnabled()
    {
        if (null === $this->enablePdfPreview) {
            $this->enablePdfPreview = $this->getContainer()->getParameter('kunstmaan_media.enable_pdf_preview');
        }

        return $this->enablePdfPreview;
    }
1018499
public boolean hasWebDocumentation(final Class<?>  clazz) {
        for (final String pkg : PACKAGES_WITH_WEB_DOCUMENTATION) {
            if (clazz.getPackage().getName().startsWith(pkg)) {
                return true;
            }
        }
        return false;
    }
1128074
public boolean isEnabled(Feature feature) {
        Boolean enabled = features.get(feature);
        if (enabled == null) {
            return feature.isEnabledByDefault();
        } else {
            return enabled;
        }
    }
511271
public static boolean checkConfiguredInModules() {

        Boolean result = m_moduleCheckCache.get();
        if (result == null) {
            result = Boolean.valueOf(getConfiguredTemplateMapping() != null);
            m_moduleCheckCache.set(result);
        }
        return result.booleanValue();
    }
264416
public static function isEnabled(): bool
    {
        static::init();

        if (array_key_exists(self::ENABLED, static::$config)) {
            return static::$config[self::ENABLED] ?? false;
        }

        return static::getParameterName() !== null;
    }
1286758
protected function enabled()
	{
		if ( !extension_loaded('xdebug') ) {
			throw new \RuntimeException('Xdebug extension must be enabled for coverage collection');
		}

		return isset($_COOKIE[self::TEST_ID_VARIABLE]) && !isset($_GET[self::TEST_ID_VARIABLE]);
	}
1224673
public boolean isTraceEnabled() {
		return MINIMUM_LEVEL_COVERS_TRACE && provider.isEnabled(STACKTRACE_DEPTH, null, org.tinylog.Level.TRACE);
	}
576424
public static boolean isTodoItem(final Document todoItemDoc) {
    return todoItemDoc.containsKey(ID_KEY)
        && todoItemDoc.containsKey(TASK_KEY)
        && todoItemDoc.containsKey(CHECKED_KEY);
  }
163381
public static function isEnabled()
    {
        if (is_null(self::$isEnabled)) {
            self::$isEnabled = (bool) Config::getInstance()->Development['enabled'];
        }

        return self::$isEnabled;
    }
799843
public boolean isEnabled() {
        ACL acl = Jenkins.getInstance().getAuthorizationStrategy().getRootACL();
        if (acl != null) {
            Authentication authentication = Jenkins.getAuthentication();
            assert authentication != null;
            for (Permission p : _getRequiredPermissions()) {
                if (!acl.hasPermission(authentication, p)) {
                    return false;
                }
            }
        }
        return true;
    }
45922
private boolean isForkDisabled(Plugin plugin) throws MojoExecutionException {
        String forkCountValue = extractParamValue(plugin, FORK_COUNT_PARAM_NAME);
        String forkModeValue = extractParamValue(plugin, FORK_MODE_PARAM_NAME);
        return (forkCountValue != null && forkCountValue.equals("0")) ||
            (forkModeValue != null && forkModeValue.equals("never"));
    }