From be4f78978faba3d3ceb88df02a7f93a2e09ff1e0 Mon Sep 17 00:00:00 2001 From: Kenji Hosokawa Date: Tue, 3 Aug 2021 18:42:39 +0900 Subject: Initial commit Bug-AGL: SPEC-4033 Signed-off-by: Kenji Hosokawa --- .../AbstractContentOperatorValidator.xtend | 7 ++ .../validators/AbstractContentValidator.xtend | 59 +++++++++++ .../validators/ActiveContentsValidator.xtend | 33 +++++++ .../validators/ActiveStateValidator.xtend | 32 ++++++ .../validators/AllocatableSetValidator.xtend | 59 +++++++++++ .../validators/AllocatedContentValidator.xtend | 36 +++++++ .../validators/AndOperatorValidator.xtend | 35 +++++++ .../validation/validators/AreaSetValidator.xtend | 47 +++++++++ .../validation/validators/AreaValidator.xtend | 74 ++++++++++++++ .../ComparisonAndOperatorValidator.xtend | 39 ++++++++ .../validators/CompositeAreaValidator.xtend | 26 +++++ .../validators/ConstraintValidator.xtend | 27 +++++ .../validators/ContentSetValidator.xtend | 59 +++++++++++ .../validators/ContentStateValidator.xtend | 26 +++++ .../validation/validators/ContentValidator.xtend | 20 ++++ .../validators/ContentValueValidator.xtend | 34 +++++++ .../validation/validators/DisplayValidator.xtend | 91 +++++++++++++++++ .../validators/DisplayingContentValidator.xtend | 34 +++++++ .../validators/EqualToOperatorValidatior.xtend | 42 ++++++++ .../validators/ExistsOperatorValidator.xtend | 48 +++++++++ .../validators/FixedPositionLayoutValidator.xtend | 25 +++++ .../validators/ForAllOperatorValidator.xtend | 58 +++++++++++ .../validators/GetAllocatablesValidator.xtend | 34 +++++++ .../validators/GetContentsListValidator.xtend | 34 +++++++ .../validators/GetPropertyValidator.xtend | 60 ++++++++++++ .../validators/GreaterThanOperatorValidator.xtend | 40 ++++++++ .../validators/HasComeEarlierThanValidator.xtend | 51 ++++++++++ .../validators/HasComeLaterThanValidator.xtend | 51 ++++++++++ .../validators/HideLowerPriorityValidator.xtend | 39 ++++++++ .../validators/HorizontalLayoutValidator.xtend | 25 +++++ .../validators/IfStatementValidator.xtend | 44 +++++++++ .../validators/ImpliesOperatorValidator.xtend | 35 +++++++ .../validators/IntegerPropertyValidator.xtend | 17 ++++ .../validation/validators/IsActiveValidator.xtend | 34 +++++++ .../validators/IsAllocatedToValidator.xtend | 48 +++++++++ .../validators/IsAttenuatedValidator.xtend | 34 +++++++ .../validators/IsCanceledValidator.xtend | 37 +++++++ .../validators/IsChangedDisplayValidator.xtend | 32 ++++++ .../validators/IsChangedOutputValidator.xtend | 32 ++++++ .../validation/validators/IsChangedValidator.xtend | 31 ++++++ .../validators/IsDisappearedValidator.xtend | 37 +++++++ .../validators/IsDisplayedOnValidator.xtend | 39 ++++++++ .../validators/IsEqualToOperatorValidator.xtend | 36 +++++++ .../IsGreaterThanEqualOperatorValidator.xtend | 36 +++++++ .../IsGreaterThanOperatorValidator.xtend | 36 +++++++ .../validation/validators/IsHiddenValidator.xtend | 34 +++++++ .../IsLowerThanEqualOperatorValidator.xtend | 36 +++++++ .../validators/IsLowerThanOperatorValidator.xtend | 36 +++++++ .../validation/validators/IsMutedValidator.xtend | 34 +++++++ .../validation/validators/IsOnValidator.xtend | 32 ++++++ .../validators/IsOutputtedOnValidator.xtend | 39 ++++++++ .../validators/IsOutputtedValidator.xtend | 34 +++++++ .../validators/IsSoundingValidator.xtend | 34 +++++++ .../validators/IsTranslatedSoundToValidator.xtend | 39 ++++++++ .../validators/IsTranslatedToValidator.xtend | 48 +++++++++ .../validators/IsTranslatedViewToValidator.xtend | 39 ++++++++ .../validation/validators/IsTypeOfValidator.xtend | 33 +++++++ .../validation/validators/IsVisibleValidator.xtend | 34 +++++++ .../validators/LambdaExpressionValidator.xtend | 25 +++++ .../validators/LetStatementValidator.xtend | 35 +++++++ .../validators/LowerThanOperatorValidator.xtend | 40 ++++++++ .../validators/MaxOperatorValidator.xtend | 33 +++++++ .../validators/MinOperatorValidator.xtend | 33 +++++++ .../MuchGreaterThanOperatorValidator.xtend | 40 ++++++++ .../validators/MuteLowerPriorityValidator.xtend | 39 ++++++++ .../validators/NamedElementValidator.xtend | 60 ++++++++++++ .../validators/NotOperatorValidator.xtend | 34 +++++++ .../validators/ObjectCompareNotValidator.xtend | 15 +++ .../validators/ObjectCompareValidator.xtend | 71 ++++++++++++++ .../validation/validators/OffSceneValidator.xtend | 33 +++++++ .../validation/validators/OffsetValidator.xtend | 64 ++++++++++++ .../validation/validators/OnSceneValidator.xtend | 33 +++++++ .../validators/OrOperatorValidator.xtend | 35 +++++++ .../validators/OutputtingSoundValidator.xtend | 34 +++++++ .../validation/validators/PackageValidator.xtend | 31 ++++++ .../validators/PlusOperatorValidator.xtend | 47 +++++++++ .../validators/PositionContainerValidator.xtend | 74 ++++++++++++++ .../validation/validators/ProjectValidator.xtend | 34 +++++++ .../validation/validators/SceneValidator.xtend | 40 ++++++++ .../validators/SelectOperatorValidator.xtend | 33 +++++++ .../validators/SetOfOperatorValidator.xtend | 106 ++++++++++++++++++++ .../validators/SetPropertyValidator.xtend | 83 ++++++++++++++++ .../validators/SizeOperatorValidator.xtend | 37 +++++++ .../validation/validators/SizeValidator.xtend | 28 ++++++ .../validators/SoundContentSetValidator.xtend | 70 +++++++++++++ .../validators/SoundContentValidator.xtend | 86 ++++++++++++++++ .../validators/StateValueValidator.xtend | 28 ++++++ .../validators/ThatOfOperatorValidator.xtend | 69 +++++++++++++ .../validation/validators/ValidatorUtils.xtend | 109 +++++++++++++++++++++ .../validators/VerticalLayoutValidator.xtend | 25 +++++ .../validators/ViewContentSetValidator.xtend | 70 +++++++++++++ .../validators/ViewContentValidator.xtend | 91 +++++++++++++++++ .../validation/validators/ZoneSetValidator.xtend | 47 +++++++++ .../validation/validators/ZoneValidator.xtend | 69 +++++++++++++ 94 files changed, 4046 insertions(+) create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveContentsValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveStateValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatableSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatedContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AndOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AreaSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/AreaValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ComparisonAndOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/CompositeAreaValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ConstraintValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ContentSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ContentStateValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValueValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayingContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/EqualToOperatorValidatior.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ExistsOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/FixedPositionLayoutValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ForAllOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/GetAllocatablesValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/GetContentsListValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/GetPropertyValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/GreaterThanOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeEarlierThanValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeLaterThanValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/HideLowerPriorityValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/HorizontalLayoutValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IfStatementValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ImpliesOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IntegerPropertyValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsActiveValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsAllocatedToValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsAttenuatedValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsCanceledValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedDisplayValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedOutputValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisappearedValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisplayedOnValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsEqualToOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanEqualOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsHiddenValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanEqualOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsMutedValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsOnValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedOnValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsSoundingValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedSoundToValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedToValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedViewToValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsTypeOfValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/IsVisibleValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/LambdaExpressionValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/LetStatementValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/LowerThanOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/MaxOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/MinOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/MuchGreaterThanOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/MuteLowerPriorityValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/NamedElementValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/NotOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareNotValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/OffSceneValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/OffsetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/OnSceneValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/OrOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/OutputtingSoundValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/PackageValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/PlusOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/PositionContainerValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ProjectValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SceneValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SelectOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SetOfOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SetPropertyValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SizeOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SizeValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/StateValueValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ThatOfOperatorValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ValidatorUtils.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/VerticalLayoutValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneSetValidator.xtend create mode 100644 rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneValidator.xtend (limited to 'rba.tool.editor/src/rba/tool/editor/validation/validators') diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentOperatorValidator.xtend new file mode 100644 index 0000000..7ed88f3 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentOperatorValidator.xtend @@ -0,0 +1,7 @@ +package rba.tool.editor.validation.validators + +import rba.tool.editor.validation.AbstractRBAModelValidator + +abstract class AbstractContentOperatorValidator extends AbstractRBAModelValidator { + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentValidator.xtend new file mode 100644 index 0000000..3fc2a1a --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AbstractContentValidator.xtend @@ -0,0 +1,59 @@ +package rba.tool.editor.validation.validators + +import com.google.common.collect.Sets +import com.google.inject.Inject +import java.util.Set +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.CancelableDiagnostician +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AbstractContent +import rba.tool.editor.util.RBAModelEditorToolUtil +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.tool.editor.validation.ContentAllocatableListValidationHelper + +abstract class AbstractContentValidator extends AbstractRBAModelValidator { + + @Inject private ContentAllocatableListValidationHelper helper; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def public void checkCircularContainment(AbstractContent abstractContent) { + val context = getContext(); + val resource = abstractContent.eResource(); + if(resource === null) { + return; + } + + if(context !== null) { + var Object contextValue; + if(context.containsKey(resource)) { + contextValue = context.get(resource); + } + if(!(contextValue instanceof Set)) { + context.put(resource, Sets.newHashSet()); + } + if(RBAModelEditorToolUtil.isValidated((contextValue), this)) { + return; // resource was already validated + } + + (contextValue as Set).add(this); + docheckCrossReferenceEmpty(resource, context.get(CancelableDiagnostician.CANCEL_INDICATOR) as CancelIndicator); + return; + } + docheckCrossReferenceEmpty(resource, null); + } + + def public void docheckCrossReferenceEmpty(Resource resource, CancelIndicator cancelIndicator) { + helper.checkCrossReferenceEmpty(resource, cancelIndicator, this); + } + + override protected checkIsFromCurrentlyCheckedResource(EObject object) { + // do nothing + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveContentsValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveContentsValidator.xtend new file mode 100644 index 0000000..e250efa --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveContentsValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ActiveContents +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType + +class ActiveContentsValidator extends AbstractRBAModelValidator { + + private String OPERAND_SIZE_ONE = Messages.OPERAND_SIZE_ONE; + private String FIRST_OPERAND_MUST_ALLOCATABLE = Messages.FIRST_OPERAND_MUST_ALLOCATABLE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkActivateContent(ActiveContents op) { + if (op.operand.size != 1) { + error(String.format(OPERAND_SIZE_ONE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var firstOperand = op.operand.get(0) + if (firstOperand.type != ExpressionType::AREA && firstOperand.type != ExpressionType::ZONE) { + error(String.format(FIRST_OPERAND_MUST_ALLOCATABLE, op.symbol), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveStateValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveStateValidator.xtend new file mode 100644 index 0000000..4522163 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ActiveStateValidator.xtend @@ -0,0 +1,32 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType +import rba.core.ActiveState + +class ActiveStateValidator extends AbstractRBAModelValidator { + + private String OPERAND_SIZE_ONE = Messages.OPERAND_SIZE_ONE; + private String FIRST_OPERAND_MUST_CONTENT = Messages.FIRST_OPERAND_MUST_CONTENT; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkActiveState(ActiveState op) { + if (op.operand.size < 1) { + error(String.format(OPERAND_SIZE_ONE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if (operand.type != ExpressionType.CONTENT && operand.type != ExpressionType.SOUND) { + error(String.format(FIRST_OPERAND_MUST_CONTENT, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatableSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatableSetValidator.xtend new file mode 100644 index 0000000..d408d23 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatableSetValidator.xtend @@ -0,0 +1,59 @@ +package rba.tool.editor.validation.validators + +import com.google.common.collect.Sets +import com.google.inject.Inject +import java.util.Set +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.CancelableDiagnostician +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AllocatableSet +import rba.tool.editor.util.RBAModelEditorToolUtil +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.tool.editor.validation.CircularContainmentValidationHelper + +abstract class AllocatableSetValidator extends AbstractRBAModelValidator { + + @Inject private CircularContainmentValidationHelper helper; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def public void checkCircularContainment(AllocatableSet allocatableSet) { + val context = getContext(); + val resource = allocatableSet.eResource(); + if (resource === null) { + return; + } + + if (context !== null) { + var Object contextValue; + if (context.containsKey(resource)) { + contextValue = context.get(resource); + } + if (!(contextValue instanceof Set)) { + context.put(resource, Sets.newHashSet()); + } + if (RBAModelEditorToolUtil.isValidated((contextValue), this)) { + return; // resource was already validated + } + + (contextValue as Set).add(this); + doCheckCircularContainment(resource, context.get(CancelableDiagnostician.CANCEL_INDICATOR) as CancelIndicator); + return; + } + doCheckCircularContainment(resource, null); + } + + def public void doCheckCircularContainment(Resource resource, CancelIndicator cancelIndicator) { + helper.checkCircularContainment(resource, cancelIndicator, this); + } + + override protected checkIsFromCurrentlyCheckedResource(EObject object) { + // do nothing + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatedContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatedContentValidator.xtend new file mode 100644 index 0000000..5e07e8e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AllocatedContentValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AllocatedContent +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class AllocatedContentValidator extends AbstractRBAModelValidator { + + private String ALLOCATEDCONTENT_TYPE = Messages.ALLOCATEDCONTENT_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkAllocatedContent(AllocatedContent allocatedContent) { + for (operand : allocatedContent.operand) { + switch (operand.type) { + case ExpressionType.AREA, + case ExpressionType.SET_OF_AREA, + case ExpressionType.ZONE, + case ExpressionType.SET_OF_ZONE: { + return; + } + default: { + error(ALLOCATEDCONTENT_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AndOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AndOperatorValidator.xtend new file mode 100644 index 0000000..8bea0d5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AndOperatorValidator.xtend @@ -0,0 +1,35 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AndOperator +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class AndOperatorValidator extends AbstractRBAModelValidator { + + private String AND_OPERAND_SIZE = Messages.AND_OPERAND_SIZE; + + private String AND_OPERAND_TYPE = Messages.AND_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkAndOperator(AndOperator andOperator) { + if (andOperator.operand.size < 2) { + error(AND_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < andOperator.operand.size; i++) { + var operand = andOperator.operand.get(i) + if (operand.type != ExpressionType.BOOLEAN) { + error(AND_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaSetValidator.xtend new file mode 100644 index 0000000..b87dcb6 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaSetValidator.xtend @@ -0,0 +1,47 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import org.eclipse.xtext.validation.Check +import rba.core.AbstractAllocatable +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.view.Area +import rba.view.AreaSet + +class AreaSetValidator extends AllocatableSetValidator { + + private String AREASET_TARGET_SIZE = Messages.AREASET_TARGET_SIZE; + + private String AREASET_TARGET_INVALID_TYPE = Messages.AREASET_TARGET_INVALID_TYPE; + + private String AREASET_TARGET_INCLUDE_SELF = Messages.AREASET_TARGET_INCLUDE_SELF; + + private String AREASET_TARGET_DUPLICATE = Messages.AREASET_TARGET_DUPLICATE; + + @Check(NORMAL) + def checkContent(AreaSet areaSet) { + if (areaSet.target.size === 0) { + warning(String.format(AREASET_TARGET_SIZE, areaSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET); + } + + if (areaSet.target.contains(areaSet)) { + error(String.format(AREASET_TARGET_INCLUDE_SELF, areaSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, areaSet.target.indexOf(areaSet)); + return; + } + + var hash = new HashSet + for (var index = 0; index < areaSet.target.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = areaSet.target.get(index); + if (!(abstractAllocatable instanceof Area || abstractAllocatable instanceof AreaSet)) { + error(String.format(AREASET_TARGET_INVALID_TYPE, areaSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, index); + return; + } + if (hash.contains(abstractAllocatable)) { + error(String.format(AREASET_TARGET_DUPLICATE, areaSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, index); + return; + } else { + hash.add(abstractAllocatable) + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaValidator.xtend new file mode 100644 index 0000000..9df27ec --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/AreaValidator.xtend @@ -0,0 +1,74 @@ +package rba.tool.editor.validation.validators + +import java.util.function.Consumer +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.rbaEditorModel.CTag +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.Area +import rba.view.RBAViewPackage + +class AreaValidator extends AbstractRBAModelValidator { + + + private String AREA_VISIBILITY_TYPE = Messages.AREA_VISIBILITY_TYPE; + + private String AREA_ZORDER_TYPE = Messages.AREA_ZORDER_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + private Consumer errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkArea(Area area) { +// for (var index = 0; index < area.tags.size; index.operator_plusPlus()) { +// val Tag tag = area.tags.get(index); +// if (!tag.stereotype.targetModelName.equals(Area.simpleName)) { +// error(String.format(TARGET_MODEL_NAME_MISMATCH, Area.simpleName, tag.stereotype.targetModelName), RBACorePackage.Literals.TAG__STEREOTYPE); +// return; +// } +// } + } + + @Check(NORMAL) + def check0RequiredFields(Area area) { +// println(this.class.simpleName) + val tags = area.tags; + + if(tags.isNullOrEmpty || !tags.filter(CTag).isEmpty) { + if(!doRequiredFieldsCheck(area)) return; + } + } + + def protected doRequiredFieldsCheck(Area area) { + var passed = false; + passed = ValidatorUtils.mustHaveVisibility(area, errorToName) + if(!passed) { + return false; + } + if(area.visibility.type != ExpressionType.VALUE) { + error(String.format(AREA_VISIBILITY_TYPE, area.name), RBACorePackage.Literals.ALLOCATABLE__VISIBILITY); + return false; + } + passed = ValidatorUtils.mustHaveZorder(area, errorToName); + if(!passed) { + return false; + } + if(area.zorder.type != ExpressionType.VALUE) { + error(String.format(AREA_ZORDER_TYPE, area.name), RBAViewPackage.Literals.AREA__ZORDER); + return false; + } + passed = ValidatorUtils.mustHaveLeastOneSize(area, errorToName); + if(!passed) { + return false; + } + + return true; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ComparisonAndOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ComparisonAndOperatorValidator.xtend new file mode 100644 index 0000000..945ce88 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ComparisonAndOperatorValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ComparisonAnd +import rba.core.ComparisonOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ComparisonAndOperatorValidator extends AbstractRBAModelValidator { + + private String COMPARISONAND_OPERAND_SIZE = Messages.COMPARISONAND_OPERAND_SIZE; + + private String COMPARISONAND_OPERAND_TYPE = Messages.COMPARISONAND_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(FAST) + def checkComparisonOperatorFast(ComparisonAnd comparisonAnd) { + if (comparisonAnd.operand.size < 2) { + error(COMPARISONAND_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + + @Check(NORMAL) + def checkComparisonOperatorNormal(ComparisonAnd comparisonAnd) { + for (operand : comparisonAnd.operand) { + if (operand instanceof ComparisonOperator) { + } else { + error(COMPARISONAND_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/CompositeAreaValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/CompositeAreaValidator.xtend new file mode 100644 index 0000000..03a9d5b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/CompositeAreaValidator.xtend @@ -0,0 +1,26 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.CompositeArea +import rba.view.RBAViewPackage + +class CompositeAreaValidator extends AbstractRBAModelValidator { + + private String COMPOSITE_AREA_CHECK = Messages.COMPOSITE_AREA_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkCompositeArea(CompositeArea compositeArea) { + if (compositeArea.layout === null) { + error(String.format(COMPOSITE_AREA_CHECK, compositeArea.name), + RBAViewPackage.Literals.COMPOSITE_AREA__LAYOUT); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ConstraintValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ConstraintValidator.xtend new file mode 100644 index 0000000..1625897 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ConstraintValidator.xtend @@ -0,0 +1,27 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.Constraint +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ConstraintValidator extends AbstractRBAModelValidator { + + private String CONSTRAINT_EXPRESSION_TYPE = Messages.CONSTRAINT_EXPRESSION_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkConstraint(Constraint constraint) { + if (constraint.expression.type !== ExpressionType.BOOLEAN) { + error(CONSTRAINT_EXPRESSION_TYPE, RBACorePackage.Literals.ABSTRACT_CONSTRAINT__EXPRESSION); + return; + } + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentSetValidator.xtend new file mode 100644 index 0000000..701e445 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentSetValidator.xtend @@ -0,0 +1,59 @@ +package rba.tool.editor.validation.validators + +import com.google.common.collect.Sets +import com.google.inject.Inject +import java.util.Set +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.CancelableDiagnostician +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ContentSet +import rba.tool.editor.util.RBAModelEditorToolUtil +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.tool.editor.validation.CircularContainmentValidationHelper + +abstract class ContentSetValidator extends AbstractRBAModelValidator { + + @Inject private CircularContainmentValidationHelper helper; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def public void checkCircularContainment(ContentSet contentSet) { + val context = getContext(); + val resource = contentSet.eResource(); + if (resource === null) { + return; + } + + if (context !== null) { + var Object contextValue; + if (context.containsKey(resource)) { + contextValue = context.get(resource); + } + if (!(contextValue instanceof Set)) { + context.put(resource, Sets.newHashSet()); + } + if (RBAModelEditorToolUtil.isValidated((contextValue), this)) { + return; // resource was already validated + } + + (contextValue as Set).add(this); + doCheckCircularContainment(resource, context.get(CancelableDiagnostician.CANCEL_INDICATOR) as CancelIndicator); + return; + } + doCheckCircularContainment(resource, null); + } + + def public void doCheckCircularContainment(Resource resource, CancelIndicator cancelIndicator) { + helper.checkCircularContainment(resource, cancelIndicator, this); + } + + override protected checkIsFromCurrentlyCheckedResource(EObject object) { + // do nothing + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentStateValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentStateValidator.xtend new file mode 100644 index 0000000..2dd45a3 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentStateValidator.xtend @@ -0,0 +1,26 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ContentState +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ContentStateValidator extends AbstractRBAModelValidator { + + private String CONTENTSTATE_TYPE = Messages.CONTENTSTATE_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkContentState(ContentState contentState) { + if (contentState.value.type != ExpressionType.VALUE) { + error(String.format(CONTENTSTATE_TYPE, contentState.name), RBACorePackage.Literals.CONTENT_STATE__VALUE) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValidator.xtend new file mode 100644 index 0000000..885698e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValidator.xtend @@ -0,0 +1,20 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.Content + +class ContentValidator extends AbstractRBAModelValidator { + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkContent(Content content) { + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValueValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValueValidator.xtend new file mode 100644 index 0000000..fc97945 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ContentValueValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ContentValue +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ContentValueValidator extends AbstractRBAModelValidator { + + private String CONTENTVALUE_SIZE = Messages.CONTENTVALUE_SIZE; + + private String CONTENTVALUE_TYPE = Messages.CONTENTVALUE_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkContentValue(ContentValue contentValue) { + if (contentValue.operand.size > 1) { + error(CONTENTVALUE_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : contentValue.operand) { + if (operand.type != ExpressionType.AREA && operand.type != ExpressionType.ZONE) { + error(CONTENTVALUE_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayValidator.xtend new file mode 100644 index 0000000..5e7225d --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayValidator.xtend @@ -0,0 +1,91 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import java.util.Set +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.AlignedLayout +import rba.view.Area +import rba.view.CompositeArea +import rba.view.Display +import rba.view.FixedPositionLayout +import rba.view.PositionContainer +import rba.view.RBAViewPackage +import rba.view.Size +import rba.view.SizeIdentifier +import rba.view.SizeReference + +class DisplayValidator extends AbstractRBAModelValidator { + + private String DISPLAY_AREA_SIZE_CHECK = Messages.DISPLAY_AREA_SIZE_CHECK + + private String DISPLAY_ROOT_CHECK = Messages.DISPLAY_ROOT_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkDisplay(Display display) { + if (display.root === null) { + error(String.format(DISPLAY_ROOT_CHECK, display.name), RBAViewPackage.Literals.DISPLAY__ROOT); + return; + } + var size = display.size as SizeIdentifier + var displaySize = getSize(size); + var displayWidth = displaySize.width + var displayHeight = displaySize.height + + if (display.root !== null && display.root.eContainer !== null) { + var Set areaList = new HashSet + getAreas(display.root, areaList) + for (a : areaList) { + var area = a as Area + for (sizeIdentifier : area.size) { + var areaSize = getSize(sizeIdentifier) + var areaWidth = areaSize.width + var areaHeight = areaSize.height + + if (areaWidth > displayWidth || areaHeight > displayHeight) { + warning(String.format(DISPLAY_AREA_SIZE_CHECK, display.name), RBAViewPackage.Literals.DISPLAY__ROOT) + return; + } + } + } + } + } + + // get all areas from display + def void getAreas(CompositeArea compositeArea, Set areaList) { + if (compositeArea !== null) { + var layout = compositeArea.layout + if (layout instanceof AlignedLayout) { + var aliginedLayout = layout as AlignedLayout + for (subArea : aliginedLayout.subarea) { + areaList.addAll(subArea); + } + } else if (layout instanceof FixedPositionLayout) { + var fixedPositionLayout = layout as FixedPositionLayout + var positions = fixedPositionLayout.subAreaPosition + for (position : positions) { + if (position instanceof PositionContainer) { + var pos = position as PositionContainer + areaList.add(pos.area); + } + } + } + } + } + + // get Size from SizeIdentifier + def Size getSize(SizeIdentifier size) { + if (size instanceof Size) { + return size as Size + } else if (size instanceof SizeReference) { + var sizeRef = size as SizeReference + return sizeRef.size as Size + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayingContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayingContentValidator.xtend new file mode 100644 index 0000000..9b2cac6 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/DisplayingContentValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.DisplayingContent + +class DisplayingContentValidator extends AbstractRBAModelValidator { + + private String DISPLAYINGCONTENT_SIZE = Messages.DISPLAYINGCONTENT_SIZE; + + private String DISPLAYINGCONTENT_TYPE = Messages.DISPLAYINGCONTENT_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkDisplayingContent(DisplayingContent displayingContent) { + if (displayingContent.operand.size > 1) { + error(DISPLAYINGCONTENT_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : displayingContent.operand) { + if (operand.type != ExpressionType.AREA) { + error(DISPLAYINGCONTENT_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/EqualToOperatorValidatior.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/EqualToOperatorValidatior.xtend new file mode 100644 index 0000000..0786662 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/EqualToOperatorValidatior.xtend @@ -0,0 +1,42 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.EqualToOperator +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class EqualToOperatorValidatior extends AbstractRBAModelValidator { + + private String EQUALTO_OPERAND_SIZE_NULL = Messages.EQUALTO_OPERAND_SIZE_NULL; + + private String EQUALTO_OPERAND_SIZE = Messages.EQUALTO_OPERAND_SIZE; + + private String EQUALTO_OPERAND_TYPE = Messages.EQUALTO_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkEqualToOperator(EqualToOperator equalToOperator) { + + if (equalToOperator.operand.size == 0) { + error(EQUALTO_OPERAND_SIZE_NULL, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + if (equalToOperator.operand.size != 1) { + error(EQUALTO_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + for (operand : equalToOperator.operand) { + if (operand.type != ExpressionType.VALUE) { + error(EQUALTO_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ExistsOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ExistsOperatorValidator.xtend new file mode 100644 index 0000000..ea86433 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ExistsOperatorValidator.xtend @@ -0,0 +1,48 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExistsOperator +import rba.core.Expression +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.core.SetOfOperator +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ExistsOperatorValidator extends AbstractRBAModelValidator { + + private String EXISTS_OPERAND_SIZE = Messages.EXISTS_OPERAND_SIZE; + + private String EXISTS_OPERAND_TYPE = Messages.EXISTS_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkExistsOperator(ExistsOperator existsOperator) { + if (existsOperator.operand.size > 1) { + error(EXISTS_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand = existsOperator.operand.get(0) + if (operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && + operand.type != ExpressionType.SET_OF_ZONE && operand.type != ExpressionType.SET_OF_SOUND && + isInvalidSetOfOperator(operand)) { + error(EXISTS_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + + // check whether operator is SetOfOperator and operand type is not type of Area,Content,Zone,Sound or Animation + def isInvalidSetOfOperator(Expression operand) { + if (operand instanceof SetOfOperator) { + if (operand.type == ExpressionType.AREA || operand.type == ExpressionType.CONTENT || + operand.type == ExpressionType.ZONE || operand.type == ExpressionType.SOUND) { + return false + } + } + return true + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/FixedPositionLayoutValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/FixedPositionLayoutValidator.xtend new file mode 100644 index 0000000..718f135 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/FixedPositionLayoutValidator.xtend @@ -0,0 +1,25 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.FixedPositionLayout +import rba.view.RBAViewPackage + +class FixedPositionLayoutValidator extends AbstractRBAModelValidator { + + private String FIXEDPOSITION_LAYOUT_CHECK = Messages.FIXEDPOSITION_LAYOUT_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkFixedPositionLayout(FixedPositionLayout fixedPositionLayout) { + if (fixedPositionLayout.subAreaPosition.size == 0) { + error(FIXEDPOSITION_LAYOUT_CHECK, RBAViewPackage.Literals.FIXED_POSITION_LAYOUT__SUB_AREA_POSITION); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ForAllOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ForAllOperatorValidator.xtend new file mode 100644 index 0000000..2e05f33 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ForAllOperatorValidator.xtend @@ -0,0 +1,58 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.Expression +import rba.core.ExpressionType +import rba.core.ForAllOperator +import rba.core.RBACorePackage +import rba.core.SetOfOperator +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ForAllOperatorValidator extends AbstractRBAModelValidator { + + private String FORALL_OPERAND_SIZE = Messages.FORALL_OPERAND_SIZE; + + private String FORALL_OPERAND_TYPE = Messages.FORALL_OPERAND_TYPE; + + private String FORALL_LAMBDA_TYPE = Messages.FORALL_LAMBDA_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkForAllOperator(ForAllOperator forAllOperator) { + if (forAllOperator.operand.size > 1) { + error(FORALL_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand = forAllOperator.operand.get(0) + + if (operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && + operand.type != ExpressionType.SET_OF_SOUND && operand.type != ExpressionType.SET_OF_ZONE && + isInvalidSetOfOperator(operand)) { + error(FORALL_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + + var bodytext = forAllOperator.lambda.bodyText; + if (bodytext.type != ExpressionType.BOOLEAN) { + error(FORALL_LAMBDA_TYPE, RBACorePackage.Literals.LAMBDA_EXPRESSION__BODY_TEXT) + return; + } + + } + + //check whether operator is SetOfOperator and operand type is not type of Area,Content,Zone,Sound or Animation + def isInvalidSetOfOperator(Expression operand) { + if (operand instanceof SetOfOperator) { + if (operand.type == ExpressionType.AREA || operand.type == ExpressionType.CONTENT || + operand.type == ExpressionType.ZONE || operand.type == ExpressionType.SOUND) { + return false + } + } + return true + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/GetAllocatablesValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetAllocatablesValidator.xtend new file mode 100644 index 0000000..a31f2f8 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetAllocatablesValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.GetAllocatables +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class GetAllocatablesValidator extends AbstractRBAModelValidator { + + private String GETALLOCATABLES_SIZE = Messages.GETALLOCATABLES_SIZE; + + private String GETALLOCATABLES_TYPE = Messages.GETALLOCATABLES_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkGetAllocatable(GetAllocatables getAllocatable) { + if (getAllocatable.operand.size > 1) { + error(GETALLOCATABLES_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : getAllocatable.operand) { + if (operand.type != ExpressionType.CONTENT && operand.type != ExpressionType.SOUND) { + error(GETALLOCATABLES_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/GetContentsListValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetContentsListValidator.xtend new file mode 100644 index 0000000..9912496 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetContentsListValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.GetContentsList +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class GetContentsListValidator extends AbstractRBAModelValidator { + + private String GETCONTENTSLIST_SIZE = Messages.GETCONTENTSLIST_SIZE; + + private String GETCONTENTSLIST_TYPE = Messages.GETCONTENTSLIST_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkGetContentsList(GetContentsList getContentsList) { + if (getContentsList.operand.size > 1) { + error(GETCONTENTSLIST_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : getContentsList.operand) { + if (operand.type != ExpressionType.AREA && operand.type != ExpressionType.ZONE) { + error(GETCONTENTSLIST_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/GetPropertyValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetPropertyValidator.xtend new file mode 100644 index 0000000..e21fbd7 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/GetPropertyValidator.xtend @@ -0,0 +1,60 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.GetProperty +import rba.core.IntegerProperty +import rba.core.ObjectReference +import rba.core.RBACorePackage +import rba.core.Scene +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType + +class GetPropertyValidator extends AbstractRBAModelValidator { + + private String GETPROPERTY_OPERAND_SIZE_CHECK = Messages.GETPROPERTY_OPERAND_SIZE_CHECK; + + private String GETPROPERTY_OPERAND_TYPE_CHECK = Messages.GETPROPERTY_OPERAND_TYPE_CHECK; + + private String GETPROPERTY_OPERAND_ISGLOBALSCENE = Messages.GETPROPERTY_OPERAND_ISGLOBALSCENE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkGetProperty(GetProperty getProperty) { + if (getProperty.operand.size > 1) { + error(GETPROPERTY_OPERAND_SIZE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand = getProperty.operand.get(0) + if (operand.type != ExpressionType.PROPERTY) { + error(GETPROPERTY_OPERAND_TYPE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (operand instanceof ObjectReference) { + var parent = isParentScene(operand.refObject) + if (parent !== null) { + var scene = parent as Scene + if (!scene.global) { + error(GETPROPERTY_OPERAND_ISGLOBALSCENE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } else { + } + } + } + + def EObject isParentScene(EObject object) { + if (object instanceof Scene) { + return object as Scene; + } + if (object instanceof IntegerProperty) { + return isParentScene(object.owner) + } + return null; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/GreaterThanOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/GreaterThanOperatorValidator.xtend new file mode 100644 index 0000000..81adc96 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/GreaterThanOperatorValidator.xtend @@ -0,0 +1,40 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.GreaterThanOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class GreaterThanOperatorValidator extends AbstractRBAModelValidator { + + private String GREATERTHAN_OPERAND_SIZE_NULL = Messages.GREATERTHAN_OPERAND_SIZE_NULL; + + private String GREATERTHAN_OPERAND_SIZE = Messages.GREATERTHAN_OPERAND_SIZE; + + private String GREATERTHAN_OPERAND_TYPE = Messages.GREATERTHAN_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkGreaterThanOperator(GreaterThanOperator greaterThanOperator) { + if (greaterThanOperator.operand.size === 0) { + error(GREATERTHAN_OPERAND_SIZE_NULL, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + if (greaterThanOperator.operand.size != 1) { + error(GREATERTHAN_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + for (operand : greaterThanOperator.operand) { + if (operand.type != ExpressionType.VALUE) { + error(GREATERTHAN_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeEarlierThanValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeEarlierThanValidator.xtend new file mode 100644 index 0000000..16a8c34 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeEarlierThanValidator.xtend @@ -0,0 +1,51 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.HasComeEarlierThan +import rba.core.PreviousModifier +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class HasComeEarlierThanValidator extends AbstractRBAModelValidator { + + private static final String TargetOperatorName = HasComeEarlierThan.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkContentValue(HasComeEarlierThan hasComeEarlierThan) { + if (hasComeEarlierThan.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var firstOperand = hasComeEarlierThan.operand.get(0) + if (firstOperand.type != ExpressionType::CONTENT && firstOperand.type != ExpressionType::SOUND) { + error(String.format(Messages.FIRST_OPERAND_MUST_CONTENT, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var argument = hasComeEarlierThan.operand.get(1) + if (argument.type != ExpressionType::CONTENT && argument.type != ExpressionType::SOUND) { + error(String.format(Messages.ARGUMENT_MUST_CONTENT, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + if (firstOperand instanceof PreviousModifier) { + error(String.format(Messages.OPERAND_CANNOT_USE_PRE, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (argument instanceof PreviousModifier) { + error(String.format(Messages.ARGUMENT_CANNOT_USE_PRE, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeLaterThanValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeLaterThanValidator.xtend new file mode 100644 index 0000000..3d2d449 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/HasComeLaterThanValidator.xtend @@ -0,0 +1,51 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.HasComeLaterThan +import rba.core.PreviousModifier +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class HasComeLaterThanValidator extends AbstractRBAModelValidator { + + private static final String TargetOperatorName = HasComeLaterThan.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkContentValue(HasComeLaterThan hasComeLaterThan) { + if (hasComeLaterThan.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var firstOperand = hasComeLaterThan.operand.get(0) + if (firstOperand.type != ExpressionType::CONTENT && firstOperand.type != ExpressionType::SOUND) { + error(String.format(Messages.FIRST_OPERAND_MUST_CONTENT, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var argument = hasComeLaterThan.operand.get(1) + if (argument.type != ExpressionType::CONTENT && argument.type != ExpressionType::SOUND) { + error(String.format(Messages.ARGUMENT_MUST_CONTENT, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + if (firstOperand instanceof PreviousModifier) { + error(String.format(Messages.OPERAND_CANNOT_USE_PRE, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (argument instanceof PreviousModifier) { + error(String.format(Messages.ARGUMENT_CANNOT_USE_PRE, TargetOperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/HideLowerPriorityValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/HideLowerPriorityValidator.xtend new file mode 100644 index 0000000..294558c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/HideLowerPriorityValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.HideLowerPriority + +class HideLowerPriorityValidator extends AbstractRBAModelValidator { + private static final String OperatorName = HideLowerPriority.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkHideLowerPriority(HideLowerPriority hideLowerPriority) { + if (hideLowerPriority.operand.size != 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstArgument = hideLowerPriority.operand.get(0) + if (firstArgument.type != ExpressionType::AREA) { + error(String.format(Messages.ARGUMENT_MUST_AREA, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var secondArgument = hideLowerPriority.operand.get(1) + if (secondArgument.type != ExpressionType::AREA) { + error(String.format(Messages.ARGUMENT_MUST_AREA, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/HorizontalLayoutValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/HorizontalLayoutValidator.xtend new file mode 100644 index 0000000..e16e33b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/HorizontalLayoutValidator.xtend @@ -0,0 +1,25 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.HorizontalLayout +import rba.view.RBAViewPackage + +class HorizontalLayoutValidator extends AbstractRBAModelValidator { + + private String HORIZONTAL_LAYOUT_CHECK = Messages.HORIZONTAL_LAYOUT_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkHorizontalLayout(HorizontalLayout horizontalLayout) { + if (horizontalLayout.subarea.size == 0) { + warning(HORIZONTAL_LAYOUT_CHECK, RBAViewPackage.Literals.ALIGNED_LAYOUT__SUBAREA); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IfStatementValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IfStatementValidator.xtend new file mode 100644 index 0000000..2eefb6b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IfStatementValidator.xtend @@ -0,0 +1,44 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IfStatement +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +class IfStatementValidator extends AbstractRBAModelValidator { + + private String CONDITION_BOOLEAN_TYPE_CHECK = Messages.CONDITION_BOOLEAN_TYPE_CHECK; + + private String CONDITION_TPYE_EQUAL_CHECK = Messages.CONDITION_TPYE_EQUAL_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIfStatement(IfStatement ifStatement) { + if (ifStatement.condition.type !== ExpressionType.BOOLEAN) { + error(CONDITION_BOOLEAN_TYPE_CHECK, RBACorePackage.Literals.IF_STATEMENT__CONDITION); + return; + } + if (!isExpressionTypeEquals(ifStatement.thenExpression.type, ifStatement.elseExpression.type)) { + error(CONDITION_TPYE_EQUAL_CHECK, RBACorePackage.Literals.IF_STATEMENT__ELSE_EXPRESSION); + return; + } + } + + def boolean isExpressionTypeEquals(ExpressionType type1, ExpressionType type2) { + if (type1 === type2) { + return true; + } + return false + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ImpliesOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ImpliesOperatorValidator.xtend new file mode 100644 index 0000000..c625ce2 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ImpliesOperatorValidator.xtend @@ -0,0 +1,35 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.ImpliesOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ImpliesOperatorValidator extends AbstractRBAModelValidator { + + private String IMPLIES_OPERAND_SIZE = Messages.IMPLIES_OPERAND_SIZE; + + private String IMPLIES_OPERAND_TYPE = Messages.IMPLIES_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkImpliesOperator(ImpliesOperator impliesOperator) { + if (impliesOperator.operand.size < 2) { + error(IMPLIES_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < impliesOperator.operand.size; i++) { + var operand = impliesOperator.operand.get(i) + if (operand.type != ExpressionType.BOOLEAN) { + error(IMPLIES_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IntegerPropertyValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IntegerPropertyValidator.xtend new file mode 100644 index 0000000..4e3fbfd --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IntegerPropertyValidator.xtend @@ -0,0 +1,17 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.IntegerProperty +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IntegerPropertyValidator extends AbstractRBAModelValidator { + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkRequiredValue(IntegerProperty property) { + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsActiveValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsActiveValidator.xtend new file mode 100644 index 0000000..3d552d4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsActiveValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsActive +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsActiveValidator extends AbstractRBAModelValidator { + + private String ISACTIVE_SIZE = Messages.ISACTIVE_SIZE; + + private String ISACTIVE_TYPE = Messages.ISACTIVE_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsActive(IsActive isActive) { + if (isActive.operand.size > 1) { + error(ISACTIVE_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : isActive.operand) { + if (operand.type != ExpressionType.CONTENT && operand.type != ExpressionType.SOUND) { + error(ISACTIVE_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAllocatedToValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAllocatedToValidator.xtend new file mode 100644 index 0000000..e2d63cb --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAllocatedToValidator.xtend @@ -0,0 +1,48 @@ +package rba.tool.editor.validation.validators + +import rba.tool.editor.validation.AbstractRBAModelValidator +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.IsAllocatedTo +import rba.tool.editor.messages.Messages +import rba.core.RBACorePackage +import rba.core.ExpressionType +import org.eclipse.xtext.validation.Check + +class IsAllocatedToValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsAllocatedTo.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsAllocatedTo(IsAllocatedTo isAllocatedTo) { + if (isAllocatedTo.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isAllocatedTo.operand.get(0) + if (firstOperand.type != ExpressionType::CONTENT && firstOperand.type != ExpressionType::SOUND) { + error(String.format(Messages.FIRST_OPERAND_MUST_CONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isAllocatedTo.operand.get(1) + if (argument.type != ExpressionType::AREA && argument.type != ExpressionType::ZONE) { + error(String.format(Messages.ARGUMENT_MUST_ALLOCATABLE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + + if ((firstOperand.type == ExpressionType::CONTENT && argument.type == ExpressionType::ZONE) || + (firstOperand.type == ExpressionType::SOUND && argument.type == ExpressionType::AREA ) || + (argument.type == ExpressionType::ZONE ) || + (firstOperand.type == ExpressionType::SOUND )) { + error(String.format(Messages.COMBINATION_OPERAND_ARGUMENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAttenuatedValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAttenuatedValidator.xtend new file mode 100644 index 0000000..cbdd194 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsAttenuatedValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsAttenuated +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsAttenuatedValidator extends AbstractRBAModelValidator { + + private String ISATTENUATED_SIZE = Messages.ISATTENUATED_SIZE; + + private String ISATTENUATED_TYPE = Messages.ISATTENUATED_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(IsAttenuated isAttenuated) { + if (isAttenuated.operand.size > 1) { + error(ISATTENUATED_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + for (operand : isAttenuated.operand) { + if (operand.type != ExpressionType.ZONE) { + error(ISATTENUATED_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsCanceledValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsCanceledValidator.xtend new file mode 100644 index 0000000..daf29bf --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsCanceledValidator.xtend @@ -0,0 +1,37 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsCanceled +import rba.core.PreviousModifier +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages + +class IsCanceledValidator extends AbstractContentOperatorValidator { + private String ISCANCELED_OPERAND_SIZE = Messages.ISCANCELED_OPERAND_SIZE; + + private String ISCANCELED_OPERAND_0_TYPE = Messages.ISCANCELED_OPERAND_0_TYPE; + + private String ISCANCELED_OPERAND_0_CHECK = Messages.ISCANCELED_OPERAND_0_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsCanceledOperator(IsCanceled isCanceled) { + if (isCanceled.operand.size > 1) { + error(ISCANCELED_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (isCanceled.operand.get(0).type != ExpressionType.CONTENT && isCanceled.operand.get(0).type != ExpressionType.SOUND) { + error(ISCANCELED_OPERAND_0_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (isCanceled.operand.get(0) instanceof PreviousModifier) { + error(ISCANCELED_OPERAND_0_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedDisplayValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedDisplayValidator.xtend new file mode 100644 index 0000000..55bd12e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedDisplayValidator.xtend @@ -0,0 +1,32 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.IsChangedDisplay +import rba.core.ExpressionType + +class IsChangedDisplayValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsChangedDisplay.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsChangedDisplay(IsChangedDisplay isChangedDisplay) { + if (isChangedDisplay.operand.size > 1) { + error(String.format(Messages.OPERAND_SIZE_ONE, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isChangedDisplay.operand.get(0) + if (firstOperand.type != ExpressionType::AREA) { + error(String.format(Messages.FIRST_OPERAND_MUST_AREA, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedOutputValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedOutputValidator.xtend new file mode 100644 index 0000000..4186e33 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedOutputValidator.xtend @@ -0,0 +1,32 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsChangedOutput +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsChangedOutputValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsChangedOutput.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsChangedOutput(IsChangedOutput isChangedOutput) { + if (isChangedOutput.operand.size > 1) { + error(String.format(Messages.OPERAND_SIZE_ONE, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isChangedOutput.operand.get(0) + if (firstOperand.type != ExpressionType::ZONE) { + error(String.format(Messages.FIRST_OPERAND_MUST_ZONE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedValidator.xtend new file mode 100644 index 0000000..d807fcc --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsChangedValidator.xtend @@ -0,0 +1,31 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.IsChanged +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType + +class IsChangedValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsChanged.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsChanged(IsChanged isChanged) { + if (isChanged.operand.size > 1) { + error(String.format(Messages.OPERAND_SIZE_ONE, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + } + + var firstOperand = isChanged.operand.get(0) + if (firstOperand.type != ExpressionType::AREA && firstOperand.type != ExpressionType::ZONE) { + error(String.format(Messages.FIRST_OPERAND_MUST_ALLOCATABLE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisappearedValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisappearedValidator.xtend new file mode 100644 index 0000000..c303c04 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisappearedValidator.xtend @@ -0,0 +1,37 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsDisappeared +import rba.core.PreviousModifier +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages + +class IsDisappearedValidator extends AbstractContentOperatorValidator { + private String ISDISAPPEARED_OPERAND_SIZE = Messages.ISDISAPPEARED_OPERAND_SIZE; + + private String ISDISAPPEARED_OPERAND_0_TYPE = Messages.ISDISAPPEARED_OPERAND_0_TYPE; + + private String ISDISAPPEARED_OPERAND_0_CHECK = Messages.ISDISAPPEARED_OPERAND_0_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsDisappearedOperator(IsDisappeared isDisappeared) { + if (isDisappeared.operand.size > 1) { + error(ISDISAPPEARED_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (isDisappeared.operand.get(0).type != ExpressionType.CONTENT && isDisappeared.operand.get(0).type != ExpressionType.SOUND) { + error(ISDISAPPEARED_OPERAND_0_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (isDisappeared.operand.get(0) instanceof PreviousModifier) { + error(ISDISAPPEARED_OPERAND_0_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisplayedOnValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisplayedOnValidator.xtend new file mode 100644 index 0000000..fd46da8 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsDisplayedOnValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.IsDisplayedOn + +class IsDisplayedOnValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsDisplayedOn.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsDisplayedOn(IsDisplayedOn isDisplayedOn) { + if (isDisplayedOn.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isDisplayedOn.operand.get(0) + if (firstOperand.type != ExpressionType::CONTENT) { + error(String.format(Messages.FIRST_OPERAND_MUST_VIEWCONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isDisplayedOn.operand.get(1) + if (argument.type != ExpressionType::AREA) { + error(String.format(Messages.ARGUMENT_MUST_AREA, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsEqualToOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsEqualToOperatorValidator.xtend new file mode 100644 index 0000000..25549f3 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsEqualToOperatorValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsEqualToOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsEqualToOperatorValidator extends AbstractRBAModelValidator { + + private String ISEQUALTO_OPERAND_SIZE = Messages.ISEQUALTO_OPERAND_SIZE; + + private String ISEQUALTO_OPERAND_TYPE = Messages.ISEQUALTO_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsEqualToOperator(IsEqualToOperator isEqualToOperator) { + if (isEqualToOperator.operand.size < 2) { + error(ISEQUALTO_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < isEqualToOperator.operand.size; i++) { + var operand = isEqualToOperator.operand.get(i) + + if (operand.type != ExpressionType.VALUE) { + error(ISEQUALTO_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanEqualOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanEqualOperatorValidator.xtend new file mode 100644 index 0000000..52caef5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanEqualOperatorValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsGreaterThanEqualOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsGreaterThanEqualOperatorValidator extends AbstractRBAModelValidator { + + private String ISGREATERTHANEQUAL_OPERAND_SIZE = Messages.ISGREATERTHANEQUAL_OPERAND_SIZE; + + private String ISGREATERTHANEQUAL_OPERAND_TYPE = Messages.ISGREATERTHANEQUAL_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsGreaterThanEqualOperator(IsGreaterThanEqualOperator isGreaterThanEqualOperator) { + if (isGreaterThanEqualOperator.operand.size < 2) { + error(ISGREATERTHANEQUAL_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < isGreaterThanEqualOperator.operand.size; i++) { + var operand = isGreaterThanEqualOperator.operand.get(i) + + if (operand.type != ExpressionType.VALUE) { + error(ISGREATERTHANEQUAL_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanOperatorValidator.xtend new file mode 100644 index 0000000..e018fd0 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsGreaterThanOperatorValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsGreaterThanOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsGreaterThanOperatorValidator extends AbstractRBAModelValidator { + + private String ISGREATERTHAN_OPERAND_SIZE = Messages.ISGREATERTHAN_OPERAND_SIZE; + + private String ISGREATERTHAN_OPERAND_TYPE = Messages.ISGREATERTHAN_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsGreaterThanOperator(IsGreaterThanOperator isGreaterThanOperator) { + if (isGreaterThanOperator.operand.size < 2) { + error(ISGREATERTHAN_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < isGreaterThanOperator.operand.size; i++) { + var operand = isGreaterThanOperator.operand.get(i) + + if (operand.type != ExpressionType.VALUE) { + error(ISGREATERTHAN_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsHiddenValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsHiddenValidator.xtend new file mode 100644 index 0000000..979fee6 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsHiddenValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.IsHidden + +class IsHiddenValidator extends AbstractRBAModelValidator { + + private String ISHIDDEN_SIZE = Messages.ISHIDDEN_SIZE; + + private String ISHIDDEN_TYPE = Messages.ISHIDDEN_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(IsHidden IsHidden) { + if (IsHidden.operand.size > 1) { + error(ISHIDDEN_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : IsHidden.operand) { + if (operand.type != ExpressionType.AREA) { + error(ISHIDDEN_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanEqualOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanEqualOperatorValidator.xtend new file mode 100644 index 0000000..efd3de4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanEqualOperatorValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsLowerThanEqualOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsLowerThanEqualOperatorValidator extends AbstractRBAModelValidator { + + private String ISLOWERTHANEQUAL_OPERAND_SIZE = Messages.ISLOWERTHANEQUAL_OPERAND_SIZE; + + private String ISLOWERTHANEQUAL_OPERAND_TYPE = Messages.ISLOWERTHANEQUAL_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsLowerThanEqualOperator(IsLowerThanEqualOperator isLowerThanEqualOperator) { + if (isLowerThanEqualOperator.operand.size < 2) { + error(ISLOWERTHANEQUAL_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < isLowerThanEqualOperator.operand.size; i++) { + var operand = isLowerThanEqualOperator.operand.get(i) + + if (operand.type != ExpressionType.VALUE) { + error(ISLOWERTHANEQUAL_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanOperatorValidator.xtend new file mode 100644 index 0000000..af1b6f4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsLowerThanOperatorValidator.xtend @@ -0,0 +1,36 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsLowerThanOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsLowerThanOperatorValidator extends AbstractRBAModelValidator { + + private String ISLOWERTHAN_OPERAND_SIZE = Messages.ISLOWERTHAN_OPERAND_SIZE; + + private String ISLOWERTHAN_OPERAND_TYPE = Messages.ISLOWERTHAN_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsLowerThanOperator(IsLowerThanOperator isLowerThanOperator) { + if (isLowerThanOperator.operand.size < 2) { + error(ISLOWERTHAN_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < isLowerThanOperator.operand.size; i++) { + var operand = isLowerThanOperator.operand.get(i) + + if (operand.type != ExpressionType.VALUE) { + error(ISLOWERTHAN_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsMutedValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsMutedValidator.xtend new file mode 100644 index 0000000..d16b34d --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsMutedValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsMuted +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsMutedValidator extends AbstractRBAModelValidator { + + private String ISMUTED_SIZE = Messages.ISMUTED_SIZE; + + private String ISMUTED_TYPE = Messages.ISMUTED_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(IsMuted isMuted) { + if (isMuted.operand.size > 1) { + error(ISMUTED_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + for (operand : isMuted.operand) { + if (operand.type != ExpressionType.ZONE) { + error(ISMUTED_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOnValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOnValidator.xtend new file mode 100644 index 0000000..4959161 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOnValidator.xtend @@ -0,0 +1,32 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsOn +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsOnValidator extends AbstractRBAModelValidator { + + private String ISON_SIZE = Messages.ISON_SIZE; + + private String ISON_TYPE = Messages.ISON_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsOnOperator(IsOn isOn) { + if (isOn.operand.size > 1) { + error(ISON_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + if (isOn.operand.get(0).type != ExpressionType.SCENE) { + error(ISON_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedOnValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedOnValidator.xtend new file mode 100644 index 0000000..fd72494 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedOnValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsOutputtedOn +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsOutputtedOnValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsOutputtedOn.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsOutputtedOn(IsOutputtedOn isOutputtedOn) { + if (isOutputtedOn.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isOutputtedOn.operand.get(0) + if (firstOperand.type != ExpressionType::SOUND) { + error(String.format(Messages.FIRST_OPERAND_MUST_SOUNDCONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isOutputtedOn.operand.get(1) + if (argument.type != ExpressionType::ZONE) { + error(String.format(Messages.ARGUMENT_MUST_ZONE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedValidator.xtend new file mode 100644 index 0000000..fc43966 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsOutputtedValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsOutputted +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsOutputtedValidator extends AbstractRBAModelValidator { + + private String ISOUTPUTTED_SIZE = Messages.ISOUTPUTTED_SIZE; + + private String ISOUTPUTTED_TYPE = Messages.ISOUTPUTTED_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(IsOutputted isOutputted) { + if (isOutputted.operand.size > 1) { + error(ISOUTPUTTED_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + for (operand : isOutputted.operand) { + if (operand.type != ExpressionType.ZONE) { + error(ISOUTPUTTED_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsSoundingValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsSoundingValidator.xtend new file mode 100644 index 0000000..fe1fe4b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsSoundingValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsSounding +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsSoundingValidator extends AbstractRBAModelValidator { + + private String ISSOUNDING_SIZE = Messages.ISSOUNDING_SIZE; + + private String ISSOUNDING_TYPE = Messages.ISSOUNDING_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(IsSounding isSounding) { + if (isSounding.operand.size > 1) { + error(ISSOUNDING_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + for (operand : isSounding.operand) { + if (operand.type != ExpressionType.SOUND) { + error(ISSOUNDING_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedSoundToValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedSoundToValidator.xtend new file mode 100644 index 0000000..87e471a --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedSoundToValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.IsTranslatedSoundTo +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsTranslatedSoundToValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsTranslatedSoundTo.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsTranslatedSoundTo(IsTranslatedSoundTo isTranslatedSoundTo) { + if (isTranslatedSoundTo.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isTranslatedSoundTo.operand.get(0) + if (firstOperand.type != ExpressionType::ZONE) { + error(String.format(Messages.FIRST_OPERAND_MUST_ZONE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isTranslatedSoundTo.operand.get(1) + if (argument.type != ExpressionType::SOUND) { + error(String.format(Messages.ARGUMENT_MUST_SOUNDCONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedToValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedToValidator.xtend new file mode 100644 index 0000000..bd8cf33 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedToValidator.xtend @@ -0,0 +1,48 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IsTranslatedTo +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class IsTranslatedToValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsTranslatedTo.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsTranslatedTo(IsTranslatedTo isTranslatedTo) { + if (isTranslatedTo.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isTranslatedTo.operand.get(0) + if (firstOperand.type != ExpressionType::AREA && firstOperand.type != ExpressionType::ZONE) { + error(String.format(Messages.FIRST_OPERAND_MUST_ALLOCATABLE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isTranslatedTo.operand.get(1) + if (argument.type != ExpressionType::CONTENT && argument.type != ExpressionType::SOUND) { + error(String.format(Messages.ARGUMENT_MUST_CONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + + if ((firstOperand.type == ExpressionType::AREA && argument.type == ExpressionType::SOUND) || + (firstOperand.type == ExpressionType::ZONE && argument.type == ExpressionType::CONTENT ) || + (firstOperand.type == ExpressionType::ZONE ) || + (argument.type == ExpressionType::SOUND )) { + error(String.format(Messages.COMBINATION_OPERAND_ARGUMENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedViewToValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedViewToValidator.xtend new file mode 100644 index 0000000..c010644 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTranslatedViewToValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.IsTranslatedViewTo +import rba.core.ExpressionType + +class IsTranslatedViewToValidator extends AbstractRBAModelValidator { + private static final String OperatorName = IsTranslatedViewTo.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsTranslatedViewTo(IsTranslatedViewTo isTranslatedViewTo) { + if (isTranslatedViewTo.operand.size < 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstOperand = isTranslatedViewTo.operand.get(0) + if (firstOperand.type != ExpressionType::AREA) { + error(String.format(Messages.FIRST_OPERAND_MUST_AREA, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var argument = isTranslatedViewTo.operand.get(1) + if (argument.type != ExpressionType::CONTENT) { + error(String.format(Messages.ARGUMENT_MUST_VIEWCONTENT, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTypeOfValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTypeOfValidator.xtend new file mode 100644 index 0000000..c765268 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsTypeOfValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.IsTypeOf +import rba.core.ExpressionType + +class IsTypeOfValidator extends AbstractRBAModelValidator { + + private String OPERAND_SIZE_TWO = Messages.OPERAND_SIZE_TWO; + private String FIRST_OPERAND_MUST_FOR_ISTYPEOF = Messages.FIRST_OPERAND_MUST_FOR_ISTYPEOF; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsTypeOf(IsTypeOf op) { + if (op.operand.size < 1) { + error(String.format(OPERAND_SIZE_TWO, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if (operand.type != ExpressionType.CONTENT && operand.type != ExpressionType.AREA && operand.type != ExpressionType.SOUND && + operand.type != ExpressionType.ZONE) { + error(String.format(FIRST_OPERAND_MUST_FOR_ISTYPEOF, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/IsVisibleValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsVisibleValidator.xtend new file mode 100644 index 0000000..5d44d34 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/IsVisibleValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.IsVisible + +class IsVisibleValidator extends AbstractRBAModelValidator { + + private String ISVISIBLE_SIZE = Messages.ISVISIBLE_SIZE; + + private String ISVISIBLE_TYPE = Messages.ISVISIBLE_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsVisible(IsVisible isVisible) { + if (isVisible.operand.size > 1) { + error(ISVISIBLE_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : isVisible.operand) { + if (operand.type != ExpressionType.CONTENT) { + error(ISVISIBLE_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/LambdaExpressionValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/LambdaExpressionValidator.xtend new file mode 100644 index 0000000..6daad3e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/LambdaExpressionValidator.xtend @@ -0,0 +1,25 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.LambdaExpression +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class LambdaExpressionValidator extends AbstractRBAModelValidator { + + private String LAMBDAEXPRESSION_TYPE = Messages.LAMBDAEXPRESSION_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkLambdaExpression(LambdaExpression lambdaExpression) { + if (lambdaExpression.x.expressionType != lambdaExpression.context.contextType) { + error(LAMBDAEXPRESSION_TYPE, RBACorePackage.Literals.LAMBDA_EXPRESSION__CONTEXT) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/LetStatementValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/LetStatementValidator.xtend new file mode 100644 index 0000000..83102a7 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/LetStatementValidator.xtend @@ -0,0 +1,35 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.LetStatement + +class LetStatementValidator extends AbstractRBAModelValidator { + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(LetStatement op) { + if (op.body.type != ExpressionType::VALUE && + op.body.type != ExpressionType::BOOLEAN && + op.body.type != ExpressionType::AREA && + op.body.type != ExpressionType::CONTENT && + op.body.type != ExpressionType::SET_OF_AREA && + op.body.type != ExpressionType::SET_OF_CONTENT && + op.body.type != ExpressionType::SCENE && + op.body.type != ExpressionType::ZONE && + op.body.type != ExpressionType::SET_OF_ZONE && + op.body.type != ExpressionType::SOUND && + op.body.type != ExpressionType::SET_OF_SOUND && + op.body.type != ExpressionType::CONTENT_STATE) { + error(String.format(Messages.BODY_MUST_OBJECT, "let"), RBACorePackage.Literals.LET_STATEMENT__BODY) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/LowerThanOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/LowerThanOperatorValidator.xtend new file mode 100644 index 0000000..1fde1f0 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/LowerThanOperatorValidator.xtend @@ -0,0 +1,40 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.LowerThanOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class LowerThanOperatorValidator extends AbstractRBAModelValidator { + + private String LOWERTHAN_OPERAND_SIZE_NULL = Messages.LOWERTHAN_OPERAND_SIZE_NULL; + + private String LOWERTHAN_OPERAND_SIZE = Messages.LOWERTHAN_OPERAND_SIZE; + + private String LOWERTHAN_OPERAND_TYPE = Messages.LOWERTHAN_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkLowerThanOperator(LowerThanOperator lowerThanOperator) { + if (lowerThanOperator.operand.size == 0) { + error(LOWERTHAN_OPERAND_SIZE_NULL, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (lowerThanOperator.operand.size != 1) { + error(LOWERTHAN_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : lowerThanOperator.operand) { + if (operand.type != ExpressionType.VALUE) { + error(LOWERTHAN_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/MaxOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/MaxOperatorValidator.xtend new file mode 100644 index 0000000..4927d71 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/MaxOperatorValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType +import rba.core.MaxOperator + +class MaxOperatorValidator extends AbstractRBAModelValidator { + + private String MAX_OP_OPERAND_SIZE = Messages.MAX_OP_OPERAND_SIZE; + private String MAX_OP_OPERAND_TYPE = Messages.MAX_OP_OPERAND_SIZE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkMaxOperator(MaxOperator op) { + if (op.operand.size == 0) { + error(String.format(MAX_OP_OPERAND_SIZE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if (operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && operand.type != ExpressionType.SET_OF_SOUND && + operand.type != ExpressionType.SET_OF_ZONE) { + error(String.format(MAX_OP_OPERAND_TYPE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/MinOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/MinOperatorValidator.xtend new file mode 100644 index 0000000..81417fb --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/MinOperatorValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType +import rba.core.MinOperator + +class MinOperatorValidator extends AbstractRBAModelValidator { + + private String MIN_OP_OPERAND_SIZE = Messages.MIN_OP_OPERAND_SIZE; + private String MIN_OP_OPERAND_TYPE = Messages.MIN_OP_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkMinOperator(MinOperator op) { + if (op.operand.size == 0) { + error(String.format(MIN_OP_OPERAND_SIZE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if (operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && operand.type != ExpressionType.SET_OF_SOUND && + operand.type != ExpressionType.SET_OF_ZONE) { + error(String.format(MIN_OP_OPERAND_TYPE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/MuchGreaterThanOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/MuchGreaterThanOperatorValidator.xtend new file mode 100644 index 0000000..13de568 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/MuchGreaterThanOperatorValidator.xtend @@ -0,0 +1,40 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.MuchGreaterThanOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class MuchGreaterThanOperatorValidator extends AbstractRBAModelValidator { + + private String MUCHGREATERTHAN_OPERAND_SIZE_NULL = Messages.MUCHGREATERTHAN_OPERAND_SIZE_NULL; + + private String MUCHGREATERTHAN_OPERAND_SIZE = Messages.MUCHGREATERTHAN_OPERAND_SIZE; + + private String MUCHGREATERTHAN_OPERAND_TYPE = Messages.MUCHGREATERTHAN_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkMuchGreaterThanOperator(MuchGreaterThanOperator muchGreaterThanOperator) { + if (muchGreaterThanOperator.operand.size == 0) { + error(MUCHGREATERTHAN_OPERAND_SIZE_NULL, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (muchGreaterThanOperator.operand.size != 1) { + error(MUCHGREATERTHAN_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : muchGreaterThanOperator.operand) { + if (operand.type != ExpressionType.VALUE) { + error(MUCHGREATERTHAN_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/MuteLowerPriorityValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/MuteLowerPriorityValidator.xtend new file mode 100644 index 0000000..fe4dc34 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/MuteLowerPriorityValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.MuteLowerPriority +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class MuteLowerPriorityValidator extends AbstractRBAModelValidator { + private static final String OperatorName = MuteLowerPriority.simpleName + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkMuteLowerPriority(MuteLowerPriority muteLowerPriority) { + if (muteLowerPriority.operand.size != 2) { + error(String.format(Messages.OPERAND_SIZE_TWO, OperatorName), RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var firstArgument = muteLowerPriority.operand.get(0) + if (firstArgument.type != ExpressionType::ZONE) { + error(String.format(Messages.ARGUMENT_MUST_ZONE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 0) + return; + } + + var secondArgument = muteLowerPriority.operand.get(1) + if (secondArgument.type != ExpressionType::ZONE) { + error(String.format(Messages.ARGUMENT_MUST_ZONE, OperatorName), + RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/NamedElementValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/NamedElementValidator.xtend new file mode 100644 index 0000000..19b0e8e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/NamedElementValidator.xtend @@ -0,0 +1,60 @@ +package rba.tool.editor.validation.validators + +import com.google.common.collect.Sets +import com.google.inject.Inject +import java.util.Set +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.CancelableDiagnostician +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.NamedElement +import rba.tool.editor.util.RBAModelEditorToolUtil +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.tool.editor.validation.UniqueNameValidationHelper + +class NamedElementValidator extends AbstractRBAModelValidator { + + @Inject private UniqueNameValidationHelper helper; + + override register(EValidatorRegistrar registrar) { + // library validator is not registered for a specific language + } + + @Check(NORMAL) + def public void checkUniqueNamesInResourceOf(NamedElement namedElement) { + val context = getContext(); + val resource = namedElement.eResource(); + if (resource === null) { + return; + } + + if (context !== null) { + var Object contextValue; + if (context.containsKey(resource)) { + contextValue = context.get(resource); + } + if (!(contextValue instanceof Set)) { + context.put(resource, Sets.newHashSet()); + } + if (RBAModelEditorToolUtil.isValidated((contextValue), this)) { + return; // resource was already validated + } + + (contextValue as Set).add(this); + doCheckUniqueNames(resource, context.get(CancelableDiagnostician.CANCEL_INDICATOR) as CancelIndicator); + return; + } + doCheckUniqueNames(resource, null); + } + + def public void doCheckUniqueNames(Resource resource, CancelIndicator cancelIndicator) { + helper.checkUniqueNames(resource, cancelIndicator, this); + } + + override protected checkIsFromCurrentlyCheckedResource(EObject object) { + // do nothing + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/NotOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/NotOperatorValidator.xtend new file mode 100644 index 0000000..1881a22 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/NotOperatorValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.NotOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class NotOperatorValidator extends AbstractRBAModelValidator { + + private String NOT_OPERAND_SIZE = Messages.NOT_OPERAND_SIZE; + + private String NOT_OPERAND_TYPE = Messages.NOT_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkNotOperator(NotOperator notOperator) { + if (notOperator.operand.size > 1) { + error(NOT_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (operand : notOperator.operand) { + if (operand.type != ExpressionType.BOOLEAN) { + error(NOT_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareNotValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareNotValidator.xtend new file mode 100644 index 0000000..7700e3a --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareNotValidator.xtend @@ -0,0 +1,15 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import rba.core.ObjectCompareNot + +class ObjectCompareNotValidator extends ObjectCompareValidator { + def override protected getOperatorName() { + return ObjectCompareNot.simpleName; + } + + @Check(NORMAL) + def check(ObjectCompareNot operator) { + doCheck(operator.operand); + } +} \ No newline at end of file diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareValidator.xtend new file mode 100644 index 0000000..ba897e1 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ObjectCompareValidator.xtend @@ -0,0 +1,71 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.ObjectCompare +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import static rba.tool.editor.validation.validators.ValidatorUtils.*; +import rba.core.Expression +import java.util.List + +class ObjectCompareValidator extends AbstractRBAModelValidator { + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + def protected getOperatorName() { + return ObjectCompare.simpleName; + } + + @Check(NORMAL) + def checkObjectCompare(ObjectCompare objectCompare) { + doCheck(objectCompare.operand); + } + + /** Check points. + * * operand size is 2. + * * type of operands are AREA/CONTENT/ZONE/SOUND. + */ + def protected doCheck(List operands) { + if (!operandSizeMustBeTwo(operands, getOperatorName, [ msg | error(msg, RBACorePackage.Literals.OPERATOR__OPERAND, 0)])) { + return; + } + + val first = operands.get(0) + switch (first.type) { + case ExpressionType.VALUE: { + val message = String.format(Messages.FIRST_OPERAND_MUST_BE_OBJECT, getOperatorName); + error(message, RBACorePackage.Literals.OPERATOR__OPERAND, 0, null) + return; + } + case AREA, + case CONTENT, + case CONTENT_STATE, + case ZONE, + case SOUND: { + } + default: { + val message = String.format(Messages.OPERANDS_MUST_BE_OBJECT, getOperatorName); + error(message, RBACorePackage.Literals.OPERATOR__OPERAND, 0, null) + return; + } + } + + for (var i = 1; i < operands.size; i++) { + var operand = operands.get(i) + if (operand.type !== first.type && ObjectsMustBeAreaOrContent(operand.type, first.type)) { + val message = String.format(Messages.OPERANDS_MUST_BE_OBJECT, getOperatorName); + error(message, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } + + def private boolean ObjectsMustBeAreaOrContent(ExpressionType type1, ExpressionType type2) { + return true + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/OffSceneValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/OffSceneValidator.xtend new file mode 100644 index 0000000..f6ecce1 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/OffSceneValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.OffScene +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class OffSceneValidator extends AbstractRBAModelValidator { + + private String OFFSCENE_OPERAND_SIZE_CHECK = Messages.OFFSCENE_OPERAND_SIZE_CHECK; + + private String OFFSCENE_OPERAND_TYPE_CHECK = Messages.OFFSCENE_OPERAND_TYPE_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkOffScene(OffScene offScene) { + if (offScene.operand.size > 1) { + error(OFFSCENE_OPERAND_SIZE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand = offScene.operand.get(0) + if (operand.type != ExpressionType.SCENE) { + error(OFFSCENE_OPERAND_TYPE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/OffsetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/OffsetValidator.xtend new file mode 100644 index 0000000..57ea7b4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/OffsetValidator.xtend @@ -0,0 +1,64 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.Area +import rba.view.Offset +import rba.view.PositionContainer +import rba.view.RBAViewPackage +import rba.view.SizeIdentifier +import rba.view.SizeReference + +class OffsetValidator extends AbstractRBAModelValidator { + + private String OFFSET_SIZE_DUPLICATE = Messages.OFFSET_SIZE_DUPLICATE; + + private String OFFSET_SIZE_AREA_REF = Messages.OFFSET_SIZE_AREA_REF; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkOffset(Offset offset) { + var parent = offset.eContainer as PositionContainer + for (Offset target : parent.offset) { + if (target != offset) { + if (target.size.size == offset.size.size) { + warning(OFFSET_SIZE_DUPLICATE, RBAViewPackage.Literals.OFFSET__SIZE); + return; + } + } + } + + if (!hasSameSizeInArea(parent, offset)) { + warning(OFFSET_SIZE_AREA_REF, RBAViewPackage.Literals.OFFSET__SIZE); + return; + } + } + + def hasSameSizeInArea(PositionContainer parent, Offset offset) { + var chk = false; + + if (!(parent.area instanceof Area)) { + return false + } + + var area = parent.area as Area + for (SizeIdentifier sizeId : area.size) { + if (sizeId instanceof SizeReference) { + var sizeRef = sizeId as SizeReference + if (sizeRef.size == offset.size.size) { + chk = true + } + } + } + if (chk == true) { + return true; + } + + return false; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/OnSceneValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/OnSceneValidator.xtend new file mode 100644 index 0000000..d2b3792 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/OnSceneValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.OnScene +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class OnSceneValidator extends AbstractRBAModelValidator { + + private String ONSCENE_OPERAND_SIZE_CHECK = Messages.ONSCENE_OPERAND_SIZE_CHECK; + + private String ONSCENE_OPERAND_TYPE_CHECK = Messages.ONSCENE_OPERAND_TYPE_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkOnScene(OnScene onScene) { + if (onScene.operand.size > 1) { + error(ONSCENE_OPERAND_SIZE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand = onScene.operand.get(0) + if (operand.type != ExpressionType.SCENE) { + error(ONSCENE_OPERAND_TYPE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/OrOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/OrOperatorValidator.xtend new file mode 100644 index 0000000..3afcd05 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/OrOperatorValidator.xtend @@ -0,0 +1,35 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.OrOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class OrOperatorValidator extends AbstractRBAModelValidator { + + private String OR_OPERAND_SIZE = Messages.OR_OPERAND_SIZE; + + private String OR_OPERAND_TYPE = Messages.OR_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkOrOperator(OrOperator orOperator) { + if (orOperator.operand.size < 2) { + error(OR_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + for (var i = 0; i < orOperator.operand.size; i++) { + var operand = orOperator.operand.get(i) + if (operand.type != ExpressionType.BOOLEAN) { + error(OR_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/OutputtingSoundValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/OutputtingSoundValidator.xtend new file mode 100644 index 0000000..7a5f7fa --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/OutputtingSoundValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.RBACorePackage +import rba.sound.OutputtingSound +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class OutputtingSoundValidator extends AbstractRBAModelValidator { + + private String OUTPUTTINGSOUND_SIZE = Messages.OUTPUTTINGSOUND_SIZE; + + private String OUTPUTTINGSOUND_TYPE = Messages.OUTPUTTINGSOUND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsHidden(OutputtingSound outputtingSound) { + if (outputtingSound.operand.size > 1) { + error(OUTPUTTINGSOUND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + for (operand : outputtingSound.operand) { + if (operand.type != ExpressionType.ZONE) { + error(OUTPUTTINGSOUND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/PackageValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/PackageValidator.xtend new file mode 100644 index 0000000..39f2084 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/PackageValidator.xtend @@ -0,0 +1,31 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.Package +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.Project + +class PackageValidator extends AbstractRBAModelValidator { + + private String PACKAGE_CHILD_EXISTENCE_CHECK = Messages.PACKAGE_CHILD_EXISTENCE_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkPackage(Package pack) { + if(pack instanceof Project) + { + return; + } + if (pack.packagableelement.size == 0) { + warning(String.format(PACKAGE_CHILD_EXISTENCE_CHECK, pack.name), + RBACorePackage.Literals.PACKAGE__PACKAGABLEELEMENT); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/PlusOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/PlusOperatorValidator.xtend new file mode 100644 index 0000000..b98e8f5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/PlusOperatorValidator.xtend @@ -0,0 +1,47 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ComparisonOperator +import rba.core.ExpressionType +import rba.core.PlusOperator +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class PlusOperatorValidator extends AbstractRBAModelValidator { + + private String PLUS_OPERAND_SIZE = Messages.PLUS_OPERAND_SIZE; + + private String PLUS_OPERAND_TYPE = Messages.PLUS_OPERAND_TYPE; + + private String PLUS_OPERAND_TYPE_NOT_OPERATOR = Messages.PLUS_OPERAND_TYPE_NOT_OPERATOR; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(FAST) + def checkPlusOperatorFast(PlusOperator plusOperator) { + if (plusOperator.operand.size < 2) { + error(PLUS_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + + @Check(NORMAL) + def checkPlusOperatorNormal(PlusOperator plusOperator) { + for (var i = 0; i < plusOperator.operand.size; i++) { + var operand = plusOperator.operand.get(i) + if (operand instanceof ComparisonOperator) { + error(PLUS_OPERAND_TYPE_NOT_OPERATOR, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + + if (operand.type != ExpressionType.VALUE) { + error(PLUS_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND, i, null) + return; + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/PositionContainerValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/PositionContainerValidator.xtend new file mode 100644 index 0000000..da27f6c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/PositionContainerValidator.xtend @@ -0,0 +1,74 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import java.util.Set +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.Area +import rba.view.Display +import rba.view.PositionContainer +import rba.view.RBAViewPackage +import rba.view.Size +import rba.view.SizeIdentifier +import rba.view.SizeReference +import rba.view.impl.DisplayImpl + +class PositionContainerValidator extends AbstractRBAModelValidator { + + private String POSITION_CONTAINER_COORDINATE_CHECK = Messages.POSITION_CONTAINER_COORDINATE_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkPositionContainer(PositionContainer positionContainer) { + var display = getDisplay(positionContainer) + var displaySizeIden = display.size as SizeIdentifier + var displaySize = getSize(displaySizeIden) + var displayWidth = displaySize.width + var displayHeight = displaySize.height + + var Set areaList = new HashSet + if (positionContainer.area !== null) { + areaList.add(positionContainer.area); + } + for (Area area : areaList) { + for (sizeIdentifier : area.size) { + var areaSize = getSize(sizeIdentifier) + var areaWidth = areaSize.width + var areaHeight = areaSize.height + + // warning displays total of position container start point and size exceeds display's size + if (positionContainer.x + areaWidth > displayWidth || positionContainer.y + areaHeight > displayHeight) { + warning(POSITION_CONTAINER_COORDINATE_CHECK, RBAViewPackage.Literals.POSITION_CONTAINER__X) + return; + } + } + + } + } + +//get Display from position container + def Display getDisplay(PositionContainer positionContainer) { + var parent = positionContainer.eContainer + while (parent !== null) { + if (parent instanceof DisplayImpl) { + return parent as Display; + } + parent = parent.eContainer + } + } + + // get Size from SizeIdentifier + def Size getSize(SizeIdentifier size) { + if (size instanceof Size) { + return size as Size + } else if (size instanceof SizeReference) { + var sizeRef = size as SizeReference + return sizeRef.size as Size + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ProjectValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ProjectValidator.xtend new file mode 100644 index 0000000..ffe51f6 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ProjectValidator.xtend @@ -0,0 +1,34 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.core.Project + +class ProjectValidator extends AbstractContentValidator { + + public static String PROJECT_SIZE_CHECK = Messages.PROJECT_SIZE_CHECK; + public static String PROJECT_NAME_CHECK = Messages.PROJECT_NAME_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkProject(Project project) { + + val allProjects =project.eResource.resourceSet.resources.map(r|r.allContents.toIterable.filter(Project)).flatten; + val definedPrjCnts = allProjects.size; + if(definedPrjCnts != 1) { + error(PROJECT_SIZE_CHECK, RBACorePackage.Literals.NAMED_ELEMENT__NAME); + } + + if(project.getDummyName != null){ + error(PROJECT_NAME_CHECK, RBACorePackage.Literals.NAMED_ELEMENT__NAME); + } + + return true; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SceneValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SceneValidator.xtend new file mode 100644 index 0000000..f6646e5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SceneValidator.xtend @@ -0,0 +1,40 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.core.Scene +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class SceneValidator extends AbstractRBAModelValidator { + + private String SCENE_GLOBAL = Messages.SCENE_GLOBAL; + private String SCENE_PROPERTY_NEGATIVE = Messages.SCENE_PROPERTY_NEGATIVE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkSceneProperty(Scene scene) { + + if (scene.properties.size > 0 && scene.global == false) { + error(SCENE_GLOBAL, RBACorePackage.Literals.SCENE__PROPERTIES); + return; + } + val properties = scene.properties + for (var int i = 0; i < properties.size; i++) { + var property = properties.get(i) + if (property instanceof rba.core.impl.IntegerPropertyImpl) { + var value = property.getValue() + if (value instanceof rba.core.impl.IntegerValueImpl) { + if (value.getValue() < 0) { + error(SCENE_PROPERTY_NEGATIVE, RBACorePackage.Literals.SCENE__PROPERTIES, i); + return; + } + } + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SelectOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SelectOperatorValidator.xtend new file mode 100644 index 0000000..8bd676e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SelectOperatorValidator.xtend @@ -0,0 +1,33 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.SelectOperator +import rba.core.ExpressionType + +class SelectOperatorValidator extends AbstractRBAModelValidator { + + private String SELECT_OPERAND_SIZE = Messages.SELECT_OPERAND_SIZE; + private String SELECT_OPERAND_TYPE = Messages.SELECT_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkSelectOperator(SelectOperator op) { + if (op.operand.size == 0) { + error(String.format(SELECT_OPERAND_SIZE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if (operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && operand.type != ExpressionType.SET_OF_SOUND && + operand.type != ExpressionType.SET_OF_ZONE) { + error(String.format(SELECT_OPERAND_TYPE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SetOfOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SetOfOperatorValidator.xtend new file mode 100644 index 0000000..4cede2c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SetOfOperatorValidator.xtend @@ -0,0 +1,106 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.ObjectReference +import rba.core.RBACorePackage +import rba.core.RuleObject +import rba.core.SetOfOperator +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.PreviousModifier + +class SetOfOperatorValidator extends AbstractRBAModelValidator { + + private String SET_OF_OPERAND_TYPE = Messages.SET_OF_OPERAND_TYPE; + + private String SET_OF_OPERAND_DUPLICATE = Messages.SET_OF_OPERAND_DUPLICATE; + + private String OPERANDS_CANNOT_USE_PRE = Messages.OPERANDS_CANNOT_USE_PRE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsEqualToOperator(SetOfOperator setOfOperator) { + val notNullOp = setOfOperator.operand.filter(o|o.type != ExpressionType.NULL) + if (notNullOp.size == 0) { + return; + } + val firstType = notNullOp.get(0).type + + var hash = new HashSet + for (operand : setOfOperator.operand) { + + if (operand instanceof PreviousModifier) { + error(String.format(OPERANDS_CANNOT_USE_PRE, "SetOf"), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + + var opType = operand.type + + switch (firstType) { + case ExpressionType.AREA, + case ExpressionType.SET_OF_AREA: { + if (!(opType === ExpressionType.AREA || opType === ExpressionType.SET_OF_AREA || opType === ExpressionType.NULL) + ) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + case ExpressionType.CONTENT, + case ExpressionType.SET_OF_CONTENT: { + if (!(opType === ExpressionType.CONTENT || opType === ExpressionType.SET_OF_CONTENT + || opType === ExpressionType.NULL + )) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + case ExpressionType.ZONE, + case ExpressionType.SET_OF_ZONE: { + if (!(opType === ExpressionType.ZONE || opType === ExpressionType.SET_OF_ZONE)) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + case ExpressionType.SOUND, + case ExpressionType.SET_OF_SOUND: { + if (!(opType === ExpressionType.SOUND || opType === ExpressionType.SET_OF_SOUND)) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + case ExpressionType.SCENE: { + if (!(opType === ExpressionType.SCENE)) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + case ExpressionType.PROPERTY: { + if (!(opType === ExpressionType.PROPERTY)) { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + default: { + error(SET_OF_OPERAND_TYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + + if (operand instanceof ObjectReference) { + var refObj = (operand as ObjectReference).refObject + if (hash.contains(refObj)) { + error(SET_OF_OPERAND_DUPLICATE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } else { + hash.add(refObj) + } + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SetPropertyValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SetPropertyValidator.xtend new file mode 100644 index 0000000..15abc53 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SetPropertyValidator.xtend @@ -0,0 +1,83 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.ExpressionType +import rba.core.IntegerProperty +import rba.core.ObjectReference +import rba.core.RBACorePackage +import rba.core.Scene +import rba.core.SetProperty +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.IntegerValue +import org.eclipse.xtext.EcoreUtil2 +import rba.core.PreviousModifier + +class SetPropertyValidator extends AbstractRBAModelValidator { + + private String SETPROPERTY_OPERAND_SIZE_CHECK = Messages.SETPROPERTY_OPERAND_SIZE_CHECK; + + private String SETPROPERTY_OPERAND_0_TYPE_CHECK = Messages.SETPROPERTY_OPERAND_0_TYPE_CHECK; + + private String SETPROPERTY_OPERAND_ISGLOBALSCENE = Messages.SETPROPERTY_OPERAND_ISGLOBALSCENE; + + private String SETPROPERTY_OPERAND_1_TYPE_CHECK = Messages.SETPROPERTY_OPERAND_1_TYPE_CHECK; + + private String SETPROPERTY_PROPERTY_NEGATIVE = Messages.SETPROPERTY_PROPERTY_NEGATIVE + + private String OPERAND_CANNOT_USE_PRE = Messages.OPERAND_CANNOT_USE_PRE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkSetProperty(SetProperty setProperty) { + if (setProperty.operand.size < 2) { + error(SETPROPERTY_OPERAND_SIZE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + var operand0 = setProperty.operand.get(0) + if (operand0.type != ExpressionType.PROPERTY) { + error(SETPROPERTY_OPERAND_0_TYPE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (operand0 instanceof PreviousModifier || EcoreUtil2.getAllContentsOfType(operand0, PreviousModifier).size != 0) { + error(String.format(OPERAND_CANNOT_USE_PRE, setProperty.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (operand0 instanceof ObjectReference) { + var parent = isParentScene(operand0.refObject) + if (parent !== null) { + var scene = parent as Scene + if (!scene.global) { + error(SETPROPERTY_OPERAND_ISGLOBALSCENE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } + var operand1 = setProperty.operand.get(1) + if (!(operand1 instanceof IntegerValue)) { + error(SETPROPERTY_OPERAND_1_TYPE_CHECK, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + if (operand1 instanceof IntegerValue) { + if(operand1.getValue() < 0) { + error(SETPROPERTY_PROPERTY_NEGATIVE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + } + + def EObject isParentScene(EObject object) { + if (object instanceof Scene) { + return object as Scene; + } + if (object instanceof IntegerProperty) { + return isParentScene(object.owner) + } + return null; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeOperatorValidator.xtend new file mode 100644 index 0000000..c1c1f6c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeOperatorValidator.xtend @@ -0,0 +1,37 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.core.ExpressionType +import rba.core.IfStatement +import org.eclipse.xtext.EcoreUtil2 +import rba.core.SizeOperator + +class SizeOperatorValidator extends AbstractRBAModelValidator { + + private String OPERAND_SIZE_ONE = Messages.OPERAND_SIZE_ONE; + private String SIZE_OPERAND_TYPE = Messages.SIZE_OPERAND_TYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkSizeOperator(SizeOperator op) { + if (op.operand.size > 1) { + error(OPERAND_SIZE_ONE, RBACorePackage.Literals.OPERATOR__OPERAND, 1) + return; + } + var operand = op.operand.get(0) + if ((operand instanceof IfStatement) || + (EcoreUtil2.getAllContentsOfType(operand, IfStatement).size != 0) || + operand.type != ExpressionType.SET_OF_CONTENT && operand.type != ExpressionType.SET_OF_AREA && operand.type != ExpressionType.SET_OF_SOUND && + operand.type != ExpressionType.SET_OF_ZONE) { + error(String.format(SIZE_OPERAND_TYPE, op.symbol), RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeValidator.xtend new file mode 100644 index 0000000..203c086 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SizeValidator.xtend @@ -0,0 +1,28 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.RBAViewPackage + +class SizeValidator extends AbstractRBAModelValidator { + + private String SIZE_NEGATIVE = Messages.SIZE_NEGATIVE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkSize(rba.view.Size size) { + if (size.getWidth() < 0) { + error(SIZE_NEGATIVE, RBAViewPackage.Literals.SIZE__WIDTH); + return; + } + if (size.getHeight() < 0) { + error(SIZE_NEGATIVE, RBAViewPackage.Literals.SIZE__HEIGHT); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentSetValidator.xtend new file mode 100644 index 0000000..b12cd3c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentSetValidator.xtend @@ -0,0 +1,70 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import org.eclipse.xtext.validation.Check +import rba.core.AbstractAllocatable +import rba.core.AbstractContent +import rba.core.RBACorePackage +import rba.sound.SoundContent +import rba.sound.SoundContentSet +import rba.sound.Zone +import rba.sound.ZoneSet +import rba.tool.editor.messages.Messages + +class SoundContentSetValidator extends ContentSetValidator { + + private String SOUNDCONTENTSET_TARGET_SIZE = Messages.SOUNDCONTENTSET_TARGET_SIZE; + + private String SOUNDCONTENTSET_TARGET_INVALID_TYPE = Messages.SOUNDCONTENTSET_TARGET_INVALID_TYPE; + + private String SOUNDCONTENTSET_TARGET_INCLUDE_SELF = Messages.SOUNDCONTENTSET_TARGET_INCLUDE_SELF; + + private String SOUNDCONTENTSET_TARGET_DUPLICATE = Messages.SOUNDCONTENTSET_TARGET_DUPLICATE; + + private String SOUNDCONTENTSET_ALLOCATABLE_INVALID_TYPE = Messages.SOUNDCONTENTSET_ALLOCATABLE_INVALID_TYPE; + + private String SOUNDCONTENTSET_ALLOCATABLE_DUPLICATE = Messages.SOUNDCONTENTSET_ALLOCATABLE_DUPLICATE; + + @Check(NORMAL) + def checkContent(SoundContentSet soundContentSet) { + if (soundContentSet.target.size === 0) { + warning(String.format(SOUNDCONTENTSET_TARGET_SIZE, soundContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET); + } + + if (soundContentSet.target.contains(soundContentSet)) { + error(String.format(SOUNDCONTENTSET_TARGET_INCLUDE_SELF, soundContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, + soundContentSet.target.indexOf(soundContentSet)); + return; + } + + var hash = new HashSet + for (var index = 0; index < soundContentSet.target.size; index.operator_plusPlus()) { + val AbstractContent abstractContent = soundContentSet.target.get(index); + if (!(abstractContent instanceof SoundContent || abstractContent instanceof SoundContentSet)) { + error(String.format(SOUNDCONTENTSET_TARGET_INVALID_TYPE, soundContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, index); + return; + } + if (hash.contains(abstractContent)) { + error(String.format(SOUNDCONTENTSET_TARGET_DUPLICATE, soundContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, index); + return; + } else { + hash.add(abstractContent) + } + } + + var allocatableSet = new HashSet + for (var index = 0; index < soundContentSet.allocatable.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = soundContentSet.allocatable.get(index); + if (!(abstractAllocatable instanceof Zone || abstractAllocatable instanceof ZoneSet)) { + error(String.format(SOUNDCONTENTSET_ALLOCATABLE_INVALID_TYPE, soundContentSet.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } + if (allocatableSet.contains(abstractAllocatable)) { + error(String.format(SOUNDCONTENTSET_ALLOCATABLE_DUPLICATE, soundContentSet.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } else { + allocatableSet.add(abstractAllocatable) + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentValidator.xtend new file mode 100644 index 0000000..68f5d35 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/SoundContentValidator.xtend @@ -0,0 +1,86 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import java.util.function.Consumer +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AbstractAllocatable +import rba.core.RBACorePackage +import rba.sound.SoundContent +import rba.sound.Zone +import rba.sound.ZoneSet +import rba.tool.editor.messages.Messages +import rba.tool.editor.rbaEditorModel.CTag +import rba.sound.RBASoundPackage + +class SoundContentValidator extends AbstractContentValidator { + + private String SOUND_ALLOCATABLE_INVALID_TYPE = Messages.SOUND_ALLOCATABLE_INVALID_TYPE; + + private String SOUND_ALLOCATABLE_DUPLICATE = Messages.SOUND_ALLOCATABLE_DUPLICATE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + private Consumer errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkSOUND(SoundContent soundContent) { + var hash = new HashSet + for (var index = 0; index < soundContent.allocatable.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = soundContent.allocatable.get(index); + if(!(abstractAllocatable instanceof Zone || abstractAllocatable instanceof ZoneSet)) { + error(String.format(SOUND_ALLOCATABLE_INVALID_TYPE, soundContent.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } + if(hash.contains(abstractAllocatable)) { + error(String.format(SOUND_ALLOCATABLE_DUPLICATE, soundContent.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } else { + hash.add(abstractAllocatable) + } + } + +// for (var index = 0; index < soundContent.tags.size; index.operator_plusPlus()) { +// val Tag tag = soundContent.tags.get(index); +// if (!tag.stereotype.targetModelName.equals(SoundContent.simpleName)) { +// error(String.format(TARGET_MODEL_NAME_MISMATCH, SoundContent.simpleName, tag.stereotype.targetModelName), RBACorePackage.Literals.TAG__STEREOTYPE); +// return; +// } +// } + } + + @Check(NORMAL) + def check0RequiredFields(SoundContent soundContent) { +// println(this.class.simpleName) + val tags = soundContent.tags; + + if(tags.isNullOrEmpty || !tags.filter(CTag).isEmpty) { + if(!doRequiredFieldsCheck(soundContent)) return; + } + } + + def protected doRequiredFieldsCheck(SoundContent soundContent) { + var passed = false; + passed = ValidatorUtils.mustHaveLeastOneState(soundContent, errorToName); + if(!passed) { + return false; + } + passed = false; + for (var index = 0; index < soundContent.contentGroup.size; index.operator_plusPlus()) { + if(!soundContent.contentGroup.get(index).allocatable.empty) { + passed = true + } + } + if(!passed) { + passed = ValidatorUtils.mustHaveLeastOneAllocatable(soundContent, errorToName); + if(!passed) { + return false; + } + } + + return true; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/StateValueValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/StateValueValidator.xtend new file mode 100644 index 0000000..598f1c9 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/StateValueValidator.xtend @@ -0,0 +1,28 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.core.StateValue +import rba.tool.editor.validation.AbstractRBAModelValidator + +import static rba.tool.editor.validation.validators.ValidatorUtils.* + +class StateValueValidator extends AbstractRBAModelValidator { + + private static final String TargetOperatorName = StateValue.simpleName; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkIsActive(StateValue operator) { + val passed = operandSizeMustBeOne(operator.operand, TargetOperatorName, [ msg | error(msg, RBACorePackage.Literals.OPERATOR__OPERAND, 0)]) + if (!passed) { + return; + } + val firstOperand = operator.operand.get(0); + firstOperandMustBeContent(firstOperand, TargetOperatorName, [ msg | error(msg, RBACorePackage.Literals.OPERATOR__OPERAND, 0)]); + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ThatOfOperatorValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ThatOfOperatorValidator.xtend new file mode 100644 index 0000000..e6092c4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ThatOfOperatorValidator.xtend @@ -0,0 +1,69 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.Allocatable +import rba.core.ContentState +import rba.core.ExpressionType +import rba.core.ObjectReference +import rba.core.RBACorePackage +import rba.core.ThatOfOperator +import rba.core.impl.OperatorImpl +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ThatOfOperatorValidator extends AbstractRBAModelValidator { + + private String THATOF_OPERAND_SIZE = Messages.THATOF_OPERAND_SIZE; + + private String THATOF_OPERAND_OBJECTREFERENCE = Messages.THATOF_OPERAND_OBJECTREFERENCE; + + private String THATOF_OPERAND_OBJECTREFERENCE_EQUAL = Messages.THATOF_OPERAND_OBJECTREFERENCE_EQUAL; + + private String THATOF_OPERAND_EXPRESSIONTYPE = Messages.THATOF_OPERAND_EXPRESSIONTYPE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkThatOfOperator(ThatOfOperator thatOfOperator) { + if (thatOfOperator.operand.size != 1) { + error(THATOF_OPERAND_SIZE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + for (operand : thatOfOperator.operand) { + if (operand.type != ExpressionType.AREA && operand.type != ExpressionType.CONTENT_STATE && operand.type != ExpressionType.ZONE) { + error(THATOF_OPERAND_EXPRESSIONTYPE, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } + var thatOfoperand = thatOfOperator.operand.get(0) + if (thatOfoperand instanceof ObjectReference) { + var objRef = thatOfoperand as ObjectReference + if (objRef.refObject.name !== null) { + var parent = getParent(thatOfOperator) + if ((parent instanceof ContentState && objRef.refObject instanceof ContentState) || (parent instanceof Allocatable && objRef.refObject instanceof Allocatable)) { + } else { + error(THATOF_OPERAND_OBJECTREFERENCE_EQUAL, RBACorePackage.Literals.OPERATOR__OPERAND) + return; + } + } else { + error(THATOF_OPERAND_OBJECTREFERENCE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + } else { + error(THATOF_OPERAND_OBJECTREFERENCE, RBACorePackage.Literals.OPERATOR__OPERAND); + return; + } + } + + def EObject getParent(ThatOfOperator thatOfOperator) { + var parent = thatOfOperator.eContainer + while (parent instanceof OperatorImpl) { + parent = parent.eContainer + } + return parent; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ValidatorUtils.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ValidatorUtils.xtend new file mode 100644 index 0000000..2416be7 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ValidatorUtils.xtend @@ -0,0 +1,109 @@ +package rba.tool.editor.validation.validators + +import java.util.List +import java.util.function.Consumer +import rba.core.Expression +import rba.core.ExpressionType +import rba.tool.editor.messages.Messages +import rba.core.Allocatable +import rba.core.RBACorePackage +import rba.core.Content +import rba.view.RBAViewPackage +import rba.view.Area +import rba.view.ViewContent + + +class ValidatorUtils { + + def public static boolean isContent(Expression operand) { + return (operand.type != ExpressionType.CONTENT && operand.type != ExpressionType.SOUND); + } + def private static String getModelType(Object obj) { + return obj.class.simpleName.replaceAll("Impl", ""); + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveVisibility(Allocatable model, Consumer handling) { + if (!model.eIsSet(RBACorePackage.eINSTANCE.allocatable_Visibility)) { + handling.accept(String.format(Messages.VISIBILITY_IS_REQUIRED, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveZorder(Area model, Consumer handling) { + if (!model.eIsSet(RBAViewPackage.eINSTANCE.area_Zorder)) { + handling.accept(String.format(Messages.ZORDER_IS_REQUIRED, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveLeastOneSize(Area model, Consumer handling) { + if (model.size.empty) { + handling.accept(String.format(Messages.HAS_AT_LEAST_ONE_SIZE, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveLeastOneSize(ViewContent model, Consumer handling) { + if (model.size.empty) { + handling.accept(String.format(Messages.HAS_AT_LEAST_ONE_SIZE, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveLeastOneState(Content model, Consumer handling) { + if (model.states.empty) { + handling.accept(String.format(Messages.HAS_AT_LEAST_ONE_STATE, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean mustHaveLeastOneAllocatable(Content model, Consumer handling) { + if (model.allocatable.empty) { + handling.accept(String.format(Messages.ALLOCATABLE_SIZE, getModelType(model), model.name)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean operandSizeMustBeOne(List operands, String operatorName, + Consumer handling) { + if (operands.size != 1) { + handling.accept(String.format(Messages.OPERAND_SIZE_ONE, operatorName)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Find an error. */ + def public static boolean operandSizeMustBeTwo(List operands, String operatorName, + Consumer handling) { + if (operands.size != 2) { + handling.accept(String.format(Messages.OPERAND_SIZE_TWO, operatorName)); + return false; + } + return true; + } + + /** @return true: Check passed. false: Error occurs. */ + def public static boolean firstOperandMustBeContent(Expression firstOperand, String operatorName, + Consumer handling) { + if (isContent(firstOperand)) { + handling.accept(String.format(Messages.FIRST_OPERAND_MUST_CONTENT, operatorName)); + return false; + } + return true; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/VerticalLayoutValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/VerticalLayoutValidator.xtend new file mode 100644 index 0000000..47efaf2 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/VerticalLayoutValidator.xtend @@ -0,0 +1,25 @@ +package rba.tool.editor.validation.validators + +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.tool.editor.messages.Messages +import rba.tool.editor.validation.AbstractRBAModelValidator +import rba.view.RBAViewPackage +import rba.view.VerticalLayout + +class VerticalLayoutValidator extends AbstractRBAModelValidator { + + private String VERTICAL_LAYOUT_CHECK = Messages.VERTICAL_LAYOUT_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + @Check(NORMAL) + def checkVerticalLayout(VerticalLayout verticalLayout) { + if (verticalLayout.subarea.size == 0) { + warning(VERTICAL_LAYOUT_CHECK, RBAViewPackage.Literals.ALIGNED_LAYOUT__SUBAREA); + return; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentSetValidator.xtend new file mode 100644 index 0000000..6130d75 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentSetValidator.xtend @@ -0,0 +1,70 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import org.eclipse.xtext.validation.Check +import rba.core.AbstractAllocatable +import rba.core.AbstractContent +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.view.Area +import rba.view.AreaSet +import rba.view.ViewContent +import rba.view.ViewContentSet + +class ViewContentSetValidator extends ContentSetValidator { + + private String VIEWCONTENTSET_TARGET_SIZE = Messages.VIEWCONTENTSET_TARGET_SIZE; + + private String VIEWCONTENTSET_TARGET_INVALID_TYPE = Messages.VIEWCONTENTSET_TARGET_INVALID_TYPE; + + private String VIEWCONTENTSET_TARGET_INCLUDE_SELF = Messages.VIEWCONTENTSET_TARGET_INCLUDE_SELF; + + private String VIEWCONTENTSET_TARGET_DUPLICATE = Messages.VIEWCONTENTSET_TARGET_DUPLICATE; + + private String VIEWCONTENTSET_ALLOCATABLE_INVALID_TYPE = Messages.VIEWCONTENTSET_ALLOCATABLE_INVALID_TYPE; + + private String VIEWCONTENTSET_ALLOCATABLE_DUPLICATE = Messages.VIEWCONTENTSET_ALLOCATABLE_DUPLICATE; + + @Check(NORMAL) + def checkContent(ViewContentSet viewContentSet) { + if (viewContentSet.target.size === 0) { + warning(String.format(VIEWCONTENTSET_TARGET_SIZE, viewContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET); + } + + if (viewContentSet.target.contains(viewContentSet)) { + error(String.format(VIEWCONTENTSET_TARGET_INCLUDE_SELF, viewContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, viewContentSet.target.indexOf( + viewContentSet)); + return; + } + + var hash = new HashSet + for (var index = 0; index < viewContentSet.target.size; index.operator_plusPlus()) { + val AbstractContent abstractContent = viewContentSet.target.get(index); + if (!(abstractContent instanceof ViewContent || abstractContent instanceof ViewContentSet)) { + error(String.format(VIEWCONTENTSET_TARGET_INVALID_TYPE, viewContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, index); + return; + } + if (hash.contains(abstractContent)) { + error(String.format(VIEWCONTENTSET_TARGET_DUPLICATE, viewContentSet.name), RBACorePackage.Literals.CONTENT_SET__TARGET, index); + return; + } else { + hash.add(abstractContent) + } + } + + var allocatableSet = new HashSet + for (var index = 0; index < viewContentSet.allocatable.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = viewContentSet.allocatable.get(index); + if (!(abstractAllocatable instanceof Area || abstractAllocatable instanceof AreaSet)) { + error(String.format(VIEWCONTENTSET_ALLOCATABLE_INVALID_TYPE, viewContentSet.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } + if (allocatableSet.contains(abstractAllocatable)) { + error(String.format(VIEWCONTENTSET_ALLOCATABLE_DUPLICATE, viewContentSet.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } else { + allocatableSet.add(abstractAllocatable) + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentValidator.xtend new file mode 100644 index 0000000..ae4dde2 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ViewContentValidator.xtend @@ -0,0 +1,91 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import java.util.function.Consumer +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.AbstractAllocatable +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.rbaEditorModel.CTag +import rba.view.Area +import rba.view.AreaSet +import rba.view.ViewContent + +class ViewContentValidator extends AbstractContentValidator { + + private String CONTENT_ALLOCATABLE_INVALID_TYPE = Messages.CONTENT_ALLOCATABLE_INVALID_TYPE; + + private String CONTENT_ALLOCATABLE_DUPLICATE = Messages.CONTENT_ALLOCATABLE_DUPLICATE; + + public static String CONTENT_DISPLAY_SIZE_CHECK = Messages.CONTENT_DISPLAY_SIZE_CHECK; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + private Consumer errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkContent(ViewContent viewContent) { + var hash = new HashSet + for (var index = 0; index < viewContent.allocatable.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = viewContent.allocatable.get(index); + if(!(abstractAllocatable instanceof Area || abstractAllocatable instanceof AreaSet)) { + error(String.format(CONTENT_ALLOCATABLE_INVALID_TYPE, viewContent.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } + if(hash.contains(abstractAllocatable)) { + error(String.format(CONTENT_ALLOCATABLE_DUPLICATE, viewContent.name), RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE, index); + return; + } else { + hash.add(abstractAllocatable) + } + } + +// for (var index = 0; index < viewContent.tags.size; index.operator_plusPlus()) { +// val Tag tag = viewContent.tags.get(index); +// if (!tag.stereotype.targetModelName.equals(ViewContent.simpleName)) { +// error(String.format(TARGET_MODEL_NAME_MISMATCH, ViewContent.simpleName, tag.stereotype.targetModelName), RBACorePackage.Literals.TAG__STEREOTYPE); +// return; +// } +// } + } + + @Check(NORMAL) + def check0RequiredFields(ViewContent viewContent) { +// println(this.class.simpleName) + val tags = viewContent.tags; + + if(tags.isNullOrEmpty || !tags.filter(CTag).isEmpty) { + if(!doRequiredFieldsCheck(viewContent)) return; + } + } + + def protected doRequiredFieldsCheck(ViewContent viewContent) { + var passed = false; + passed = ValidatorUtils.mustHaveLeastOneState(viewContent, errorToName); + if(!passed) { + return false; + } + passed = ValidatorUtils.mustHaveLeastOneSize(viewContent, errorToName); + if(!passed) { + return false; + } + passed = false; + for (var index = 0; index < viewContent.contentGroup.size; index.operator_plusPlus()) { + if(!viewContent.contentGroup.get(index).allocatable.empty) { + passed = true + } + } + if(!passed) { + passed = ValidatorUtils.mustHaveLeastOneAllocatable(viewContent, errorToName); + if(!passed) { + return false; + } + } + + return true; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneSetValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneSetValidator.xtend new file mode 100644 index 0000000..0e0ce9f --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneSetValidator.xtend @@ -0,0 +1,47 @@ +package rba.tool.editor.validation.validators + +import java.util.HashSet +import org.eclipse.xtext.validation.Check +import rba.core.AbstractAllocatable +import rba.core.RBACorePackage +import rba.sound.Zone +import rba.sound.ZoneSet +import rba.tool.editor.messages.Messages + +class ZoneSetValidator extends AllocatableSetValidator { + + private String ZONESET_TARGET_SIZE = Messages.ZONESET_TARGET_SIZE; + + private String ZONESET_TARGET_INVALID_TYPE = Messages.ZONESET_TARGET_INVALID_TYPE; + + private String ZONESET_TARGET_INCLUDE_SELF = Messages.ZONESET_TARGET_INCLUDE_SELF; + + private String ZONESET_TARGET_DUPLICATE = Messages.ZONESET_TARGET_DUPLICATE; + + @Check(NORMAL) + def checkContent(ZoneSet zoneSet) { + if (zoneSet.target.size === 0) { + warning(String.format(ZONESET_TARGET_SIZE, zoneSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET); + } + + if (zoneSet.target.contains(zoneSet)) { + error(String.format(ZONESET_TARGET_INCLUDE_SELF, zoneSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, zoneSet.target.indexOf(zoneSet)); + return; + } + + var hash = new HashSet + for (var index = 0; index < zoneSet.target.size; index.operator_plusPlus()) { + val AbstractAllocatable abstractAllocatable = zoneSet.target.get(index); + if (!(abstractAllocatable instanceof Zone || abstractAllocatable instanceof ZoneSet)) { + error(String.format(ZONESET_TARGET_INVALID_TYPE, zoneSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, index); + return; + } + if (hash.contains(abstractAllocatable)) { + error(String.format(ZONESET_TARGET_DUPLICATE, zoneSet.name), RBACorePackage.Literals.ALLOCATABLE_SET__TARGET, index); + return; + } else { + hash.add(abstractAllocatable) + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneValidator.xtend new file mode 100644 index 0000000..36a0f80 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/validators/ZoneValidator.xtend @@ -0,0 +1,69 @@ +package rba.tool.editor.validation.validators + +import java.util.function.Consumer +import org.eclipse.xtext.validation.Check +import org.eclipse.xtext.validation.EValidatorRegistrar +import rba.core.RBACorePackage +import rba.sound.RBASoundPackage +import rba.sound.Zone +import rba.tool.editor.messages.Messages +import rba.tool.editor.rbaEditorModel.CTag +import rba.tool.editor.validation.AbstractRBAModelValidator + +class ZoneValidator extends AbstractRBAModelValidator { + private String TARGET_MODEL_NAME_MISMATCH = Messages.TARGET_MODEL_NAME_MISMATCH; + private String ZONE_VISIBILITY_NEGATIVE = Messages.ZONE_VISIBILITY_NEGATIVE; + private String ZONE_ATTENUATE_NEGATIVE = Messages.ZONE_ATTENUATE_NEGATIVE; + + override register(EValidatorRegistrar registrar) { + // not needed for classes used as ComposedCheck + } + + private Consumer errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkZone(Zone zone) { + var visibility = zone.getVisibility() + if (visibility instanceof rba.core.impl.IntegerValueImpl) { + if (visibility.getValue() < 0) { + error(ZONE_VISIBILITY_NEGATIVE, RBACorePackage.Literals.ALLOCATABLE__VISIBILITY); + return; + } + } + var attenuate = zone.getAttenuate(); + if (attenuate instanceof rba.core.impl.IntegerValueImpl) { + if (attenuate.getValue() < 0) { + error(ZONE_ATTENUATE_NEGATIVE, RBASoundPackage.Literals.ZONE__ATTENUATE); + return; + } + } + +// for (var index = 0; index < zone.tags.size; index.operator_plusPlus()) { +// val Tag tag = zone.tags.get(index); +// if (!tag.stereotype.targetModelName.equals(Zone.simpleName)) { +// error(String.format(TARGET_MODEL_NAME_MISMATCH, Zone.simpleName, tag.stereotype.targetModelName), RBACorePackage.Literals.TAG__STEREOTYPE); +// return; +// } +// } + } + + @Check(NORMAL) + def check0RequiredFields(Zone zone) { +// println(this.class.simpleName) + val tags = zone.tags; + + if(tags.isNullOrEmpty || !tags.filter(CTag).isEmpty) { + if(!doRequiredFieldsCheck(zone)) return; + } + } + + def protected doRequiredFieldsCheck(Zone zone) { + var passed = ValidatorUtils.mustHaveVisibility(zone, errorToName) + if(!passed) { + return false; + } + + return true; + } + +} -- cgit 1.2.3-korg