Return true if there are transitions available as true.

@param source
@return
346491
private boolean areNextStatesAvailable(Automaton source) {
        ArrayList<Transition> r = possibleTransitions.get(source);
        if (r != null) {
            for (Transition t : r) {
                if (t.evaluate()) {
                    return true;
                }
            }
        }
        return false;
    }
132741
public function contains(TransitionInterface $transition): bool
    {
        foreach ($this->internal_set as $cur_transition) {
            if ($cur_transition->getFrom() === $transition->getFrom()
                && $cur_transition->getTo() === $transition->getTo()
            ) {
                return true;
            }
        }
        return false;
    }
819921
protected static boolean getBoolean(final Context context, final DataSource source) throws FlowException {

		if (source != null) {

			final Object value = source.get(context);
			if (value instanceof Boolean) {

				return (Boolean)value;
			}

			if (value instanceof String) {

				return Boolean.valueOf((String)value);
			}
		}

		return false;
	}
418523
function(intent, isIntermediate) {
        try {
          return getTransitionByIntent.apply(this, arguments);
        } catch(e) {
          return new Transition(this, intent, null, e);
        }
      }
454582
private List<Transition> getIncomingTransitions(Process procdef, Long activityId,
            Map<String,String> idToEscapedName) {
        List<Transition> incomingTransitions = new ArrayList<Transition>();
        for (Transition trans : procdef.getTransitions()) {
            if (trans.getToId().equals(activityId)) {
                Transition sync = new Transition();
                sync.setId(trans.getId());
                Activity act = procdef.getActivityVO(trans.getFromId());
                String logicalId = act.getLogicalId();
                // id to escaped name map is for backward compatibility
                idToEscapedName.put(logicalId, escape(act.getName()));
                sync.setCompletionCode(logicalId);
                incomingTransitions.add(sync);
            }
        }
        return incomingTransitions;
    }
811501
private static int search(
        long posixTime,
        ZonalTransition[] transitions
    ) {

        int low = 0;
        int high = transitions.length - 1;

        while (low <= high) {
            int middle = (low + high) / 2;

            if (transitions[middle].getPosixTime() <= posixTime) {
                low = middle + 1;
            } else {
                high = middle - 1;
            }
        }

        return low;

    }
707828
function() {
		var s = document.createElement('p').style, // 's' for style. better to create an element if body yet to exist
			v = ['ms','O','Moz','Webkit']; // 'v' for vendor

		if( s['transition'] !== undefined ) {
			return true; 
		}
			
		while( v.length ) {
			if( v.pop() + 'Transition' in s ) {
				return true;
			}
		}
				
		return false;
	}
196327
private void onEndStepProgress(Object source)
    {
        // Try to find the right step based on the source
        DefaultJobProgressStep step = findStep(this.currentStep, source);

        if (step == null) {
            LOGGER.warn("Could not find any matching step for source [{}]. Ignoring EndStepProgress.",
                source.toString());

            return;
        }

        this.currentStep = step;
        this.currentStep.finish();
    }
1174271
def transition(self, duration, brightness=None):
        
        if duration == 0:
            if brightness is not None:
                self.brightness = brightness
            return
        if brightness != self.brightness:
            self._transition(duration, brightness)
935446
private static void checkTransition(Map<Transition, Collection<TileRef>> transitions,
                                        MapTransitionExtractor extractor,
                                        Tile tile)
    {
        final Transition transition = extractor.getTransition(tile);
        if (transition != null)
        {
            getTiles(transitions, transition).add(new TileRef(tile));

            final Transition symetric = new Transition(transition.getType().getSymetric(),
                                                       transition.getOut(),
                                                       transition.getIn());
            getTiles(transitions, symetric).add(new TileRef(tile));
        }
    }
1154714
public boolean replaceIn(final StrBuilder source) {
        if (source == null) {
            return false;
        }
        return substitute(source, 0, source.length());
    }
133811
protected void verifyStatusTransitionIsValid(JobInstanceEntity instance, BatchStatus toStatus) throws BatchIllegalJobStatusTransitionException {

        switch (instance.getBatchStatus()) {
            case COMPLETED:
                //COMPLETED to ABANDONED is allowed since it's already allowed in released TCK tests.
                if (toStatus == BatchStatus.ABANDONED) {
                    break;
                }
            case ABANDONED:
                throw new BatchIllegalJobStatusTransitionException("Job instance: " + instance.getInstanceId()
                                                                   + " cannot be transitioned from Batch Status: " + instance.getBatchStatus().name()
                                                                   + " to " + toStatus.name());
            case STARTING:
            case STARTED:
            case STOPPING:
            case FAILED:

            default:
        }

    }
614319
private TTTState<I, D> createState(@Nonnull TTTTransition<I, D> transition) {
        return hypothesis.createState(transition);
    }
1056946
public Transition<S> getTransition(S fromState, T transition){
		Transition<S> transitionDef = transitions.get(new DoubleValueBean<S, T>(fromState, transition));
		if (transitionDef == null){
			throw new IllegalArgumentException("Transition '" + transition + "' from state '" + fromState + "' has not been defined.");
		}
		return transitionDef;
	}
518683
public Navigate animate(@Nullable Transitions transition) {
        if (application != null) {
            throw new IllegalArgumentException(
                    "You can't animate activity transition when using application context");
        }
        this.transition = transition;
        return this;
    }
443183
protected function getNextFollowingTransition($source, $sourceId, $hydrationMode)
    {
        $transition = $this->transitionManager->findOneBySource($source, $sourceId);

        if ($transition !== null) {
            $transitionResult = $this->createTransitionResult(
                $transition->getDestination(),
                $transition->getDestinationId(),
                $hydrationMode
            );

            if (!$transitionResult) {
                return null;
            }

            $transitionResult->setId($transition->getId());
            $transitionResult->setTransition($transition);

            return $transitionResult;
        }

        return null;
    }
530416
def can_be_(self, state):
    """"""
    translator = self._meta['translator']
    state = translator.translate(state)

    if self._meta['complete']:
        return True

    if self.actual_state is None:
        return True

    transitions = self._meta['transitions'][self.actual_state]
    return state in transitions