Lazily checks and answers whether the Aqua look&amp;feel is active.

@return {@code true} if the current look&amp;feel is Aqua
10598
public static boolean isLafAqua() {
        ensureValidCache();
        if (cachedIsLafAqua == null) {
            cachedIsLafAqua = Boolean.valueOf(computeIsLafAqua());
        }
        return cachedIsLafAqua.booleanValue();
    }
103703
public static boolean isDartControllerActive() {
		Map<String, Object> sessionMap = FacesContext.getCurrentInstance().getExternalContext().getSessionMap();
		if (sessionMap.containsKey(DART_CONTROLLER)) {
			return "true".equals(sessionMap.get(DART_CONTROLLER));
		}
		return false;
	}
1145365
@Override
	public boolean isActive() {
		try {
			return hasMethodThat(named("getCurrentTemplate")
					.and(ElementMatchers.<MethodDescription.InDefinedShape>isPublic())
					.and(takesArguments(0)))
					.matches(new TypeDescription.ForLoadedType(Class.forName("freemarker.core.Environment")));
		} catch (ClassNotFoundException e) {
			return false;
		}
	}
1055321
public function is_active() {

		if ( ! empty( $this->struct['screen'] ) && ! in_array( $this->screen->id, (array) $this->struct['screen'] ) ) {
			return false;
		}

		return parent::is_active();
	}
1006379
def is_active(self):
        
        self.open()
        active = lvm_lv_is_active(self.__lvh)
        self.close()
        return bool(active)
1238993
private boolean hasSameStructure() {
        Object wrappedCollection = getWrappedValue();
        if (wrappedCollection == null) {
            return bufferedListModel.size() == 0;
        }
        else if (wrappedCollection instanceof Object[]) {
            Object[] wrappedArray = (Object[])wrappedCollection;
            if (wrappedArray.length != bufferedListModel.size()) {
                return false;
            }
            for (int i = 0; i < bufferedListModel.size(); i++) {
                if(super.hasValueChanged(wrappedArray[i], bufferedListModel.get(i))) {
                    return false;
                }
            }
        }
        else {
            if (((Collection)wrappedCollection).size() != bufferedListModel.size()) {
                return false;
            }
            for (Iterator i = ((Collection)wrappedCollection).iterator(), j = bufferedListModel.iterator(); i.hasNext();) {
                if (super.hasValueChanged(i.next(), j.next())) {
                    return false;
                }
            }
        }
        return true;
    }
406891
public boolean isBusy() {
        lock.readLock().lock();
        try {
            return workUnit != null || executable != null;
        } finally {
            lock.readLock().unlock();
        }
    }
13369
public boolean isTerminated() {
        return this.currentState == COMPLETED || this.currentState == REJECTED || this.currentState == CANCELLED
                || this.currentState == FAILED || this.currentState == REDIRECT;
    }
786434
public boolean isEmpty() {
        return (newTopicPool == null ? true : newTopicPool.isEmpty()) && (updatedTopicPool == null ? true : updatedTopicPool.isEmpty());
    }
454017
public function isActive() {
        if (!$this->getValue(
                self::KEY_ACTIVE,
                $this->storeManager->getStore()
            )) {
            return false;
        }

        $quote = $this->checkoutSession->getQuote();

        return (bool) in_array($quote->getQuoteCurrencyCode(), $this->getAcceptedCurrencies());
    }
434595
def is_active(self, state: 'State') -> bool:
        
        # Remove the genes which does not contribute to the multiplex
        sub_state = state.sub_state_by_gene_name(*self.expression.variables)
        # If this state is not in the cache
        if sub_state not in self._is_active:
            params = self._transform_state_to_dict(sub_state)
            # We add the result of the expression for this state of the multiplex to the cache
            self._is_active[sub_state] = self.expression.evaluate(**params)
        return self._is_active[sub_state]
88331
public boolean isActive(VehicleDataSource skipSource) {
        boolean connected = false;
        for(VehicleDataSource s : mSources) {
            if(s != skipSource) {
                connected = connected || s.isConnected();
            }
        }
        return connected;
    }
105994
@SuppressLint("NewApi")
	protected boolean isActivitiyDestroyed() {

		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
			return mActivity.isFinishing() || mActivity.isDestroyed();
		} else {
			return mActivity.isFinishing();
		}

	}
1230594
public function isActive()
    {
        switch ($this->type) {

            case MenuPresenceType::GROUP:
                return false;

            case MenuPresenceType::ACTION:
                // Activity is based on named route match, unless specific match is defined
                return false;

            case MenuPresenceType::LINK:
                // Activity is based on URL match, unless specific match is defined
                return false;

            // Default omitted on purpose
        }

        return false;
    }
603904
public function isActive(): bool
    {
        if (is_callable($activeWhen = $this->activeWhen)) {
            return call_user_func($activeWhen);
        }

        if ($this->route) {
            return $this->hasActiveStateFromRoute();
        }

        return $this->hasActiveStateFromUrl();
    }
632658
def is_active(self):
    
    if not self.multiplexer:
      return False

    if self._is_active:
      # We have already determined that the projector plugin should be active.
      # Do not re-compute that. We have no reason to later set this plugin to be
      # inactive.
      return True

    if self._thread_for_determining_is_active:
      # We are currently determining whether the plugin is active. Do not start
      # a separate thread.
      return self._is_active

    # The plugin is currently not active. The frontend might check again later.
    # For now, spin off a separate thread to determine whether the plugin is
    # active.
    new_thread = threading.Thread(
        target=self._determine_is_active,
        name='ProjectorPluginIsActiveThread')
    self._thread_for_determining_is_active = new_thread
    new_thread.start()
    return False
1323012
def is_active(self):
    
    if not self._multiplexer:
      return False

    scalars_plugin_instance = self._get_scalars_plugin()
    if not (scalars_plugin_instance and
            scalars_plugin_instance.is_active()):
      return False

    # This plugin is active if any run has a layout.
    return bool(self._multiplexer.PluginRunToTagToContent(metadata.PLUGIN_NAME))