| /******************************************************************************* |
| * Copyright (c) 2008, 2016 IBM Corporation, Zeligsoft Inc., and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM - Initial API and implementation |
| * Zeligsoft - Bug 207365 |
| *******************************************************************************/ |
| package org.eclipse.ocl.uml.util; |
| |
| import java.util.Map; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.common.util.DiagnosticChain; |
| import org.eclipse.emf.common.util.ResourceLocator; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.util.EObjectValidator; |
| import org.eclipse.ocl.expressions.util.ExpressionsValidator; |
| import org.eclipse.ocl.types.util.TypesValidator; |
| import org.eclipse.ocl.uml.AnyType; |
| import org.eclipse.ocl.uml.AssociationClassCallExp; |
| import org.eclipse.ocl.uml.BagType; |
| import org.eclipse.ocl.uml.BooleanLiteralExp; |
| import org.eclipse.ocl.uml.CallExp; |
| import org.eclipse.ocl.uml.CollectionItem; |
| import org.eclipse.ocl.uml.CollectionLiteralExp; |
| import org.eclipse.ocl.uml.CollectionLiteralPart; |
| import org.eclipse.ocl.uml.CollectionRange; |
| import org.eclipse.ocl.uml.CollectionType; |
| import org.eclipse.ocl.uml.ElementType; |
| import org.eclipse.ocl.uml.EnumLiteralExp; |
| import org.eclipse.ocl.uml.ExpressionInOCL; |
| import org.eclipse.ocl.uml.FeatureCallExp; |
| import org.eclipse.ocl.uml.IfExp; |
| import org.eclipse.ocl.uml.IntegerLiteralExp; |
| import org.eclipse.ocl.uml.InvalidLiteralExp; |
| import org.eclipse.ocl.uml.InvalidType; |
| import org.eclipse.ocl.uml.IterateExp; |
| import org.eclipse.ocl.uml.IteratorExp; |
| import org.eclipse.ocl.uml.LetExp; |
| import org.eclipse.ocl.uml.LiteralExp; |
| import org.eclipse.ocl.uml.LoopExp; |
| import org.eclipse.ocl.uml.MessageExp; |
| import org.eclipse.ocl.uml.MessageType; |
| import org.eclipse.ocl.uml.NavigationCallExp; |
| import org.eclipse.ocl.uml.NullLiteralExp; |
| import org.eclipse.ocl.uml.NumericLiteralExp; |
| import org.eclipse.ocl.uml.OCLExpression; |
| import org.eclipse.ocl.uml.OperationCallExp; |
| import org.eclipse.ocl.uml.OrderedSetType; |
| import org.eclipse.ocl.uml.PrimitiveLiteralExp; |
| import org.eclipse.ocl.uml.PrimitiveType; |
| import org.eclipse.ocl.uml.PropertyCallExp; |
| import org.eclipse.ocl.uml.RealLiteralExp; |
| import org.eclipse.ocl.uml.SequenceType; |
| import org.eclipse.ocl.uml.SetType; |
| import org.eclipse.ocl.uml.StateExp; |
| import org.eclipse.ocl.uml.StringLiteralExp; |
| import org.eclipse.ocl.uml.TemplateParameterType; |
| import org.eclipse.ocl.uml.TupleLiteralExp; |
| import org.eclipse.ocl.uml.TupleLiteralPart; |
| import org.eclipse.ocl.uml.TupleType; |
| import org.eclipse.ocl.uml.TypeExp; |
| import org.eclipse.ocl.uml.TypeType; |
| import org.eclipse.ocl.uml.UMLPackage; |
| import org.eclipse.ocl.uml.UnlimitedNaturalLiteralExp; |
| import org.eclipse.ocl.uml.UnspecifiedValueExp; |
| import org.eclipse.ocl.uml.Variable; |
| import org.eclipse.ocl.uml.VariableExp; |
| import org.eclipse.ocl.uml.VoidType; |
| import org.eclipse.ocl.uml.internal.OCLUMLPlugin; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * The <b>Validator</b> for the model. |
| * <!-- end-user-doc --> |
| * @see org.eclipse.ocl.uml.UMLPackage |
| * @generated |
| */ |
| public class UMLValidator |
| extends EObjectValidator { |
| |
| /** |
| * The cached model package |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public static final UMLValidator INSTANCE = new UMLValidator(); |
| |
| /** |
| * A constant for the {@link org.eclipse.emf.common.util.Diagnostic#getSource() source} of diagnostic {@link org.eclipse.emf.common.util.Diagnostic#getCode() codes} from this package. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see org.eclipse.emf.common.util.Diagnostic#getSource() |
| * @see org.eclipse.emf.common.util.Diagnostic#getCode() |
| * @generated |
| */ |
| public static final String DIAGNOSTIC_SOURCE = "org.eclipse.ocl.uml"; //$NON-NLS-1$ |
| |
| /** |
| * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Has type' of 'OCL Expression'. |
| * <!-- begin-user-doc --> |
| * @since 5.4 |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public static final int OCL_EXPRESSION__HAS_TYPE = 1; |
| |
| /** |
| * A constant with a fixed name that can be used as the base value for additional hand written constants. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| private static final int GENERATED_DIAGNOSTIC_CODE_COUNT = 1; |
| |
| /** |
| * A constant with a fixed name that can be used as the base value for additional hand written constants in a derived class. |
| * <!-- begin-user-doc --> |
| * @since 5.4 |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected static final int DIAGNOSTIC_CODE_COUNT = GENERATED_DIAGNOSTIC_CODE_COUNT; |
| |
| /** |
| * The cached base package validator. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected org.eclipse.uml2.uml.util.UMLValidator umlValidator; |
| |
| /** |
| * The cached base package validator. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected TypesValidator typesValidator; |
| |
| /** |
| * The cached base package validator. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected ExpressionsValidator expressionsValidator; |
| |
| /** |
| * Creates an instance of the switch. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public UMLValidator() { |
| super(); |
| umlValidator = org.eclipse.uml2.uml.util.UMLValidator.INSTANCE; |
| typesValidator = TypesValidator.INSTANCE; |
| expressionsValidator = ExpressionsValidator.INSTANCE; |
| } |
| |
| /** |
| * Returns the package of this validator switch. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| protected EPackage getEPackage() { |
| return UMLPackage.eINSTANCE; |
| } |
| |
| /** |
| * Calls <code>validateXXX</code> for the corresponding classifier of the model. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| protected boolean validate(int classifierID, Object value, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| switch (classifierID) { |
| case UMLPackage.ANY_TYPE : |
| return validateAnyType((AnyType) value, diagnostics, context); |
| case UMLPackage.VOID_TYPE : |
| return validateVoidType((VoidType) value, diagnostics, context); |
| case UMLPackage.INVALID_TYPE : |
| return validateInvalidType((InvalidType) value, diagnostics, |
| context); |
| case UMLPackage.ELEMENT_TYPE : |
| return validateElementType((ElementType) value, diagnostics, |
| context); |
| case UMLPackage.TYPE_TYPE : |
| return validateTypeType((TypeType) value, diagnostics, context); |
| case UMLPackage.MESSAGE_TYPE : |
| return validateMessageType((MessageType) value, diagnostics, |
| context); |
| case UMLPackage.PRIMITIVE_TYPE : |
| return validatePrimitiveType((PrimitiveType) value, diagnostics, |
| context); |
| case UMLPackage.COLLECTION_TYPE : |
| return validateCollectionType((CollectionType) value, |
| diagnostics, context); |
| case UMLPackage.TUPLE_TYPE : |
| return validateTupleType((TupleType) value, diagnostics, |
| context); |
| case UMLPackage.BAG_TYPE : |
| return validateBagType((BagType) value, diagnostics, context); |
| case UMLPackage.SET_TYPE : |
| return validateSetType((SetType) value, diagnostics, context); |
| case UMLPackage.ORDERED_SET_TYPE : |
| return validateOrderedSetType((OrderedSetType) value, |
| diagnostics, context); |
| case UMLPackage.SEQUENCE_TYPE : |
| return validateSequenceType((SequenceType) value, diagnostics, |
| context); |
| case UMLPackage.EXPRESSION_IN_OCL : |
| return validateExpressionInOCL((ExpressionInOCL) value, |
| diagnostics, context); |
| case UMLPackage.ASSOCIATION_CLASS_CALL_EXP : |
| return validateAssociationClassCallExp( |
| (AssociationClassCallExp) value, diagnostics, context); |
| case UMLPackage.NAVIGATION_CALL_EXP : |
| return validateNavigationCallExp((NavigationCallExp) value, |
| diagnostics, context); |
| case UMLPackage.FEATURE_CALL_EXP : |
| return validateFeatureCallExp((FeatureCallExp) value, |
| diagnostics, context); |
| case UMLPackage.CALL_EXP : |
| return validateCallExp((CallExp) value, diagnostics, context); |
| case UMLPackage.OCL_EXPRESSION : |
| return validateOCLExpression((OCLExpression) value, diagnostics, |
| context); |
| case UMLPackage.BOOLEAN_LITERAL_EXP : |
| return validateBooleanLiteralExp((BooleanLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.PRIMITIVE_LITERAL_EXP : |
| return validatePrimitiveLiteralExp((PrimitiveLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.LITERAL_EXP : |
| return validateLiteralExp((LiteralExp) value, diagnostics, |
| context); |
| case UMLPackage.COLLECTION_ITEM : |
| return validateCollectionItem((CollectionItem) value, |
| diagnostics, context); |
| case UMLPackage.COLLECTION_LITERAL_PART : |
| return validateCollectionLiteralPart( |
| (CollectionLiteralPart) value, diagnostics, context); |
| case UMLPackage.COLLECTION_LITERAL_EXP : |
| return validateCollectionLiteralExp( |
| (CollectionLiteralExp) value, diagnostics, context); |
| case UMLPackage.COLLECTION_RANGE : |
| return validateCollectionRange((CollectionRange) value, |
| diagnostics, context); |
| case UMLPackage.ENUM_LITERAL_EXP : |
| return validateEnumLiteralExp((EnumLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.IF_EXP : |
| return validateIfExp((IfExp) value, diagnostics, context); |
| case UMLPackage.INTEGER_LITERAL_EXP : |
| return validateIntegerLiteralExp((IntegerLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.NUMERIC_LITERAL_EXP : |
| return validateNumericLiteralExp((NumericLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.UNLIMITED_NATURAL_LITERAL_EXP : |
| return validateUnlimitedNaturalLiteralExp( |
| (UnlimitedNaturalLiteralExp) value, diagnostics, context); |
| case UMLPackage.INVALID_LITERAL_EXP : |
| return validateInvalidLiteralExp((InvalidLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.ITERATE_EXP : |
| return validateIterateExp((IterateExp) value, diagnostics, |
| context); |
| case UMLPackage.LOOP_EXP : |
| return validateLoopExp((LoopExp) value, diagnostics, context); |
| case UMLPackage.ITERATOR_EXP : |
| return validateIteratorExp((IteratorExp) value, diagnostics, |
| context); |
| case UMLPackage.LET_EXP : |
| return validateLetExp((LetExp) value, diagnostics, context); |
| case UMLPackage.MESSAGE_EXP : |
| return validateMessageExp((MessageExp) value, diagnostics, |
| context); |
| case UMLPackage.NULL_LITERAL_EXP : |
| return validateNullLiteralExp((NullLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.OPERATION_CALL_EXP : |
| return validateOperationCallExp((OperationCallExp) value, |
| diagnostics, context); |
| case UMLPackage.PROPERTY_CALL_EXP : |
| return validatePropertyCallExp((PropertyCallExp) value, |
| diagnostics, context); |
| case UMLPackage.REAL_LITERAL_EXP : |
| return validateRealLiteralExp((RealLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.STATE_EXP : |
| return validateStateExp((StateExp) value, diagnostics, context); |
| case UMLPackage.STRING_LITERAL_EXP : |
| return validateStringLiteralExp((StringLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.TUPLE_LITERAL_EXP : |
| return validateTupleLiteralExp((TupleLiteralExp) value, |
| diagnostics, context); |
| case UMLPackage.TUPLE_LITERAL_PART : |
| return validateTupleLiteralPart((TupleLiteralPart) value, |
| diagnostics, context); |
| case UMLPackage.TYPE_EXP : |
| return validateTypeExp((TypeExp) value, diagnostics, context); |
| case UMLPackage.UNSPECIFIED_VALUE_EXP : |
| return validateUnspecifiedValueExp((UnspecifiedValueExp) value, |
| diagnostics, context); |
| case UMLPackage.VARIABLE : |
| return validateVariable((Variable) value, diagnostics, context); |
| case UMLPackage.VARIABLE_EXP : |
| return validateVariableExp((VariableExp) value, diagnostics, |
| context); |
| case UMLPackage.TEMPLATE_PARAMETER_TYPE : |
| return validateTemplateParameterType( |
| (TemplateParameterType) value, diagnostics, context); |
| default : |
| return true; |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateAnyType(AnyType anyType, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(anyType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(anyType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(anyType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(anyType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(anyType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(anyType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| anyType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(anyType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateVoidType(VoidType voidType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(voidType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(voidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(voidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(voidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(voidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(voidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| voidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(voidType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateInvalidType(InvalidType invalidType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(invalidType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(invalidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(invalidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(invalidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(invalidType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(invalidType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| invalidType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| invalidType, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateElementType(ElementType elementType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(elementType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(elementType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(elementType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(elementType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(elementType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(elementType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| elementType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| elementType, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTypeType(TypeType typeType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(typeType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(typeType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(typeType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(typeType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(typeType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(typeType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| typeType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(typeType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateMessageType(MessageType messageType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(messageType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(messageType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(messageType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(messageType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(messageType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| messageType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateMessageType_checkExclusiveSignature(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateMessageType_checkOperationParameters(messageType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator.validateMessageType_checkSignalAttributes( |
| messageType, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validatePrimitiveType(PrimitiveType primitiveType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(primitiveType, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(primitiveType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(primitiveType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(primitiveType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(primitiveType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| primitiveType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| primitiveType, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCollectionType(CollectionType collectionType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(collectionType, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(collectionType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(collectionType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(collectionType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| collectionType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkCollectionTypeName(collectionType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkNoInvalidValues(collectionType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTupleType(TupleType tupleType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(tupleType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(tupleType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(tupleType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(tupleType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(tupleType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(tupleType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator.validateTupleType_checkTupleTypeName( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator.validateTupleType_checkPartNamesUnique( |
| tupleType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateTupleType_checkFeaturesOnlyProperties(tupleType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateBagType(BagType bagType, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(bagType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(bagType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(bagType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(bagType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(bagType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| bagType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkCollectionTypeName(bagType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkNoInvalidValues(bagType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateSetType(SetType setType, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(setType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(setType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(setType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(setType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(setType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| setType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkCollectionTypeName(setType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkNoInvalidValues(setType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateOrderedSetType(OrderedSetType orderedSetType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(orderedSetType, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(orderedSetType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(orderedSetType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(orderedSetType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| orderedSetType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkCollectionTypeName(orderedSetType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkNoInvalidValues(orderedSetType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateSequenceType(SequenceType sequenceType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(sequenceType, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(sequenceType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(sequenceType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(sequenceType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(sequenceType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| sequenceType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkCollectionTypeName(sequenceType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= typesValidator |
| .validateCollectionType_checkNoInvalidValues(sequenceType, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateExpressionInOCL(ExpressionInOCL expressionInOCL, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(expressionInOCL, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(expressionInOCL, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(expressionInOCL, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(expressionInOCL, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(expressionInOCL, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(expressionInOCL, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(expressionInOCL, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(expressionInOCL, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateOpaqueExpression_validateLanguageBodySize( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateOpaqueExpression_validateOneReturnResultParameter( |
| expressionInOCL, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateOpaqueExpression_validateOnlyReturnResultParameters( |
| expressionInOCL, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateAssociationClassCallExp( |
| AssociationClassCallExp associationClassCallExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(associationClassCallExp, |
| diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(associationClassCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(associationClassCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(associationClassCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(associationClassCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(associationClassCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| associationClassCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(associationClassCallExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateNavigationCallExp( |
| NavigationCallExp navigationCallExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(navigationCallExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(navigationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(navigationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(navigationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(navigationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(navigationCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(navigationCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(navigationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| navigationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(navigationCallExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateFeatureCallExp(FeatureCallExp featureCallExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(featureCallExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(featureCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(featureCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(featureCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| featureCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(featureCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(featureCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(featureCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(featureCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| featureCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| featureCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| featureCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(featureCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(featureCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(featureCallExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCallExp(CallExp callExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(callExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(callExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(callExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(callExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(callExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(callExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(callExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(callExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(callExp, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateOCLExpression(OCLExpression oclExpression, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(oclExpression, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(oclExpression, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(oclExpression, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(oclExpression, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| oclExpression, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(oclExpression, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(oclExpression, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(oclExpression, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(oclExpression, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| oclExpression, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| oclExpression, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| oclExpression, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(oclExpression, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(oclExpression, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(oclExpression, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * Validates the has_type constraint of '<em>OCL Expression</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated NOT |
| */ |
| public boolean validateOCLExpression_has_type(OCLExpression oclExpression, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (oclExpression.getType() == null) { |
| if (diagnostics != null) { |
| diagnostics.add(createDiagnostic(Diagnostic.ERROR, |
| DIAGNOSTIC_SOURCE, 0, "_UI_GenericConstraint_diagnostic", //$NON-NLS-1$ |
| new Object[]{"has_type", //$NON-NLS-1$ |
| getObjectLabel(oclExpression, context)}, |
| new Object[]{oclExpression}, context)); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateBooleanLiteralExp( |
| BooleanLiteralExp booleanLiteralExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(booleanLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(booleanLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(booleanLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| booleanLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(booleanLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateBooleanLiteralExp_checkBooleanType(booleanLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validatePrimitiveLiteralExp( |
| PrimitiveLiteralExp primitiveLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(primitiveLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(primitiveLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(primitiveLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(primitiveLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(primitiveLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(primitiveLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(primitiveLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(primitiveLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| primitiveLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(primitiveLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateLiteralExp(LiteralExp literalExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(literalExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(literalExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(literalExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(literalExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(literalExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(literalExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| literalExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| literalExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(literalExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(literalExp, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCollectionItem(CollectionItem collectionItem, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(collectionItem, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(collectionItem, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(collectionItem, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(collectionItem, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| collectionItem, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(collectionItem, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(collectionItem, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(collectionItem, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(collectionItem, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| collectionItem, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| collectionItem, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| collectionItem, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(collectionItem, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(collectionItem, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateCollectionItem_checkItemType( |
| collectionItem, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCollectionLiteralPart( |
| CollectionLiteralPart collectionLiteralPart, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(collectionLiteralPart, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(collectionLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(collectionLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(collectionLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(collectionLiteralPart, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(collectionLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(collectionLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| collectionLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| collectionLiteralPart, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCollectionLiteralExp( |
| CollectionLiteralExp collectionLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(collectionLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(collectionLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(collectionLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionLiteralExp_checkNoCollectionInstances( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionLiteralExp_checkSetKind(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionLiteralExp_checkSequenceKind( |
| collectionLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionLiteralExp_checkBagKind(collectionLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionLiteralExp_checkElementType( |
| collectionLiteralExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateCollectionRange(CollectionRange collectionRange, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(collectionRange, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(collectionRange, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(collectionRange, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(collectionRange, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(collectionRange, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(collectionRange, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(collectionRange, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(collectionRange, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| collectionRange, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateCollectionRange_checkRangeType(collectionRange, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateEnumLiteralExp(EnumLiteralExp enumLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(enumLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| enumLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(enumLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(enumLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(enumLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(enumLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| enumLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| enumLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| enumLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(enumLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateEnumLiteralExp_checkEnumType( |
| enumLiteralExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateIfExp(IfExp ifExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(ifExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(ifExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(ifExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(ifExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(ifExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(ifExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(ifExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(ifExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(ifExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(ifExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIfExp_checkBooleanCondition( |
| ifExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIfExp_checkIfType(ifExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateIntegerLiteralExp( |
| IntegerLiteralExp integerLiteralExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(integerLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(integerLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(integerLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| integerLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(integerLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateIntegerLiteralExp_checkIntegerType(integerLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateNumericLiteralExp( |
| NumericLiteralExp numericLiteralExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(numericLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(numericLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(numericLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(numericLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(numericLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(numericLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(numericLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(numericLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| numericLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(numericLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateUnlimitedNaturalLiteralExp( |
| UnlimitedNaturalLiteralExp unlimitedNaturalLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(unlimitedNaturalLiteralExp, |
| diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(unlimitedNaturalLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(unlimitedNaturalLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(unlimitedNaturalLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(unlimitedNaturalLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(unlimitedNaturalLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateUnlimitedNaturalLiteralExp_checkNaturalType( |
| unlimitedNaturalLiteralExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateInvalidLiteralExp( |
| InvalidLiteralExp invalidLiteralExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(invalidLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(invalidLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(invalidLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(invalidLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(invalidLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(invalidLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(invalidLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(invalidLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| invalidLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(invalidLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateIterateExp(IterateExp iterateExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(iterateExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(iterateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkSourceCollection(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableInit(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableType(iterateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIterateExp_checkIterateType( |
| iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIterateExp_checkBodyType( |
| iterateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIterateExp_checkResultInit( |
| iterateExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateLoopExp(LoopExp loopExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(loopExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(loopExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(loopExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(loopExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkSourceCollection(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableInit(loopExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableType(loopExp, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateIteratorExp(IteratorExp iteratorExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(iteratorExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(iteratorExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| iteratorExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| iteratorExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkSourceCollection(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableInit(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateLoopExp_checkLoopVariableType(iteratorExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIteratorExp_checkBooleanType( |
| iteratorExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateIteratorExp_checkCollectType( |
| iteratorExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateIteratorExp_checkSelectRejectType(iteratorExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateIteratorExp_checkBooleanBodyType(iteratorExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateLetExp(LetExp letExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(letExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(letExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(letExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(letExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(letExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(letExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(letExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(letExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(letExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(letExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateLetExp_checkLetType(letExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateMessageExp(MessageExp messageExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(messageExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(messageExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(messageExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(messageExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(messageExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(messageExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| messageExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| messageExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(messageExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateMessageExp_checkOperationArguments(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateMessageExp_checkSignalArguments(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateMessageExp_checkTargetDefinesOperation(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateMessageExp_checkHasOperationOrSignal(messageExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateMessageExp_checkTargetNotCollection(messageExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateNullLiteralExp(NullLiteralExp nullLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(nullLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(nullLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(nullLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(nullLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| nullLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(nullLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(nullLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(nullLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(nullLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| nullLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| nullLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| nullLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(nullLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(nullLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(nullLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateOperationCallExp(OperationCallExp operationCallExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(operationCallExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(operationCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(operationCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(operationCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateOperationCallExp_checkArgumentsConform( |
| operationCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateOperationCallExp_checkArgumentCount(operationCallExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validatePropertyCallExp(PropertyCallExp propertyCallExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(propertyCallExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(propertyCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(propertyCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(propertyCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(propertyCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(propertyCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(propertyCallExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(propertyCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| propertyCallExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(propertyCallExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validatePropertyCallExp_checkPropertyType(propertyCallExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateRealLiteralExp(RealLiteralExp realLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(realLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| realLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(realLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(realLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(realLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(realLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| realLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| realLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| realLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(realLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateRealLiteralExp_checkRealType( |
| realLiteralExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateStateExp(StateExp stateExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(stateExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(stateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(stateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(stateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(stateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(stateExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(stateExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(stateExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(stateExp, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateStringLiteralExp(StringLiteralExp stringLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(stringLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(stringLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(stringLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| stringLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(stringLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateStringLiteralExp_checkStringType(stringLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTupleLiteralExp(TupleLiteralExp tupleLiteralExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(tupleLiteralExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(tupleLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(tupleLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(tupleLiteralExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| tupleLiteralExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateTupleLiteralExp_checkTupleType(tupleLiteralExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateTupleLiteralExp_checkPartsUnique(tupleLiteralExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTupleLiteralPart(TupleLiteralPart tupleLiteralPart, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(tupleLiteralPart, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(tupleLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(tupleLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(tupleLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(tupleLiteralPart, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(tupleLiteralPart, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(tupleLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(tupleLiteralPart, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| tupleLiteralPart, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateTupleLiteralPart_checkValueType(tupleLiteralPart, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTypeExp(TypeExp typeExp, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(typeExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(typeExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(typeExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(typeExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(typeExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(typeExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(typeExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(typeExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(typeExp, diagnostics, |
| context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateUnspecifiedValueExp( |
| UnspecifiedValueExp unspecifiedValueExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(unspecifiedValueExp, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(unspecifiedValueExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(unspecifiedValueExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(unspecifiedValueExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(unspecifiedValueExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(unspecifiedValueExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(unspecifiedValueExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(unspecifiedValueExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| unspecifiedValueExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(unspecifiedValueExp, |
| diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateVariable(Variable variable, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(variable, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(variable, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(variable, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(variable, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(variable, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(variable, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(variable, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(variable, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator |
| .validateVariable_checkInitType(variable, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateVariableExp(VariableExp variableExp, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(variableExp, diagnostics, context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(variableExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(variableExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(variableExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(variableExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(variableExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| variableExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| variableExp, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName(variableExp, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validateOCLExpression_has_type(variableExp, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= expressionsValidator.validateVariableExp_checkVarType( |
| variableExp, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * @since 3.0 |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean validateTemplateParameterType( |
| TemplateParameterType templateParameterType, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(templateParameterType, diagnostics, |
| context)) |
| return false; |
| boolean result = validate_EveryMultiplicityConforms( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryDataValueConforms(templateParameterType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryReferenceIsContained(templateParameterType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryBidirectionalReferenceIsPaired( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryProxyResolves(templateParameterType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_UniqueID(templateParameterType, diagnostics, |
| context); |
| if (result || diagnostics != null) |
| result &= validate_EveryKeyUnique(templateParameterType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= validate_EveryMapEntryUnique(templateParameterType, |
| diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateHasOwner( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateElement_validateNotOwnSelf( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateVisibilityNeedsOwnership( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasQualifiedName( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamedElement_validateHasNoQualifiedName( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateMembersDistinguishable( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateNamespace_validateCannotImportSelf( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateNamespace_validateCannotImportOwnedMembers( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionConsistent( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateNonLeafRedefinition( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateRedefinableElement_validateRedefinitionContextValid( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validatePackageableElement_validateNamespaceNeedsVisibility( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateSpecializeType( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateMapsToGeneralizationSet( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator.validateClassifier_validateNonFinalParents( |
| templateParameterType, diagnostics, context); |
| if (result || diagnostics != null) |
| result &= umlValidator |
| .validateClassifier_validateNoCyclesInGeneralization( |
| templateParameterType, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * Returns the resource locator that will be used to fetch messages for this validator's diagnostics. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public ResourceLocator getResourceLocator() { |
| return OCLUMLPlugin.INSTANCE; |
| } |
| |
| } //UMLValidator |
