Returns a flag indicating if also unreleased resources should be found.
@return A flag indicating if also unreleased resources should be found.
187045
protected Boolean getIgnoreReleaseDate() {

        Boolean isIgnoreReleaseDate = parseOptionalBooleanValue(m_configObject, JSON_KEY_IGNORE_RELEASE_DATE);
        return (null == isIgnoreReleaseDate) && (m_baseConfig != null)
        ? Boolean.valueOf(m_baseConfig.getGeneralConfig().getIgnoreReleaseDate())
        : isIgnoreReleaseDate;
    }
502461
public boolean isSearchClasspathForResources() {
        if (logger!=null)
            logger.logp(Level.INFO, CLASS_NAME,"isSearchClasspathForResources", "searchClasspathForResources: {"+searchClasspathForResources+"]");
        return searchClasspathForResources;
    }
435957
public static boolean areSoSourcesAbisSupported() {
    sSoSourcesLock.readLock().lock();
    try {
      if (sSoSources == null) {
        return false;
      }

      String supportedAbis[] = SysUtil.getSupportedAbis();
      for (int i = 0; i < sSoSources.length; ++i) {
        String[] soSourceAbis = sSoSources[i].getSoSourceAbis();
        for (int j = 0; j < soSourceAbis.length; ++j) {
          boolean soSourceSupported = false;
          for (int k = 0; k < supportedAbis.length && !soSourceSupported; ++k) {
            soSourceSupported = soSourceAbis[j].equals(supportedAbis[k]);
          }
          if (!soSourceSupported) {
            Log.e(TAG, "abi not supported: " + soSourceAbis[j]);
            return false;
          }
        }
      }

      return true;
    } finally {
      sSoSourcesLock.readLock().unlock();
    }
  }
738705
public Set<Resource<L>> getRootResources() {
        graphLockRead.lock();
        try {
            Set<Resource<L>> roots = new HashSet<>();
            Set<Resource<L>> allResources = resourcesGraph.vertexSet();
            for (Resource<L> resource : allResources) {
                if (neighborIndex.predecessorsOf(resource).isEmpty()) {
                    roots.add(resource);
                }
            }
            return Collections.unmodifiableSet(roots);
        } finally {
            graphLockRead.unlock();
        }
    }
872297
public boolean isValid() {
        if (valid == null) {
            valid = (this.resource != null);
            if (valid) {
                valid = (getResourceResolver().getResource(getPath()) != null);
            }
        }
        return valid;
    }
609908
@javax.annotation.Nonnull
  public File getResourceDir() {
    @javax.annotation.Nonnull final File etc = new File(workingDir, "etc");
    etc.mkdirs();
    return etc;
  }
406060
@Override
	public ESat isEntailed() {
		boolean done = true;
		for (int i = 0; i < n; i++) {
			if ((!degrees[i].contains(0)) && !g.getPotentialNodes().contains(i)) {
				return ESat.FALSE;
			}
			ISet env = target.getPotSet(g, i);
			ISet ker = target.getMandSet(g, i);
			if (degrees[i].getLB() > env.size()
					|| degrees[i].getUB() < ker.size()) {
				return ESat.FALSE;
			}
			if (env.size() != ker.size() || !degrees[i].isInstantiated()) {
				done = false;
			}
		}
		if (!done) {
			return ESat.UNDEFINED;
		}
		return ESat.TRUE;
	}
1257004
public String getSource() {
		if (source != null) {
			return source;
		}
		if (parentSequence != null) {
			return parentSequence.getSource();
		}
		return null;
	}
610857
public boolean isLowOnResources()
    {
        int spare=getMaxThreads()-getThreads();
        int lr = _lowResources>0?_lowResources:getMinThreads();
        boolean low = (spare+getIdleThreads())<lr;
        
        if (low && !_isLow)
        {
            log.info("LOW ON THREADS (("+
                      getMaxThreads()+"-"+
                      getThreads()+"+"+
                      getIdleThreads()+")<"+
                      getMinThreads()+") on "+ this);
            _warned=System.currentTimeMillis();
            _isLow=true;
        }
        else if (!low && _isLow)
        {
            if (System.currentTimeMillis()-_warned > 1000)
            {
                _isOut=false;
                _isLow=false;
            }
        }
        return low;
    }
544420
public static boolean doesResourceExist(final Resource res) {
        if (res != null) {
            try {
                IOUtils.read(res.getInputStream(), new byte[1]);
                return res.contentLength() > 0;
            } catch (final FileNotFoundException e) {
                LOGGER.trace(e.getMessage());
                return false;
            } catch (final Exception e) {
                LOGGER.trace(e.getMessage(), e);
                return false;
            }
        }
        return false;
    }
6262
public boolean hasModuleResourcesWithUndefinedSite() {

        if (getSite() == null) {
            for (String modRes : getResources()) {
                if (!CmsStringUtil.isPrefixPath("/system/", modRes)
                    && !OpenCms.getSiteManager().startsWithShared(modRes)) {
                    return true;
                }

            }
        }
        return false;
    }
722747
private boolean hasOnlyNewResources(List<CmsResource> projectResources) {

        boolean hasOnlyNewResources = true;
        for (CmsResource projectRes : projectResources) {
            if (!projectRes.getState().isNew()) {
                hasOnlyNewResources = false;
                break;
            }
        }
        return hasOnlyNewResources;
    }
1222437
private boolean isStale() {
    long lastRun = outputFile.lastModified();
    long sourcesLastModified = Math.max(
        getLastModifiedTime(this.sourceFileLists),
        getLastModifiedTime(this.sourcePaths));
    long externsLastModified = getLastModifiedTime(this.externFileLists);

    return lastRun <= sourcesLastModified || lastRun <= externsLastModified;
  }
1308567
protected boolean checkResourcesModified(GeneratorContext context, List<FilePathMapping> fMappings) {
		boolean resourceModified = false;

		for (Iterator<FilePathMapping> iter = fMappings.iterator(); iter.hasNext() && !resourceModified;) {
			FilePathMapping fMapping = iter.next();
			resourceModified = fMapping.getLastModified() != rsHandler.getLastModified(fMapping.getPath());
		}
		return resourceModified;
	}
704455
public boolean isValidAndEnabled() {

        return (getMode() != null)
            && (getMode() != Mode.disabled)
            && (getPort() > -1)
            && !CmsStringUtil.isEmptyOrWhitespaceOnly(getCertConfigPath())
            && !CmsStringUtil.isEmptyOrWhitespaceOnly(getHost());
    }
559901
protected boolean isOperationOnFolder() {

        Iterator<String> i = getResourceList().iterator();
        while (i.hasNext()) {
            String resName = i.next();
            try {
                CmsResource curRes = getCms().readResource(resName, CmsResourceFilter.ALL);
                if (curRes.isFolder()) {
                    // found a folder
                    return true;
                }
            } catch (CmsException e) {
                // can usually be ignored
                if (LOG.isInfoEnabled()) {
                    LOG.info(e.getLocalizedMessage());
                }
            }
        }
        return false;
    }
1173266
public boolean checkForRWPaths() {

        boolean result = false;

        String[] lines = mountReader();

        if (lines == null){
            // Could not read, assume false;
            return false;
        }

        for (String line : lines) {

            // Split lines into parts
            String[] args = line.split(" ");

            if (args.length < 4){
                // If we don't have enough options per line, skip this and log an error
                QLog.e("Error formatting mount line: "+line);
                continue;
            }

            String mountPoint = args[1];
            String mountOptions = args[3];

            for(String pathToCheck: Const.pathsThatShouldNotBeWrtiable) {
                if (mountPoint.equalsIgnoreCase(pathToCheck)) {

                    // Split options out and compare against "rw" to avoid false positives
                    for (String option : mountOptions.split(",")){

                        if (option.equalsIgnoreCase("rw")){
                            QLog.v(pathToCheck+" path is mounted with rw permissions! "+line);
                            result = true;
                            break;
                        }
                    }
                }
            }
        }

        return result;
    }