Looks at the current {@link RouteProgressState} and returns if
is {@link RouteProgressState#ROUTE_ARRIVED}.

@param routeProgress the current route progress
@return true if in arrival state, false if not
179701
public boolean isArrivalEvent(@NonNull RouteProgress routeProgress) {
    RouteProgressState currentState = routeProgress.currentState();
    return currentState != null && currentState == RouteProgressState.ROUTE_ARRIVED;
  }
1334010
public void setImportTablesInProgress(java.util.Collection<String> importTablesInProgress) {
        if (importTablesInProgress == null) {
            this.importTablesInProgress = null;
            return;
        }

        this.importTablesInProgress = new com.amazonaws.internal.SdkInternalList<String>(importTablesInProgress);
    }
519996
func isRouteIngressValid(routeIngress *routeapi.RouteIngress) bool {
	if len(routeIngress.Host) == 0 {
		return false
	}
	for _, condition := range routeIngress.Conditions {
		if condition.Type == routeapi.RouteAdmitted && condition.Status == corev1.ConditionTrue {
			return true
		}
	}
	return false
}
891418
private boolean validSecondStep(LegStep secondStep, RouteProgress routeProgress) {
    return routeProgress.currentLegProgress().upComingStep() != null
      && routeProgress.currentLegProgress().upComingStep().equals(secondStep);
  }
1084369
public boolean next() {
		if (currentBlkNum == 0 && !moveTo(1))
			return false;
		while (true) {
			if (rp.next())
				return true;
			if (!moveTo(currentBlkNum + 1))
				return false;
		}
	}
27821
public void start(DirectionsRoute route) {
    if (route != null) {
      currentRouteInformation = buildRouteInformationFromRoute(route);
    }
    navigation.addProgressChangeListener(progressChangeListener);
  }
1082531
public Vector<TaskInProgress> reportTasksInProgress(boolean shouldBeMap, boolean shouldBeComplete) {
    Vector<TaskInProgress> results = new Vector<TaskInProgress>();
    TaskInProgress tips[] = null;
    if (shouldBeMap) {
      tips = maps;
    } else {
      tips = reduces;
    }

    for (int i = 0; i < tips.length; i++) {
      if (tips[i].isComplete() == shouldBeComplete) {
        results.add(tips[i]);
      }
    }
    return results;
  }
1355876
public Double getProgress() {

        if (state.equals(ParallelTaskState.IN_PROGRESS)) {
            if (requestNum != 0) {
                return 100.0 * ((double) responsedNum / (double) requestNumActual);
            } else {
                return 0.0;
            }
        }

        if (state.equals(ParallelTaskState.WAITING)) {
            return 0.0;
        }

        // fix task if fail validation, still try to poll progress 0901
        if (state.equals(ParallelTaskState.COMPLETED_WITH_ERROR)
                || state.equals(ParallelTaskState.COMPLETED_WITHOUT_ERROR)) {
            return 100.0;
        }

        return 0.0;

    }
425056
public int currentStepCount() {
    if (currentDirectionRoute() == null) {
      return 0;
    }
    int stepCount = 0;
    for (RouteLeg leg : currentDirectionRoute().legs()) {
      stepCount += leg.steps().size();
    }
    return stepCount;
  }
384763
public boolean transit(T transition){
		S currentState = definition.getState(currentStateId.get());
		if (currentState != null){
			try{
				Transition<S> transitionDef = definition.getTransition(currentState, transition);
				return currentStateId.compareAndSet(transitionDef.fromStateId, transitionDef.toStateId);
			}catch(IllegalArgumentException iae){
				return false;
			}catch(NullPointerException npe){
				return false;
			}
		}
		return false;
	}
32230
public void updateProgress(float progress) {
        if (mLastProgress == progress) {
            return;
        }
        mLastProgress = progress;
        //TODO this makes ViewPager work, but will probably break more complex transition setup, will think of a better solution
        if (mUpdateStateAfterUpdateProgress) {
            boolean positive = progress >= 0;
            TransitionController transitionController;
            for (int i = 0, size = mTransitionControls.size(); i < size; i++) {
                transitionController = mTransitionControls.get(i);
                if (positive) {
                    if (transitionController.getEnd() > 0) {
                        transitionController.setEnable(true);
                    } else {
                        transitionController.setEnable(false);
                    }
                } else {
                    if (transitionController.getEnd() < 0) {
                        transitionController.setEnable(true);
                    } else {
                        transitionController.setEnable(false);
                    }
                }
            }
        }

        TransitionController transitionController;
        for (int i = 0, size = mTransitionControls.size(); i < size; i++) {
            transitionController = mTransitionControls.get(i);
            if (transitionController.isEnable()) {
                transitionController.updateProgress(progress);
            }
        }
    }
53403
public boolean ruleEvaluationProgress(String name, int currentPosition, int total, int timeRemainingInSeconds)
    {
        boolean windupStopRequested = false;
        for (RuleLifecycleListener listener : listeners)
            windupStopRequested = listener.ruleEvaluationProgress(this, name, currentPosition, total, timeRemainingInSeconds);

        return windupStopRequested;
    }

    public boolean shouldWindupStop()
    {
        for (RuleLifecycleListener listener : listeners)
            if (listener.shouldWindupStop())
                return true;
        return false;
    }
}
651505
@OverrideOnDemand
  protected boolean isLoginInProgress (@Nonnull final IRequestWebScopeWithoutResponse aRequestScope)
  {
    return CLogin.REQUEST_ACTION_VALIDATE_LOGIN_CREDENTIALS.equals (aRequestScope.params ()
                                                                                 .getAsString (CLogin.REQUEST_PARAM_ACTION));
  }
394798
public boolean getForwardScanning()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getForwardScanning");
            SibTr.exit(tc, "getForwardScanning", Boolean.valueOf(_forwardScanning));
        }

        return _forwardScanning;
    }
237562
public synchronized boolean statusUpdate(TaskAttemptID taskid,
                                              TaskStatus taskStatus)
  throws IOException {
    TaskInProgress tip = tasks.get(taskid);
    if (tip != null) {
      tip.reportProgress(taskStatus);
      myInstrumentation.statusUpdate(tip.getTask(), taskStatus);
      return true;
    } else {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Progress from unknown child task: "+taskid);
      }
      return false;
    }
  }
1292329
protected boolean checkConfiguration(IProgressMonitor progress) {
		assert progress != null;
		progress.subTask(Messages.SarlBatchCompiler_55);
		final File output = getOutputPath();
		if (getLogger().isDebugEnabled()) {
			getLogger().debug(Messages.SarlBatchCompiler_35, output);
		}
		if (output == null) {
			reportInternalError(Messages.SarlBatchCompiler_36);
			return false;
		}
		progress.subTask(Messages.SarlBatchCompiler_56);
		for (final File sourcePath : getSourcePaths()) {
			if (progress.isCanceled()) {
				return false;
			}
			try {
				if (getLogger().isDebugEnabled()) {
					getLogger().debug(Messages.SarlBatchCompiler_37, sourcePath);
				}
				if (isContainedIn(output.getCanonicalFile(), sourcePath.getCanonicalFile())) {
					reportInternalError(Messages.SarlBatchCompiler_10, output, sourcePath);
					return false;
				}
			} catch (IOException e) {
				reportInternalError(Messages.SarlBatchCompiler_11, e);
			}
		}
		return true;
	}
35714
public java.util.List<String> getImportTablesInProgress() {
        if (importTablesInProgress == null) {
            importTablesInProgress = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return importTablesInProgress;
    }