Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
<!-- begin-user-doc -->
<!-- end-user-doc -->
@return the first non-null result returned by a <code>caseXXX</code> call.
@generated
435634
@Override
	protected T doSwitch(int classifierID, EObject theEObject)
	{
		switch (classifierID)
		{
			case XbasePackage.XEXPRESSION:
			{
				XExpression xExpression = (XExpression)theEObject;
				T result = caseXExpression(xExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XIF_EXPRESSION:
			{
				XIfExpression xIfExpression = (XIfExpression)theEObject;
				T result = caseXIfExpression(xIfExpression);
				if (result == null) result = caseXExpression(xIfExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XSWITCH_EXPRESSION:
			{
				XSwitchExpression xSwitchExpression = (XSwitchExpression)theEObject;
				T result = caseXSwitchExpression(xSwitchExpression);
				if (result == null) result = caseXExpression(xSwitchExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCASE_PART:
			{
				XCasePart xCasePart = (XCasePart)theEObject;
				T result = caseXCasePart(xCasePart);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XBLOCK_EXPRESSION:
			{
				XBlockExpression xBlockExpression = (XBlockExpression)theEObject;
				T result = caseXBlockExpression(xBlockExpression);
				if (result == null) result = caseXExpression(xBlockExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XVARIABLE_DECLARATION:
			{
				XVariableDeclaration xVariableDeclaration = (XVariableDeclaration)theEObject;
				T result = caseXVariableDeclaration(xVariableDeclaration);
				if (result == null) result = caseXExpression(xVariableDeclaration);
				if (result == null) result = caseJvmIdentifiableElement(xVariableDeclaration);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XABSTRACT_FEATURE_CALL:
			{
				XAbstractFeatureCall xAbstractFeatureCall = (XAbstractFeatureCall)theEObject;
				T result = caseXAbstractFeatureCall(xAbstractFeatureCall);
				if (result == null) result = caseXExpression(xAbstractFeatureCall);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XMEMBER_FEATURE_CALL:
			{
				XMemberFeatureCall xMemberFeatureCall = (XMemberFeatureCall)theEObject;
				T result = caseXMemberFeatureCall(xMemberFeatureCall);
				if (result == null) result = caseXAbstractFeatureCall(xMemberFeatureCall);
				if (result == null) result = caseXExpression(xMemberFeatureCall);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XFEATURE_CALL:
			{
				XFeatureCall xFeatureCall = (XFeatureCall)theEObject;
				T result = caseXFeatureCall(xFeatureCall);
				if (result == null) result = caseXAbstractFeatureCall(xFeatureCall);
				if (result == null) result = caseXExpression(xFeatureCall);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCONSTRUCTOR_CALL:
			{
				XConstructorCall xConstructorCall = (XConstructorCall)theEObject;
				T result = caseXConstructorCall(xConstructorCall);
				if (result == null) result = caseXExpression(xConstructorCall);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XBOOLEAN_LITERAL:
			{
				XBooleanLiteral xBooleanLiteral = (XBooleanLiteral)theEObject;
				T result = caseXBooleanLiteral(xBooleanLiteral);
				if (result == null) result = caseXExpression(xBooleanLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XNULL_LITERAL:
			{
				XNullLiteral xNullLiteral = (XNullLiteral)theEObject;
				T result = caseXNullLiteral(xNullLiteral);
				if (result == null) result = caseXExpression(xNullLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XNUMBER_LITERAL:
			{
				XNumberLiteral xNumberLiteral = (XNumberLiteral)theEObject;
				T result = caseXNumberLiteral(xNumberLiteral);
				if (result == null) result = caseXExpression(xNumberLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XSTRING_LITERAL:
			{
				XStringLiteral xStringLiteral = (XStringLiteral)theEObject;
				T result = caseXStringLiteral(xStringLiteral);
				if (result == null) result = caseXExpression(xStringLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCOLLECTION_LITERAL:
			{
				XCollectionLiteral xCollectionLiteral = (XCollectionLiteral)theEObject;
				T result = caseXCollectionLiteral(xCollectionLiteral);
				if (result == null) result = caseXExpression(xCollectionLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XLIST_LITERAL:
			{
				XListLiteral xListLiteral = (XListLiteral)theEObject;
				T result = caseXListLiteral(xListLiteral);
				if (result == null) result = caseXCollectionLiteral(xListLiteral);
				if (result == null) result = caseXExpression(xListLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XSET_LITERAL:
			{
				XSetLiteral xSetLiteral = (XSetLiteral)theEObject;
				T result = caseXSetLiteral(xSetLiteral);
				if (result == null) result = caseXCollectionLiteral(xSetLiteral);
				if (result == null) result = caseXExpression(xSetLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCLOSURE:
			{
				XClosure xClosure = (XClosure)theEObject;
				T result = caseXClosure(xClosure);
				if (result == null) result = caseXExpression(xClosure);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCASTED_EXPRESSION:
			{
				XCastedExpression xCastedExpression = (XCastedExpression)theEObject;
				T result = caseXCastedExpression(xCastedExpression);
				if (result == null) result = caseXExpression(xCastedExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XBINARY_OPERATION:
			{
				XBinaryOperation xBinaryOperation = (XBinaryOperation)theEObject;
				T result = caseXBinaryOperation(xBinaryOperation);
				if (result == null) result = caseXAbstractFeatureCall(xBinaryOperation);
				if (result == null) result = caseXExpression(xBinaryOperation);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XUNARY_OPERATION:
			{
				XUnaryOperation xUnaryOperation = (XUnaryOperation)theEObject;
				T result = caseXUnaryOperation(xUnaryOperation);
				if (result == null) result = caseXAbstractFeatureCall(xUnaryOperation);
				if (result == null) result = caseXExpression(xUnaryOperation);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XPOSTFIX_OPERATION:
			{
				XPostfixOperation xPostfixOperation = (XPostfixOperation)theEObject;
				T result = caseXPostfixOperation(xPostfixOperation);
				if (result == null) result = caseXAbstractFeatureCall(xPostfixOperation);
				if (result == null) result = caseXExpression(xPostfixOperation);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XFOR_LOOP_EXPRESSION:
			{
				XForLoopExpression xForLoopExpression = (XForLoopExpression)theEObject;
				T result = caseXForLoopExpression(xForLoopExpression);
				if (result == null) result = caseXExpression(xForLoopExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION:
			{
				XBasicForLoopExpression xBasicForLoopExpression = (XBasicForLoopExpression)theEObject;
				T result = caseXBasicForLoopExpression(xBasicForLoopExpression);
				if (result == null) result = caseXExpression(xBasicForLoopExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XABSTRACT_WHILE_EXPRESSION:
			{
				XAbstractWhileExpression xAbstractWhileExpression = (XAbstractWhileExpression)theEObject;
				T result = caseXAbstractWhileExpression(xAbstractWhileExpression);
				if (result == null) result = caseXExpression(xAbstractWhileExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XDO_WHILE_EXPRESSION:
			{
				XDoWhileExpression xDoWhileExpression = (XDoWhileExpression)theEObject;
				T result = caseXDoWhileExpression(xDoWhileExpression);
				if (result == null) result = caseXAbstractWhileExpression(xDoWhileExpression);
				if (result == null) result = caseXExpression(xDoWhileExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XWHILE_EXPRESSION:
			{
				XWhileExpression xWhileExpression = (XWhileExpression)theEObject;
				T result = caseXWhileExpression(xWhileExpression);
				if (result == null) result = caseXAbstractWhileExpression(xWhileExpression);
				if (result == null) result = caseXExpression(xWhileExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XTYPE_LITERAL:
			{
				XTypeLiteral xTypeLiteral = (XTypeLiteral)theEObject;
				T result = caseXTypeLiteral(xTypeLiteral);
				if (result == null) result = caseXExpression(xTypeLiteral);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XINSTANCE_OF_EXPRESSION:
			{
				XInstanceOfExpression xInstanceOfExpression = (XInstanceOfExpression)theEObject;
				T result = caseXInstanceOfExpression(xInstanceOfExpression);
				if (result == null) result = caseXExpression(xInstanceOfExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XTHROW_EXPRESSION:
			{
				XThrowExpression xThrowExpression = (XThrowExpression)theEObject;
				T result = caseXThrowExpression(xThrowExpression);
				if (result == null) result = caseXExpression(xThrowExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION:
			{
				XTryCatchFinallyExpression xTryCatchFinallyExpression = (XTryCatchFinallyExpression)theEObject;
				T result = caseXTryCatchFinallyExpression(xTryCatchFinallyExpression);
				if (result == null) result = caseXExpression(xTryCatchFinallyExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XCATCH_CLAUSE:
			{
				XCatchClause xCatchClause = (XCatchClause)theEObject;
				T result = caseXCatchClause(xCatchClause);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XASSIGNMENT:
			{
				XAssignment xAssignment = (XAssignment)theEObject;
				T result = caseXAssignment(xAssignment);
				if (result == null) result = caseXAbstractFeatureCall(xAssignment);
				if (result == null) result = caseXExpression(xAssignment);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XRETURN_EXPRESSION:
			{
				XReturnExpression xReturnExpression = (XReturnExpression)theEObject;
				T result = caseXReturnExpression(xReturnExpression);
				if (result == null) result = caseXExpression(xReturnExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case XbasePackage.XSYNCHRONIZED_EXPRESSION:
			{
				XSynchronizedExpression xSynchronizedExpression = (XSynchronizedExpression)theEObject;
				T result = caseXSynchronizedExpression(xSynchronizedExpression);
				if (result == null) result = caseXExpression(xSynchronizedExpression);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			default: return defaultCase(theEObject);
		}
	}
852631
public FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>> getOrCreateCase()
   {
      List<Node> nodeList = childNode.get("case");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionSwitchCaseTypeImpl<FacesConfigFlowDefinitionSwitchType<T>>(this, "case", childNode, nodeList.get(0));
      }
      return createCase();
   }
459822
public EntityResult<SqlResultSetMapping<T>> getOrCreateEntityResult()
   {
      List<Node> nodeList = childNode.get("entity-result");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new EntityResultImpl<SqlResultSetMapping<T>>(this, "entity-result", childNode, nodeList.get(0));
      }
      return createEntityResult();
   }
836329
@Nonnull
	public <V extends T> LObjBiIntPredicateBuilder<T> casesOf(Class<V> argC1, Consumer<LObjBiIntPredicateBuilder<V>> pcpConsumer) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
562921
@Override
	protected T doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
		case GeometryPackage.GEOMETRY_INFO: {
			GeometryInfo geometryInfo = (GeometryInfo) theEObject;
			T result = caseGeometryInfo(geometryInfo);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.VECTOR3F: {
			Vector3f vector3f = (Vector3f) theEObject;
			T result = caseVector3f(vector3f);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.BOUNDS: {
			Bounds bounds = (Bounds) theEObject;
			T result = caseBounds(bounds);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.BUFFER: {
			Buffer buffer = (Buffer) theEObject;
			T result = caseBuffer(buffer);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.GEOMETRY_DATA: {
			GeometryData geometryData = (GeometryData) theEObject;
			T result = caseGeometryData(geometryData);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.VECTOR4F: {
			Vector4f vector4f = (Vector4f) theEObject;
			T result = caseVector4f(vector4f);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.COLOR_PACK: {
			ColorPack colorPack = (ColorPack) theEObject;
			T result = caseColorPack(colorPack);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		default:
			return defaultCase(theEObject);
		}
	}
1115824
private TestClassResults getResultsForClass(Map<IClass, TestClassResults> flattenedResults,
                                                ITestResult testResult)
    {
        TestClassResults resultsForClass = flattenedResults.get(testResult.getTestClass());
        if (resultsForClass == null)
        {
            resultsForClass = new TestClassResults(testResult.getTestClass());
            flattenedResults.put(testResult.getTestClass(), resultsForClass);
        }
        return resultsForClass;
    }
396838
@Nonnull
	public final LCharSupplier build() {

		final LCharSupplier eventuallyFinal = this.eventually;

		LCharSupplier retval;

		final Case<LBoolSupplier, LCharSupplier>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LCharSupplier.charSup(() -> {
			try {
				for (Case<LBoolSupplier, LCharSupplier> aCase : casesArray) {
					if (aCase.casePredicate().getAsBool()) {
						return aCase.caseFunction().getAsChar();
					}
				}

				return eventuallyFinal.getAsChar();
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
1031460
public ClassInfoList getAllClasses() {
        if (closed.get()) {
            throw new IllegalArgumentException("Cannot use a ScanResult after it has been closed");
        }
        if (!scanSpec.enableClassInfo) {
            throw new IllegalArgumentException("Please call ClassGraph#enableClassInfo() before #scan()");
        }
        return ClassInfo.getAllClasses(classNameToClassInfo.values(), scanSpec);
    }
743549
def result
      case @type
      when :anime
        iter { |i| Jikan::AnimeResult.new(i) }
      when :manga
        iter { |i| Jikan::MangaResult.new(i) }
      when :character
        iter { |i| Jikan::CharacterResult.new(i) }
      when :person
        iter { |i| Jikan::PersonResult.new(i) }
      end
    end
866228
@Override
    public int classIndex() {
        int classIndex = instanceHeader.classIndex();
       // return  ? classIndex : 0;
        if(classIndex == Integer.MAX_VALUE)
        	if(this.instanceHeader.instanceInformation.range!=null)
        		classIndex=instanceHeader.instanceInformation.range.getStart();
        	else
        		classIndex=0;
        return classIndex;
    }
386830
public XCalValue firstValue() {
		for (Element child : children()) {
			String childNamespace = child.getNamespaceURI();
			if (XCAL_NS.equals(childNamespace)) {
				ICalDataType dataType = toDataType(child.getLocalName());
				String value = child.getTextContent();
				return new XCalValue(dataType, value);
			}
		}

		return new XCalValue(null, element.getTextContent());
	}
468905
public UseCase selectUseCase()
    {
        displayUseCases();
        System.out.println("type in number to select a use case");
        String in = readLine();
        int index = Integer.parseInt(in);
        return (UseCase) useCases.get(index);
    }
778152
public List<FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>>> getAllCase()
   {
      List<FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>>> list = new ArrayList<FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>>>();
      List<Node> nodeList = childNode.get("case");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>>  type = new FacesConfigFlowDefinitionSwitchCaseTypeImpl<FacesConfigFlowDefinitionSwitchType<T>>(this, "case", childNode, node);
         list.add(type);
      }
      return list;
   }
401564
public ITestCaseGenerator getGenerator( String functionName)
    {
    ITestCaseGenerator generator = generators_.get( getFunctionKey( functionName));
    return generator==null? generators_.get( ALL) : generator;
    }
1041549
@Override
	public T next() {
		SQLException sqlException = null;
		try {
			T result = nextThrow();
			if (result != null) {
				return result;
			}
		} catch (SQLException e) {
			sqlException = e;
		}
		// we have to throw if there is no next or on a SQLException
		last = null;
		closeQuietly();
		throw new IllegalStateException("Could not get next result for " + dataClass, sqlException);
	}
872980
@Override
	public <T> T first(final Class<T> type) {
		return findFirst(type).orElseThrow(() -> new DataNotFoundException("query result is empty."));
	}
1214924
@Nonnull
	public final LBoolToDblFunction build() {

		final LBoolToDblFunction eventuallyFinal = this.eventually;

		LBoolToDblFunction retval;

		final Case<LLogicalOperator, LBoolToDblFunction>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LBoolToDblFunction.boolToDblFunc(a -> {
			try {
				for (Case<LLogicalOperator, LBoolToDblFunction> aCase : casesArray) {
					if (aCase.casePredicate().apply(a)) {
						return aCase.caseFunction().applyAsDbl(a);
					}
				}

				return eventuallyFinal.applyAsDbl(a);
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}