Is eligible for context refresh ?

@return the boolean
168358
public boolean isEligibleForContextRefresh() {
        if (this.override) {
            return true;
        }
        if (getFile() != null) {
            return CONFIG_FILE_PATTERN.matcher(getFile().toFile().getName()).find();
        }
        return false;
    }
545669
public boolean checkAndScan() {
		String changeLogs=null;
		try {
			synchronized (lock) {
				checkFileChange();
			}
			if(changes.isEmpty())
			{
				return false;
			}
			for(;;)
			{
				String log=changes.poll();
				if(log==null)
				{
					break;
				}
				if(changeLogs==null)
				{
					changeLogs="";
				}
				changeLogs+=log+"\n";
			}
		} catch (Throwable e) {
			log.error(e.getMessage(),e);
		}
		if(changeLogs!=null)
		{
			log.debug("startScanClassSources from events:\n"+changeLogs);
			scanClassSources();
			return true;
		}
		return false;
	}
266413
@Override
    public boolean contextListenerStart() {
		boolean ok = super.contextListenerStart();
		//the web listeners couldn't be started so we don't even try to load the sip ones
		if(!ok) {
			return ok;
		}

		if (logger.isDebugEnabled())
            logger.debug("Configuring sip listeners");

        // Instantiate the required listeners
        ClassLoader loader = getLoader().getClassLoader();
        ok = sipListeners.loadListeners(findSipApplicationListeners(), loader);
        if(!ok) {
			return ok;
		}

        List<ServletContextListener> servletContextListeners = sipListeners.getServletContextListeners();
        if (servletContextListeners != null) {
            ServletContextEvent event =
                new ServletContextEvent(getServletContext());
            for (ServletContextListener servletContextListener : servletContextListeners) {
                if (servletContextListener == null)
                    continue;

                try {
                    fireContainerEvent("beforeContextInitialized", servletContextListener);
                    servletContextListener.contextInitialized(event);
                    fireContainerEvent("afterContextInitialized", servletContextListener);
                } catch (Throwable t) {
                    fireContainerEvent("afterContextInitialized", servletContextListener);
//                    getLogger().error
//                        (sm.getString("standardContext.listenerStart",
//                        		servletContextListener.getClass().getName()), t);
                    getLogger().error
                    	(MESSAGES.errorSendingContextInitializedEvent(servletContextListener.getClass().getName()), t);
                    ok = false;
                }

                // TODO Annotation processing
            }
        }

        return (ok);

    }
461477
public boolean isForUpdate() {
        mLock.lock();
        try {
            return (mClosed || mActive == null) ? false : mActive.isForUpdate();
        } finally {
            mLock.unlock();
        }
    }
525393
public boolean isActive()
    {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        if (facesContext != null)
        {
            return facesContext.getViewRoot() != null;
        }
        else
        {
            // No FacesContext means no view scope active.
            return false;
        }
    }
1338490
@Override
	public boolean canRetry(RetryContext context) {
		Throwable t = context.getLastThrowable();
		return (t == null || retryForException(t))
				&& context.getRetryCount() < this.maxAttempts;
	}
513403
public boolean isPersistent()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
    {
      SibTr.entry(this, tc, "isPersistent");
      SibTr.exit(tc, "isPersistent", Boolean.valueOf(persistent));	
    }
    return persistent;
  }
727141
@Override
    public Boolean isReady() {
        try {
            validateInitialization();
            validateActivation();
            validateMiddleware();
            return true;
        } catch (InvalidStateException e) {
            return false;
        }
    }
1241110
private boolean checkCache() {
        if (this.cacheValid) {
            long now = System.nanoTime();
            if ((now - this.cacheExpiryTime) > 0) {
                this.cacheValid = false;
            }
        }
        return this.cacheValid;
    }
1157884
public Context getContext() {
		if (context == null) {
			context = Model.getSingleton().getSession().getContext(this.contextId);
		}
		return context;
	}
1304664
protected function isRefresh()
    {
        return $this->wei->isDebug()
            && $this->request->getServer('HTTP_PRAGMA') == 'no-cache'
            && strpos($this->request->getServer('HTTP_USER_AGENT'), 'wechatdevtools') === false;
    }
820750
protected boolean needsToLoadCredentials() {
        if (credentials == null) return true;

        if (credentialsExpiration != null) {
            if (isWithinExpirationThreshold()) return true;
        }

        if (lastInstanceProfileCheck != null) {
            if (isPastRefreshThreshold()) return true;
        }

        return false;
    }
1042514
private boolean needsNewSession() {
        if (sessionCredentials == null) return true;

        long timeRemaining = sessionCredentialsExpiration.getTime() - System.currentTimeMillis();
        return timeRemaining < (this.refreshThreshold * 1000);
    }
1106655
private boolean entryInRefreshProbationAccessed(final Entry<K, V> e, final long now) {
    long  nrt = e.getRefreshProbationNextRefreshTime();
    if (nrt > now) {
      reviveRefreshedEntry(e, nrt);
      return true;
    }
    return false;
  }
808305
private function isCurrentTokenValidInEnclosingContexts() {
        for ($contextKind = 0; $contextKind < ParseContext::Count; $contextKind++) {
            if ($this->isInParseContext($contextKind)) {
                if ($this->isValidListElement($contextKind, $this->getCurrentToken()) || $this->isListTerminator($contextKind)) {
                    return true;
                }
            }
        }
        return false;
    }
233603
public BoxFutureTask<BoxSession> refresh() {
        if (mRefreshTask != null && mRefreshTask.get() != null){
            BoxFutureTask<BoxSession> lastRefreshTask = mRefreshTask.get();
            if (!(lastRefreshTask.isCancelled() || lastRefreshTask.isDone())){
                return lastRefreshTask;
            }
        }
        final BoxFutureTask<BoxSession> task = (new BoxSessionRefreshRequest(this)).toTask();
        new Thread(){
            @Override
            public void run() {
                task.run();
            }
        }.start();
        mRefreshTask = new WeakReference<BoxFutureTask<BoxSession>>(task);
        return task;
    }
1209163
public static boolean isRssEnabled(ServletContext servletContext) {
		// Note: no locking performed since it's ok for two threads to do the work concurrently at first
		Boolean isRssEnabled = (Boolean)servletContext.getAttribute(ISS_RSS_ENABLED_CACHE_KEY);
		if(isRssEnabled == null) {
			try {
				Class.forName(RSS_SERVLET_CLASSNAME);
				isRssEnabled = true;
			} catch(ClassNotFoundException e) {
				isRssEnabled = false;
			}
			servletContext.setAttribute(ISS_RSS_ENABLED_CACHE_KEY, isRssEnabled);
		}
		return isRssEnabled;
	}