Returns true if the application with the specified name is started, otherwise false.

@return true if the application with the specified name is started, otherwise false.
423774
boolean isStarted(String appName) {
        lock.readLock().lock();
        try {
            return appStates.get(appName) == ApplicationState.STARTED;
        } finally {
            lock.readLock().unlock();
        }
    }
736194
protected boolean atStart()
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass
                        , "atStart"
                            );

        boolean atStartOfLogRecord = (bufferCursor == 0) && (bufferByteCursor == 0);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass
                       , "atStart"
                       , "returns atStartOfLogRecord=" + atStartOfLogRecord + "(boolean)"
                            );
        return atStartOfLogRecord;
    }
629593
private boolean start() {
        if (scheduledFuture == null || scheduledFuture.isCancelled()) {
            scheduledFuture = scheduler.scheduleWithFixedDelay(cacheManagingTask, delay, delay, TimeUnit.MINUTES);
            if (LOG.isDebugEnabled()) {
                LOG.debug("{} Cache Manager Started.", cache.getClass().getSimpleName());
            }
            return true;
        }
        return false;
    }
480724
public boolean isSentenceStart() {
    return posToken != null && JLanguageTool.SENTENCE_START_TAGNAME.equals(posToken.posTag) && !posToken.negation;
  }
623699
public boolean toPostInit()
   {
     synchronized (this) {
       if (_state == STOPPED) {
         _state = INIT;

         _lastChangeTime = CurrentTime.currentTime();

         notifyListeners(STOPPED, INIT);

         return true;
       }
       else {
         return _state.isInit();
       }
     }
   }
1029252
private static boolean isStartWith(String testString, String[] targetStrings) {
        for (String s : targetStrings) {
            if (testString.startsWith(s)) {
                return true;
            }
        }

        return false;
    }
885787
public final boolean isStarted() {

        String thisMethodName = "isStarted";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, this);
        }

        boolean retVal = (_state == STATE_STARTED);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, Boolean.toString(retVal));
        }

        return retVal;
    }
419894
private static boolean isPropertyName(String name) {
        return ((name.length() > 0) && Character.isUpperCase(name.charAt(0))) || ((name.length() > 1) && Character.isUpperCase(name.charAt(1)));
    }
836944
boolean isDefault() {
        if (entries.size() == 1) {
            StartupEntry sue = entries.get(0);
            if (sue.isBuiltIn && sue.name.equals(DEFAULT_STARTUP_NAME)) {
                return true;
            }
        }
        return false;
    }
447557
boolean isAccepted(final String name) {
        for (String str : encodings) {
            if (str.equalsIgnoreCase(name)) {
                return true;
            }
        }
        return false;
    }
20568
protected function checkStarted(): bool
    {
        if (!$this->started) {
            $this->started = self::sessionStart();
        }
        if (isset($_SESSION[$this->namespace]) && !is_array($_SESSION[$this->namespace])) {
            $_SESSION[$this->namespace] = [];
        }
        return (bool) $this->started;
    }
230534
public final boolean start() {

        if (running || booting || stopping || terminated) {
            // do nothing if this instance is not stopped
            return false;
        } else {
            // mark this instance started
            booting = true;
            running = true;

            onStarted();

            return true;
        }
    }
402068
@Override
	public synchronized boolean start()
    {
    	if (started)
    		return false;
    	
    	try
    	{
	    	long startTime = System.currentTimeMillis();
	    	
	    	// Banners
	        log.info("FFMQ server "+getVersion()+
	                 " (Java "+System.getProperty("java.version")+")");
	        log.info("Running on "+System.getProperty("os.name","?")+" "+System.getProperty("os.version","?"));
	        log.info("JVM is "+System.getProperty("java.vm.vendor","?")+" "+System.getProperty("java.runtime.version","?")+" ["+System.getProperty("java.vm.name","?")+"] at "+System.getProperty("java.home","?"));
	        log.info("Server local engine name is '"+engineName+"'");
	    	
	        log.debug("Server startup ...");
	        
	        // Deploy JMX support
	        boolean jmxAgentEnabled = settings.getBooleanProperty(FFMQCoreSettings.JMX_AGENT_ENABLED, false);
	        int jmxJndiRmiPort = settings.getIntProperty(FFMQCoreSettings.JMX_AGENT_JNDI_RMI_PORT,10003);
	        String jmxRmiListenAddr = InetUtils.resolveAutoInterfaceAddress(settings.getStringProperty(FFMQCoreSettings.JMX_AGENT_RMI_LISTEN_ADDR, "0.0.0.0"));
	        if (jmxAgentEnabled)
	        {
	        	jmxAgent = new JMXOverRMIAgent("FFMQ-server",jmxJndiRmiPort,jmxRmiListenAddr);
	        }
	        else
	        if (settings.getStringProperty(FFMQCoreSettings.JMX_AGENT_ENABLED,"false").equals("local"))
	        {
	        	jmxAgent = new PlatformJMXAgent(); // Use a local-only agent
	        }
	        
	        if (jmxAgent != null)
	        {
	        	try
	        	{
	        		jmxAgent.register(new ObjectName(JMXAgent.JMX_DOMAIN+":type=Server"), this);
	        	}
	        	catch (Exception e)
	        	{
	        		log.error("Cannot register server on JMX agent",e);
	        	}
	        }
	        
	        // Deploy local engine
	        engine = new FFMQEngine(engineName,settings,this);
	        try
	    	{
	    		if (jmxAgent != null)
	    			jmxAgent.register(new ObjectName(JMXAgent.JMX_DOMAIN+":type=Engines,engine="+engine.getName()), engine);
	    	}
	    	catch (Exception e)
	    	{
	    		log.error("Cannot register local engine on JMX agent",e);
	    	}
	        engine.deploy();
	        
	        // Deploy listeners
	        String listenAddr          = InetUtils.resolveAutoInterfaceAddress(settings.getStringProperty(FFMQServerSettings.LISTENER_TCP_LISTEN_ADDR,null));
	        int listenPort             = settings.getIntProperty(FFMQServerSettings.LISTENER_TCP_LISTEN_PORT,FFMQConstants.DEFAULT_SERVER_PORT);
	        boolean tcpListenerEnabled = settings.getBooleanProperty(FFMQServerSettings.LISTENER_TCP_ENABLED,true);
	        boolean useNIOListener     = settings.getBooleanProperty(FFMQServerSettings.LISTENER_TCP_USE_NIO,false);
	        boolean useSSL             = settings.getBooleanProperty(FFMQCoreSettings.TRANSPORT_TCP_SSL_ENABLED, false);
	        if (useSSL && useNIOListener)
	        	throw new FFMQException("Cannot enable SSL & NIO listener at the same time.","CONFIGURATION_ERROR"); // JDK 1.4 limitation
	
	        if (tcpListenerEnabled)
	        {
	        	if (useNIOListener)
	        		tcpListener = new NIOTcpListener(engine,listenAddr,listenPort,settings,jmxAgent);
	        	else
	        		tcpListener = new TcpListener(engine,listenAddr,listenPort,settings,jmxAgent);
	
	        	if (jmxAgent != null)
	        	{
					try
					{
						jmxAgent.register(new ObjectName(JMXAgent.JMX_DOMAIN+":type=Listeners,listener="+tcpListener.getName()),tcpListener);
					}
					catch (Exception e)
					{
						log.error("Cannot register listener on JMX agent",e);
					}
	        	}
	        		
	            tcpListener.start();
	        }
	        
	        // Deploy remote admin support
	        boolean remoteAdminEnabled = settings.getBooleanProperty(FFMQServerSettings.REMOTE_ADMIN_ENABLED,false);
	        if (remoteAdminEnabled)
	        {
	            adminThread = new RemoteAdministrationThread(this,engine);
	            adminThread.start();
	            try
	            {
	                adminThread.waitForStartup();
	            }
	            catch (InterruptedException e)
	            {
	                throw new FFMQException("Deploy was interrupted while waiting for the admin thread to start","INTERNAL_ERROR");
	            }
	        }
	        
	        // Deploy bridges
	        deployBridges();
	        
	        long endTime = System.currentTimeMillis();
	        log.info("Server startup complete. ("+(endTime-startTime)+" ms)");
	        
	        started = true;
	        startupTime = System.currentTimeMillis();
	        	        
	        return true;
    	}
    	catch (JMSException e)
    	{
    		if (e.getLinkedException() != null)
        	{
        		log.error("Server startup failed",e);
        		log.error("Original error was :",e.getLinkedException());
        	}
        	else
        		log.error("Server startup failed",e);
    		
    		return false;
    	}
    	catch (Exception e)
    	{
    		log.error("Server startup failed",e);
    		return false;
    	}
    }
65206
public boolean start() {
        if (!this.isTailing.compareAndSet(false, true)) {
            return false;
        }
        final boolean willReadFromEnd = this.willReadFromEnd();
        LogWatchTailingManager.LOGGER.debug("Tailer {} ignore existing file contents.", willReadFromEnd ? "will"
                : "won't");
        this.tailer = new SplitlogTailer(this.watch.getWatchedFile(), new LogWatchTailerListener(this),
                this.delayBetweenReads, this.willReadFromEnd(), this.reopenBetweenReads, this.bufferSize);
        LogWatchTailingManager.EXECUTOR.submit(this.tailer);
        final long start = System.nanoTime();
        this.tailer.waitUntilStarted();
        final long duration = System.nanoTime() - start;
        LogWatchTailingManager.LOGGER.debug("It took {} ms for the tailing to actually start.",
                TimeUnit.NANOSECONDS.toMillis(duration));
        final long iterationNum = this.numberOfTimesThatTailerWasStarted.incrementAndGet();
        LogWatchTailingManager.LOGGER.info("Tailing #{} started for {}.", iterationNum, this.watch);
        return true;
    }
535999
@Override
    public boolean has(String name, Scriptable start)
    {
        return null != slotMap.query(name, 0);
    }
234931
public synchronized boolean has(String name, Scriptable start) {
        if (isEmpty(name)) {
            return indexedProps.containsKey(name);
        } else {
            synchronized (context) {
                return context.getAttributesScope(name) != -1;
            }
        }
    }
1206119
protected boolean doesStartingTimeAllowServiceAccess() {
        if (this.startingDateTime != null) {
            val st = DateTimeUtils.zonedDateTimeOf(this.startingDateTime);
            if (st != null) {
                val now = ZonedDateTime.now(ZoneOffset.UTC);
                if (now.isBefore(st)) {
                    LOGGER.warn("Service access not allowed because it starts at [{}]. Zoned now is [{}]", this.startingDateTime, now);
                    return false;
                }
            } else {
                val stLocal = DateTimeUtils.localDateTimeOf(this.startingDateTime);
                if (stLocal != null) {
                    val now = LocalDateTime.now(ZoneOffset.UTC);
                    if (now.isBefore(stLocal)) {
                        LOGGER.warn("Service access not allowed because it starts at [{}]. Local now is [{}]", this.startingDateTime, now);
                        return false;
                    }
                }
            }
        }
        return true;
    }