| /******************************************************************************* |
| * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Eugen Neufeld - initial API and implementation |
| * Christian W. Damus - bug 543190 |
| *******************************************************************************/ |
| package org.eclipse.emf.ecp.view.validation.test.model.util; |
| |
| import java.util.ArrayList; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.common.util.DiagnosticChain; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.ResourceLocator; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.util.EObjectValidator; |
| import org.eclipse.emf.ecore.xml.type.util.XMLTypeUtil; |
| import org.eclipse.emf.ecp.view.internal.validation.ValidationNotification; |
| import org.eclipse.emf.ecp.view.validation.test.model.Book; |
| import org.eclipse.emf.ecp.view.validation.test.model.Color; |
| import org.eclipse.emf.ecp.view.validation.test.model.Computer; |
| import org.eclipse.emf.ecp.view.validation.test.model.Container; |
| import org.eclipse.emf.ecp.view.validation.test.model.Content; |
| import org.eclipse.emf.ecp.view.validation.test.model.CrossReferenceContainer; |
| import org.eclipse.emf.ecp.view.validation.test.model.CrossReferenceContent; |
| import org.eclipse.emf.ecp.view.validation.test.model.Gender; |
| import org.eclipse.emf.ecp.view.validation.test.model.Librarian; |
| import org.eclipse.emf.ecp.view.validation.test.model.Library; |
| import org.eclipse.emf.ecp.view.validation.test.model.Mainboard; |
| import org.eclipse.emf.ecp.view.validation.test.model.Person; |
| import org.eclipse.emf.ecp.view.validation.test.model.PowerBlock; |
| import org.eclipse.emf.ecp.view.validation.test.model.Referencer; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableContent; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableContentWithInnerChild; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableContentWithInnerChild2; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableContentWithValidation; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableContentWithoutValidation; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableObject; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableWithMultiplicity; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableWithUnique; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableWithoutMultiplicity; |
| import org.eclipse.emf.ecp.view.validation.test.model.TableWithoutMultiplicityConcrete; |
| import org.eclipse.emf.ecp.view.validation.test.model.TestPackage; |
| import org.eclipse.emf.ecp.view.validation.test.model.Writer; |
| |
| /** |
| * <!-- begin-user-doc --> |
| * The <b>Validator</b> for the model. |
| * <!-- end-user-doc --> |
| * |
| * @see org.eclipse.emf.ecp.view.validation.test.model.TestPackage |
| * @generated |
| */ |
| public class TestValidator extends EObjectValidator { |
| /** |
| * The cached model package |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public static final TestValidator INSTANCE = new TestValidator(); |
| |
| /** |
| * 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.emf.ecp.view.validation.test.model"; |
| |
| /** |
| * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate' of 'Library'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public static final int LIBRARY__VALIDATE = 1; |
| |
| /** |
| * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate' of 'Writer'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public static final int WRITER__VALIDATE = 2; |
| |
| /** |
| * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate' of 'Book'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public static final int BOOK__VALIDATE = 3; |
| |
| /** |
| * The {@link org.eclipse.emf.common.util.Diagnostic#getCode() code} for constraint 'Validate' of 'Librarian'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public static final int LIBRARIAN__VALIDATE = 4; |
| |
| /** |
| * 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 = 4; |
| |
| /** |
| * 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 --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| protected static final int DIAGNOSTIC_CODE_COUNT = GENERATED_DIAGNOSTIC_CODE_COUNT; |
| |
| /** |
| * Creates an instance of the switch. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public TestValidator() { |
| super(); |
| } |
| |
| /** |
| * Returns the package of this validator switch. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| @Override |
| protected EPackage getEPackage() { |
| return TestPackage.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 TestPackage.LIBRARY: |
| return validateLibrary((Library) value, diagnostics, context); |
| case TestPackage.WRITER: |
| return validateWriter((Writer) value, diagnostics, context); |
| case TestPackage.BOOK: |
| return validateBook((Book) value, diagnostics, context); |
| case TestPackage.LIBRARIAN: |
| return validateLibrarian((Librarian) value, diagnostics, context); |
| case TestPackage.COMPUTER: |
| return validateComputer((Computer) value, diagnostics, context); |
| case TestPackage.MAINBOARD: |
| return validateMainboard((Mainboard) value, diagnostics, context); |
| case TestPackage.POWER_BLOCK: |
| return validatePowerBlock((PowerBlock) value, diagnostics, context); |
| case TestPackage.CONTAINER: |
| return validateContainer((Container) value, diagnostics, context); |
| case TestPackage.CONTENT: |
| return validateContent((Content) value, diagnostics, context); |
| case TestPackage.TABLE_WITH_MULTIPLICITY: |
| return validateTableWithMultiplicity((TableWithMultiplicity) value, diagnostics, context); |
| case TestPackage.TABLE_CONTENT: |
| return validateTableContent((TableContent) value, diagnostics, context); |
| case TestPackage.TABLE_CONTENT_WITHOUT_VALIDATION: |
| return validateTableContentWithoutValidation((TableContentWithoutValidation) value, diagnostics, context); |
| case TestPackage.TABLE_CONTENT_WITH_VALIDATION: |
| return validateTableContentWithValidation((TableContentWithValidation) value, diagnostics, context); |
| case TestPackage.TABLE_WITHOUT_MULTIPLICITY: |
| return validateTableWithoutMultiplicity((TableWithoutMultiplicity) value, diagnostics, context); |
| case TestPackage.TABLE_WITH_UNIQUE: |
| return validateTableWithUnique((TableWithUnique) value, diagnostics, context); |
| case TestPackage.TABLE_CONTENT_WITH_INNER_CHILD2: |
| return validateTableContentWithInnerChild2((TableContentWithInnerChild2) value, diagnostics, context); |
| case TestPackage.TABLE_CONTENT_WITH_INNER_CHILD: |
| return validateTableContentWithInnerChild((TableContentWithInnerChild) value, diagnostics, context); |
| case TestPackage.TABLE_WITHOUT_MULTIPLICITY_CONCRETE: |
| return validateTableWithoutMultiplicityConcrete((TableWithoutMultiplicityConcrete) value, diagnostics, |
| context); |
| case TestPackage.REFERENCER: |
| return validateReferencer((Referencer) value, diagnostics, context); |
| case TestPackage.CROSS_REFERENCE_CONTAINER: |
| return validateCrossReferenceContainer((CrossReferenceContainer) value, diagnostics, context); |
| case TestPackage.CROSS_REFERENCE_CONTENT: |
| return validateCrossReferenceContent((CrossReferenceContent) value, diagnostics, context); |
| case TestPackage.PERSON: |
| return validatePerson((Person) value, diagnostics, context); |
| case TestPackage.TABLE_OBJECT: |
| return validateTableObject((TableObject) value, diagnostics, context); |
| case TestPackage.GENDER: |
| return validateGender((Gender) value, diagnostics, context); |
| case TestPackage.COLOR: |
| return validateColor((Color) value, diagnostics, context); |
| case TestPackage.STRING_WITH_MAX_LENGTH8: |
| return validateStringWithMaxLength8((String) value, diagnostics, context); |
| case TestPackage.ONLY_CAPITALS: |
| return validateOnlyCapitals((String) value, diagnostics, context); |
| case TestPackage.CUSTOM_DATA_TYPE: |
| return validateCustomDataType((String) value, diagnostics, context); |
| case TestPackage.PHONE_NUMBER: |
| return validatePhoneNumber((String) value, diagnostics, context); |
| case TestPackage.MIN_LENGTH_OF3: |
| return validateMinLengthOf3((String) value, diagnostics, context); |
| case TestPackage.STRICT_MIN_LENGTH_OF3: |
| return validateStrictMinLengthOf3((String) value, diagnostics, context); |
| case TestPackage.AGE: |
| return validateAge((Integer) value, diagnostics, context); |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateLibrary(Library library, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(library, diagnostics, context)) { |
| return false; |
| } |
| boolean result = validate_EveryMultiplicityConforms(library, diagnostics, context); |
| if (result || diagnostics != null) { |
| result &= validate_EveryDataValueConforms(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryReferenceIsContained(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryBidirectionalReferenceIsPaired(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryProxyResolves(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_UniqueID(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryKeyUnique(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryMapEntryUnique(library, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validateLibrary_validate(library, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * Validates the validate constraint of '<em>Library</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateLibrary_validate(Library library, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return library.validate(diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateWriter(Writer writer, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(writer, diagnostics, context)) { |
| return false; |
| } |
| boolean result = validate_EveryMultiplicityConforms(writer, diagnostics, context); |
| if (result || diagnostics != null) { |
| result &= validate_EveryDataValueConforms(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryReferenceIsContained(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryBidirectionalReferenceIsPaired(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryProxyResolves(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_UniqueID(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryKeyUnique(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryMapEntryUnique(writer, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validateWriter_validate(writer, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * Validates the validate constraint of '<em>Writer</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateWriter_validate(Writer writer, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return writer.validate(diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateBook(Book book, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(book, diagnostics, context)) { |
| return false; |
| } |
| boolean result = validate_EveryMultiplicityConforms(book, diagnostics, context); |
| if (result || diagnostics != null) { |
| result &= validate_EveryDataValueConforms(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryReferenceIsContained(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryBidirectionalReferenceIsPaired(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryProxyResolves(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_UniqueID(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryKeyUnique(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryMapEntryUnique(book, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validateBook_validate(book, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * Validates the validate constraint of '<em>Book</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateBook_validate(Book book, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return book.validate(diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateLibrarian(Librarian librarian, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (!validate_NoCircularContainment(librarian, diagnostics, context)) { |
| return false; |
| } |
| boolean result = validate_EveryMultiplicityConforms(librarian, diagnostics, context); |
| if (result || diagnostics != null) { |
| result &= validate_EveryDataValueConforms(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryReferenceIsContained(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryBidirectionalReferenceIsPaired(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryProxyResolves(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_UniqueID(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryKeyUnique(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validate_EveryMapEntryUnique(librarian, diagnostics, context); |
| } |
| if (result || diagnostics != null) { |
| result &= validateLibrarian_validate(librarian, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * Validates the validate constraint of '<em>Librarian</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateLibrarian_validate(Librarian librarian, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return librarian.validate(diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateComputer(Computer computer, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(computer, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateMainboard(Mainboard mainboard, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(mainboard, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validatePowerBlock(PowerBlock powerBlock, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(powerBlock, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean validateContainer(Container container, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(container, diagnostics, context) |
| && validateContainerUniqueAttribuite(container, diagnostics, context); |
| } |
| |
| /** |
| * |
| * @generated NOT |
| */ |
| public boolean validateContainerUniqueAttribuite(Container container, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| // TODO implement the constraint |
| // -> specify the condition that violates the constraint |
| // -> verify the diagnostic details, including severity, code, and message |
| // Ensure that you remove @generated or mark it @generated NOT |
| final EList<Content> contents = container.getContents(); |
| final Map<String, Set<Content>> uniqueAttToContentMap = new LinkedHashMap<>(); |
| |
| for (final Content content : contents) { |
| final String uniquiAtt = content.getUniqueAttribute(); |
| if (!uniqueAttToContentMap.containsKey(uniquiAtt)) { |
| uniqueAttToContentMap.put(uniquiAtt, new LinkedHashSet<Content>()); |
| } |
| uniqueAttToContentMap.get(uniquiAtt).add(content); |
| } |
| final List<Content> duplicates = new ArrayList<>(); |
| for (final String language : uniqueAttToContentMap.keySet()) { |
| if (uniqueAttToContentMap.get(language).size() > 1) { |
| duplicates.addAll(uniqueAttToContentMap.get(language)); |
| } |
| } |
| if (!duplicates.isEmpty()) { |
| createUniqueDiagnostic(duplicates, diagnostics, context, |
| "Same unique Attribute not allowed.", TestPackage.eINSTANCE.getContent_UniqueAttribute(), |
| Diagnostic.ERROR); |
| return false; |
| } |
| // create ok results |
| for (final Content content : contents) { |
| content.eNotify(new ValidationNotification(content)); |
| } |
| |
| final boolean result = true; |
| return result; |
| } |
| |
| /** |
| * @generated NOT |
| */ |
| private void createUniqueDiagnostic(List<? extends EObject> duplicates, DiagnosticChain diagnostics, |
| Map<Object, Object> context, String message, EStructuralFeature feature, int severity) { |
| if (diagnostics != null) { |
| for (final EObject duplicate : duplicates) { |
| diagnostics.add(createDiagnostic(severity, DIAGNOSTIC_SOURCE, 0, |
| "_UI_GenericConstraint_diagnostic", |
| new Object[] { message, getObjectLabel(duplicate, context) }, new Object[] { duplicate, |
| feature }, |
| context)); |
| } |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean validateContent(Content content, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| content.eNotify(new ValidationNotification(content.eContainer())); |
| return validate_EveryDefaultConstraint(content, diagnostics, context); |
| // && validate(content.eContainer().eClass().getClassifierID(), content.eContainer(), |
| // diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableWithMultiplicity(TableWithMultiplicity tableWithMultiplicity, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableWithMultiplicity, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableContent(TableContent tableContent, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableContent, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean validateTableContentWithoutValidation(TableContentWithoutValidation tableContentWithoutValidation, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| tableContentWithoutValidation.eNotify(new ValidationNotification(tableContentWithoutValidation.eContainer())); |
| return validate_EveryDefaultConstraint(tableContentWithoutValidation, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean validateTableContentWithValidation(TableContentWithValidation tableContentWithValidation, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| tableContentWithValidation.eNotify(new ValidationNotification(tableContentWithValidation.eContainer())); |
| return validate_EveryDefaultConstraint(tableContentWithValidation, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableWithoutMultiplicity(TableWithoutMultiplicity tableWithoutMultiplicity, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableWithoutMultiplicity, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean validateTableWithUnique(TableWithUnique tableWithUnique, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableWithUnique, diagnostics, context) |
| & validateUniqueness(tableWithUnique, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableContentWithInnerChild2(TableContentWithInnerChild2 tableContentWithInnerChild2, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableContentWithInnerChild2, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableContentWithInnerChild(TableContentWithInnerChild tableContentWithInnerChild, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableContentWithInnerChild, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableWithoutMultiplicityConcrete( |
| TableWithoutMultiplicityConcrete tableWithoutMultiplicityConcrete, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableWithoutMultiplicityConcrete, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateReferencer(Referencer referencer, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(referencer, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateCrossReferenceContainer(CrossReferenceContainer crossReferenceContainer, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(crossReferenceContainer, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateCrossReferenceContent(CrossReferenceContent crossReferenceContent, |
| DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(crossReferenceContent, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validatePerson(Person person, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(person, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateTableObject(TableObject tableObject, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validate_EveryDefaultConstraint(tableObject, diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateGender(Gender gender, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return true; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateColor(Color color, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| return true; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateStringWithMaxLength8(String stringWithMaxLength8, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final boolean result = validateStringWithMaxLength8_MaxLength(stringWithMaxLength8, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * Validates the MaxLength constraint of '<em>String With Max Length8</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateStringWithMaxLength8_MaxLength(String stringWithMaxLength8, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final int length = stringWithMaxLength8.length(); |
| final boolean result = length <= 8; |
| if (!result && diagnostics != null) { |
| reportMaxLengthViolation(TestPackage.Literals.STRING_WITH_MAX_LENGTH8, stringWithMaxLength8, length, 8, |
| diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateOnlyCapitals(String onlyCapitals, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| final boolean result = validateOnlyCapitals_Pattern(onlyCapitals, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| * @see #validateOnlyCapitals_Pattern |
| */ |
| public static final PatternMatcher[][] ONLY_CAPITALS__PATTERN__VALUES = new PatternMatcher[][] { |
| new PatternMatcher[] { |
| XMLTypeUtil.createPatternMatcher("[A-Z]+") |
| } |
| }; |
| |
| /** |
| * Validates the Pattern constraint of '<em>Only Capitals</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateOnlyCapitals_Pattern(String onlyCapitals, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validatePattern(TestPackage.Literals.ONLY_CAPITALS, onlyCapitals, ONLY_CAPITALS__PATTERN__VALUES, |
| diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateCustomDataType(String customDataType, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return true; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validatePhoneNumber(String phoneNumber, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| final boolean result = validatePhoneNumber_Pattern(phoneNumber, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| * @see #validatePhoneNumber_Pattern |
| */ |
| public static final PatternMatcher[][] PHONE_NUMBER__PATTERN__VALUES = new PatternMatcher[][] { |
| new PatternMatcher[] { |
| XMLTypeUtil.createPatternMatcher("((\\+)?[a-c0-9*#]{1,20}){0,1}") |
| } |
| }; |
| |
| /** |
| * Validates the Pattern constraint of '<em>Phone Number</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validatePhoneNumber_Pattern(String phoneNumber, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| return validatePattern(TestPackage.Literals.PHONE_NUMBER, phoneNumber, PHONE_NUMBER__PATTERN__VALUES, |
| diagnostics, context); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateMinLengthOf3(String minLengthOf3, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| final boolean result = validateMinLengthOf3_MinLength(minLengthOf3, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * Validates the MinLength constraint of '<em>Min Length Of3</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateMinLengthOf3_MinLength(String minLengthOf3, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final int length = minLengthOf3.length(); |
| final boolean result = length >= 3; |
| if (!result && diagnostics != null) { |
| reportMinLengthViolation(TestPackage.Literals.MIN_LENGTH_OF3, minLengthOf3, length, 3, diagnostics, |
| context); |
| } |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateStrictMinLengthOf3(String strictMinLengthOf3, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final boolean result = validateStrictMinLengthOf3_MinLength(strictMinLengthOf3, diagnostics, context); |
| return result; |
| } |
| |
| /** |
| * Validates the MinLength constraint of '<em>Strict Min Length Of3</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateStrictMinLengthOf3_MinLength(String strictMinLengthOf3, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final int length = strictMinLengthOf3.length(); |
| final boolean result = length >= 3; |
| if (!result && diagnostics != null) { |
| reportMinLengthViolation(TestPackage.Literals.STRICT_MIN_LENGTH_OF3, strictMinLengthOf3, length, 3, |
| diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateAge(Integer age, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| boolean result = validateAge_Min(age, diagnostics, context); |
| if (result || diagnostics != null) { |
| result &= validateAge_Max(age, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| * @see #validateAge_Min |
| */ |
| public static final Integer AGE__MIN__VALUE = new Integer(0); |
| |
| /** |
| * Validates the Min constraint of '<em>Age</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateAge_Min(Integer age, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| final boolean result = age.compareTo(AGE__MIN__VALUE) >= 0; |
| if (!result && diagnostics != null) { |
| reportMinViolation(TestPackage.Literals.AGE, age, AGE__MIN__VALUE, true, diagnostics, context); |
| } |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| * @see #validateAge_Max |
| */ |
| public static final Integer AGE__MAX__VALUE = new Integer(100); |
| |
| /** |
| * Validates the Max constraint of '<em>Age</em>'. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * |
| * @generated |
| */ |
| public boolean validateAge_Max(Integer age, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| final boolean result = age.compareTo(AGE__MAX__VALUE) <= 0; |
| if (!result && diagnostics != null) { |
| reportMaxViolation(TestPackage.Literals.AGE, age, AGE__MAX__VALUE, true, diagnostics, context); |
| } |
| return result; |
| } |
| |
| private boolean validateUniqueness(TableWithUnique tableWithUnique, DiagnosticChain diagnostics, |
| Map<Object, Object> context) { |
| final EList<TableContent> contents = tableWithUnique.getContent(); |
| final Map<String, Set<TableContent>> uniqueAttToContentMap = new LinkedHashMap<>(); |
| |
| EStructuralFeature nameFeature = null; |
| |
| for (final TableContent content : contents) { |
| String uniquiAtt = null; |
| if (TableContentWithoutValidation.class.isInstance(content)) { |
| uniquiAtt = ((TableContentWithoutValidation) content).getName(); |
| nameFeature = TestPackage.eINSTANCE.getTableContentWithoutValidation_Name(); |
| } |
| if (TableContentWithValidation.class.isInstance(content)) { |
| uniquiAtt = ((TableContentWithValidation) content).getName(); |
| nameFeature = TestPackage.eINSTANCE.getTableContentWithValidation_Name(); |
| } |
| if (!uniqueAttToContentMap.containsKey(uniquiAtt)) { |
| uniqueAttToContentMap.put(uniquiAtt, new LinkedHashSet<TableContent>()); |
| } |
| uniqueAttToContentMap.get(uniquiAtt).add(content); |
| } |
| final List<TableContent> duplicates = new ArrayList<>(); |
| for (final String language : uniqueAttToContentMap.keySet()) { |
| if (uniqueAttToContentMap.get(language).size() > 1) { |
| duplicates.addAll(uniqueAttToContentMap.get(language)); |
| } |
| } |
| |
| boolean noDuplicates = true; |
| |
| if (!duplicates.isEmpty()) { |
| createUniqueDiagnostic(duplicates, diagnostics, context, |
| "Same unique name not allowed.", nameFeature, Diagnostic.WARNING); |
| noDuplicates = false; |
| } |
| // create ok results |
| for (final TableContent content : contents) { |
| content.eNotify(new ValidationNotification(content)); |
| } |
| |
| return noDuplicates; |
| } |
| |
| /** |
| * 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() { |
| // TODO |
| // Specialize this to return a resource locator for messages specific to this validator. |
| // Ensure that you remove @generated or mark it @generated NOT |
| return super.getResourceLocator(); |
| } |
| |
| } // TestValidator |
