diff options
Diffstat (limited to 'rba.tool.editor/src/rba/tool/editor')
143 files changed, 12043 insertions, 0 deletions
diff --git a/rba.tool.editor/src/rba/tool/editor/GenerateRBAModel.mwe2 b/rba.tool.editor/src/rba/tool/editor/GenerateRBAModel.mwe2 new file mode 100644 index 0000000..c1354f5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/GenerateRBAModel.mwe2 @@ -0,0 +1,74 @@ +module rba.tool.editor.GenerateRBAModel + +import org.eclipse.emf.mwe.utils.* +import org.eclipse.xtext.xtext.generator.* +import org.eclipse.xtext.xtext.generator.model.project.* + +var rootPath = ".." + +Workflow { + + bean = StandaloneSetup { + scanClassPath = true + platformUri = "../" + registerGeneratedEPackage="rba.core.RBACorePackage" + registerGenModelFile="platform:/resource/rba.model.core/model/rbacore.genmodel" + registerGeneratedEPackage="rba.view.RBAViewPackage" + registerGenModelFile="platform:/resource/rba.model.view/model/rbaview.genmodel" + registerGeneratedEPackage="rba.sound.RBASoundPackage" + registerGenModelFile="platform:/resource/rba.model.sound/model/rbasound.genmodel" + } + + component = XtextGenerator { + configuration = { + project = StandardProjectConfig { + baseName = "rba.tool.editor" + rootPath = rootPath + runtimeTest = { + enabled = false + } + eclipsePlugin = { + enabled = true + } + eclipsePluginTest = { + enabled = false + } + createEclipseMetaData = true + } + code = { + encoding = "UTF-8" + lineDelimiter = "\r\n" + fileHeader = "/*\n * generated by Xtext \${version}\n */" + } + } + language = StandardLanguage { + name = "rba.tool.editor.RBAModel" + fileExtensions = "rba" + grammarUri = "platform:/resource/rba.tool.editor/src/rba/tool/editor/RBAModel.xtext" + + fragment = exporting.SimpleNamesFragment2 auto-inject {} + fragment = builder.BuilderIntegrationFragment2 auto-inject {} + fragment = scoping.ImportNamespacesScopingFragment2 auto-inject {} + + serializer = { + generateStub = false + } + formatter = { + generateStub = true + } + validator = { + generateStub = true + } + // ジェネレーター機能 + generator = { + generateStub = false + } + // ウィザード + newProjectWizardForEclipse = { + generate = true + pluginProject = false + } + } + } +} + diff --git a/rba.tool.editor/src/rba/tool/editor/RBAModel.xtext b/rba.tool.editor/src/rba/tool/editor/RBAModel.xtext new file mode 100644 index 0000000..a9022c1 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/RBAModel.xtext @@ -0,0 +1,1196 @@ +grammar rba.tool.editor.RBAModel hidden(WS, ML_COMMENT, SL_COMMENT) + +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.denso.com/ict/rba/core" as rbacore +import "http://www.denso.com/ict/rba/view" as rbaview +import "http://www.denso.com/ict/rba/sound" as rbasound + +generate rbaEditorModel "http://www.denso.com/ict/rbatooleditor" + +/* Top Level */ +TopLevel: + {TopLevel} ('module' QualifiedName)? + (project+=Project)* + (imports+=Import)* + (packages+=Package)*; + +Import: + 'import' importedNamespace=QualifiedNameWithWildcard; + +/* Abstract Structured Data Type */ + +PackagableElement returns rbacore::PackagableElement: + Package | Stereotype | RuleObject | Display | AbstractConstraint | Size; + +AbstractConstraint returns rbacore::AbstractConstraint: + Constraint; + +SizeIdentifier returns rbaview::SizeIdentifier: + SizeReference | Size; + +RuleObject returns rbacore::RuleObject: + AbstractContent | AbstractScene | AbstractAllocatable; + +AbstractAllocatable returns rbacore::AbstractAllocatable: + Allocatable | AllocatableSet; + +Allocatable returns rbacore::Allocatable: + Area | Zone; + +AllocatableSet returns rbacore::AllocatableSet: + AreaSet | ZoneSet; + +AbstractContent returns rbacore::AbstractContent: + Content | ContentSet; + +Content returns rbacore::Content: + ViewContent | SoundContent; + +ContentSet returns rbacore::ContentSet: + ViewContentSet | SoundContentSet; + +AbstractScene returns rbacore::AbstractScene: + Scene; + +AbstractProperty returns rbacore::AbstractProperty: + ({rbacore::IntegerProperty} 'int') name=ValidID (':' value=IntegerValue)?; + +LayoutManager returns rbaview::LayoutManager: + AlignedLayout | FixedPositionLayout; + +AlignedLayout returns rbaview::AlignedLayout: + VerticalLayout | HorizontalLayout; + +/* Structured Data Type */ +Tag returns rbacore::Tag: + =>( + ({rbacore::Tag} '<<' name=QualifiedName '>>') | + ({CTag} '«' name=QualifiedName '»') + ) ('{' (values+=EString (',' values+=EString)*)? '}')?; + +Package returns rbacore::Package: + {rbacore::Package} + 'Package' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + (packagableelement+=PackagableElement)* + ) '}'; + +/* Structured Data Type */ +Stereotype returns rbacore::Stereotype: + {rbacore::Stereotype} + 'Stereotype' '<' targetModelName=StereotypableElementName '>' + name=QualifiedName + '(' (variables+=Variable (',' variables+=Variable)*)? ')' + (bodyText=RichString)?; + +StereotypableElementName: + 'Area' | 'Zone' | 'SoundContent' | 'ViewContent' +; + +Display returns rbaview::Display: + {rbaview::Display} + 'Display' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + (size=SizeIdentifier)? & + (root=CompositeArea)? + ) '}'; + +Constraint returns rbacore::Constraint: + {rbacore::Constraint} + 'Constraint' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('runtime:' runtime=EBoolean)? & + (expression=ComplexExpression)? + ) '}'; + +ViewContent returns rbaview::ViewContent: + {rbaview::ViewContent} + 'ViewContent' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('loserType:' loserType=LoserType)? & + ('allocatable:' '[' (allocatable+=[rbacore::AbstractAllocatable|QualifiedName] ("," allocatable+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? & + (states+=ViewContentState)* & + (size+=SizeIdentifier)* & + (tags+=Tag)* + ) '}'; + +SoundContent returns rbasound::SoundContent: + {rbasound::SoundContent} + 'SoundContent' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('loserType:' loserType=LoserType)? & + ('allocatable:' '[' (allocatable+=[rbacore::AbstractAllocatable|QualifiedName] ("," allocatable+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? & + (states+=SoundContentState)* & + (tags+=Tag)* + ) '}'; + +Size returns rbaview::Size: + {rbaview::Size} + 'Size' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('width:' width=EInt)? & + ('height:' height=EInt)? + ) '}'; + +SizeReference returns rbaview::SizeReference: + {rbaview::SizeReference} + 'sizeReference:' size=[rbaview::Size|QualifiedName]; + +Offset returns rbaview::Offset: + {rbaview::Offset} + 'Offset' + '{' ( + ('description:' description=EString)? & + ('x:' x=EInt)? & + ('y:' y=EInt)? & + (size=SizeReference)? + ) '}'; + +AreaSet returns rbaview::AreaSet: + {rbaview::AreaSet} + 'AreaSet' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('target:' '[' (target+=[rbacore::AbstractAllocatable|QualifiedName] ("," target+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? + ) '}'; + +ZoneSet returns rbasound::ZoneSet: + {rbasound::ZoneSet} + 'ZoneSet' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('target:' '[' (target+=[rbacore::AbstractAllocatable|QualifiedName] ("," target+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? + ) '}'; + +CompositeArea returns rbaview::CompositeArea: + {rbaview::CompositeArea} + 'CompositeArea' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('layout:' layout=LayoutManager)? + ) '}'; + +Area returns rbaview::Area: + {rbaview::Area} + 'Area' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('arbitrationPolicy:' arbitrationPolicy=ArbitrationPolicy)? & + (size+=SizeIdentifier)* & + (('visibility:' | 'priority:') visibility=VExpression)? & + ('zorder:' zorder=VExpression)? & + (tags+=Tag)* + ) '}'; + +Zone returns rbasound::Zone: + {rbasound::Zone} + 'Zone' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('arbitrationPolicy:' arbitrationPolicy=ArbitrationPolicy)? & + (('visibility:' | 'priority:') visibility=VExpression)? & + ('attenuateValue:' attenuate=IntegerValue)? & + (tags+=Tag)* + ) '}'; + +ViewContentState returns rbaview::ViewContentState: + {rbaview::ViewContentState} + 'State' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + (('priority:' | 'value:') value=VExpression)? + ) '}'; + +SoundContentState returns rbasound::SoundContentState: + {rbasound::SoundContentState} + 'State' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + (('priority:' | 'value:') value=VExpression)? + ) '}'; + +Project returns rbacore::Project: + {rbacore::Project} + 'Project' + (dummyName=QualifiedName)? + '{' + 'version:' version=EString + '}'; + +/* ####################################### + * Sort Value Expression(VExpression) + * ####################################### */ +VExpression returns rbacore::Expression: + VPlusOperator; + +VPlusOperator returns rbacore::Expression: + VComparisonAnd (=>({rbacore::PlusOperator.operand+=current} OpPlus) operand+=VComparisonAnd)*; + +OpPlus: + '+'; + +VComparisonAnd returns rbacore::Expression: + VRelationalExpression (=>({rbacore::ComparisonAnd.operand+=current} OpAnd) operand+=VRelationalExpression)*; + +VRelationalExpression returns rbacore::Expression: + VPrimaryExpression | + ({rbacore::MuchGreaterThanOperator} OpMuchGreaterThan operand+=VPrimaryExpression) | + ({rbacore::EqualToOperator} OpEqualTo operand+=VPrimaryExpression) | + ({rbacore::GreaterThanOperator} OpGreaterThan operand+=VPrimaryExpression) | + ({rbacore::LowerThanOperator} OpLowerThan operand+=VPrimaryExpression); + +OpMuchGreaterThan: + '>>'; +OpEqualTo: + '='; +OpGreaterThan: + '>'; +OpLowerThan: + '<'; + +VPrimaryExpression returns rbacore::Expression: + ThatOfOperator | + VValueExpression | + '(' VExpression ')'; + +VValueExpression returns rbacore::Expression: + IntegerValue | + StandardValue | + NoneValue | + MinValue | + MaxValue; + +ThatOfOperator returns rbacore::Expression: + ({rbacore::ThatOfOperator} 'That-of' operand+=VMemberFeatureReference?); + +VMemberFeatureReference returns rbacore::ObjectReference: + {rbacore::ObjectReference} refObject=[rbacore::RuleObject|ValidID] + ({MemberFeatureReference.operand+=current} '.' refObject=[rbacore::RuleObject|ValidID])*; + +IntegerValue returns rbacore::IntegerValue: + {rbacore::IntegerValue} + (value=EInt); +StandardValue returns rbacore::StandardValue: + {rbacore::StandardValue} + 'STANDARD_VALUE'; +NoneValue returns rbacore::NoneValue: + {rbacore::NoneValue} + 'NONE_VALUE'; +MinValue returns rbacore::MinValue: + {rbacore::MinValue} + 'MIN_VALUE'; +MaxValue returns rbacore::MaxValue: + {rbacore::MaxValue} + 'MAX_VALUE'; + +/* ####################################### + * Constraint Expression(CExpression) + * ####################################### */ +CExpression returns rbacore::Expression: + CImpliesOperator; + +CImpliesOperator returns rbacore::Expression: + COrOperator (=>({rbacore::ImpliesOperator.operand+=current} OpImplies) operand+=COrOperator)*; + +OpImplies: + '->'; + +COrOperator returns rbacore::Expression: + CAndOperator (=>({rbacore::OrOperator.operand+=current} OpOr) operand+=CAndOperator)*; + +OpOr: + 'OR'; + +CAndOperator returns rbacore::Expression: + CEqualityExpression (=>({rbacore::AndOperator.operand+=current} OpAnd) operand+=CEqualityExpression)*; + +OpAnd: + 'AND'; + +CEqualityExpression returns rbacore::Expression: + CRelationalExpression ( + =>( + ({rbacore::ObjectCompare.operand+=current} OpObjectCompare) | + ({rbacore::ObjectCompareNot.operand+=current} OpObjectNotCompare) | + ({rbacore::IsEqualToOperator.operand+=current} OpEquality) + ) operand+=CRelationalExpression)*; + +OpObjectCompare: + '=='; +OpObjectNotCompare: + '!='; +OpEquality: + '='; + +CRelationalExpression returns rbacore::Expression: + CUnaryOperation ( + =>( + ({rbacore::IsGreaterThanEqualOperator.operand+=current} OpIsGreaterThanEqual) | + ({rbacore::IsLowerThanEqualOperator.operand+=current} OpIsLowerThanEqual) | + ({rbacore::IsGreaterThanOperator.operand+=current} OpIsGreaterThan) | + ({rbacore::IsLowerThanOperator.operand+=current} OpIsLowerThan) + ) operand+=CUnaryOperation)*; + +OpIsGreaterThanEqual: + '>='; +OpIsLowerThanEqual: + '<='; +OpIsGreaterThan: + '>'; +OpIsLowerThan: + '<'; + +CUnaryOperation returns rbacore::Expression: + ({rbacore::NotOperator} OpNot operand+=CUnaryOperation) + | COperationFeatureCall; + +OpNot: + "!"; + +COperationFeatureCall returns rbacore::Expression: + CPrimaryExpression + (=>(".") + ( + (( + //({MemberFeatureReference.operand+=current} refObject=[rbacore::RuleObject|ValidID]) | + ({rbacore::GetProperty.operand+=current} OpGetProperty) | + ({rbacore::IsOn.operand+=current} OpIsOn) | + ({rbacore::GetContentsList.operand+=current} OpGetContentsList) | + ({rbacore::ContentValue.operand+=current} OpContentValue) | + ({rbacore::IsActive.operand+=current} OpIsActive) | + ({rbacore::GetAllocatables.operand+=current} OpGetAllocatables) | + ({rbacore::AllocatedContent.operand+=current} OpAllocatedContent) | + ({rbacore::HasComeEarlierThan.operand+=current} OpHasComeEarlierThan) | + ({rbacore::HasComeLaterThan.operand+=current} OpHasComeLaterThan) | + ({rbacore::StateValue.operand+=current} OpStateValue) | + ({rbacore::ActiveContents.operand+=current} OpActiveContents) | + ({rbacore::SizeOperator.operand+=current} OpSizeOperator) | + ({rbacore::HasBeenDisplayed.operand+=current} OpHasBeenDisplayed) | + ({rbacore::ActiveState.operand+=current} OpActiveState) | + ({rbaview::IsDisplayed.operand+=current} OpIsDisplayed) | + ({rbaview::IsHidden.operand+=current} OpIsHidden) | + ({rbaview::DisplayingContent.operand+=current} OpDisplayingContent) | + ({rbaview::IsVisible.operand+=current} OpIsVisible) | + ({rbasound::IsOutputted.operand+=current} OpIsOutputted) | + ({rbasound::IsMuted.operand+=current} OpIsMuted) | + ({rbasound::OutputtingSound.operand+=current} OpOutputtingSound) | + ({rbasound::IsSounding.operand+=current} OpIsSounding) | + ({rbacore::IsAllocatedTo.operand+=current} OpIsAllocatedTo) | + ({rbacore::IsChanged.operand+=current} OpIsChanged) | + ({rbacore::IsTranslatedTo.operand+=current} OpIsTranslatedTo) | + ({rbaview::IsDisplayedOn.operand+=current} OpIsDisplayedOn) | + ({rbaview::IsChangedDisplay.operand+=current} OpIsChangedDisplay) | + ({rbaview::IsTranslatedViewTo.operand+=current} OpIsTranslatedViewTo) | + ({rbasound::IsOutputtedOn.operand+=current} OpIsOutputtedOn) | + ({rbasound::IsChangedOutput.operand+=current} OpIsChangedOutput) | + ({rbasound::IsTranslatedSoundTo.operand+=current} OpIsTranslatedSoundTo) | + ({rbasound::IsAttenuated.operand+=current} OpIsAttenuated) + ) =>('(' (operand+=CExpression)? ')') + ) | + ( + ( + ({rbacore::IsTypeOf.operand+=current} OpIsTypeOf) + ) =>('(' (tagName=EString)? ')')? + ) | + ( + ( + ({rbacore::MaxOperator.operand+=current} OpMaxOperator lambda=LambdaExpression) | + ({rbacore::MinOperator.operand+=current} OpMinOperator lambda=LambdaExpression) | + ({rbacore::SelectOperator.operand+=current} OpSelectOperator lambda=LambdaExpression) + ) + ) + ) + )*; + +OpGetProperty: + 'get'; +OpIsOn: + 'isOn'; +OpGetContentsList: + 'contentsList'; +OpContentValue: + 'contentValue'; +OpIsActive: + 'isActive'; +OpGetAllocatables: + 'allocatables'; +OpAllocatedContent: + 'allocatedContent'; +OpIsDisplayed: + 'isDisplayed'; +OpIsHidden: + 'isHidden'; +OpDisplayingContent: + 'displayingContent'; +OpIsVisible: + 'isVisible'; +OpIsOutputted: + 'isOutputted'; +OpIsMuted: + 'isMuted'; +OpOutputtingSound: + 'outputtingSound'; +OpIsSounding: + 'isSounding'; +OpIsAttenuated: + 'isAttenuated'; +OpHasComeEarlierThan: + 'hasComeEarlierThan'; +OpHasComeLaterThan: + 'hasComeLaterThan'; +OpStateValue: + 'stateValue'; +OpIsAllocatedTo: + 'isAllocatedTo'; +OpIsChanged: + 'isChanged'; +OpIsTranslatedTo: + 'isTranslatedTo'; +OpIsDisplayedOn: + 'isDisplayedOn'; +OpIsChangedDisplay: + 'isChangedDisplay'; +OpIsTranslatedViewTo: + 'isTranslatedViewTo'; +OpIsOutputtedOn: + 'isOutputtedOn'; +OpIsChangedOutput: + 'isChangedOutput'; +OpIsTranslatedSoundTo: + 'isTranslatedSoundTo'; +OpIsTypeOf: + 'isTypeOf'; +OpActiveContents: + 'activeContents'; +OpSizeOperator: + 'size'; +OpHasBeenDisplayed: + 'hasBeenDisplayed'; +OpActiveState: + 'activeState'; +OpGetState: + 'state'; +OpMaxOperator: + 'max'; +OpMinOperator: + 'min'; +OpSelectOperator: + 'select'; +OpStartOprator: + 'start'; +OpStopOprator: + 'stop'; +OpActivateOprator: + 'activate'; + +CPrimaryExpression returns rbacore::Expression: + CMemberFeatureReference | + PreviousModifier | + AllInstanceOfExpression | + NullExpression | + IntegerValue | + MuteLowerPriority | + HideLowerPriority | + SetOfOperator | + IfStatement | + ForAllOperator | + ExistsOperator | + '(' CExpression ')'; + +AllInstanceOfExpression returns rbacore::Expression: + =>( + ({rbaview::AllInstanceOfArea} 'ALL_AREAS') | + ({rbaview::AllInstanceOfViewContent} 'ALL_VIEWCONTENTS') | + ({rbasound::AllInstanceOfZone} 'ALL_ZONES') | + ({rbasound::AllInstanceOfSoundContent} 'ALL_SOUNDCONTENTS') + ); + +NullExpression returns rbacore::Expression: + =>({rbacore::NullExpression} 'NULL'); + +PreviousModifier returns rbacore::PreviousModifier: + {rbacore::PreviousModifier} + '(pre)' (objReference=CMemberFeatureReference); + +HideLowerPriority returns rbaview::HideLowerPriority: + {rbaview::HideLowerPriority} + 'HideLowerPriority' '(' (operand+=CExpression) ',' (operand+=CExpression) ')'; + +MuteLowerPriority returns rbasound::MuteLowerPriority: + {rbasound::MuteLowerPriority} + 'MuteLowerPriority' '(' (operand+=CExpression) ',' (operand+=CExpression) ')'; + +SetOfOperator returns rbacore::SetOfOperator: + {rbacore::SetOfOperator} + '{' (operand+=CExpression (',' operand+=CExpression)*)? '}'; +IfStatement returns rbacore::IfStatement: + {rbacore::IfStatement} + 'IF' '(' condition=CExpression? ')' + (=>'THEN' thenExpression=CExpression)? + (=>'ELSE' elseExpression=CExpression)?; +ForAllOperator returns rbacore::ForAllOperator: + {rbacore::ForAllOperator} + 'For-All' (operand+=CExpression) (lambda=LambdaExpression); +ExistsOperator returns rbacore::ExistsOperator: + {rbacore::ExistsOperator} + 'Exists' (operand+=CExpression) (lambda=LambdaExpression); + +// Other +LambdaExpression returns rbacore::LambdaExpression: + =>({rbacore::LambdaExpression} + '{') + (x=Variable? '|')? + (letStatements+=LetStatement)* + bodyText=CExpression + '}'; +Variable returns rbacore::Variable: + {rbacore::Variable} + name=QualifiedName; + +CObjectReference returns rbacore::ObjectReference: + {rbacore::ObjectReference} refObject=[rbacore::RuleObject|IdOrThis]; + +CMemberFeatureReference returns rbacore::ObjectReference: + {rbacore::ObjectReference} refObject=[rbacore::RuleObject|IdOrThis] + ({MemberFeatureReference.operand+=current} '.' refObject=[rbacore::RuleObject|ValidID])*; + +LetStatement returns rbacore::LetStatement: + {rbacore::LetStatement} + ('let') (=>variable=Variable) ('=' body=CExpression)?; + +ComplexExpression returns rbacore::ComplexExpression: + {rbacore::ComplexExpression} + (letStatements+=LetStatement)* + otherExpression=CExpression; + +EnumExpression returns rbacore::EnumExpression: + ('LoserType::' =>LoserTypeExpression) | ('ArbitrationPolicy::' =>ArbitrationPolicyExpression); + +LoserTypeExpression returns rbacore::LoserTypeExpression: + {rbacore::LoserTypeExpression} + value=LoserType; + +ArbitrationPolicyExpression returns rbacore::ArbitrationPolicyExpression: + {rbacore::ArbitrationPolicyExpression} + value=ArbitrationPolicy; + +// ################################################################################################ // + +ViewContentSet returns rbaview::ViewContentSet: + {rbaview::ViewContentSet} + 'ViewContentSet' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('target:' '[' (target+=[rbacore::AbstractContent|QualifiedName] ("," target+=[rbacore::AbstractContent|QualifiedName])*)? ']')? & + ('allocatable:' '[' (allocatable+=[rbacore::AbstractAllocatable|QualifiedName] ("," allocatable+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? + ) '}'; + +SoundContentSet returns rbasound::SoundContentSet: + {rbasound::SoundContentSet} + 'SoundContentSet' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('target:' '[' (target+=[rbacore::AbstractContent|QualifiedName] ("," target+=[rbacore::AbstractContent|QualifiedName])*)? ']')? & + ('allocatable:' '[' (allocatable+=[rbacore::AbstractAllocatable|QualifiedName] ("," allocatable+=[rbacore::AbstractAllocatable|QualifiedName])*)? ']')? + ) '}'; + +Scene returns rbacore::Scene: + {rbacore::Scene} + 'Scene' + name=QualifiedName + '{' ( + ('description:' description=EString)? & + ('global:' global=EBoolean)? & + (properties+=AbstractProperty)* + ) '}'; + +VerticalLayout returns rbaview::VerticalLayout: + {rbaview::VerticalLayout} + 'VerticalLayout' + '{' ( + ('basePoint:' basePoint=BasePoint)? & + ('subarea:' '[' (subarea+=[rbaview::Area|QualifiedName] ("," subarea+=[rbaview::Area|QualifiedName])*)? ']')? + ) '}'; + +HorizontalLayout returns rbaview::HorizontalLayout: + {rbaview::HorizontalLayout} + 'HorizontalLayout' + '{' ( + ('basePoint:' basePoint=BasePoint)? & + ('subarea:' '[' (subarea+=[rbaview::Area|QualifiedName] ("," subarea+=[rbaview::Area|QualifiedName])*)? ']')? + ) '}'; + +FixedPositionLayout returns rbaview::FixedPositionLayout: + {rbaview::FixedPositionLayout} + 'FixedPositionLayout' + '{' + (subAreaPosition+=PositionContainer)* + '}'; + +PositionContainer returns rbaview::PositionContainer: + {rbaview::PositionContainer} + 'PositionContainer' + '{' ( + ('x:' x=EInt)? & + ('y:' y=EInt)? & + ('basePoint:' basePoint=BasePoint)? & + ('areaReference:' area=[rbaview::Area|QualifiedName])? & + (offset+=Offset)* + ) '}'; + +/* Primitive Data Type */ +EBoolean returns ecore::EBoolean: + 'true' | 'false'; + +EInt returns ecore::EInt: + '-'? INT; + +EString returns ecore::EString: + STRING; + +RichString returns ecore::EString: + RICH_STRING; + +QualifiedNameWithWildcard: + QualifiedName '.*'?; + +QualifiedName: + ID ('.' ID)*; + +IdOrThis: + ValidID | 'this'; + +ValidID: + ID; + +/* Enum */ +enum ArbitrationPolicy returns rbacore::ArbitrationPolicy: + DEFAULT='DEFAULT' | FIRST_COME_FIRST='FIRST_COME_FIRST' | LAST_COME_FIRST='LAST_COME_FIRST' | + PRIORITY_FIRST_COME_FIRST='PRIORITY_FIRST_COME_FIRST' | PRIORITY_LAST_COME_FIRST='PRIORITY_LAST_COME_FIRST'; + +enum BasePoint returns rbaview::BasePoint: + LEFT_TOP='LEFT_TOP' | LEFT_MIDDLE='LEFT_MIDDLE' | LEFT_BOTTOM='LEFT_BOTTOM' | RIGHT_TOP='RIGHT_TOP' | + RIGHT_MIDDLE='RIGHT_MIDDLE' | RIGHT_BOTTOM='RIGHT_BOTTOM' | CENTER_TOP='CENTER_TOP' | CENTER_MIDDLE='CENTER_MIDDLE' | + CENTER_BOTTOM='CENTER_BOTTOM'; + +enum LoserType returns rbacore::LoserType: + NEVER_GIVEUP='NEVER_GIVEUP' | GOOD_LOSER='GOOD_LOSER' | DO_NOT_GIVEUP_UNTIL_WIN='DO_NOT_GIVEUP_UNTIL_WIN'; + +/* Terminal */ +terminal ID: + (IDENTIFIER_START | UNICODE_ESCAPE) (IDENTIFIER_PART | UNICODE_ESCAPE)*; + +terminal fragment IDENTIFIER_START_IMPL: + '\u0024' + | '\u0041'..'\u005A' + | '\uff08'..'\uff09' + | '\u005F' + | '\u0061'..'\u007A' + | '\u00A2'..'\u00A5' + | '\u00AA' + | '\u00B5' + | '\u00BA' + | '\u00C0'..'\u00D6' + | '\u00D8'..'\u00F6' + | '\u00F8'..'\u0236' + | '\u0250'..'\u02C1' + | '\u02C6'..'\u02D1' + | '\u02E0'..'\u02E4' + | '\u02EE' + | '\u037A' + | '\u0386' + | '\u0388'..'\u038A' + | '\u038C' + | '\u038E'..'\u03A1' + | '\u03A3'..'\u03CE' + | '\u03D0'..'\u03F5' + | '\u03F7'..'\u03FB' + | '\u0400'..'\u0481' + | '\u048A'..'\u04CE' + | '\u04D0'..'\u04F5' + | '\u04F8'..'\u04F9' + | '\u0500'..'\u050F' + | '\u0531'..'\u0556' + | '\u0559' + | '\u0561'..'\u0587' + | '\u05D0'..'\u05EA' + | '\u05F0'..'\u05F2' + | '\u0621'..'\u063A' + | '\u0640'..'\u064A' + | '\u066E'..'\u066F' + | '\u0671'..'\u06D3' + | '\u06D5' + | '\u06E5'..'\u06E6' + | '\u06EE'..'\u06EF' + | '\u06FA'..'\u06FC' + | '\u06FF' + | '\u0710' + | '\u0712'..'\u072F' + | '\u074D'..'\u074F' + | '\u0780'..'\u07A5' + | '\u07B1' + | '\u0904'..'\u0939' + | '\u093D' + | '\u0950' + | '\u0958'..'\u0961' + | '\u0985'..'\u098C' + | '\u098F'..'\u0990' + | '\u0993'..'\u09A8' + | '\u09AA'..'\u09B0' + | '\u09B2' + | '\u09B6'..'\u09B9' + | '\u09BD' + | '\u09DC'..'\u09DD' + | '\u09DF'..'\u09E1' + | '\u09F0'..'\u09F3' + | '\u0A05'..'\u0A0A' + | '\u0A0F'..'\u0A10' + | '\u0A13'..'\u0A28' + | '\u0A2A'..'\u0A30' + | '\u0A32'..'\u0A33' + | '\u0A35'..'\u0A36' + | '\u0A38'..'\u0A39' + | '\u0A59'..'\u0A5C' + | '\u0A5E' + | '\u0A72'..'\u0A74' + | '\u0A85'..'\u0A8D' + | '\u0A8F'..'\u0A91' + | '\u0A93'..'\u0AA8' + | '\u0AAA'..'\u0AB0' + | '\u0AB2'..'\u0AB3' + | '\u0AB5'..'\u0AB9' + | '\u0ABD' + | '\u0AD0' + | '\u0AE0'..'\u0AE1' + | '\u0AF1' + | '\u0B05'..'\u0B0C' + | '\u0B0F'..'\u0B10' + | '\u0B13'..'\u0B28' + | '\u0B2A'..'\u0B30' + | '\u0B32'..'\u0B33' + | '\u0B35'..'\u0B39' + | '\u0B3D' + | '\u0B5C'..'\u0B5D' + | '\u0B5F'..'\u0B61' + | '\u0B71' + | '\u0B83' + | '\u0B85'..'\u0B8A' + | '\u0B8E'..'\u0B90' + | '\u0B92'..'\u0B95' + | '\u0B99'..'\u0B9A' + | '\u0B9C' + | '\u0B9E'..'\u0B9F' + | '\u0BA3'..'\u0BA4' + | '\u0BA8'..'\u0BAA' + | '\u0BAE'..'\u0BB5' + | '\u0BB7'..'\u0BB9' + | '\u0BF9' + | '\u0C05'..'\u0C0C' + | '\u0C0E'..'\u0C10' + | '\u0C12'..'\u0C28' + | '\u0C2A'..'\u0C33' + | '\u0C35'..'\u0C39' + | '\u0C60'..'\u0C61' + | '\u0C85'..'\u0C8C' + | '\u0C8E'..'\u0C90' + | '\u0C92'..'\u0CA8' + | '\u0CAA'..'\u0CB3' + | '\u0CB5'..'\u0CB9' + | '\u0CBD' + | '\u0CDE' + | '\u0CE0'..'\u0CE1' + | '\u0D05'..'\u0D0C' + | '\u0D0E'..'\u0D10' + | '\u0D12'..'\u0D28' + | '\u0D2A'..'\u0D39' + | '\u0D60'..'\u0D61' + | '\u0D85'..'\u0D96' + | '\u0D9A'..'\u0DB1' + | '\u0DB3'..'\u0DBB' + | '\u0DBD' + | '\u0DC0'..'\u0DC6' + | '\u0E01'..'\u0E30' + | '\u0E32'..'\u0E33' + | '\u0E3F'..'\u0E46' + | '\u0E81'..'\u0E82' + | '\u0E84' + | '\u0E87'..'\u0E88' + | '\u0E8A' + | '\u0E8D' + | '\u0E94'..'\u0E97' + | '\u0E99'..'\u0E9F' + | '\u0EA1'..'\u0EA3' + | '\u0EA5' + | '\u0EA7' + | '\u0EAA'..'\u0EAB' + | '\u0EAD'..'\u0EB0' + | '\u0EB2'..'\u0EB3' + | '\u0EBD' + | '\u0EC0'..'\u0EC4' + | '\u0EC6' + | '\u0EDC'..'\u0EDD' + | '\u0F00' + | '\u0F40'..'\u0F47' + | '\u0F49'..'\u0F6A' + | '\u0F88'..'\u0F8B' + | '\u1000'..'\u1021' + | '\u1023'..'\u1027' + | '\u1029'..'\u102A' + | '\u1050'..'\u1055' + | '\u10A0'..'\u10C5' + | '\u10D0'..'\u10F8' + | '\u1100'..'\u1159' + | '\u115F'..'\u11A2' + | '\u11A8'..'\u11F9' + | '\u1200'..'\u1206' + | '\u1208'..'\u1246' + | '\u1248' + | '\u124A'..'\u124D' + | '\u1250'..'\u1256' + | '\u1258' + | '\u125A'..'\u125D' + | '\u1260'..'\u1286' + | '\u1288' + | '\u128A'..'\u128D' + | '\u1290'..'\u12AE' + | '\u12B0' + | '\u12B2'..'\u12B5' + | '\u12B8'..'\u12BE' + | '\u12C0' + | '\u12C2'..'\u12C5' + | '\u12C8'..'\u12CE' + | '\u12D0'..'\u12D6' + | '\u12D8'..'\u12EE' + | '\u12F0'..'\u130E' + | '\u1310' + | '\u1312'..'\u1315' + | '\u1318'..'\u131E' + | '\u1320'..'\u1346' + | '\u1348'..'\u135A' + | '\u13A0'..'\u13F4' + | '\u1401'..'\u166C' + | '\u166F'..'\u1676' + | '\u1681'..'\u169A' + | '\u16A0'..'\u16EA' + | '\u16EE'..'\u16F0' + | '\u1700'..'\u170C' + | '\u170E'..'\u1711' + | '\u1720'..'\u1731' + | '\u1740'..'\u1751' + | '\u1760'..'\u176C' + | '\u176E'..'\u1770' + | '\u1780'..'\u17B3' + | '\u17D7' + | '\u17DB'..'\u17DC' + | '\u1820'..'\u1877' + | '\u1880'..'\u18A8' + | '\u1900'..'\u191C' + | '\u1950'..'\u196D' + | '\u1970'..'\u1974' + | '\u1D00'..'\u1D6B' + | '\u1E00'..'\u1E9B' + | '\u1EA0'..'\u1EF9' + | '\u1F00'..'\u1F15' + | '\u1F18'..'\u1F1D' + | '\u1F20'..'\u1F45' + | '\u1F48'..'\u1F4D' + | '\u1F50'..'\u1F57' + | '\u1F59' + | '\u1F5B' + | '\u1F5D' + | '\u1F5F'..'\u1F7D' + | '\u1F80'..'\u1FB4' + | '\u1FB6'..'\u1FBC' + | '\u1FBE' + | '\u1FC2'..'\u1FC4' + | '\u1FC6'..'\u1FCC' + | '\u1FD0'..'\u1FD3' + | '\u1FD6'..'\u1FDB' + | '\u1FE0'..'\u1FEC' + | '\u1FF2'..'\u1FF4' + | '\u1FF6'..'\u1FFC' + | '\u203F'..'\u2040' + | '\u2054' + | '\u2071' + | '\u207F' + | '\u20A0'..'\u20B1' + | '\u2102' + | '\u2107' + | '\u210A'..'\u2113' + | '\u2115' + | '\u2119'..'\u211D' + | '\u2124' + | '\u2126' + | '\u2128' + | '\u212A'..'\u212D' + | '\u212F'..'\u2131' + | '\u2133'..'\u2139' + | '\u213D'..'\u213F' + | '\u2145'..'\u2149' + | '\u2160'..'\u2183' + | '\u3005'..'\u3007' + | '\u3021'..'\u3029' + | '\u3031'..'\u3035' + | '\u3038'..'\u303C' + | '\u3041'..'\u3096' + | '\u309D'..'\u309F' + | '\u30A1'..'\u30FF' + | '\u3105'..'\u312C' + | '\u3131'..'\u318E' + | '\u31A0'..'\u31B7' + | '\u31F0'..'\u31FF' + | '\u3400'..'\u4DB5' + | '\u4E00'..'\u9FA5' + | '\uA000'..'\uA48C' + | '\uAC00'..'\uD7A3' + | '\uF900'..'\uFA2D' + | '\uFA30'..'\uFA6A' + | '\uFB00'..'\uFB06' + | '\uFB13'..'\uFB17' + | '\uFB1D' + | '\uFB1F'..'\uFB28' + | '\uFB2A'..'\uFB36' + | '\uFB38'..'\uFB3C' + | '\uFB3E' + | '\uFB40'..'\uFB41' + | '\uFB43'..'\uFB44' + | '\uFB46'..'\uFBB1' + | '\uFBD3'..'\uFD3D' + | '\uFD50'..'\uFD8F' + | '\uFD92'..'\uFDC7' + | '\uFDF0'..'\uFDFC' + | '\uFE33'..'\uFE34' + | '\uFE4D'..'\uFE4F' + | '\uFE69' + | '\uFE70'..'\uFE74' + | '\uFE76'..'\uFEFC' + | '\uFF04' + | '\uFF1A' + | '\uFF21'..'\uFF3A' + | '\uFF3F' + | '\uFF41'..'\uFF5A' + | '\uFF65'..'\uFFBE' + | '\uFFC2'..'\uFFC7' + | '\uFFCA'..'\uFFCF' + | '\uFFD2'..'\uFFD7' + | '\uFFDA'..'\uFFDC' + | '\uFFE0'..'\uFFE1' + | '\uFFE5'..'\uFFE6'; + +terminal fragment IDENTIFIER_PART_IMPL: + '\u0000'..'\u0008' + | '\u000E'..'\u001B' + | '\u007F'..'\u009F' + | '\u00AD' + | '\u3001'..'\u3002' + | '\u0300'..'\u0357' + | '\u035D'..'\u036F' + | '\u0483'..'\u0486' + | '\u0591'..'\u05A1' + | '\u05A3'..'\u05B9' + | '\u05BB'..'\u05BD' + | '\u05BF' + | '\u05C1'..'\u05C2' + | '\u05C4' + | '\u0600'..'\u0603' + | '\u0610'..'\u0615' + | '\u064B'..'\u0658' + | '\u0660'..'\u0669' + | '\u0670' + | '\u06D6'..'\u06DD' + | '\u06DF'..'\u06E4' + | '\u06E7'..'\u06E8' + | '\u06EA'..'\u06ED' + | '\u06F0'..'\u06F9' + | '\u070F' + | '\u0711' + | '\u0730'..'\u074A' + | '\u07A6'..'\u07B0' + | '\u0901'..'\u0903' + | '\u093C' + | '\u093E'..'\u094D' + | '\u0951'..'\u0954' + | '\u0962'..'\u0963' + | '\u0966'..'\u096F' + | '\u0981'..'\u0983' + | '\u09BC' + | '\u09BE'..'\u09C4' + | '\u09C7'..'\u09C8' + | '\u09CB'..'\u09CD' + | '\u09D7' + | '\u09E2'..'\u09E3' + | '\u09E6'..'\u09EF' + | '\u0A01'..'\u0A03' + | '\u0A3C' + | '\u0A3E'..'\u0A42' + | '\u0A47'..'\u0A48' + | '\u0A4B'..'\u0A4D' + | '\u0A66'..'\u0A71' + | '\u0A81'..'\u0A83' + | '\u0ABC' + | '\u0ABE'..'\u0AC5' + | '\u0AC7'..'\u0AC9' + | '\u0ACB'..'\u0ACD' + | '\u0AE2'..'\u0AE3' + | '\u0AE6'..'\u0AEF' + | '\u0B01'..'\u0B03' + | '\u0B3C' + | '\u0B3E'..'\u0B43' + | '\u0B47'..'\u0B48' + | '\u0B4B'..'\u0B4D' + | '\u0B56'..'\u0B57' + | '\u0B66'..'\u0B6F' + | '\u0B82' + | '\u0BBE'..'\u0BC2' + | '\u0BC6'..'\u0BC8' + | '\u0BCA'..'\u0BCD' + | '\u0BD7' + | '\u0BE7'..'\u0BEF' + | '\u0C01'..'\u0C03' + | '\u0C3E'..'\u0C44' + | '\u0C46'..'\u0C48' + | '\u0C4A'..'\u0C4D' + | '\u0C55'..'\u0C56' + | '\u0C66'..'\u0C6F' + | '\u0C82'..'\u0C83' + | '\u0CBC' + | '\u0CBE'..'\u0CC4' + | '\u0CC6'..'\u0CC8' + | '\u0CCA'..'\u0CCD' + | '\u0CD5'..'\u0CD6' + | '\u0CE6'..'\u0CEF' + | '\u0D02'..'\u0D03' + | '\u0D3E'..'\u0D43' + | '\u0D46'..'\u0D48' + | '\u0D4A'..'\u0D4D' + | '\u0D57' + | '\u0D66'..'\u0D6F' + | '\u0D82'..'\u0D83' + | '\u0DCA' + | '\u0DCF'..'\u0DD4' + | '\u0DD6' + | '\u0DD8'..'\u0DDF' + | '\u0DF2'..'\u0DF3' + | '\u0E31' + | '\u0E34'..'\u0E3A' + | '\u0E47'..'\u0E4E' + | '\u0E50'..'\u0E59' + | '\u0EB1' + | '\u0EB4'..'\u0EB9' + | '\u0EBB'..'\u0EBC' + | '\u0EC8'..'\u0ECD' + | '\u0ED0'..'\u0ED9' + | '\u0F18'..'\u0F19' + | '\u0F20'..'\u0F29' + | '\u0F35' + | '\u0F37' + | '\u0F39' + | '\u0F3E'..'\u0F3F' + | '\u0F71'..'\u0F84' + | '\u0F86'..'\u0F87' + | '\u0F90'..'\u0F97' + | '\u0F99'..'\u0FBC' + | '\u0FC6' + | '\u102C'..'\u1032' + | '\u1036'..'\u1039' + | '\u1040'..'\u1049' + | '\u1056'..'\u1059' + | '\u1369'..'\u1371' + | '\u1712'..'\u1714' + | '\u1732'..'\u1734' + | '\u1752'..'\u1753' + | '\u1772'..'\u1773' + | '\u17B4'..'\u17D3' + | '\u17DD' + | '\u17E0'..'\u17E9' + | '\u180B'..'\u180D' + | '\u1810'..'\u1819' + | '\u18A9' + | '\u1920'..'\u192B' + | '\u1930'..'\u193B' + | '\u1946'..'\u194F' + | '\u200C'..'\u200F' + | '\u202A'..'\u202E' + | '\u2060'..'\u2063' + | '\u206A'..'\u206F' + | '\u20D0'..'\u20DC' + | '\u20E1' + | '\u20E5'..'\u20EA' + | '\u302A'..'\u302F' + | '\u3099'..'\u309A' + | '\uFB1E' + | '\uFE00'..'\uFE0F' + | '\uFE20'..'\uFE23' + | '\uFEFF' + | '\uFF10'..'\uFF19' + | '\uFFF9'..'\uFFFB'; + +terminal fragment IDENTIFIER_DIGITS: + '\u0030'..'\u0039'; + +terminal fragment HEX_DIGIT: + '0'..'9' | 'a'..'f' | 'A'..'F'; + +terminal fragment UNICODE_ESCAPE: + '\\' 'u' ( HEX_DIGIT ( HEX_DIGIT ( HEX_DIGIT HEX_DIGIT? )? )? )?; + +terminal fragment IDENTIFIER_PART: + IDENTIFIER_START_IMPL | IDENTIFIER_DIGITS | IDENTIFIER_PART_IMPL; + +terminal fragment IDENTIFIER_START: + IDENTIFIER_START_IMPL | IDENTIFIER_PART_IMPL; + +terminal WS: + (' '|'\t'|'\r'|'\n')+; + +terminal INT returns ecore::EInt: + ('0'..'9')+; + +terminal STRING: + '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"' | "'" | '\n' | '\r'))* '"'; + +terminal RICH_STRING: + '@BEGIN@' -> '@END@'; + +terminal ML_COMMENT: '/*' -> '*/'; + +terminal SL_COMMENT: '//' !('\n'|'\r')* ('\r'? '\n')?; + + +ConfigurationParserRule_OperatorWithMultipleOperand: OpHasComeEarlierThan | OpHasComeLaterThan | OpIsAllocatedTo | OpIsTranslatedTo | OpIsDisplayedOn | OpIsTranslatedViewTo | OpIsOutputtedOn | OpIsTranslatedSoundTo | OpIsTypeOf; + +ConfigurationParserRule_AreaOperatorForConstraint: OpAllocatedContent | OpContentValue | OpGetContentsList | OpIsDisplayed | OpDisplayingContent | OpIsHidden | OpIsChanged | OpIsTranslatedTo | OpIsChangedDisplay | OpIsTranslatedViewTo; + +ContentOperatorsCommon: OpIsActive | OpGetAllocatables | OpIsVisible | OpHasComeEarlierThan | OpHasComeLaterThan | OpStateValue | OpIsAllocatedTo | OpIsDisplayedOn; +ConfigurationParserRule_ContentOperatorForConstraint: ContentOperatorsCommon; + +ConfigurationParserRule_ZoneOperatorForConstraint: OpAllocatedContent | OpContentValue | OpGetContentsList | OpIsOutputted | OpOutputtingSound | OpIsMuted | OpIsAttenuated | OpIsChanged | OpIsTranslatedTo | OpIsChangedOutput | OpIsTranslatedSoundTo; + +SoundOperatorsCommon: OpIsActive | OpGetAllocatables | OpIsSounding | OpHasComeEarlierThan | OpHasComeLaterThan | OpStateValue | OpIsAllocatedTo | OpIsOutputtedOn; +ConfigurationParserRule_SoundOperatorForConstraint: SoundOperatorsCommon; + +ConfigurationParserRule_SceneOperatorForConstraint: OpIsOn; + +ConfigurationParserRule_PropertyOperatorForConstraint: OpGetProperty; + diff --git a/rba.tool.editor/src/rba/tool/editor/RBAModelRuntimeModule.xtend b/rba.tool.editor/src/rba/tool/editor/RBAModelRuntimeModule.xtend new file mode 100644 index 0000000..dabff8f --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/RBAModelRuntimeModule.xtend @@ -0,0 +1,88 @@ +/* + * generated by Xtext 2.12.0 + */ +package rba.tool.editor + +import com.google.inject.Binder +import com.google.inject.Provider +import com.google.inject.name.Names +import org.eclipse.xtext.linking.impl.DefaultLinkingService +import org.eclipse.xtext.scoping.IScopeProvider +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider +import org.eclipse.xtext.validation.CompositeEValidator +import rba.tool.editor.generator.RBAModelGeneratorExtensions +import rba.tool.editor.generator.z3.ConstraintGeneratorImpl +import rba.tool.editor.generator.z3.IConstraintGenerator +import rba.tool.editor.generator.z3.ISortValueGenerator +import rba.tool.editor.generator.z3.SortValueGeneratorImpl +import rba.tool.editor.linking.RBAModelLinker +import rba.tool.editor.linking.RBAModelLinkingService +import rba.tool.editor.naming.RBAModelSimpleNameProvider +import rba.tool.editor.resource.RBAModelLocationInFileProvider +import rba.tool.editor.scoping.IExpressionScope +import rba.tool.editor.scoping.RBAModelExpressionScope +import rba.tool.editor.scoping.RBAModelImportedNamespaceAwareLocalScopeProvider +import rba.tool.editor.scoping.internal.RBAModelMemberFieldScopes +import rba.tool.editor.scoping.internal.RBAModelMemberOperationScopes +import rba.tool.editor.validation.RBADiagnostician +import rba.tool.editor.validation.RBAModelCompositeEValidatorProvider + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +class RBAModelRuntimeModule extends AbstractRBAModelRuntimeModule { + + override bindIQualifiedNameProvider() { + return RBAModelSimpleNameProvider; + } + + override bindILinker() { + return RBAModelLinker; + } + + def public Class<? extends ISortValueGenerator> bindISortValueGenerator() { + return SortValueGeneratorImpl; + } + + + def public Class<? extends IConstraintGenerator> bindIConstraintGenerator() { + return ConstraintGeneratorImpl; + } + + override bindILocationInFileProvider() { + return RBAModelLocationInFileProvider; + } + + def public Class<? extends RBAModelGeneratorExtensions> bindRBAModelGeneratorExtensions() { + return RBAModelGeneratorExtensions; + } + + override bindDiagnostician() { + return RBADiagnostician; + } + + def public Class<? extends IExpressionScope> bindIExpressionScope() { + return RBAModelExpressionScope; + } + + def public Class<? extends RBAModelMemberFieldScopes> bindRBAModelMemberFieldScopes() { + return RBAModelMemberFieldScopes; + } + + def public Class<? extends RBAModelMemberOperationScopes> bindRBAModelMemberOperationScopes() { + return RBAModelMemberOperationScopes; + } + + def public Class<? extends Provider<CompositeEValidator>> provideRBAModelCompositeEValidatorProvider() { + return RBAModelCompositeEValidatorProvider; + } + + def public Class<? extends DefaultLinkingService> bindRBAModelLinkingService() { + return RBAModelLinkingService; + } + + override configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(RBAModelImportedNamespaceAwareLocalScopeProvider); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/RBAModelStandaloneSetup.xtend b/rba.tool.editor/src/rba/tool/editor/RBAModelStandaloneSetup.xtend new file mode 100644 index 0000000..73b8b5f --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/RBAModelStandaloneSetup.xtend @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.12.0 + */ +package rba.tool.editor + + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +class RBAModelStandaloneSetup extends RBAModelStandaloneSetupGenerated { + + def static void doSetup() { + new RBAModelStandaloneSetup().createInjectorAndDoEMFRegistration() + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/formatting2/RBAModelFormatter.xtend b/rba.tool.editor/src/rba/tool/editor/formatting2/RBAModelFormatter.xtend new file mode 100644 index 0000000..1a79638 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/formatting2/RBAModelFormatter.xtend @@ -0,0 +1,132 @@ +/* + * generated by Xtext 2.13.0 + */ +package rba.tool.editor.formatting2 + +import com.google.inject.Inject +import org.eclipse.xtext.formatting2.AbstractFormatter2 +import org.eclipse.xtext.formatting2.IFormattableDocument +import rba.core.Content +import rba.core.ContentSet +import rba.core.ContentState +import rba.core.PackagableElement +import rba.core.Package +import rba.core.Scene +import rba.core.State +import rba.tool.editor.rbaEditorModel.TopLevel +import rba.tool.editor.services.RBAModelGrammarAccess +import rba.view.Area +import rba.view.AreaSet +import rba.view.CompositeArea +import rba.view.Display +import rba.view.FixedPositionLayout +import rba.view.HorizontalLayout +import rba.view.PositionContainer +import rba.view.Size +import rba.view.VerticalLayout +import rba.view.ViewContent + +class RBAModelFormatter extends AbstractFormatter2 { + + @Inject RBAModelGrammarAccess grammarAccess; + + def dispatch void format(TopLevel topLevel, extension IFormattableDocument document) { + System.out.println("---------------------------------"); + System.out.println(document.class.simpleName); + System.out.println("---------------------------------"); + + for (Package _package : topLevel.getPackages()) { + _package.format; + } + } + + def dispatch void format(Package _package, extension IFormattableDocument document) { + for (PackagableElement _packagableElement : _package.packagableelement) { + _packagableElement.format; + } + } + + def dispatch void format(Display _display, extension IFormattableDocument document) { + if (_display.size !== null) { + _display.size.format + } + if (_display.root !== null) { + _display.root.format + } + } + + def dispatch void format(CompositeArea _compositeArea, extension IFormattableDocument document) { + if (_compositeArea.layout !== null) { + _compositeArea.layout.format + } + } + + def dispatch void format(FixedPositionLayout _fixedPositionLayout, extension IFormattableDocument document) { + for (subAreaPosition : _fixedPositionLayout.subAreaPosition) { + subAreaPosition.format + } + } + + def dispatch void format(VerticalLayout _verticalLayout, extension IFormattableDocument document) { + for (subarea : _verticalLayout.subarea) { + // TODO -> ('subarea:' '[' (subarea+=[rba::AbstractArea|QualifiedName] ("," subarea+=[rba::AbstractArea|QualifiedName])*)? ']')? + } + } + + def dispatch void format(HorizontalLayout _horizontalLayout, extension IFormattableDocument document) { + for (subarea : _horizontalLayout.subarea) { + // TODO -> ('subarea:' '[' (subarea+=[rba::AbstractArea|QualifiedName] ("," subarea+=[rba::AbstractArea|QualifiedName])*)? ']')? + } + } + + def dispatch void format(PositionContainer _positionContainer, extension IFormattableDocument document) { + // TODO -> ('areaReference:' area=[rba::AbstractArea|QualifiedName])? + // TODO -> x & y + } + + def dispatch void format(ContentSet _contentSet, extension IFormattableDocument document) { + for (target : _contentSet.target) { + // TODO -> ('target:' '[' (target+=[rba::AbstractContent|QualifiedName] ("," target+=[rba::AbstractContent|QualifiedName])*)? ']')? + } + } + + def dispatch void format(Content _content, extension IFormattableDocument document) { + for (allocatable : _content.allocatable) { + // TODO -> ('allocatable:' '[' (allocatable+=[rba::Allocatable|QualifiedName] ("," allocatable+=[rba::Allocatable|QualifiedName])*)? ']')? & + } + for (state : _content.states) { + state.format + } + if (_content instanceof ViewContent) { + for (size : (_content as ViewContent).size) { + size.format + } + } + } + + def dispatch void format(AreaSet _areaSet, extension IFormattableDocument document) { + for (target : _areaSet.target) { + // TODO -> ('target:' '[' (target+=[rba::AbstractArea|QualifiedName] ("," target+=[rba::AbstractArea|QualifiedName])*)? ']')? + } + } + + def dispatch void format(Area _area, extension IFormattableDocument document) { + for (size : _area.size) { + size.format + } + // TODO -> visibility[ref Area] + // TODO -> zorder[ref Area] + } + + def dispatch void format(Size _size, extension IFormattableDocument document) { + // TODO -> width & height + } + + def dispatch void format(ContentState _contentState, extension IFormattableDocument document) { + // TODO -> priority[ref ContentState] + } + + def dispatch void format(Scene _scene, extension IFormattableDocument document) { + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorDelegate.xtend b/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorDelegate.xtend new file mode 100644 index 0000000..5d0b582 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorDelegate.xtend @@ -0,0 +1,184 @@ +package rba.tool.editor.generator + +import com.google.inject.Inject +import java.util.Set +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.GeneratorContext +import org.eclipse.xtext.generator.IFileSystemAccess +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGenerator +import org.eclipse.xtext.generator.IGenerator2 +import org.eclipse.xtext.generator.IGeneratorContext +import org.eclipse.xtext.generator.OutputConfiguration +import org.eclipse.xtext.util.CancelIndicator +import rba.tool.editor.generator.json.IJSONGenerator +import rba.tool.editor.generator.rtmodel.IRTModelUpdater +import rba.tool.editor.generator.z3.IConstraintGenerator +import rba.tool.editor.generator.z3.ISortValueGenerator + +class RBAModelGeneratorDelegate implements IGenerator, IGenerator2 { + + @Inject(optional=true) + private ISortValueGenerator sortValueGenerator; + + private ThreadLocal<Boolean> sortValueGeneratorInBuilding = new ThreadLocal<Boolean>() { + override protected initialValue() { + return false; + } + }; + + @Inject(optional=true) + private IRTModelUpdater rtModelUpdater; + + private ThreadLocal<Boolean> rtModelUpdaterInBuilding = new ThreadLocal<Boolean>() { + override protected initialValue() { + return false; + } + }; + + @Inject(optional=true) + private IConstraintGenerator constraintGenerator; + + private ThreadLocal<Boolean> constraintGeneratorInBuilding = new ThreadLocal<Boolean>() { + override protected initialValue() { + return false; + } + }; + + @Inject(optional=true) + private IJSONGenerator jsonGenerator; + + private ThreadLocal<Boolean> jsonGeneratorInBuilding = new ThreadLocal<Boolean>() { + override protected initialValue() { + return false; + } + }; + + def public void generate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + generate(input.resourceSet, fsa, context); + } + + def public void generate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (sortValueGenerator !== null && !sortValueGeneratorInBuilding.get.booleanValue) { + sortValueGeneratorInBuilding.set(true); + } + if (rtModelUpdater !== null && !rtModelUpdaterInBuilding.get.booleanValue) { + rtModelUpdaterInBuilding.set(true); + } + if (constraintGenerator !== null && !constraintGeneratorInBuilding.get.booleanValue) { + constraintGeneratorInBuilding.set(true); + } + if (jsonGenerator !== null && !jsonGeneratorInBuilding.get.booleanValue) { + jsonGeneratorInBuilding.set(true); + } + + try { + beforeGenerate(input, fsa, context); + doGenerate(input, fsa, context); + } finally { + afterGenerate(input, fsa, context); + } + } + + override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + doGenerate(input.resourceSet, fsa, context); + } + + def void doGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (sortValueGenerator !== null && sortValueGeneratorInBuilding.get.booleanValue) { + sortValueGenerator.doGenerate(input, fsa, context); + } + if (rtModelUpdater !== null && rtModelUpdaterInBuilding.get.booleanValue) { + rtModelUpdater.doGenerate(input, fsa, context); + } + if (constraintGenerator !== null && constraintGeneratorInBuilding.get.booleanValue) { + constraintGenerator.doGenerate(input, fsa, context); + } + if (jsonGenerator !== null && jsonGeneratorInBuilding.get.booleanValue) { + jsonGenerator.doGenerate(input, fsa, context); + } + } + + override beforeGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + beforeGenerate(input.resourceSet, fsa, context); + } + + def void beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (sortValueGenerator !== null && sortValueGeneratorInBuilding.get.booleanValue) { + sortValueGenerator.beforeGenerate(input, fsa, context); + } + if (rtModelUpdater !== null && rtModelUpdaterInBuilding.get.booleanValue) { + rtModelUpdater.beforeGenerate(input, fsa, context); + } + if (constraintGenerator !== null && constraintGeneratorInBuilding.get.booleanValue) { + constraintGenerator.beforeGenerate(input, fsa, context); + } + if (jsonGenerator !== null && jsonGeneratorInBuilding.get.booleanValue) { + jsonGenerator.beforeGenerate(input, fsa, context); + } + } + + override afterGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + afterGenerate(input.resourceSet, fsa, context); + } + + def void afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (sortValueGenerator !== null && sortValueGeneratorInBuilding.get.booleanValue) { + sortValueGenerator.afterGenerate(input, fsa, context); + } + if (rtModelUpdater !== null && rtModelUpdaterInBuilding.get.booleanValue) { + rtModelUpdater.afterGenerate(input, fsa, context); + } + if (constraintGenerator !== null && constraintGeneratorInBuilding.get.booleanValue) { + constraintGenerator.afterGenerate(input, fsa, context); + } + if (jsonGenerator !== null && jsonGeneratorInBuilding.get.booleanValue) { + jsonGenerator.afterGenerate(input, fsa, context); + } + } + + override doGenerate(Resource input, IFileSystemAccess fsa) { + doGenerate(input.resourceSet, fsa); + } + + def void doGenerate(ResourceSet input, IFileSystemAccess fsa) { + val casted = fsa as IFileSystemAccess2; + val context = new GeneratorContext(); + context.setCancelIndicator(CancelIndicator.NullImpl); + try { + beforeGenerate(input, casted, context); + doGenerate(input, casted, context); + } finally { + afterGenerate(input, casted, context); + } + } + + def public void setRBAModelInBuilding(boolean value) { + sortValueGeneratorInBuilding.set(value); + rtModelUpdaterInBuilding.set(value); + constraintGeneratorInBuilding.set(value); + jsonGeneratorInBuilding.set(value); + } + + def public boolean isRBAModelInBuilding() { + if (sortValueGeneratorInBuilding.get().booleanValue) { + return true; + } + if (rtModelUpdaterInBuilding.get().booleanValue) { + return true; + } + if (constraintGeneratorInBuilding.get().booleanValue) { + return true; + } + if (jsonGeneratorInBuilding.get().booleanValue) { + return true; + } + return false; + } + + def public Set<OutputConfiguration> getRBAModelGeneratorOutputConfigurations() { + return newHashSet(IJSONGenerator.OUTPUT_CONFIGURATION); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorExtensions.xtend b/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorExtensions.xtend new file mode 100644 index 0000000..8666e9b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/RBAModelGeneratorExtensions.xtend @@ -0,0 +1,680 @@ +package rba.tool.editor.generator + +import java.util.HashMap +import java.util.Map +import org.eclipse.emf.ecore.EObject +import rba.core.AbstractProperty +import rba.core.AllocatedContent +import rba.core.AndOperator +import rba.core.Content +import rba.core.ContentSet +import rba.core.ContentValue +import rba.core.ExistsOperator +import rba.core.Expression +import rba.core.ForAllOperator +import rba.core.GetAllocatables +import rba.core.GetContentsList +import rba.core.GetProperty +import rba.core.IfActionOperator +import rba.core.IfStatement +import rba.core.ImpliesOperator +import rba.core.IntegerValue +import rba.core.IsActive +import rba.core.IsCanceled +import rba.core.IsDisappeared +import rba.core.IsEqualToOperator +import rba.core.IsGreaterThanEqualOperator +import rba.core.IsGreaterThanOperator +import rba.core.IsLowerThanEqualOperator +import rba.core.IsLowerThanOperator +import rba.core.IsOn +import rba.core.LambdaExpression +import rba.core.MaxValue +import rba.core.MinValue +import rba.core.NoneValue +import rba.core.NotOperator +import rba.core.ObjectCompare +import rba.core.ObjectReference +import rba.core.OffScene +import rba.core.OnScene +import rba.core.OrOperator +import rba.core.PreviousModifier +import rba.core.Scene +import rba.core.SetOfOperator +import rba.core.SetProperty +import rba.core.StandardValue +import rba.core.Variable +import rba.sound.AllInstanceOfSoundContent +import rba.sound.AllInstanceOfZone +import rba.sound.IsAttenuated +import rba.sound.IsMuted +import rba.sound.IsOutputted +import rba.sound.IsSounding +import rba.sound.OutputtingSound +import rba.sound.Zone +import rba.sound.ZoneSet +import rba.view.AllInstanceOfArea +import rba.view.AllInstanceOfViewContent +import rba.view.Area +import rba.view.AreaSet +import rba.view.DisplayingContent +import rba.view.IsDisplayed +import rba.view.IsHidden +import rba.view.IsVisible +import rba.core.ContentState +import rba.core.State + +class RBAModelGeneratorExtensions { + + public int operandIndex = 1; + + public Map<EObject, String> variableNames = new HashMap<EObject, String>(); + + def public compile(Expression e, String text) ''' + «e.compile(null, text, null)» + ''' + + def public compile(Expression e, LambdaExpression le, String text1, String text2) ''' + «IF e instanceof IsEqualToOperator » + «(e as IsEqualToOperator).compile(text1)» + «ELSEIF e instanceof IsGreaterThanOperator » + «(e as IsGreaterThanOperator).compile(text1)» + «ELSEIF e instanceof IsLowerThanOperator » + «(e as IsLowerThanOperator).compile(text1)» + «ELSEIF e instanceof IsGreaterThanEqualOperator » + «(e as IsGreaterThanEqualOperator).compile(text1)» + «ELSEIF e instanceof IsLowerThanEqualOperator » + «(e as IsLowerThanEqualOperator).compile(text1)» + «ELSEIF e instanceof AndOperator » + «(e as AndOperator).compile(text1)» + «ELSEIF e instanceof OrOperator» + «(e as OrOperator).compile(text1)» + «ELSEIF e instanceof NotOperator» + «(e as NotOperator).compile(text1)» + «ELSEIF e instanceof ImpliesOperator» + «(e as ImpliesOperator).compile(text1)» + «ELSEIF e instanceof IsActive» + «(e as IsActive).compile(text1)» + «ELSEIF e instanceof IsVisible» + «(e as IsVisible).compile(text1)» + «ELSEIF e instanceof GetAllocatables» + «(e as GetAllocatables).compile(le, text1, text2)» + «ELSEIF e instanceof IsDisplayed» + «(e as IsDisplayed).compile(text1)» + «ELSEIF e instanceof IsHidden» + «(e as IsHidden).compile(text1)» + «ELSEIF e instanceof DisplayingContent» + «(e as DisplayingContent).compile(le, text1, text2)» + «ELSEIF e instanceof AllocatedContent» + «(e as AllocatedContent).compile(le, text1, text2)» + «ELSEIF e instanceof GetContentsList» + «(e as GetContentsList).compile(le, text1, text2)» + «ELSEIF e instanceof ContentValue» + «(e as ContentValue).compile(le, text1, text2)» + «ELSEIF e instanceof ObjectReference» + «(e as ObjectReference).compile(le, text1, text2)» + «ELSEIF e instanceof PreviousModifier» + «(e as PreviousModifier).compile(text1)» + «ELSEIF e instanceof ObjectCompare» + «(e as ObjectCompare).compile(text1)» + «ELSEIF e instanceof ForAllOperator» + «(e as ForAllOperator).compile(text1)» + «ELSEIF e instanceof ExistsOperator» + «(e as ExistsOperator).compile(text1)» + «ELSEIF e instanceof AllInstanceOfArea» + «(e as AllInstanceOfArea).compile(le, text1, text2)» + «ELSEIF e instanceof AllInstanceOfViewContent» + «(e as AllInstanceOfViewContent).compile(le, text1, text2)» + «ELSEIF e instanceof AllInstanceOfZone» + «(e as AllInstanceOfZone).compile(le, text1, text2)» + «ELSEIF e instanceof AllInstanceOfSoundContent» + «(e as AllInstanceOfSoundContent).compile(le, text1, text2)» + «ELSEIF e instanceof SetOfOperator» + «(e as SetOfOperator).compile(le, text1, text2)» + «ELSEIF e instanceof IfStatement» + «(e as IfStatement).compile(le, text1, text2)» + «ELSEIF e instanceof IsOn» + «(e as IsOn).compile(text1)» + «ELSEIF e instanceof IsDisappeared» + «(e as IsDisappeared).compile(text1)» + «ELSEIF e instanceof IsCanceled» + «(e as IsCanceled).compile(text1)» + «ELSEIF e instanceof GetProperty» + «(e as GetProperty).compile(le, text1, text2)» + «ELSEIF e instanceof SetProperty» + «(e as SetProperty).compile(le, text1, text2)» + «ELSEIF e instanceof OffScene» + «(e as OffScene).compile(text1)» + «ELSEIF e instanceof OnScene» + «(e as OnScene).compile(text1)» + «ELSEIF e instanceof IsSounding» + «(e as IsSounding).compile(text1)» + «ELSEIF e instanceof IsOutputted» + «(e as IsOutputted).compile(text1)» + «ELSEIF e instanceof IsMuted» + «(e as IsMuted).compile(text1)» + «ELSEIF e instanceof OutputtingSound» + «(e as OutputtingSound).compile(le, text1, text2)» + «ELSEIF e instanceof IsAttenuated» + «(e as IsAttenuated).compile(text1)» + «ELSEIF e instanceof IfActionOperator» + «(e as IfActionOperator).compile(le, text1, text2)» + «ELSEIF e instanceof MaxValue» + «(e as MaxValue).compile(text1)» + «ELSEIF e instanceof MinValue» + «(e as MinValue).compile(text1)» + «ELSEIF e instanceof NoneValue» + «(e as NoneValue).compile(text1)» + «ELSEIF e instanceof StandardValue» + «(e as StandardValue).compile(text1)» + «ELSEIF e instanceof IntegerValue» + «(e as IntegerValue).compile(text1)» + «ENDIF» + ''' + + def public compile(IsEqualToOperator o, String addExpressionStatement) ''' + «var name = "isEqualToOperator_" + operandIndex++» + ARBIsEqualToOperator «name» = ArbFactory.eINSTANCE.createARBIsEqualToOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsGreaterThanOperator o, String addExpressionStatement) ''' + «var name = "isGreaterThanOperator_" + operandIndex++» + ARBIsGreaterThanOperator «name» = ArbFactory.eINSTANCE.createARBIsGreaterThanOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsLowerThanOperator o, String addExpressionStatement) ''' + «var name = "isLowerThanOperator_" + operandIndex++» + ARBIsLowerThanOperator «name» = ArbFactory.eINSTANCE.createARBIsLowerThanOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsGreaterThanEqualOperator o, String addExpressionStatement) ''' + «var name = "isGreaterThanEqualOperator_" + operandIndex++» + ARBIsGreaterThanEqualOperator «name» = ArbFactory.eINSTANCE.createARBIsGreaterThanEqualOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsLowerThanEqualOperator o, String addExpressionStatement) ''' + «var name = "isLowerThanEqualOperator_" + operandIndex++» + ARBIsLowerThanEqualOperator «name» = ArbFactory.eINSTANCE.createARBIsLowerThanEqualOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(AndOperator o, String addExpressionStatement) ''' + «var name = "andOperator_" + operandIndex++» + ARBAndOperator «name» = ArbFactory.eINSTANCE.createARBAndOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(OrOperator o, String addExpressionStatement) ''' + «var name = "orOperator_" + operandIndex++» + ARBOrOperator «name» = ArbFactory.eINSTANCE.createARBOrOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(NotOperator o, String addExpressionStatement) ''' + «var name = "notOperator_" + operandIndex++» + ARBNotOperator «name» = ArbFactory.eINSTANCE.createARBNotOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(ImpliesOperator o, String addExpressionStatement) ''' + «var name = "impliesOperator_" + operandIndex++» + ARBImpliesOperator «name» = ArbFactory.eINSTANCE.createARBImpliesOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(ObjectCompare o, String addExpressionStatement) ''' + «var name = "objectCompair_" + operandIndex++» + ARBObjectCompare «name» = ArbFactory.eINSTANCE.createARBObjectCompare(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsActive o, String addExpressionStatement) ''' + «var name = "isActive_" + operandIndex++» + ARBIsActive «name» = ArbFactory.eINSTANCE.createARBIsActive(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsVisible o, String addExpressionStatement) ''' + «var name = "isVisible_" + operandIndex++» + ARBIsVisible «name» = ArbFactory.eINSTANCE.createARBIsVisible(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(GetAllocatables o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "getAllocatables_" + operandIndex++» + ARBGetAllocatables «name» = ArbFactory.eINSTANCE.createARBGetAllocatables(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsDisplayed o, String addExpressionStatement) ''' + «var name = "isDisplayed_" + operandIndex++» + ARBIsDisplayed «name» = ArbFactory.eINSTANCE.createARBIsDisplayed(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsHidden o, String addExpressionStatement) ''' + «var name = "isHidden_" + operandIndex++» + ARBIsHidden «name» = ArbFactory.eINSTANCE.createARBIsHidden(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(DisplayingContent o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "displayingContent_" + operandIndex++» + ARBDisplayingContent «name» = ArbFactory.eINSTANCE.createARBDisplayingContent(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(AllocatedContent o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "allocatedContent_" + operandIndex++» + ARBAllocatedContent «name» = ArbFactory.eINSTANCE.createARBAllocatedContent(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(GetContentsList o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "getContentsList_" + operandIndex++» + ARBGetContentsList «name» = ArbFactory.eINSTANCE.createARBGetContentsList(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(ContentValue o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "contentValue_" + operandIndex++» + ARBContentValue «name» = ArbFactory.eINSTANCE.createARBContentValue(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + public static final String DummyIndicateCharacter = "|"; //$NON-NLS-1$ + + def public compile(ObjectReference o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "objectReference_" + operandIndex++» + ARBObjectReference «name» = ArbFactory.eINSTANCE.createARBObjectReference(); + «name».setRefObject(«IF o.refObject instanceof Scene »model.getScene("«o.refObject.name»"));«ELSEIF o.refObject instanceof ContentState »model.getContentState("«(o.refObject as ContentState).owner.name»", "«o.refObject.name»")); + «ELSEIF o.refObject instanceof AbstractProperty »model.getProperty("«(o.refObject as AbstractProperty).owner.name»", "«o.refObject.name»"));«ELSEIF o.refObject instanceof Zone »model.getAllocatable("«o.refObject.name»"));«ELSEIF o.refObject instanceof ZoneSet»model.getAllocatableSet("«o.refObject.name»"));«ELSEIF o.refObject instanceof Area »model.getAllocatable("«o.refObject.name»"));«ELSEIF o.refObject instanceof Content»model.getContent("«o.refObject.name»"));«ELSEIF o.refObject instanceof AreaSet»model.getAllocatableSet("«o.refObject.name»"));«ELSEIF o.refObject instanceof ContentSet»model.getContentSet("«o.refObject.name»"));«ELSEIF o.refObject instanceof Variable»«IF variableNames.containsKey(o.refObject)»«variableNames.get(o.refObject)»«ELSE»null«ENDIF»);«ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(PreviousModifier o, String addExpressionStatement) ''' + «var name = "previousModifier_" + operandIndex++» + ARBPreviousModifier «name» = ArbFactory.eINSTANCE.createARBPreviousModifier(); + «IF o.objReference !== null» + «o.objReference.compile(name + ".setObjReference")» + «ELSE» + «name».setObjReference(null); + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(ForAllOperator o, String addExpressionStatement) ''' + «var name = "forAllOperator_" + operandIndex++» + ARBForAllOperator «name» = ArbFactory.eINSTANCE.createARBForAllOperator(); + «IF o.operand !== null && o.operand.size > 0 && o.lambda !== null» + «(o.operand.get(0)).compile(o.lambda, name + ".getOperands().add", name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(ExistsOperator o, String addExpressionStatement) ''' + «var name = "existsOperator_" + operandIndex++» + ARBExistsOperator «name» = ArbFactory.eINSTANCE.createARBExistsOperator(); + «IF o.operand !== null && o.operand.size > 0 && o.lambda !== null» + «(o.operand.get(0)).compile(o.lambda, name + ".getOperands().add", name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(LambdaExpression o, String addExpressionStatement, String refContextObjectName, String setExpressionStatement) ''' + «var name = "lambdaExpression_" + operandIndex++» + ARBLambdaExpression «name» = ArbFactory.eINSTANCE.createARBLambdaExpression(); + «name».setContext(«refContextObjectName»); + «IF o.x !== null && o.bodyText !== null» + «(o.x).compile(name + ".setX", setExpressionStatement)» + «(o.bodyText).compile(name + ".setBodyText")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(Variable v, String addExpressionStatement, String refExpressionObjectName) ''' + «var name = "variable_" + operandIndex++» + «variableNames.put(v, name)» + ARBVariable «name» = ArbFactory.eINSTANCE.createARBVariable(); + «name».setDescription(«IF v.description === null»""«ELSEIF v.description.empty»""«ELSE»«v.description»«ENDIF»); + «name».setName("«v.name»"); + «name».setType(ARB«v.expressionType.class.simpleName».«v.expressionType.getName»); + «name».setExpression(«refExpressionObjectName»); + «addExpressionStatement»(«name»); + ''' + + def public compile(AllInstanceOfArea o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "allInstanceOfArea_" + operandIndex++» + ARBAllInstanceOfArea «name» = ArbFactory.eINSTANCE.createARBAllInstanceOfArea(); + «name».setRefObject(model.getAllArea()); + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(AllInstanceOfViewContent o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "allInstanceOfViewContent_" + operandIndex++» + ARBAllInstanceOfContent «name» = ArbFactory.eINSTANCE.createARBAllInstanceOfContent(); + «name».setRefObject(model.getAllViewContent()); + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(AllInstanceOfZone o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "allInstanceOfZone_" + operandIndex++» + ARBAllInstanceOfZone «name» = ArbFactory.eINSTANCE.createARBAllInstanceOfZone(); + «name».setRefObject(model.getAllZone()); + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(AllInstanceOfSoundContent o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "allInstanceOfSoundContent_" + operandIndex++» + ARBAllInstanceOfSoundContent «name» = ArbFactory.eINSTANCE.createARBAllInstanceOfSoundContent(); + «name».setRefObject(model.getAllSoundContent()); + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(SetOfOperator o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "setOfOperator_" + operandIndex++» + ARBSetOfOperator «name» = ArbFactory.eINSTANCE.createARBSetOfOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IfStatement o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "ifStatement_" + operandIndex++» + ARBIfStatement «name» = ArbFactory.eINSTANCE.createARBIfStatement(); + «IF o.condition !== null» + «(o.condition).compile(name + ".setCondition")» + «ENDIF» + «IF o.thenExpression !== null» + «(o.thenExpression).compile(name + ".setThenExpression")» + «ENDIF» + «IF o.elseExpression !== null» + «(o.elseExpression).compile(name + ".setElseExpression")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsOn o, String addExpressionStatement) ''' + «var name = "isOn_" + operandIndex++» + ARBIsOn «name» = ArbFactory.eINSTANCE.createARBIsOn(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsDisappeared o, String addExpressionStatement) ''' + «var name = "isDisappeared_" + operandIndex++» + ARBIsDisappeared «name» = ArbFactory.eINSTANCE.createARBIsDisappeared(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsCanceled o, String addExpressionStatement) ''' + «var name = "isCanceled_" + operandIndex++» + ARBIsCanceled «name» = ArbFactory.eINSTANCE.createARBIsCanceled(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(GetProperty o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "getProperty_" + operandIndex++» + ARBGetProperty «name» = ArbFactory.eINSTANCE.createARBGetProperty(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(SetProperty o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "setProperty_" + operandIndex++» + ARBSetProperty «name» = ArbFactory.eINSTANCE.createARBSetProperty(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(OffScene o, String addExpressionStatement) ''' + «var name = "offScene_" + operandIndex++» + ARBOffScene «name» = ArbFactory.eINSTANCE.createARBOffScene(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(OnScene o, String addExpressionStatement) ''' + «var name = "onScene_" + operandIndex++» + ARBOnScene «name» = ArbFactory.eINSTANCE.createARBOnScene(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsSounding o, String addExpressionStatement) ''' + «var name = "isSounding_" + operandIndex++» + ARBIsSounding «name» = ArbFactory.eINSTANCE.createARBIsSounding(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsOutputted o, String addExpressionStatement) ''' + «var name = "isOutputted_" + operandIndex++» + ARBIsOutputted «name» = ArbFactory.eINSTANCE.createARBIsOutputted(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsMuted o, String addExpressionStatement) ''' + «var name = "isMuted_" + operandIndex++» + ARBIsMuted «name» = ArbFactory.eINSTANCE.createARBIsMuted(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(OutputtingSound o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "outputtingSound_" + operandIndex++» + ARBOutputtingSound «name» = ArbFactory.eINSTANCE.createARBOutputtingSound(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IsAttenuated o, String addExpressionStatement) ''' + «var name = "isAttenuated_" + operandIndex++» + ARBIsAttenuated «name» = ArbFactory.eINSTANCE.createARBIsAttenuated(); + «IF o.operand !== null && o.operand.size > 0» + «(o.operand.get(0)).compile(name + ".getOperands().add")» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(IfActionOperator o, LambdaExpression le, String addExpressionStatement, String parentName) ''' + «var name = "ifActionOperator_" + operandIndex++» + ARBIfActionOperator «name» = ArbFactory.eINSTANCE.createARBIfActionOperator(); + «IF o.operand !== null && o.operand.size > 0» + «FOR op : o.operand» + «op.compile(name + ".getOperands().add")» + «ENDFOR» + «ENDIF» + «IF le !== null && parentName !== null && !parentName.empty» + «le.compile(parentName + ".setLambda", parentName, name)» + «ENDIF» + «addExpressionStatement»(«name»); + ''' + + def public compile(MaxValue o, String addExpressionStatement) ''' + «var name = "maxValue_" + operandIndex++» + ARBMaxValue «name» = ArbFactory.eINSTANCE.createARBMaxValue(); + «addExpressionStatement»(«name»); + ''' + + def public compile(MinValue o, String addExpressionStatement) ''' + «var name = "minValue_" + operandIndex++» + ARBMinValue «name» = ArbFactory.eINSTANCE.createARBMinValue(); + «addExpressionStatement»(«name»); + ''' + + def public compile(NoneValue o, String addExpressionStatement) ''' + «var name = "noneValue_" + operandIndex++» + ARBNoneValue «name» = ArbFactory.eINSTANCE.createARBNoneValue(); + «addExpressionStatement»(«name»); + ''' + + def public compile(StandardValue o, String addExpressionStatement) ''' + «var name = "standardValue_" + operandIndex++» + ARBStandardValue «name» = ArbFactory.eINSTANCE.createARBStandardValue(); + «addExpressionStatement»(«name»); + ''' + + def public compile(IntegerValue o, String addExpressionStatement) ''' + «var name = "integerValue_" + operandIndex++» + ARBIntegerValue «name» = ArbFactory.eINSTANCE.createARBIntegerValue(); + «name».setValue(«o.value»); + «addExpressionStatement»(«name»); + ''' +}
\ No newline at end of file diff --git a/rba.tool.editor/src/rba/tool/editor/generator/json/AbstractJSONGenerator.xtend b/rba.tool.editor/src/rba/tool/editor/generator/json/AbstractJSONGenerator.xtend new file mode 100644 index 0000000..5b5715e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/json/AbstractJSONGenerator.xtend @@ -0,0 +1,52 @@ +package rba.tool.editor.generator.json + +import java.util.List +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer +import org.eclipse.xtext.generator.AbstractFileSystemAccess +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext +import rba.tool.editor.model.manager.ResourceManager +import rba.view.Display + +abstract class AbstractJSONGenerator extends AbstractGenerator implements IJSONGenerator { + + override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + doGenerate(input.resourceSet, fsa, context); + } + + override beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override doGenerate(ResourceSet resourceSet, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (resourceSet.resources.empty) { + return; + } + val resource = resourceSet.resources.get(0); + val file = WorkspaceSynchronizer.getFile(resource); + if (!file.exists) { + return; + } + + val project = file.project; + if (project === null) { + return; + } + + if (!(fsa instanceof AbstractFileSystemAccess)) { + return; + } + + val allDisplays = ResourceManager.INSTANCE.getRbaDisplays(resourceSet); + + fsa.generateFile("data.js", OUTPUT_CONFIGURATION.name, createJSONFile(allDisplays)); + } + + def abstract public String createJSONFile(List<Display> displays); + +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/json/IJSONGenerator.xtend b/rba.tool.editor/src/rba/tool/editor/generator/json/IJSONGenerator.xtend new file mode 100644 index 0000000..e65c130 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/json/IJSONGenerator.xtend @@ -0,0 +1,18 @@ +package rba.tool.editor.generator.json + +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGenerator2 +import org.eclipse.xtext.generator.IGeneratorContext +import org.eclipse.xtext.generator.OutputConfiguration + +interface IJSONGenerator extends IGenerator2 { + + static OutputConfiguration OUTPUT_CONFIGURATION = new JSONGeneratorOutputConfiguration(); + + def void doGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/json/JSONGeneratorOutputConfiguration.xtend b/rba.tool.editor/src/rba/tool/editor/generator/json/JSONGeneratorOutputConfiguration.xtend new file mode 100644 index 0000000..fc6a73c --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/json/JSONGeneratorOutputConfiguration.xtend @@ -0,0 +1,18 @@ +package rba.tool.editor.generator.json + +import org.eclipse.xtext.generator.OutputConfiguration + +class JSONGeneratorOutputConfiguration extends OutputConfiguration { + + new() { + super("RBAMODEL_JSONGENERATOR_OUTPUT"); + setDescription("Output Folder"); + setOutputDirectory("./.RBATool/graphicalview/data"); + setOverrideExistingResources(true); + setCreateOutputDirectory(true); + setCleanUpDerivedResources(true); + setSetDerivedProperty(true); + setKeepLocalHistory(true); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/AbstractRTModelUpdater.xtend b/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/AbstractRTModelUpdater.xtend new file mode 100644 index 0000000..4435813 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/AbstractRTModelUpdater.xtend @@ -0,0 +1,23 @@ +package rba.tool.editor.generator.rtmodel + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext + +abstract class AbstractRTModelUpdater extends AbstractGenerator implements IRTModelUpdater { + + override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + doGenerate(input.resourceSet, fsa, context); + } + + override beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + +// override doGenerate(ResourceSet resourceSet, IFileSystemAccess2 fsa, IGeneratorContext context) { +// } +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/IRTModelUpdater.xtend b/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/IRTModelUpdater.xtend new file mode 100644 index 0000000..010e508 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/rtmodel/IRTModelUpdater.xtend @@ -0,0 +1,15 @@ +package rba.tool.editor.generator.rtmodel + +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGenerator2 +import org.eclipse.xtext.generator.IGeneratorContext + +interface IRTModelUpdater extends IGenerator2 { + + def void doGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeGenerationSupporter.java b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeGenerationSupporter.java new file mode 100644 index 0000000..b587cc7 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeGenerationSupporter.java @@ -0,0 +1,1599 @@ +package rba.tool.editor.generator.z3; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; + +import rba.core.AbstractAllocatable; +import rba.core.AbstractConstraint; +import rba.core.AbstractContent; +import rba.core.ActiveContents; +import rba.core.Allocatable; +import rba.core.AllocatableSet; +import rba.core.AllocatedContent; +import rba.core.AndOperator; +import rba.core.ComplexExpression; +import rba.core.Constraint; +import rba.core.Content; +import rba.core.ContentSet; +import rba.core.ContentValue; +import rba.core.ExistsOperator; +import rba.core.Expression; +import rba.core.ExpressionType; +import rba.core.ForAllOperator; +import rba.core.GetAllocatables; +import rba.core.GetContentsList; +import rba.core.GetProperty; +import rba.core.HasBeenDisplayed; +import rba.core.HasComeEarlierThan; +import rba.core.HasComeLaterThan; +import rba.core.IfStatement; +import rba.core.ImpliesOperator; +import rba.core.IntegerProperty; +import rba.core.IntegerValue; +import rba.core.IsActive; +import rba.core.IsCanceled; +import rba.core.IsDisappeared; +import rba.core.IsEqualToOperator; +import rba.core.IsGreaterThanEqualOperator; +import rba.core.IsGreaterThanOperator; +import rba.core.IsLowerThanEqualOperator; +import rba.core.IsLowerThanOperator; +import rba.core.IsOn; +import rba.core.LambdaContext; +import rba.core.LambdaExpression; +import rba.core.NotOperator; +import rba.core.ObjectCompare; +import rba.core.ObjectReference; +import rba.core.OrOperator; +import rba.core.PreviousModifier; +import rba.core.RuleObject; +import rba.core.Scene; +import rba.core.SetOfOperator; +import rba.core.SugarExpression; +import rba.core.Variable; +import rba.sound.AllInstanceOfSoundContent; +import rba.sound.AllInstanceOfZone; +import rba.sound.IsAttenuated; +import rba.sound.IsMuted; +import rba.sound.IsOutputted; +import rba.sound.IsSounding; +import rba.sound.OutputtingSound; +import rba.sound.SoundContent; +import rba.sound.SoundContentSet; +import rba.sound.Zone; +import rba.sound.ZoneSet; +import rba.view.AllInstanceOfArea; +import rba.view.AllInstanceOfViewContent; +import rba.view.Area; +import rba.view.AreaSet; +import rba.view.DisplayingContent; +import rba.view.IsDisplayed; +import rba.view.IsHidden; +import rba.view.IsVisible; +import rba.view.ViewContent; +import rba.view.ViewContentSet; + +public class ConstraintCodeGenerationSupporter implements GeneratorConstants { + + static ConstraintCodeTemplate template = new ConstraintCodeTemplate(); + + private List<Allocatable> allocatableList = new ArrayList<Allocatable>(); + + private int areaListEndIndex; + + private List<Content> contentList = new ArrayList<Content>(); + + private int viewContentListEndIndex; + + private int soundContentListEndIndex; + + private List<ContentSet> contentSetList = new ArrayList<ContentSet>(); + + private int viewContentSetListEndIndex; + + private List<AllocatableSet> allocatableSetList = new ArrayList<AllocatableSet>(); + + private int areaSetListEndIndex; + + private List<Variable> variableList; + + private List<Constraint> constraintList; + + private List<Scene> sceneList; + + private List<SetOfOperator> setOfOpeList; + + private Map<Variable, String> variableNameMap = new HashMap<Variable, String>(); + + private Map<AllocatableSet, String> allocatableSetNameMap = new HashMap<AllocatableSet, String>(); + + private Map<ContentSet, String> contentSetNameMap = new HashMap<ContentSet, String>(); + + private Map<String, String> SetOfNameMap = new HashMap<String, String>(); + + private List<ImpliseConstraintInfo> impliseMethodList = new ArrayList<ImpliseConstraintInfo>(); + + private List<ImpliseConstraintInfo> postImpliseMethodList = new ArrayList<ImpliseConstraintInfo>(); + + public String generate(List<ViewContent> viewContentList, List<SoundContent> soundContentList, List<Area> areaList, List<Zone> zoneList, + List<ViewContentSet> viewContentSetList, List<SoundContentSet> soundContentSetList, List<AreaSet> areaSetList, List<ZoneSet> zoneSetList, List<Variable> variables, + List<Constraint> constraints, List<Scene> scenes, List<SetOfOperator> setOfOperators) { + this.variableList = variables; + this.constraintList = constraints; + this.sceneList = scenes; + this.setOfOpeList = setOfOperators; + + variableNameMap.clear(); + allocatableSetNameMap.clear(); + contentSetNameMap.clear(); + SetOfNameMap.clear(); + impliseMethodList.clear(); + postImpliseMethodList.clear(); + + allocatableList.clear(); + contentList.clear(); + allocatableSetList.clear(); + contentSetList.clear(); + + areaListEndIndex = areaList.size(); + allocatableList.addAll(areaList); + allocatableList.addAll(zoneList); + + viewContentListEndIndex = viewContentList.size(); + soundContentListEndIndex = viewContentListEndIndex + soundContentList.size(); + contentList.addAll(viewContentList); + contentList.addAll(soundContentList); + + areaSetListEndIndex = areaSetList.size(); + allocatableSetList.addAll(areaSetList); + allocatableSetList.addAll(zoneSetList); + + viewContentSetListEndIndex = viewContentSetList.size(); + contentSetList.addAll(viewContentSetList); + contentSetList.addAll(soundContentSetList); + + StringBuilder setupList_Adding = new StringBuilder(); + StringBuilder init_Adding = new StringBuilder(); + StringBuilder fieldVariableAdding = new StringBuilder(); + StringBuilder allocatable_content_sizeAdding = new StringBuilder(); + + StringBuilder constraintList_Adding = new StringBuilder(); + StringBuilder impliesConstraintMethodList_Adding = new StringBuilder(); + StringBuilder impliesConstraintMethodCallList_Adding = new StringBuilder(); + + setAllocatableContext(allocatableList.subList(0, areaListEndIndex), init_Adding, "Area"); + setAllocatableContext(allocatableList.subList(areaListEndIndex, allocatableList.size()), init_Adding, "Zone"); + setContetContext(contentList.subList(0, viewContentListEndIndex), init_Adding, "ViewContent"); + setContetContext(contentList.subList(viewContentListEndIndex, soundContentListEndIndex), init_Adding, "SoundContent"); + + setAllocatableSetContext(AREASET_VAR_NAME, allocatableSetList.subList(0, areaSetListEndIndex), init_Adding, fieldVariableAdding, setupList_Adding); + setAllocatableSetContext(ZONESET_VAR_NAME, allocatableSetList.subList(areaSetListEndIndex, allocatableSetList.size()), init_Adding, fieldVariableAdding, setupList_Adding); + setContentSetContext(VIEW_CONTENTSET_VAR_NAME, contentSetList.subList(0, viewContentSetListEndIndex), init_Adding, fieldVariableAdding, setupList_Adding); + setContentSetContext(SOUND_CONTENTSET_VAR_NAME, contentSetList.subList(viewContentSetListEndIndex, contentSetList.size()), init_Adding, fieldVariableAdding, + setupList_Adding); + + allocatable_content_sizeAdding.append(_8SPACES + "allocatableSize = ctx.mkInt(" + allocatableList.size() + ");" + NL); + allocatable_content_sizeAdding.append(_8SPACES + "contentSize = ctx.mkInt(" + contentList.size() + ");"); + + for (int i = 0; i < variableList.size(); i++) { + Variable variable = variableList.get(i); + String varName = VARIABLE_VAR_NAME + (i + 1); + String define = String.format(VARIABLE_DEFINE, varName); + + constraintList_Adding.append(_8SPACES + VARIABLE_CMT + variable.getName() + NL); + constraintList_Adding.append(_8SPACES + define + NL); + constraintList_Adding.append(_8SPACES + varName + ARRAY_TOP + String.format(SET_VARIABLE_VALUE, variable.getName()) + NL); + + variableNameMap.put(variable, varName); + } + + for (int i = 0; i < setOfOpeList.size(); i++) { + SetOfOperator setOfOp = setOfOpeList.get(i); + + String varName = SETOF_OP_VAR_NAME + (i + 1); + String expressionText = setOfOp.getExpressionText(); + String string = SetOfNameMap.get(expressionText); + if (string != null) { + continue; + } + SetOfNameMap.put(expressionText, varName); + + String label = STR_QUOTE + CONSTRAINT_PREFIX + varName + STR_QUOTE; + String storeStr = getStoreExpr(setOfOp); + + fieldVariableAdding.append(_4SPACES + ARRAY_EXPR_SORT + varName + END + NL); + + setupList_Adding + .append(_8SPACES + varName + EQUAL + EX_CTX_MK_ARRAY_CONST + OPEN + STR_QUOTE + varName + STR_QUOTE + COMMA + INT_TYPE + COMMA + BOOL_TYPE + CLOSE + END + NL); + + init_Adding.append(_8SPACES + SL_COMMENT + varName + EQUAL + expressionText + NL); + init_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + varName + COMMA + storeStr + CLOSE + CLOSE + END + NL); + init_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + label + CLOSE + CLOSE + END + NL); + } + + constraintList_Adding.append(NL); + + for (int i = 0; i < constraintList.size(); i++) { + Constraint constraint = constraintList.get(i); + if (constraint.getExpression() == null) { + continue; + } + + setConstraintList(constraintList_Adding, impliesConstraintMethodList_Adding, constraint, constraint.isRuntime(), i); + } + + for (ImpliseConstraintInfo info : impliseMethodList) { + setImpliesConstraintMethod(impliesConstraintMethodCallList_Adding, info); + } + + String invarianceConstraintStr = getInvarianceConstraintStr(false); + String invariancePreConstraintStr = getInvarianceConstraintStr(true); + + template.allocatable_content_set_code = fieldVariableAdding.toString(); + template.allocatable_content_size_code = allocatable_content_sizeAdding.toString(); + template.setup_code = setupList_Adding.toString(); + template.init_code = init_Adding.toString(); + template.constraints_code = constraintList_Adding.toString(); + template.implies_constraints_call_code = impliesConstraintMethodCallList_Adding.toString(); + template.implies_constraints_method_code = impliesConstraintMethodList_Adding.toString(); + template.invariance_constr_code = invarianceConstraintStr; + template.invariance_pre_constr_code = invariancePreConstraintStr; + + return template.getCompleteCode(); + } + + private void setAllocatableContext(List<Allocatable> list, StringBuilder init_Adding, String elementId) { + if (list.isEmpty()) { + return; + } + + for (int i = 0; i < list.size(); i++) { + Allocatable area = list.get(i); + + String contents = getContents(area); + String storeStr = getStoreExpr(area); + + int index = allocatableList.indexOf(area); + + init_Adding.append(_8SPACES + SL_COMMENT + area.getName() + " = { " + contents + " }" + NL); + + String selectLeft = EX_CTX_MK_SELECT + OPEN + OP_CONTENTS_LIST + COMMA + EX_CTX_MK_INT + OPEN + (index + 1) + CLOSE + CLOSE; + init_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + selectLeft + COMMA + storeStr + CLOSE + CLOSE + END + NL); + String labelContentList = STR_QUOTE + CONSTRAINT_PREFIX + area.getName() + DOT + OP_CONTENTS_LIST + STR_QUOTE; + init_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + labelContentList + CLOSE + CLOSE + END + NL); + } + init_Adding.append(NL); + } + + private void setContetContext(List<Content> list, StringBuilder init_Adding, String elementId) { + if (list.isEmpty()) { + return; + } + + for (int i = 0; i < list.size(); i++) { + Content content = list.get(i); + + String allocatable = getAllocatables(content); + String storeStr = getStoreExpr(content); + + int index = contentList.indexOf(content); + + init_Adding.append(_8SPACES + SL_COMMENT + content.getName() + " = { " + allocatable + " }" + NL); + + String selectLeft = EX_CTX_MK_SELECT + OPEN + OP_ALLOCATABLE + COMMA + EX_CTX_MK_INT + OPEN + (index + 1) + CLOSE + CLOSE; + init_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + selectLeft + COMMA + storeStr + CLOSE + CLOSE + END + NL); + String labelContentList = STR_QUOTE + CONSTRAINT_PREFIX + content.getName() + DOT + OP_ALLOCATABLE + STR_QUOTE; + init_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + labelContentList + CLOSE + CLOSE + END + NL); + } + init_Adding.append(NL); + } + + private void setAllocatableSetContext(String name, List<AllocatableSet> list, StringBuilder init_Adding, StringBuilder fieldVariableAdding, StringBuilder setupList_Adding) { + if (list.isEmpty()) { + return; + } + + for (int i = 0; i < list.size(); i++) { + AllocatableSet set = list.get(i); + String varName = name + (i + 1); + String label = STR_QUOTE + CONSTRAINT_PREFIX + set.getName() + STR_QUOTE; + String areas = getAreas(set); + String storeStr = getStoreExpr(set); + + fieldVariableAdding.append(_4SPACES + ARRAY_EXPR_SORT + varName + END + NL); + + setupList_Adding + .append(_8SPACES + varName + EQUAL + EX_CTX_MK_ARRAY_CONST + OPEN + STR_QUOTE + varName + STR_QUOTE + COMMA + INT_TYPE + COMMA + BOOL_TYPE + CLOSE + END + NL); + + init_Adding.append(_8SPACES + SL_COMMENT + set.getName() + " = { " + areas + " }" + NL); + init_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + varName + COMMA + storeStr + CLOSE + CLOSE + END + NL); + init_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + label + CLOSE + CLOSE + END + NL); + + allocatableSetNameMap.put(set, varName); + } + setupList_Adding.append(NL); + init_Adding.append(NL); + } + + private void setContentSetContext(String name, List<ContentSet> list, StringBuilder init_Adding, StringBuilder fieldVariableAdding, StringBuilder setupList_Adding) { + if (list.isEmpty()) { + return; + } + + for (int i = 0; i < list.size(); i++) { + ContentSet contentSet = list.get(i); + String varName = name + (i + 1); + String label = STR_QUOTE + CONSTRAINT_PREFIX + contentSet.getName() + STR_QUOTE; + String contents = getContents(contentSet); + String storeStr = getStoreExpr(contentSet); + + fieldVariableAdding.append(_4SPACES + ARRAY_EXPR_SORT + varName + END + NL); + + setupList_Adding + .append(_8SPACES + varName + EQUAL + EX_CTX_MK_ARRAY_CONST + OPEN + STR_QUOTE + varName + STR_QUOTE + COMMA + INT_TYPE + COMMA + BOOL_TYPE + CLOSE + END + NL); + + init_Adding.append(_8SPACES + SL_COMMENT + contentSet.getName() + " = { " + contents + " }" + NL); + init_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + varName + COMMA + storeStr + CLOSE + CLOSE + END + NL); + init_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + label + CLOSE + CLOSE + END + NL); + + contentSetNameMap.put(contentSet, varName); + } + init_Adding.append(NL); + } + + private void setConstraintList(StringBuilder constraintList_Adding, StringBuilder impliesConstraintMethodList_Adding, AbstractConstraint constraint, boolean runtime, + int index) { + + String label = STR_QUOTE + NUMBER + String.valueOf(index + 1) + ":" + constraint.getName() + STR_QUOTE; + String expressionText = constraint.getExpression().getExpressionText(); + constraintList_Adding.append(_8SPACES + SL_COMMENT + expressionText + NL); + String constraintContextString = ""; + + try { + constraintContextString = getContextString(constraint.getExpression()); + } catch (Exception e) { + constraintList_Adding.append(NL); + e.printStackTrace(); + return; + } + + Expression targetExpression = constraint.getExpression() instanceof ComplexExpression ? ((ComplexExpression)constraint.getExpression()).getOtherExpression() : constraint.getExpression(); + + if (isBoolOperator(targetExpression)) { + constraintContextString = EX_BOOL_EXPR + constraintContextString; + } + + String indent = ""; + if (!runtime) { + indent = _4SPACES; + constraintList_Adding.append(_8SPACES + IF_OFFLINE + NL); + } + constraintList_Adding.append(indent + _8SPACES + CONSTR_LIST_ADD + OPEN + constraintContextString + CLOSE + END + NL); + constraintList_Adding.append(indent + _8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + label + CLOSE + CLOSE + END + NL); + if (!runtime) { + constraintList_Adding.append(_8SPACES + BLOCK_CLOSE + NL); + } + constraintList_Adding.append(NL); + + if (isImplieseOperator(targetExpression)) { + impliesConstraintMethodList_Adding.append(getimpliesConstraintMethodsStr(constraint, index)); + } + } + + private void setImpliesConstraintMethod(StringBuilder impliesConstraintMethodCallList_Adding, ImpliseConstraintInfo info) { + int index = info.getIndex() + 1; + String indent = ""; + if (!info.isRuntime()) { + indent = _4SPACES; + impliesConstraintMethodCallList_Adding.append(_8SPACES + IF_OFFLINE + NL); + } + String methodName = info.getMethodName(); + + impliesConstraintMethodCallList_Adding.append(indent + _8SPACES + String.format(IMPLIES_CONSTRAINT_METHOD_DETAIL1, index) + methodName + END + NL); + impliesConstraintMethodCallList_Adding.append(indent + _8SPACES + String.format(IMPLIES_CONSTRAINT_METHOD_DETAIL2, index, index) + NL); + impliesConstraintMethodCallList_Adding + .append(indent + _4SPACES + _8SPACES + String.format(IMPLIES_CONSTRAINT_METHOD_DETAIL3, index, info.getConstraint().getName(), index) + END + NL); + impliesConstraintMethodCallList_Adding.append(indent + _4SPACES + _8SPACES + String.format(IMPLIES_CONSTRAINT_METHOD_DETAIL4, index) + NL); + impliesConstraintMethodCallList_Adding.append(indent + _8SPACES + _8SPACES + IMPLIES_CONSTRAINT_METHOD_DETAIL5 + END + NL); + impliesConstraintMethodCallList_Adding.append(indent + _4SPACES + _8SPACES + BLOCK_CLOSE + NL); + impliesConstraintMethodCallList_Adding.append(indent + _8SPACES + BLOCK_CLOSE + NL); + if (!info.isRuntime()) { + impliesConstraintMethodCallList_Adding.append(_8SPACES + BLOCK_CLOSE + NL); + } + impliesConstraintMethodCallList_Adding.append(NL); + } + + private String getimpliesConstraintMethodsStr(AbstractConstraint constraint, int index) { + StringBuilder methodsCommentList_Adding = new StringBuilder(); + StringBuilder constraintList_Adding = new StringBuilder(); + + Expression targetExpression = constraint.getExpression() instanceof ComplexExpression ? ((ComplexExpression)constraint.getExpression()).getOtherExpression() : constraint.getExpression(); + Expression leftExpression = ((ImpliesOperator) targetExpression).getOperand().get(0); + + ImpliseConstraintInfo info = new ImpliseConstraintInfo(); + info.setIndex(index); + info.setConstraint(constraint); + String methodName = ""; + String allConstMethodName = ""; + + if (constraint instanceof Constraint) { + // method name + methodName = String.format(IMPLIES_CONSTRAINT_METHOD_NAME, (index + 1)); + allConstMethodName = "setAllConstraintContext"; + info.setMethodName(methodName); + impliseMethodList.add(info); + } + + // comment + methodsCommentList_Adding.append(_4SPACES + CMT_CONTENT_IMPLIES_METHOD1 + NL); + String leftText = leftExpression.getExpressionText(); + methodsCommentList_Adding.append(_4SPACES + String.format(CMT_CONTENT_IMPLIES_METHOD2, leftText) + NL); + methodsCommentList_Adding.append(_4SPACES + CMT_CONTENT_IMPLIES_METHOD3 + constraint.getName() + NL); + methodsCommentList_Adding.append(_4SPACES + CMT_CONTENT_IMPLIES_METHOD4 + constraint.getExpression().getExpressionText()); + + if (isIncludeLambdaExpression(leftExpression)) { + List<Variable> list = getVariables(leftExpression); + + for (int i = 0; i < list.size(); i++) { + Variable variable = list.get(i); + String varName = variableNameMap.get(variable); + String define = String.format(VARIABLE_DEFINE, varName); + + constraintList_Adding.append(_8SPACES + VARIABLE_CMT + variable.getName() + NL); + constraintList_Adding.append(_8SPACES + define + NL); + constraintList_Adding.append(_8SPACES + varName + ARRAY_TOP + String.format(SET_VARIABLE_VALUE, variable.getName()) + NL); + } + constraintList_Adding.append(NL); + } + + // constraint + String expression = getContextString(leftExpression); + String label = STR_QUOTE + NUMBER_ZERO + constraint.getName() + STR_QUOTE; + constraintList_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + EX_CTX_MK_EQ + OPEN + expression + COMMA + EX_CTX_MK_TRUE + CLOSE + CLOSE + END + NL); + constraintList_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + label + CLOSE + CLOSE + END + NL); + + template.implies_constrName = label; + template.implies_constraints_comment_code = methodsCommentList_Adding.toString(); + template.implies_constraints_methodName_code = _4SPACES + String.format(IMPLIES_CONSTRAINT_METHOD, methodName); + template.implies_constraints_true_code = constraintList_Adding.toString(); + + return template.getImpliesConstraintMethodCode(allConstMethodName); + } + + private String getInvarianceConstraintStr(boolean isPre) { + StringBuilder invariance_constr_Adding = new StringBuilder(); + + invariance_constr_Adding.append(getInvarianceConstraintStr_IN01(isPre)); + invariance_constr_Adding.append(NL); + invariance_constr_Adding.append(getInvarianceConstraintStr_IN02(isPre)); + invariance_constr_Adding.append(NL); + invariance_constr_Adding.append(getInvarianceConstraintStr_IN03(isPre)); + + return invariance_constr_Adding.toString(); + } + + private String getInvarianceConstraintStr_IN01(boolean isPre) { + String preLabel = ""; + String opDisplayingContent = OP_DISPLAYING_CONTENT; + if (isPre) { + opDisplayingContent = OP_PRE_DISPLAYING_CONTENT; + preLabel = "(pre)"; + } + return getInvarianceConstraintStr_IN01_IN03_Impl(preLabel, opDisplayingContent, "IN01"); + } + + private String getInvarianceConstraintStr_IN01_IN03_Impl(String preLabel, String expr, String inKind) { + StringBuilder invariance_constr_Adding = new StringBuilder(); + + invariance_constr_Adding.append(_8SPACES + "// Area." + expr + " == contentsList.get(n) OR Area." + expr + " == contentsList.get(n+1) ...)"); + invariance_constr_Adding.append(NL); + + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable mainArea = allocatableList.get(i); + String leftLabel = mainArea.getName() + "." + expr + " == "; + String areaMkInt = EX_CTX_MK_INT + OPEN + String.valueOf(i + 1) + CLOSE; + String leftconstr = EX_CTX_MK_EQ + OPEN + EX_CTX_MK_SELECT + OPEN + expr + COMMA + areaMkInt + CLOSE + COMMA; + + StringBuffer constrLabel = new StringBuffer(); + StringBuffer constr = new StringBuffer(); + + constrLabel.append(STR_QUOTE + inKind +":Constraint " + preLabel + "_" + String.valueOf(i + 1) + " - (" + leftLabel); + + List<Content> mainContents = mainArea.getContentsList(); + + int childSize = mainContents.size(); + if (childSize == 0) { + constrLabel.append("NULL"); + constr.append(leftconstr + "defNull" + CLOSE); + } else { + for (int k = 0; k < mainContents.size(); k++) { + Content content = mainContents.get(k); + String contentName = content.getName(); + + int index = contentList.indexOf(content); + String contentMkInt = EX_CTX_MK_INT + OPEN + String.valueOf(index + 1) + CLOSE; + String subConstr = ""; + if (k == 0 && k != mainContents.size() - 1) { + subConstr = EX_CTX_MK_OR + OPEN; + } + + constrLabel.append(contentName); + constr.append(subConstr + leftconstr + contentMkInt + CLOSE); + + if (k != mainContents.size() - 1) { + constrLabel.append(" OR "); + constr.append(COMMA); + } else { + if (mainContents.size() != 1) { + constr.append(CLOSE); + } + } + } + } + constrLabel.append(")" + STR_QUOTE); + + invariance_constr_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + constr.toString() + CLOSE + END + NL); + invariance_constr_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + constrLabel.toString() + CLOSE + CLOSE + END + NL); + } + + return invariance_constr_Adding.toString(); + } + + private String getInvarianceConstraintStr_IN02(boolean isPre) { + + int constNum = 1; + StringBuilder invariance_constr_Adding = new StringBuilder(); + String opIsDisplayed = OP_IS_DISPLAYED; + String opIsVisible = OP_IS_VISIBLE; + String preLabel = ""; + if (isPre) { + opIsDisplayed = OP_PRE_IS_DISPLAYED; + opIsVisible = OP_PRE_IS_VISIBLE; + preLabel = "(pre)"; + } + + invariance_constr_Adding.append(_8SPACES + "// a." + opIsDisplayed + "->c." + opIsVisible + " AND c." + opIsVisible + "->a." + opIsDisplayed); + invariance_constr_Adding.append(NL); + + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable mainArea = allocatableList.get(i); + String areaIsDisplayed = mainArea.getName() + "." + opIsDisplayed; + String areaMkInt = EX_CTX_MK_INT + OPEN + String.valueOf(i + 1) + CLOSE; + + List<Content> mainContents = mainArea.getContentsList(); + + if (mainContents.size() != 1) { + continue; + } + + for (int j = 0; j < mainContents.size(); j++) { + StringBuffer constrLabel = new StringBuffer(); + StringBuffer constr = new StringBuffer(); + Content mainContent = mainContents.get(j); + + if (mainContent.getAllocatableList().size() != 1) { + continue; + } + + int index = contentList.indexOf(mainContent); + String contentIsVisible = mainContent.getName() + "." + opIsVisible; + String mainContentMkInt = EX_CTX_MK_INT + OPEN + String.valueOf(index + 1) + CLOSE; + + constrLabel.append(STR_QUOTE + "IN02:Constraint" + preLabel + "_" + String.valueOf(constNum) + " - " + areaIsDisplayed + " -> " + contentIsVisible + " AND " + + contentIsVisible + " -> " + areaIsDisplayed + STR_QUOTE); + constNum++; + + constr.append(EX_CTX_MK_AND + OPEN); + constr.append(EX_CTX_MK_IMPLIES + OPEN + EX_BOOL_EXPR + EX_CTX_MK_SELECT + OPEN + opIsDisplayed + COMMA + areaMkInt + CLOSE + COMMA + EX_BOOL_EXPR + + EX_CTX_MK_SELECT + OPEN + opIsVisible + COMMA + mainContentMkInt + CLOSE + CLOSE); + constr.append(COMMA); + constr.append(EX_CTX_MK_IMPLIES + OPEN + EX_BOOL_EXPR + EX_CTX_MK_SELECT + OPEN + opIsVisible + COMMA + mainContentMkInt + CLOSE + COMMA + EX_BOOL_EXPR + + EX_CTX_MK_SELECT + OPEN + opIsDisplayed + COMMA + areaMkInt + CLOSE + CLOSE); + constr.append(CLOSE); + + invariance_constr_Adding.append(_8SPACES + CONSTR_LIST_ADD + OPEN + constr.toString() + CLOSE + END + NL); + invariance_constr_Adding.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + constrLabel.toString() + CLOSE + CLOSE + END + NL); + } + } + + return invariance_constr_Adding.toString(); + } + + private String getInvarianceConstraintStr_IN03(boolean isPre) { + String preLabel = ""; + String opAllocatedContent = OP_ALLOCATED_CONTENT; + if (isPre) { + opAllocatedContent = OP_PRE_ALLOCATED_CONTENT; + preLabel = "(pre)"; + } + return getInvarianceConstraintStr_IN01_IN03_Impl(preLabel, opAllocatedContent, "IN03"); + } + + private boolean isIncludeLambdaExpression(Expression expression) { + + for (Iterator<EObject> iterator = expression.eAllContents(); iterator.hasNext();) { + EObject object = iterator.next(); + if (object instanceof LambdaContext | object instanceof LambdaExpression) { + return true; + } + } + return false; + } + + private List<Variable> getVariables(Expression expression) { + List<Variable> list = new ArrayList<Variable>(); + + for (Iterator<EObject> iterator = expression.eAllContents(); iterator.hasNext();) { + EObject object = iterator.next(); + if (object instanceof Variable) { + list.add((Variable) object); + } + } + return list; + } + + private boolean isImplieseOperator(Expression expression) { + if (expression instanceof ImpliesOperator) { + return true; + } + return false; + } + + private boolean isBoolOperator(Expression expression) { + if (expression instanceof IsVisible) { + return true; + } else if (expression instanceof IsDisplayed) { + return true; + } else if (expression instanceof IsActive) { + return true; + } else if (expression instanceof IsHidden) { + return true; + } else if (expression instanceof IfStatement) { + return true; + } else if (expression instanceof IsDisappeared) { + return true; + } else if (expression instanceof IsCanceled) { + return true; + } else if (expression instanceof IsMuted) { + return true; + } else if (expression instanceof IsOutputted) { + return true; + } else if (expression instanceof IsAttenuated) { + return true; + } else if (expression instanceof IsSounding) { + return true; + } else if (expression instanceof IsOn) { + return true; + } else if (expression instanceof HasBeenDisplayed) { + return true; + } else if (expression instanceof HasComeEarlierThan) { + return true; + } else if (expression instanceof HasComeLaterThan) { + return true; + } + return false; + } + + private String getStoreExpr(Allocatable allocatable) { + String context = EMP_ARRAY_CONST; + + List<Content> contentsList = allocatable.getContentsList(); + + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (contentsList.contains(content)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + + return context; + } + + private String getStoreExpr(Content content) { + String context = EMP_ARRAY_CONST; + + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable area = allocatableList.get(i); + if (content.getAllocatableList().contains(area)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + + return context; + } + + private String getStoreExpr(AllocatableSet allocatableSet) { + String context = EMP_ARRAY_CONST; + List<RuleObject> set = getRuleObjectsBySet(allocatableSet, new ArrayList<RuleObject>()); + + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable area = allocatableList.get(i); + if (set.contains(area)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + + return context; + } + + private String getStoreExpr(ContentSet contentSet) { + String context = EMP_ARRAY_CONST; + List<RuleObject> set = getRuleObjectsBySet(contentSet, new ArrayList<RuleObject>()); + + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (set.contains(content)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + + return context; + } + + private String getStoreExpr(SetOfOperator op) { + String context = EMP_ARRAY_CONST; + + List<RuleObject> objects = new ArrayList<RuleObject>(); + EList<Expression> operand = op.getOperand(); + if (operand.isEmpty()) { + return context; + } + + for (Expression expression : operand) { + if (!(expression instanceof ObjectReference)) { + continue; + } + + RuleObject refObject = ((ObjectReference) expression).getRefObject(); + if (refObject instanceof Content || refObject instanceof Allocatable) { + objects.add(refObject); + } else if (refObject instanceof ContentSet | refObject instanceof AllocatableSet) { + objects.addAll(getRuleObjectsBySet(refObject, new ArrayList<RuleObject>())); + } + } + + if (objects.isEmpty()) { + return context; + } + + if (objects.get(0) instanceof Area) { + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable area = allocatableList.get(i); + if (objects.contains(area)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + } else if (objects.get(0) instanceof Zone) { + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable zone = allocatableList.get(i); + if (objects.contains(zone)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + } else if (objects.get(0) instanceof ViewContent) { + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (objects.contains(content)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + } else if (objects.get(0) instanceof SoundContent) { + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (objects.contains(content)) { + context = String.format(STORE_TEMPLATE, context, (i + 1)); + } + } + } + + return context; + } + + private List<RuleObject> getRuleObjectsBySet(RuleObject refObject, List<RuleObject> elementSetList) { + Set<RuleObject> sets = new HashSet<RuleObject>(); + + if (refObject instanceof AllocatableSet) { + AllocatableSet set = (AllocatableSet) refObject; + for (AbstractAllocatable abst : set.getTarget()) { + if (abst instanceof Allocatable) { + sets.add(abst); + } else if (abst instanceof AllocatableSet) { + if (!elementSetList.contains(abst)) { + elementSetList.add(abst); + sets.addAll(getRuleObjectsBySet(abst, elementSetList)); + } + } + } + } + if (refObject instanceof ContentSet) { + ContentSet set = (ContentSet) refObject; + for (AbstractContent abst : set.getTarget()) { + if (abst instanceof Content) { + sets.add(abst); + } else if (abst instanceof ContentSet) { + if (!elementSetList.contains(abst)) { + elementSetList.add(abst); + sets.addAll(getRuleObjectsBySet(abst, elementSetList)); + } + } + } + } + + return new ArrayList<RuleObject>(sets); + } + + private String getContents(Allocatable allocatable) { + String contentStr = ""; + List<Content> contents = allocatable.getContentsList(); + + for (Content content : contents) { + contentStr += content.getName(); + if (contents.indexOf(content) != contents.size() - 1) { + contentStr += COMMA + " "; + } + } + return contentStr; + } + + private String getAllocatables(Content content) { + String areas = ""; + EList<Allocatable> allocatables = content.getAllocatableList(); + for (AbstractAllocatable allocatable : allocatables) { + areas += allocatable.getName(); + if (allocatables.indexOf(allocatable) != allocatables.size() - 1) { + areas += COMMA + " "; + } + } + return areas; + } + + private String getAreas(AllocatableSet set) { + String areas = ""; + + for (AbstractAllocatable area : set.getTarget()) { + areas += area.getName(); + if (set.getTarget().indexOf(area) != set.getTarget().size() - 1) { + areas += COMMA + " "; + } + } + return areas; + } + + private String getContents(ContentSet contentSet) { + String contents = ""; + + for (AbstractContent content : contentSet.getTarget()) { + contents += content.getName(); + if (contentSet.getTarget().indexOf(content) != contentSet.getTarget().size() - 1) { + contents += COMMA + " "; + } + } + return contents; + } + + private String getContextString(Expression expression) { + String contextString = null; + + if (expression instanceof ComplexExpression) { + contextString = getContextString(((ComplexExpression) expression).getOtherExpression()); + } else if (expression instanceof AndOperator) { + contextString = resolveExpression((AndOperator) expression); + } else if (expression instanceof OrOperator) { + contextString = resolveExpression((OrOperator) expression); + } else if (expression instanceof NotOperator) { + contextString = resolveExpression((NotOperator) expression); + } else if (expression instanceof ImpliesOperator) { + contextString = resolveExpression((ImpliesOperator) expression); + } else if (expression instanceof ObjectCompare) { + contextString = resolveExpression((ObjectCompare) expression); + } else if (expression instanceof IsEqualToOperator) { + contextString = resolveExpression((IsEqualToOperator) expression); + } else if (expression instanceof IsGreaterThanOperator) { + contextString = resolveExpression((IsGreaterThanOperator) expression); + } else if (expression instanceof IsGreaterThanEqualOperator) { + contextString = resolveExpression((IsGreaterThanEqualOperator) expression); + } else if (expression instanceof IsLowerThanOperator) { + contextString = resolveExpression((IsLowerThanOperator) expression); + } else if (expression instanceof IsLowerThanEqualOperator) { + contextString = resolveExpression((IsLowerThanEqualOperator) expression); + } else if (expression instanceof IsDisplayed) { + contextString = resolveExpression((IsDisplayed) expression); + } else if (expression instanceof DisplayingContent) { + contextString = resolveExpression((DisplayingContent) expression); + } else if (expression instanceof AllocatedContent) { + contextString = resolveExpression((AllocatedContent) expression); + } else if (expression instanceof GetContentsList) { + System.out.println("GetContentsList is not supported yet!"); + } else if (expression instanceof IsHidden) { + contextString = resolveExpression((IsHidden) expression); + } else if (expression instanceof IsActive) { + contextString = resolveExpression((IsActive) expression); + } else if (expression instanceof IsVisible) { + contextString = resolveExpression((IsVisible) expression); + } else if (expression instanceof GetAllocatables) { + System.out.println("GetAllocatables is not supported yet!"); + } else if (expression instanceof ContentValue) { + contextString = resolveExpression((ContentValue) expression); + } else if (expression instanceof ExistsOperator) { + contextString = resolveExpression((ExistsOperator) expression); + } else if (expression instanceof ForAllOperator) { + contextString = resolveExpression((ForAllOperator) expression); + } else if (expression instanceof IfStatement) { + contextString = resolveExpression((IfStatement) expression); + } else if (expression instanceof IsOn) { + contextString = resolveExpression((IsOn) expression); + } else if (expression instanceof ObjectReference) { + contextString = resolveExpression((ObjectReference) expression); + } else if (expression instanceof PreviousModifier) { + contextString = resolveExpression((PreviousModifier) expression); + } else if (expression instanceof IsDisappeared) { + contextString = resolveExpression((IsDisappeared) expression); + } else if (expression instanceof IsCanceled) { + contextString = resolveExpression((IsCanceled) expression); + } else if (expression instanceof IsMuted) { + contextString = resolveExpression((IsMuted) expression); + } else if (expression instanceof IsSounding) { + contextString = resolveExpression((IsSounding) expression); + } else if (expression instanceof OutputtingSound) { + contextString = resolveExpression((OutputtingSound) expression); + } else if (expression instanceof IsAttenuated) { + contextString = resolveExpression((IsAttenuated) expression); + } else if (expression instanceof IsOutputted) { + contextString = resolveExpression((IsOutputted) expression); + } else if (expression instanceof GetProperty) { + contextString = resolveExpression((GetProperty) expression); + } else if (expression instanceof IntegerValue) { + contextString = resolveExpression((IntegerValue) expression); + } else if (expression instanceof HasComeEarlierThan) { + contextString = resolveExpression((HasComeEarlierThan) expression); + } else if (expression instanceof HasComeLaterThan) { + contextString = resolveExpression((HasComeLaterThan) expression); + } else if (expression instanceof HasBeenDisplayed) { + contextString = resolveExpression((HasBeenDisplayed) expression); + } else if (expression instanceof SugarExpression) { + contextString = getContextString(((SugarExpression) expression).getExpanded()); + } else { + // TODO Specification not found + throw new RuntimeException("Expected Expression type is not supported yet! : " + expression.getExpressionText()); + } + + return contextString; + } + + private String resolveExpression(AndOperator expression) { + List<Expression> operand = expression.getOperand(); + String context = EX_CTX_MK_AND + OPEN; + for (int i = 0; i < operand.size(); i++) { + Expression op = operand.get(i); + String opContext = getContextString(op); + context += EX_BOOL_EXPR + opContext; + + if (i != operand.size() - 1) { + context += COMMA; + } + } + + return context + CLOSE; + } + + private String resolveExpression(OrOperator expression) { + List<Expression> operand = expression.getOperand(); + + String context = EX_CTX_MK_OR + OPEN; + for (int i = 0; i < operand.size(); i++) { + Expression op = operand.get(i); + String opContext = getContextString(op); + context += EX_BOOL_EXPR + opContext; + + if (i != operand.size() - 1) { + context += COMMA; + } + } + + return context + CLOSE; + } + + private String resolveExpression(NotOperator expression) { + List<Expression> operand = ((NotOperator) expression).getOperand(); + String context = getContextString(operand.get(0)); + + return EX_CTX_MK_NOT + OPEN + EX_BOOL_EXPR + context + CLOSE; + } + + private String resolveExpression(ImpliesOperator expression) { + List<Expression> operand = ((ImpliesOperator) expression).getOperand(); + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_IMPLIES + OPEN + EX_BOOL_EXPR + leftContext + COMMA + EX_BOOL_EXPR + rightContext + CLOSE; + } + + private String resolveExpression(ObjectCompare expression) { + List<Expression> operand = expression.getOperand(); + String leftCast = EX_BOOL_EXPR; + String rightCast = EX_BOOL_EXPR; + if ((operand.get(0) instanceof ContentValue) || (operand.get(0) instanceof DisplayingContent) || (operand.get(0) instanceof AllocatedContent) + || (operand.get(0) instanceof OutputtingSound) || (operand.get(0) instanceof GetProperty) || (operand.get(0) instanceof ObjectReference)) { + leftCast = EX_INT_EXPR; + } + if ((operand.get(1) instanceof ContentValue) || (operand.get(1) instanceof DisplayingContent) || (operand.get(1) instanceof AllocatedContent) + || (operand.get(1) instanceof OutputtingSound) || (operand.get(1) instanceof GetProperty) || (operand.get(1) instanceof ObjectReference)) { + rightCast = EX_INT_EXPR; + } + + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_EQ + OPEN + leftCast + leftContext + COMMA + rightCast + rightContext + CLOSE; + } + + private String resolveExpression(IsLowerThanEqualOperator expression) { + List<Expression> operand = expression.getOperand(); + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_LE + OPEN + EX_INT_EXPR + leftContext + COMMA + EX_INT_EXPR + rightContext + CLOSE; + } + + private String resolveExpression(IsLowerThanOperator expression) { + List<Expression> operand = expression.getOperand(); + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_LT + OPEN + EX_INT_EXPR + leftContext + COMMA + EX_INT_EXPR + rightContext + CLOSE; + } + + private String resolveExpression(IsGreaterThanEqualOperator expression) { + List<Expression> operand = expression.getOperand(); + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_GE + OPEN + EX_INT_EXPR + leftContext + COMMA + EX_INT_EXPR + rightContext + CLOSE; + } + + private String resolveExpression(IsGreaterThanOperator expression) { + List<Expression> operand = expression.getOperand(); + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_GT + OPEN + EX_INT_EXPR + leftContext + COMMA + EX_INT_EXPR + rightContext + CLOSE; + } + + private String resolveExpression(IsEqualToOperator expression) { + List<Expression> operand = expression.getOperand(); + String cast = EX_INT_EXPR; + + String leftContext = getContextString(operand.get(0)); + String rightContext = getContextString(operand.get(1)); + + return EX_CTX_MK_EQ + OPEN + cast + leftContext + COMMA + cast + rightContext + CLOSE; + } + + private String resolveExpression(ExistsOperator expression) { + return resolveExpression(expression, EX_CTX_MK_EXISTS, ""); + } + + private String resolveExpression(ForAllOperator expression) { + return resolveExpression(expression, EX_CTX_MK_FORALL, EX_CTX_MK_IMPLIES); + } + + private String resolveExpression(LambdaContext expression, String mkMethod, String implies) { + LambdaExpression lambda = expression.getLambda(); + Variable x = lambda.getX(); + + EList<Expression> operand = expression.getOperand(); + + String size = ""; + String setName = ""; + String variableName = variableNameMap.get(x); + if (operand.get(0) instanceof ObjectReference) { + ObjectReference ref = (ObjectReference) operand.get(0); + if (ref.getUnderlyingType() == ExpressionType.SET_OF_AREA || ref.getUnderlyingType() == ExpressionType.SET_OF_ZONE) { + size = ALLOCATABLE_SIZE; + } else if (ref.getUnderlyingType() == ExpressionType.SET_OF_CONTENT || ref.getUnderlyingType() == ExpressionType.SET_OF_SOUND) { + size = CONTENT_SIZE; + } + + setName = resolveExpression((ObjectReference) operand.get(0)); + + } else if (operand.get(0) instanceof GetAllocatables) { + size = CONTENT_SIZE; + + GetAllocatables getAllocatable = (GetAllocatables) operand.get(0); + if (getAllocatable.getOperand().get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) getAllocatable.getOperand().get(0); + String select = resolveExpression(pre.getObjReference()); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_PRE_ALLOCATABLE + COMMA + select + CLOSE; + } else { + String select = resolveExpression((ObjectReference) getAllocatable.getOperand().get(0)); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_ALLOCATABLE + COMMA + select + CLOSE; + } + + } else if (operand.get(0) instanceof GetContentsList) { + size = ALLOCATABLE_SIZE; + + GetContentsList getContentsList = (GetContentsList) operand.get(0); + if (getContentsList.getOperand().get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) getContentsList.getOperand().get(0); + String select = resolveExpression(pre.getObjReference()); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_PRE_CONTENTS_LIST + COMMA + select + CLOSE; + } else { + String select = resolveExpression((ObjectReference) getContentsList.getOperand().get(0)); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_CONTENTS_LIST + COMMA + select + CLOSE; + } + + } else if (operand.get(0) instanceof AllInstanceOfArea) { + size = ALLOCATABLE_SIZE; + setName = ALL_AREA_CONST; + } else if (operand.get(0) instanceof AllInstanceOfZone) { + size = ALLOCATABLE_SIZE; + setName = ALL_ZONE_CONST; + } else if (operand.get(0) instanceof AllInstanceOfViewContent) { + size = CONTENT_SIZE; + setName = ALL_VIEWCONTENT_CONST; + } else if (operand.get(0) instanceof AllInstanceOfSoundContent) { + size = CONTENT_SIZE; + setName = ALL_SOUNDCONTENT_CONST; + } else if (operand.get(0) instanceof SetOfOperator) { + SetOfOperator setOfOp = (SetOfOperator) operand.get(0); + if (setOfOp.getUnderlyingType() == ExpressionType.SET_OF_AREA || setOfOp.getUnderlyingType() == ExpressionType.SET_OF_ZONE) { + size = ALLOCATABLE_SIZE; + } else if (setOfOp.getUnderlyingType() == ExpressionType.SET_OF_CONTENT || setOfOp.getUnderlyingType() == ExpressionType.SET_OF_SOUND) { + size = CONTENT_SIZE; + } + + String expressionText = setOfOp.getExpressionText(); + setName = SetOfNameMap.get(expressionText); + } else if (operand.get(0) instanceof ActiveContents) { + size = CONTENT_SIZE; + ActiveContents activeContents = (ActiveContents) operand.get(0); + if (activeContents.getOperand().get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) activeContents.getOperand().get(0); + String select = resolveExpression(pre.getObjReference()); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_PRE_ACTIVE_CONTENTS + COMMA + select + CLOSE; + } else { + String select = resolveExpression((ObjectReference) activeContents.getOperand().get(0)); + setName = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_ACTIVE_CONTENTS + COMMA + select + CLOSE; + } + } + + String setContext = EX_CTX_MK_SELECT + OPEN + setName + COMMA + variableName + ARRAY_TOP + CLOSE; + String expContext = getContextString(lambda.getBodyText()); + String rangeContext = EX_CTX_MK_AND + OPEN + EX_CTX_MK_LE + OPEN + EX_CTX_MK_INT + OPEN + 1 + CLOSE + COMMA + EX_ARITH_EXPR + variableName + ARRAY_TOP + CLOSE + COMMA + + EX_CTX_MK_LE + OPEN + EX_ARITH_EXPR + variableName + ARRAY_TOP + COMMA + size + CLOSE + CLOSE; + String bodyContext = EX_CTX_MK_AND + OPEN + rangeContext + COMMA + EX_BOOL_EXPR + setContext; + + if (!implies.isEmpty()) { + bodyContext = implies + OPEN + bodyContext + CLOSE + COMMA + EX_BOOL_EXPR + expContext + CLOSE; + } else { + bodyContext += COMMA + EX_BOOL_EXPR + expContext + CLOSE; + } + + String context = mkMethod + OPEN + variableName + COMMA + bodyContext + COMMA + 1 + COMMA + NULL_STRING + COMMA + NULL_STRING + COMMA + NULL_STRING + COMMA + NULL_STRING + + CLOSE; + return context; + } + + private String resolveExpression(IsDisplayed expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_DISPLAYED + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_DISPLAYED + COMMA + context + CLOSE; + } + + private String resolveExpression(IsVisible expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_VISIBLE + COMMA + context + CLOSE; + } + + String context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_VISIBLE + COMMA + context + CLOSE; + } + + private String resolveExpression(IsHidden expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_HIDDEN + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_HIDDEN + COMMA + context + CLOSE; + } + + private String resolveExpression(IsActive expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_ACTIVE + COMMA + context + CLOSE; + } + + String context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_ACTIVE + COMMA + context + CLOSE; + } + + private String resolveExpression(DisplayingContent expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_DISPLAYING_CONTENT + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_DISPLAYING_CONTENT + COMMA + context + CLOSE; + } + + private String resolveExpression(AllocatedContent expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_ALLOCATED_CONTENT + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_ALLOCATED_CONTENT + COMMA + context + CLOSE; + } + + private String resolveExpression(ContentValue expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_CONTENT_VALUE + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_CONTENT_VALUE + COMMA + context + CLOSE; + } + + private String resolveExpression(IsMuted expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_MUTED + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_MUTED + COMMA + context + CLOSE; + } + + private String resolveExpression(IsOutputted expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_OUTPUTTED + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_OUTPUTTED + COMMA + context + CLOSE; + } + + private String resolveExpression(IsAttenuated expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_ATTENUATED + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_ATTENUATED + COMMA + context + CLOSE; + } + + private String resolveExpression(OutputtingSound expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_OUTPUTTING_SOUND + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_OUTPUTTING_SOUND + COMMA + context + CLOSE; + } + + private String resolveExpression(IsSounding expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_SOUNDING + COMMA + context + CLOSE; + } + + String context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_SOUNDING + COMMA + context + CLOSE; + } + + private String resolveExpression(GetProperty expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return String.format(context, OP_PRE_GET_PROPERTY); + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return String.format(context, OP_GET_PROPERTY); + } + + private String resolveExpression(IntegerValue expression) { + int value = expression.getValue(); + return EX_CTX_MK_INT + OPEN + String.valueOf(value) + CLOSE; + } + + private String resolveExpression(IfStatement expression) { + + Expression condition = expression.getCondition(); + Expression thenExpression = expression.getThenExpression(); + Expression elseExpression = expression.getElseExpression(); + + String conditionContext = getContextString(condition); + String thenContext = getContextString(thenExpression); + String elseContext = getContextString(elseExpression); + + String context = EX_CTX_MK_ITE + OPEN + EX_BOOL_EXPR + conditionContext + COMMA + thenContext + COMMA + elseContext + CLOSE; + return context; + } + + private String resolveExpression(IsOn expression) { + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + String context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_ON + COMMA + context + CLOSE; + } else if (!(operand.get(0) instanceof ObjectReference)) { + String context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_ON + COMMA + context + CLOSE; + } + + String context = resolveExpression((ObjectReference) operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_ON + COMMA + context + CLOSE; + } + + private String resolveExpression(ObjectReference expression) { + if (expression.getRefObject() instanceof Area) { + Area target = (Area) expression.getRefObject(); + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable area = allocatableList.get(i); + if (target == area) { + return EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE; + } + } + } else if (expression.getRefObject() instanceof Zone) { + Zone target = (Zone) expression.getRefObject(); + for (int i = 0; i < allocatableList.size(); i++) { + Allocatable allocatable = allocatableList.get(i); + if (target == allocatable) { + return EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE; + } + } + } else if (expression.getRefObject() instanceof ViewContent) { + Content target = (Content) expression.getRefObject(); + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (target == content) { + return EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE; + } + } + } else if (expression.getRefObject() instanceof SoundContent) { + Content target = (Content) expression.getRefObject(); + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + if (target == content) { + return EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE; + } + } + } else if (expression.getRefObject() instanceof Variable) { + Variable target = (Variable) expression.getRefObject(); + + if ((expression.eContainer() instanceof GetAllocatables) || (expression.eContainer() instanceof GetContentsList)) { + return EX_CTX_MK_INT_CONST + OPEN + EX_CTX_MK_SYMBOL + OPEN + STR_QUOTE + target.getName() + STR_QUOTE + CLOSE + CLOSE; + } + + return variableNameMap.get(target) + ARRAY_TOP; + } else if (expression.getRefObject() instanceof AllocatableSet) { + AllocatableSet target = (AllocatableSet) expression.getRefObject(); + return allocatableSetNameMap.get(target); + } else if (expression.getRefObject() instanceof ContentSet) { + ContentSet target = (ContentSet) expression.getRefObject(); + return contentSetNameMap.get(target); + } else if (expression.getRefObject() instanceof Scene) { + Scene target = (Scene) expression.getRefObject(); + for (int i = 0; i < sceneList.size(); i++) { + Scene scene = sceneList.get(i); + if (target == scene) { + return EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE; + } + } + } else if (expression.getRefObject() instanceof IntegerProperty) { + IntegerProperty target = (IntegerProperty) expression.getRefObject(); + Scene parent = (Scene) target.eContainer(); + + for (int i = 0; i < sceneList.size(); i++) { + Scene scene = sceneList.get(i); + if (parent == scene) { + int propIndex = scene.getProperties().indexOf(target) + 1; + + String propContext = EX_CTX_MK_SELECT + OPEN + "%s" + COMMA + EX_CTX_MK_INT + OPEN + propIndex + CLOSE + CLOSE; + return EX_CTX_MK_SELECT + OPEN + EX_ARRAY_EXPR_CATS + propContext + COMMA + EX_CTX_MK_INT + OPEN + (i + 1) + CLOSE + CLOSE; + } + } + } + return null; + } + + private String resolveExpression(PreviousModifier expression) { + String context = resolveExpression(expression.getObjReference()); + return context; + } + + private String resolveExpression(IsDisappeared expression) { + EList<Expression> operand = expression.getOperand(); + + String context = ""; + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_DISAPPEARED + COMMA + context + CLOSE; + } + + context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_DISAPPEARED + COMMA + context + CLOSE; + } + + private String resolveExpression(IsCanceled expression) { + EList<Expression> operand = expression.getOperand(); + + String context = ""; + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_IS_CANCELED + COMMA + context + CLOSE; + } + + context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_IS_CANCELED + COMMA + context + CLOSE; + } + + private String resolveExpression(HasBeenDisplayed expression) { + EList<Expression> operand = expression.getOperand(); + + String context = ""; + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + context = resolveExpression(pre.getObjReference()); + return EX_CTX_MK_SELECT + OPEN + OP_PRE_HAS_BEEN_DISPLAYED + COMMA + context + CLOSE; + } + + context = getContextString(operand.get(0)); + return EX_CTX_MK_SELECT + OPEN + OP_HAS_BEEN_DISPLAYED + COMMA + context + CLOSE; + } + private String resolveExpression(HasComeEarlierThan expression) { + String context = ""; + String leftContext = ""; + String rightContext = ""; + + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + leftContext = resolveExpression(pre.getObjReference()); + } else { + leftContext = getContextString(operand.get(0)); + } + + if (operand.get(1) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(1); + rightContext = resolveExpression(pre.getObjReference()); + } else { + rightContext = getContextString(operand.get(1)); + } + + String context1 = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_HAS_COME_EARLIER_THAN + COMMA + leftContext + CLOSE; + context = EX_CTX_MK_SELECT + OPEN + context1 + COMMA + rightContext + CLOSE; + + return context; + } + + private String resolveExpression(HasComeLaterThan expression) { + String context = ""; + String leftContext = ""; + String rightContext = ""; + + EList<Expression> operand = expression.getOperand(); + + if (operand.get(0) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(0); + leftContext = resolveExpression(pre.getObjReference()); + } else { + leftContext = getContextString(operand.get(0)); + } + + if (operand.get(1) instanceof PreviousModifier) { + PreviousModifier pre = (PreviousModifier) operand.get(1); + rightContext = resolveExpression(pre.getObjReference()); + } else { + rightContext = getContextString(operand.get(1)); + } + + String context1 = EX_ARRAY_EXPR_CATS + EX_CTX_MK_SELECT + OPEN + OP_HAS_COME_LATER_THAN + COMMA + leftContext + CLOSE; + context = EX_CTX_MK_SELECT + OPEN + context1 + COMMA + rightContext + CLOSE; + + return context; + } + + class ImpliseConstraintInfo { + int index; + + AbstractConstraint constraint; + + String methodName; + + public int getIndex() { + return index; + } + + public String getMethodName() { + return methodName; + } + + public boolean isRuntime() { + if (constraint instanceof Constraint) { + return ((Constraint) constraint).isRuntime(); + } + return true; + } + + public void setMethodName(String methodName) { + this.methodName = methodName; + } + + public void setIndex(int index) { + this.index = index; + } + + public AbstractConstraint getConstraint() { + return constraint; + } + + public void setConstraint(AbstractConstraint constraint) { + this.constraint = constraint; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeTemplate.java b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeTemplate.java new file mode 100644 index 0000000..1f96853 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintCodeTemplate.java @@ -0,0 +1,315 @@ +package rba.tool.editor.generator.z3; + +public class ConstraintCodeTemplate { + + String allocatable_content_set_code; + String allocatable_content_size_code; + String init_code; + String setup_code; + String constraints_code; + String implies_constraints_call_code; + String implies_constraints_method_code; + String implies_constraints_comment_code; + String implies_constraints_methodName_code; + String implies_constraints_true_code; + String implies_constrName; + String invariance_constr_code; + String invariance_pre_constr_code; + + private static final String NL = "\r\n"; + + String getCompleteCode() { + return "import groovy.transform.CompileStatic;" + NL + NL + + "import java.util.ArrayList;" + NL + + "import java.util.LinkedHashMap;" + NL + + "import java.util.List;" + NL + + "import java.util.Map;" + NL + NL + + + "import com.microsoft.z3.ArithExpr;" + NL + + "import com.microsoft.z3.ArrayExpr;" + NL + + "import com.microsoft.z3.BoolExpr;" + NL + + "import com.microsoft.z3.Context;" + NL + + "import com.microsoft.z3.Expr;" + NL + + "import com.microsoft.z3.IntExpr;" + NL + + "import com.microsoft.z3.Quantifier;" + NL + + "import com.microsoft.z3.Solver;" + NL + + "import com.microsoft.z3.Sort;" + NL + + "import com.microsoft.z3.Status;" + NL + NL + + "import com.microsoft.z3.IntNum;" + NL + NL + + + "import rba.tool.core.z3.Z3CodeManager;" + NL + NL + + + "@CompileStatic" + NL + + "public class ConstraintCalculation implements rba.tool.core.constraint.IConstraintCalculation {" + NL + NL + + " boolean onlyOnline;" + NL + + " IntNum defNull;" + NL + + " IntNum allocatableSize;" + NL + + " IntNum contentSize;" + NL + + " Context ctx;" + NL + + " Sort int_type;" + NL + + " Sort bool_type;" + NL + + " Sort array_int_bool_type;" + NL + + " Sort array_int_int_type;" + NL + + " ArrayExpr displayingContent;" + NL + + " ArrayExpr allocatedContent;" + NL + + " ArrayExpr isDisplayed;" + NL + + " ArrayExpr isHidden;" + NL + + " ArrayExpr contentsList;" + NL + + " ArrayExpr contentValue;" + NL + + " ArrayExpr isVisible;" + NL + + " ArrayExpr isActive;" + NL + + " ArrayExpr allocatable;" + NL + + " ArrayExpr preDisplayingContent;" + NL + + " ArrayExpr preAllocatedContent;" + NL + + " ArrayExpr preIsDisplayed;" + NL + + " ArrayExpr preIsHidden;" + NL + + " ArrayExpr preContentsList;" + NL + + " ArrayExpr preContentValue;" + NL + + " ArrayExpr preIsVisible;" + NL + + " ArrayExpr preIsActive;" + NL + + " ArrayExpr preAllocatable;" + NL + + " ArrayExpr isMuted;" + NL + + " ArrayExpr isOutputted;" + NL + + " ArrayExpr isAttenuated;" + NL + + " ArrayExpr outputtingSound;" + NL + + " ArrayExpr isSounding;" + NL + + " ArrayExpr preIsMuted;" + NL + + " ArrayExpr preIsOutputted;" + NL + + " ArrayExpr preIsAttenuated;" + NL + + " ArrayExpr preOutputtingSound;" + NL + + " ArrayExpr preIsSounding;" + NL + + " ArrayExpr isOn;" + NL + + " ArrayExpr getProperty;" + NL + + " ArrayExpr preIsOn;" + NL + + " ArrayExpr preGetProperty;" + NL + + " ArrayExpr isDefeatedBy;" + NL + + " ArrayExpr defeats;" + NL + + " ArrayExpr isDisappeared;" + NL + + " ArrayExpr isCanceled;" + NL + + + " ArrayExpr hasBeenDisplayed;" + NL + + " ArrayExpr hasComeEarlierThan;" + NL + + " ArrayExpr hasComeLaterThan;" + NL + + + " ArrayExpr preIsDefeatedBy;" + NL + + " ArrayExpr preDefeats;" + NL + + " ArrayExpr preIsDisappeared;" + NL + + " ArrayExpr preIsCanceled;" + NL + NL + + + " ArrayExpr activeContents;" + NL + + " ArrayExpr preActiveContents;" + NL + + " ArrayExpr preHasBeenDisplayed;" + NL + + + " ArrayExpr emp;" + NL + + " ArrayExpr empArrayConst;" + NL + + " ArrayExpr allInstanceOfArea;" + NL + + " ArrayExpr allInstanceOfAreaConst;" + NL + + " ArrayExpr allInstanceOfZone;" + NL + + " ArrayExpr allInstanceOfZoneConst;" + NL + + " ArrayExpr allInstanceOfViewContent;" + NL + + " ArrayExpr allInstanceOfViewContentConst;" + NL + NL + + " ArrayExpr allInstanceOfSoundContent;" + NL + + " ArrayExpr allInstanceOfSoundContentConst;" + NL + NL + + + allocatable_content_set_code + NL + + + " public void setUp(boolean onlyOnline) {" + NL + + " this.onlyOnline = onlyOnline;" + NL + + " ctx = new Context();" + NL + + " defNull = ctx.mkInt(0);" + NL + + allocatable_content_size_code + NL + + " int_type = ctx.getIntSort();" + NL + + " bool_type = ctx.getBoolSort();" + NL + + " array_int_bool_type = ctx.mkArraySort(int_type, bool_type);" + NL + + " array_int_int_type = ctx.mkArraySort(int_type, int_type);" + NL + NL + + + " displayingContent = ctx.mkArrayConst(\"displayingContent\", int_type, int_type);" + NL + + " allocatedContent = ctx.mkArrayConst(\"allocatedContent\", int_type, int_type);" + NL + + " isDisplayed = ctx.mkArrayConst(\"isDisplayed\", int_type, bool_type);" + NL + + " contentsList = ctx.mkArrayConst(\"contentsList\", int_type, array_int_bool_type);" + NL + + " contentValue = ctx.mkArrayConst(\"contentValue\", int_type, int_type);" + NL + + " isHidden = ctx.mkArrayConst(\"isHidden\", int_type, bool_type);" + NL + + " isVisible = ctx.mkArrayConst(\"isVisible\", int_type, bool_type);" + NL + + " isActive = ctx.mkArrayConst(\"isActive\", int_type, bool_type);" + NL + + " allocatable = ctx.mkArrayConst(\"allocatable\", int_type, array_int_bool_type);" + NL + NL + + " outputtingSound = ctx.mkArrayConst(\"outputtingSound\", int_type, int_type);" + NL + + " isOutputted = ctx.mkArrayConst(\"isOutputted\", int_type, bool_type);" + NL + + " isMuted = ctx.mkArrayConst(\"isMuted\", int_type, bool_type);" + NL + + " isAttenuated = ctx.mkArrayConst(\"isAttenuated\", int_type, bool_type);" + NL + + " isSounding = ctx.mkArrayConst(\"isSounding\", int_type, bool_type);" + NL + + + " preDisplayingContent = ctx.mkArrayConst(\"preDisplayingContent\", int_type, int_type);" + NL + + " preAllocatedContent = ctx.mkArrayConst(\"preAllocatedContent\", int_type, int_type);" + NL + + " preIsDisplayed = ctx.mkArrayConst(\"preIsDisplayed\", int_type, bool_type);" + NL + + " preContentsList = ctx.mkArrayConst(\"preContentsList\", int_type, array_int_bool_type);" + NL + + " preContentValue = ctx.mkArrayConst(\"preContentValue\", int_type, int_type);" + NL + + " preIsHidden = ctx.mkArrayConst(\"preIsHidden\", int_type, bool_type);" + NL + + " preIsVisible = ctx.mkArrayConst(\"preIsVisible\", int_type, bool_type);" + NL + + " preIsActive = ctx.mkArrayConst(\"preIsActive\", int_type, bool_type);" + NL + + " preAllocatable = ctx.mkArrayConst(\"preAllocatable\", int_type, array_int_bool_type);" + NL +NL + + " preOutputtingSound = ctx.mkArrayConst(\"preOutputtingSound\", int_type, int_type);" + NL + + " preIsOutputted = ctx.mkArrayConst(\"preIsOutputted\", int_type, bool_type);" + NL + + " preIsMuted = ctx.mkArrayConst(\"preIsMuted\", int_type, bool_type);" + NL + + " preIsAttenuated = ctx.mkArrayConst(\"preIsAttenuated\", int_type, bool_type);" + NL + + " preIsSounding = ctx.mkArrayConst(\"preIsSounding\", int_type, bool_type);" + NL + + + " isOn = ctx.mkArrayConst(\"isOn\", int_type, bool_type);" + NL + + " getProperty = ctx.mkArrayConst(\"getProperty\", int_type, array_int_int_type);" + NL + + " preIsOn = ctx.mkArrayConst(\"preIsOn\", int_type, bool_type);" + NL + + " preGetProperty = ctx.mkArrayConst(\"preGetProperty\", int_type, array_int_int_type);" + NL + + " isDefeatedBy = ctx.mkArrayConst(\"isDefeatedBy\", int_type, array_int_bool_type);" + NL + + " defeats = ctx.mkArrayConst(\"defeats\", int_type, array_int_bool_type);" + NL + + " isDisappeared = ctx.mkArrayConst(\"isDisappeared\", int_type, bool_type);" + NL + + " isCanceled = ctx.mkArrayConst(\"isCanceled\", int_type, bool_type);" + NL + + + " hasBeenDisplayed = ctx.mkArrayConst(\"hasBeenDisplayed\", int_type, bool_type);" + NL + + " hasComeEarlierThan = ctx.mkArrayConst(\"hasComeEarlierThan\", int_type, array_int_bool_type);" + NL + + " hasComeLaterThan = ctx.mkArrayConst(\"hasComeLaterThan\", int_type, array_int_bool_type);" + NL + + + " preIsDefeatedBy = ctx.mkArrayConst(\"preIsDefeatedBy\", int_type, array_int_bool_type);" + NL + + " preDefeats = ctx.mkArrayConst(\"preDefeats\", int_type, array_int_bool_type);" + NL + + " preIsDisappeared = ctx.mkArrayConst(\"preIsDisappeared\", int_type, bool_type);" + NL + + " preIsCanceled = ctx.mkArrayConst(\"preIsCanceled\", int_type, bool_type);" + NL + NL + + + " preHasBeenDisplayed = ctx.mkArrayConst(\"preHasBeenDisplayed\", int_type, bool_type);" + NL + + + " activeContents = ctx.mkArrayConst(\"activeContents\", int_type, array_int_bool_type);" + NL + + " preActiveContents = ctx.mkArrayConst(\"preActiveContents\", int_type, array_int_bool_type);" + NL + + + " emp = ctx.mkArrayConst(\"emp\", int_type, bool_type);" + NL + + " empArrayConst = ctx.mkConstArray(int_type, ctx.mkFalse());" + NL + + " allInstanceOfArea = ctx.mkArrayConst(\"allInstanceOfArea\", int_type, bool_type);" + NL + + " allInstanceOfAreaConst = ctx.mkConstArray(int_type, ctx.mkTrue());" + NL + + " allInstanceOfZone = ctx.mkArrayConst(\"allInstanceOfZone\", int_type, bool_type);" + NL + + " allInstanceOfZoneConst = ctx.mkConstArray(int_type, ctx.mkTrue());" + NL + + " allInstanceOfViewContent = ctx.mkArrayConst(\"allInstanceOfViewContent\", int_type, bool_type);" + NL + + " allInstanceOfViewContentConst = ctx.mkConstArray(int_type, ctx.mkTrue());" + NL +NL + + " allInstanceOfSoundContent = ctx.mkArrayConst(\"allInstanceOfSoundContent\", int_type, bool_type);" + NL + + " allInstanceOfSoundContentConst = ctx.mkConstArray(int_type, ctx.mkTrue());" + NL +NL + + + setup_code + NL + + " }" + NL + NL + + + " public void close() {" + NL + + " ctx.close();" + NL + + " }" + NL + NL + + + " /**" + NL + + " * Initialization of constraint list" + NL + + " */" + NL + + " private void initConstraintList(List<BoolExpr> constrList, List<BoolExpr> constrLabelList) {" + NL + + " constrList.add(ctx.mkEq(emp, empArrayConst));" + NL + + " constrLabelList.add(ctx.mkBoolConst(\"Constraint : Emp \"));" + NL + + " constrList.add(ctx.mkEq(allInstanceOfArea, allInstanceOfAreaConst));" + NL + + " constrLabelList.add(ctx.mkBoolConst(\"Constraint : AllInstanceOfArea \"));" + NL + + " constrList.add(ctx.mkEq(allInstanceOfZone, allInstanceOfZoneConst));" + NL + + " constrLabelList.add(ctx.mkBoolConst(\"Constraint : AllInstanceOfZone \"));" + NL + + " constrList.add(ctx.mkEq(allInstanceOfViewContent, allInstanceOfViewContentConst));" + NL + + " constrLabelList.add(ctx.mkBoolConst(\"Constraint : AllInstanceOfViewContent \"));" + NL + NL + + " constrList.add(ctx.mkEq(allInstanceOfSoundContent, allInstanceOfSoundContentConst));" + NL + + " constrLabelList.add(ctx.mkBoolConst(\"Constraint : AllInstanceOfSoundContent \"));" + NL + NL + + + init_code + NL + + + " }" + NL + NL + + + " /**" + NL + + " * Contradiction verification of all constraints" + NL + + " */" + NL + + " public List<String> calculateAllConstraint() {" + NL + + " Solver s = ctx.mkSolver();" + NL + + " s.push();" + NL + NL + + + " List<BoolExpr> constrList = new ArrayList<BoolExpr>();" + NL + + " List<BoolExpr> constrLabelList = new ArrayList<BoolExpr>();" + NL + NL + + + " setAllConstraintContext(constrList, constrLabelList);" + NL + NL + + + " for (int i = 0; i < constrList.size(); i++) {" + NL +// + " s.assertAndTrack(constrList.get(i), constrLabelList.get(i));" + NL + + " s.assertAndTrack((BoolExpr) constrList.get(i).simplify(), constrLabelList.get(i));" + NL + + " }" + NL + NL + + + " Status st = s.check();" + NL + + " List<String> list = Z3CodeManager.INSTNACE.getErrors(ctx, s, st,\"allConstr\" ,constrList, constrLabelList);" + NL + + " s.pop();" + NL + + " return list;" + NL + + " }" + NL + NL + + + " /**" + NL + + " * Contradiction verification execution" + NL + + " */" + NL + + " public void setAllConstraintContext(List<BoolExpr> constrList, List<BoolExpr> constrLabelList) {" + NL + + " initConstraintList(constrList, constrLabelList);" + NL + + + constraints_code + NL + + + " setInvarianceConstraintContext(constrList, constrLabelList);" + NL + + " setInvariancePreConstraintContext(constrList, constrLabelList);" + NL + + + " }" + NL + NL + + + " /**" + NL + + " * Model invariant constraints" + NL + + " */" + NL + + " public void setInvarianceConstraintContext(List<BoolExpr> constrList, List<BoolExpr> constrLabelList) {" + NL + + + invariance_constr_code + NL + + + " }" + NL + NL + + + " /**" + NL + + " * Model invariant constraint (pre constraint)" + NL + + " */" + NL + + " public void setInvariancePreConstraintContext(List<BoolExpr> constrList, List<BoolExpr> constrLabelList) {" + NL + + + invariance_pre_constr_code + NL + + + " }" + NL + NL + + + " /**" + NL + + " * Contradiction verification of implication partial constraints" + NL + + " */" + NL + + " public Map<String, List<String>> calculateImpliesConstraints() {" + NL + + " Map<String, List<String>> map = new LinkedHashMap<String, List<String>>();" + NL + + + implies_constraints_call_code + NL + + + " return map;" + NL + + " }" + NL + NL + + + implies_constraints_method_code + NL + + + "}" + NL; + + } + + String getImpliesConstraintMethodCode(String allConstMethodName) { + return " /**" + NL + + implies_constraints_comment_code + NL + + " */" + NL + + implies_constraints_methodName_code + NL + + " System.out.println(\"Calculate:\" + "+implies_constrName+");" + NL + NL + + + " Solver s = ctx.mkSolver();" + NL + + " s.push();" + NL + NL + + + " List<BoolExpr> constrList = new ArrayList<BoolExpr>();" + NL + + " List<BoolExpr> constrLabelList = new ArrayList<BoolExpr>();" + NL + NL + + + implies_constraints_true_code + NL + + + " "+allConstMethodName+"(constrList, constrLabelList);" + NL + NL + + + " for (int i = 0; i < constrList.size(); i++) {" + NL + + " s.assertAndTrack((BoolExpr) constrList.get(i).simplify(), constrLabelList.get(i));" + NL + + " }" + NL + NL + + + " Status st = s.check();" + NL + + " List<String> list = Z3CodeManager.INSTNACE.getErrors(ctx, s, st, "+implies_constrName+",constrList, constrLabelList);" + NL + + " s.pop();" + NL + + " return list;" + NL + + " }" + NL; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintGeneratorImpl.xtend b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintGeneratorImpl.xtend new file mode 100644 index 0000000..907f8df --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/ConstraintGeneratorImpl.xtend @@ -0,0 +1,48 @@ +package rba.tool.editor.generator.z3 + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext +import rba.tool.editor.model.manager.ResourceManager + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +class ConstraintGeneratorImpl extends AbstractGenerator implements IConstraintGenerator { + + private static ConstraintCodeGenerationSupporter generationSupporter = new ConstraintCodeGenerationSupporter(); + + override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + doGenerate(input.resourceSet, fsa, context); + } + + override beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override void doGenerate(ResourceSet resourceSet, IFileSystemAccess2 fsa, IGeneratorContext context) { + fsa.generateFile("ConstraintCalculation.java", resourceSet.compile); + } + + def compile(ResourceSet resourceSet) ''' + «val allAreas = ResourceManager.INSTANCE.getRbaAreas(resourceSet)» + «val allZones = ResourceManager.INSTANCE.getRbaZones(resourceSet)» + «val allVContents = ResourceManager.INSTANCE.getRbaViewContents(resourceSet)» + «val allSContents = ResourceManager.INSTANCE.getRbaSoundContents(resourceSet)» + «val allAreaSets = ResourceManager.INSTANCE.getRbaAreaSets(resourceSet)» + «val allZoneSets = ResourceManager.INSTANCE.getRbaZoneSets(resourceSet)» + «val allVContentSets = ResourceManager.INSTANCE.getRbaViewContentSets(resourceSet)» + «val allSContentSets = ResourceManager.INSTANCE.getRbaSoundContentSets(resourceSet)» + «val allValiables = ResourceManager.INSTANCE.getRbaVariables(resourceSet)» + «val allConstraints = ResourceManager.INSTANCE.getRbaConstraints(resourceSet)» + «val allScenes = ResourceManager.INSTANCE.getRbaScenes(resourceSet)» + «val allSetOfOperators = ResourceManager.INSTANCE.getRbaSetOfOperators(resourceSet)» + «generationSupporter.generate(allVContents,allSContents, allAreas,allZones, allVContentSets,allSContentSets, allAreaSets,allZoneSets, allValiables, allConstraints, allScenes, allSetOfOperators)» + ''' +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/GeneratorConstants.java b/rba.tool.editor/src/rba/tool/editor/generator/z3/GeneratorConstants.java new file mode 100644 index 0000000..7ca3b74 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/GeneratorConstants.java @@ -0,0 +1,320 @@ +package rba.tool.editor.generator.z3; + +interface GeneratorConstants { + + static final String CMT_AREA_LIST = "// Area definition"; + + static final String CMT_AREA_VISIBILITY_LABEL_LIST = "// Visibility-constrained labeling"; + + static final String CMT_AREA_ZORDER_LABEL_LIST = "// Constraint expression labeling"; + + static final String CMT_CONTENT_STATE_LIST = "// Content definition"; + + static final String CMT_CONTENT_STATE_LABEL_LIST = "// Labeling Priority Constraint Expressions"; + + static final String CMT_CONTENT_STATE_PRIORITY_COMMENT_CONNECTOR = "Priority conditional expression"; + + static final String CMT_CONTENT_MULTI_START = "/**"; + + static final String CMT_CONTENT_MULTI_END = " */"; + + static final String CMT_CONTENT_IMPLIES_METHOD1 = " * Contradiction verification of implication partial constraints"; + + static final String CMT_CONTENT_IMPLIES_METHOD2 = " * %s == TRUE holds"; + + static final String CMT_CONTENT_IMPLIES_METHOD3 = " * target name : "; + + static final String CMT_CONTENT_IMPLIES_METHOD4 = " * expression text : "; + + static final String CMT_NAME_CLOSE = "]"; + + static final String CMT_NAME_OPEN = "["; + + static final String EX_NON = "non"; + + static final String EX_STD = "std"; + + static final String EX_MAX = "max"; + + static final String EX_MIN = "min"; + + static final String FUNC_ALLO_LIST = "createAlloList"; + + static final String FUNC_ALLO_VIS_CONSTR = "createAlloVisConstrList"; + + static final String FUNC_ALLO_VIS_CONSTR_LBL = "createAlloVisConstrLbl"; + + static final String FUNC_AREA_LIST = "createAreaList"; + + static final String FUNC_AREA_ZORDR_CONSTR = "createAreaZorderConstrList"; + + static final String FUNC_AREA_ZORDR_CONSTR_LBL = "createAreaZorderConstrLbl"; + + static final String FUNC_CST_LIST = "createContentList"; + + static final String FUNC_CST_CONSTR = "createConstrList"; + + static final String FUNC_CST_CONSTR_LBL = "createConstrLabelList"; + + static final String EX_CTX_MK_EQ = "ctx.mkEq"; + + static final String EX_CTX_MK_GT = "ctx.mkGt"; + + static final String EX_CTX_MK_LT = "ctx.mkLt"; + + static final String EX_CTX_MK_AND = "ctx.mkAnd"; + + static final String EX_CTX_MK_ADD = "ctx.mkAdd"; + + static final String EX_CTX_MK_INT = "ctx.mkInt"; + + static final String EX_CTX_MK_OR = "ctx.mkOr"; + + static final String EX_CTX_MK_XOR = "ctx.mkXor"; + + static final String EX_CTX_MK_NOT = "ctx.mkNot"; + + static final String EX_CTX_MK_IMPLIES = "ctx.mkImplies"; + + static final String EX_CTX_MK_GE = "ctx.mkGe"; + + static final String EX_CTX_MK_LE = "ctx.mkLe"; + + static final String EX_CTX_MK_SELECT = "ctx.mkSelect"; + + static final String EX_CTX_MK_STORE = "ctx.mkStore"; + + static final String EX_CTX_MK_EXISTS = "ctx.mkExists"; + + static final String EX_CTX_MK_FORALL = "ctx.mkForall"; + + static final String EX_CTX_MK_SYMBOL = "ctx.mkSymbol"; + + static final String EX_CTX_MK_ITE = "ctx.mkITE"; + + static final String EX_CTX_MK_TRUE = "ctx.mkTrue()"; + + static final String EX_CTX_MK_FALSE = "ctx.mkFalse()"; + + static final String EX_INT_EXPR = "(IntExpr) "; + + static final String EX_BOOL_EXPR = "(BoolExpr) "; + + static final String EX_ARITH_EXPR = "(ArithExpr) "; + + static final String EX_ARRAY_EXPR_CATS = "(ArrayExpr) "; + + static final String EX_CTX_MK_BOOL_CONST = "ctx.mkBoolConst"; + + static final String EX_CTX_MK_INT_CONST = "ctx.mkIntConst"; + + static final String EX_CTX_MK_ARRAY_CONST = "ctx.mkArrayConst"; + + static final String AREA_LIST_NAME = "areaList"; + + static final String CONSTR_LIST_NAME = "constrList"; + + static final String CONSTR_LABEL_LIST_NAME = "constrLabelList"; + + static final String CONTENT_LIST_NAME = "contentList"; + + static final String CONTENT_LIST_ADD = "contentList.add"; + + static final String CONSTR_LIST_ADD = "constrList.add"; + + static final String AREA_LIST_ADD = "areaList.add"; + + static final String CONSTR_LABEL_LIST_ADD = "constrLabelList.add"; + + static final String VISIBILITY = " Visibility : "; + + static final String ZORDER = " Zorder : "; + + static final String GET = ".get"; + + static final String CONST_ADDED_VALUE = "10"; + + static final String STR_QUOTE = "\""; + + static final String _4SPACES = " "; + + static final String _8SPACES = " "; + + static final String OPEN = "("; + + static final String CLOSE = ")"; + + static final String NAME_SEPARATOR = "_"; + + static final String COMMA = ", "; + + static final String DOT = "."; + + static final String NULL_STRING = "null"; + + static final String SL_COMMENT = "//"; + + static final String NL = "\r\n"; + + static final String END = ";"; + + static final String NUMBER = "#"; + + static final String NUMBER_ZERO = "#0:"; + + static final String VARIABLE_CMT = "// Variable "; + + static final String VARIABLE_DEFINE = "Expr[] %s = new Expr[1];"; + + static final String VARIABLE_VAR_NAME = "variable_"; + + static final String AREASET_VAR_NAME = "areaSet_"; + + static final String ZONESET_VAR_NAME = "zoneSet_"; + + static final String VIEW_CONTENTSET_VAR_NAME = "vcontentSet_"; + + static final String SOUND_CONTENTSET_VAR_NAME = "scontentSet_"; + + static final String SETOF_OP_VAR_NAME = "setOfOperator_"; + + static final String ARRAY_TOP = "[0]"; + + static final String SET_VARIABLE_VALUE = " = ctx.mkConst(ctx.mkSymbol(\"%s\"), ctx.getIntSort());"; + + static final String OP_IS_DISPLAYED = "isDisplayed"; + + static final String OP_DISPLAYING_CONTENT = "displayingContent"; + + static final String OP_ALLOCATED_CONTENT = "allocatedContent"; + + static final String OP_CONTENTS_LIST = "contentsList"; + + static final String OP_IS_HIDDEN = "isHidden"; + + static final String OP_IS_ACTIVE = "isActive"; + + static final String OP_IS_VISIBLE = "isVisible"; + + static final String OP_ALLOCATABLE = "allocatable"; + + static final String OP_CONTENT_VALUE = "contentValue"; + + static final String OP_PRE_IS_DISPLAYED = "preIsDisplayed"; + + static final String OP_PRE_DISPLAYING_CONTENT = "preDisplayingContent"; + + static final String OP_PRE_ALLOCATED_CONTENT = "preAllocatedContent"; + + static final String OP_PRE_CONTENTS_LIST = "preContentsList"; + + static final String OP_PRE_IS_HIDDEN = "preIsHidden"; + + static final String OP_PRE_IS_ACTIVE = "preIsActive"; + + static final String OP_PRE_IS_VISIBLE = "preIsVisible"; + + static final String OP_PRE_ALLOCATABLE = "preAllocatable"; + + static final String OP_PRE_CONTENT_VALUE = "preContentValue"; + + static final String OP_IS_MUTED = "isMuted"; + + static final String OP_PRE_IS_MUTED = "preIsMuted"; + + static final String OP_IS_ATTENUATED = "isAttenuated"; + + static final String OP_PRE_IS_ATTENUATED = "preIsAttenuated"; + + static final String OP_IS_SOUNDING = "isSounding"; + + static final String OP_PRE_IS_SOUNDING = "preIsSounding"; + + static final String OP_OUTPUTTING_SOUND = "outputtingSound"; + + static final String OP_PRE_OUTPUTTING_SOUND = "preOutputtingSound"; + + static final String OP_IS_OUTPUTTED = "isOutputted"; + + static final String OP_PRE_IS_OUTPUTTED = "preIsOutputted"; + + static final String OP_GET_PROPERTY = "getProperty"; + + static final String OP_PRE_GET_PROPERTY = "preGetProperty"; + + static final String OP_IS_ON = "isOn"; + + static final String OP_PRE_IS_ON = "preIsOn"; + + static final String OP_IS_DEFEATED_BY = "isDefeatedBy"; + + static final String OP_PRE_IS_DEFEATED_BY = "preIsDefeatedBy\""; + + static final String OP_DEFEATS = "defeats"; + + static final String OP_PRE_DEFEATS = "preDefeats"; + + static final String OP_IS_DISAPPEARED = "isDisappeared"; + + static final String OP_PRE_IS_DISAPPEARED = "preIsDisappeared"; + + static final String OP_IS_CANCELED = "isCanceled"; + + static final String OP_PRE_IS_CANCELED = "preIsCanceled"; + + static final String OP_HAS_BEEN_DISPLAYED = "hasBeenDisplayed"; + + static final String OP_PRE_HAS_BEEN_DISPLAYED = "preHasBeenDisplayed"; + + static final String OP_HAS_COME_EARLIER_THAN = "hasComeEarlierThan"; + + static final String OP_HAS_COME_LATER_THAN = "hasComeLaterThan"; + + static final String OP_ACTIVE_CONTENTS = "activeContents"; + + static final String OP_PRE_ACTIVE_CONTENTS = "preActiveContents"; + + static final String EMP_ARRAY_CONST = "empArrayConst"; + + static final String ALL_AREA_CONST = "allInstanceOfAreaConst"; + + static final String ALL_ZONE_CONST = "allInstanceOfZoneConst"; + + static final String ALL_SOUNDCONTENT_CONST = "allInstanceOfSoundContentConst"; + + static final String ALL_VIEWCONTENT_CONST = "allInstanceOfViewContentConst"; + + static final String ALLOCATABLE_SIZE = "allocatableSize"; + + static final String CONTENT_SIZE = "contentSize"; + + static final String ARRAY_EXPR_SORT = "ArrayExpr "; + + static final String CONSTRAINT_PREFIX = "Constraint:"; + + static final String EQUAL = " = "; + + static final String INT_TYPE = "int_type"; + + static final String BOOL_TYPE = "bool_type"; + + static final String IMPLIES_CONSTRAINT_METHOD_NAME = "doCalculateImpliesConstraint_%s()"; + + static final String IMPLIES_CONSTRAINT_METHOD = "private List<String> %s {"; + + static final String IMPLIES_CONSTRAINT_METHOD_DETAIL1 = "List<String> constraint_%s" + EQUAL; + + static final String IMPLIES_CONSTRAINT_METHOD_DETAIL2 = "if(!constraint_%s.isEmpty() && !constraint_%s.get(0).equals(\"SAT\")) {"; + + static final String IMPLIES_CONSTRAINT_METHOD_DETAIL3 = "map.put(\"#%s:%s\", constraint_%s)"; + + static final String IMPLIES_CONSTRAINT_METHOD_DETAIL4 = "if(constraint_%s.get(0).equals(\"UNSAT\")) {"; + + static final String IMPLIES_CONSTRAINT_METHOD_DETAIL5 = "return map"; + + static final String BLOCK_CLOSE = "}"; + + static final String IF_OFFLINE = "if(!onlyOnline) {"; + + static final String STORE_TEMPLATE = EX_CTX_MK_STORE + OPEN + "%s" + COMMA + EX_CTX_MK_INT + OPEN + "%s" + CLOSE + COMMA + EX_CTX_MK_TRUE + CLOSE;; +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/IConstraintGenerator.xtend b/rba.tool.editor/src/rba/tool/editor/generator/z3/IConstraintGenerator.xtend new file mode 100644 index 0000000..b1e01a9 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/IConstraintGenerator.xtend @@ -0,0 +1,15 @@ +package rba.tool.editor.generator.z3 + +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGenerator2 +import org.eclipse.xtext.generator.IGeneratorContext + +interface IConstraintGenerator extends IGenerator2 { + + def void doGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); +}
\ No newline at end of file diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/ISortValueGenerator.xtend b/rba.tool.editor/src/rba/tool/editor/generator/z3/ISortValueGenerator.xtend new file mode 100644 index 0000000..044ceae --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/ISortValueGenerator.xtend @@ -0,0 +1,15 @@ +package rba.tool.editor.generator.z3 + +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGenerator2 +import org.eclipse.xtext.generator.IGeneratorContext + +interface ISortValueGenerator extends IGenerator2 { + + def void doGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); + + def void afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context); +}
\ No newline at end of file diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeGenerationSupporter.java b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeGenerationSupporter.java new file mode 100644 index 0000000..b6e872a --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeGenerationSupporter.java @@ -0,0 +1,555 @@ +package rba.tool.editor.generator.z3; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +import org.eclipse.emf.common.util.EList; + +import rba.core.Allocatable; +import rba.core.ComparisonAnd; +import rba.core.ComparisonOperator; +import rba.core.Content; +import rba.core.ContentState; +import rba.core.EqualToOperator; +import rba.core.Expression; +import rba.core.GreaterThanOperator; +import rba.core.IfStatement; +import rba.core.IntegerValue; +import rba.core.LowerThanOperator; +import rba.core.MaxValue; +import rba.core.MinValue; +import rba.core.MuchGreaterThanOperator; +import rba.core.NoneValue; +import rba.core.ObjectReference; +import rba.core.Operator; +import rba.core.PlusOperator; +import rba.core.RuleObject; +import rba.core.StandardValue; +import rba.core.ThatOfOperator; +import rba.core.ValueExpression; +import rba.tool.editor.util.RBAModelEditorToolUtil; +import rba.view.Area; + +public class SortValueCodeGenerationSupporter implements GeneratorConstants { + + static final int LIST_LIMIT = 1000; + + static SortValueCodeTemplate template = new SortValueCodeTemplate(); + + private List<Area> areaList; + + private List<Allocatable> allocatableList; + + private List<Content> contentList; + + private List<ContentState> contentStateList; + + public String generate(List<Content> contents, List<Allocatable> allocatables, List<Area> areas) { + this.contentList = contents; + this.allocatableList = allocatables; + this.areaList = areas; + this.contentStateList = new ArrayList<ContentState>(); + + // for common + StringBuilder method_code_Adding = new StringBuilder(); + + // for calculateArea_zorder + StringBuilder area_zorder_code = new StringBuilder(); + StringBuilder areaListZorder_Adding = new StringBuilder(); + StringBuilder zorder_comment = new StringBuilder(); + StringBuilder zorderConstrList_Adding = new StringBuilder(); + StringBuilder areaConstrLabelListZorder_Adding = new StringBuilder(); + StringBuilder calculateArea_zorder_Method = new StringBuilder(); + List<StringBuilder> calculateAreaZorderMethidList = new ArrayList<StringBuilder>(); + + // for calculateAllocatable_visibility + StringBuilder allocatable_visibility_code = new StringBuilder(); + StringBuilder allocatableList_Adding = new StringBuilder(); + StringBuilder visibility_comment = new StringBuilder(); + StringBuilder visibilityConstrList_Adding = new StringBuilder(); + StringBuilder allocatableConstrLabelList_Adding = new StringBuilder(); + List<StringBuilder> calculateAllocatableVisibilityMethidList = new ArrayList<StringBuilder>(); + + // for calculateContentState_priority + StringBuilder content_state_priority_code = new StringBuilder(); + List<StringBuilder> contentStateMethidList = new ArrayList<StringBuilder>(); + StringBuilder content_state_priority_method_code = new StringBuilder(); + + area_zorder_code.append(_8SPACES + CMT_AREA_LIST + NL); + allocatable_visibility_code.append(_8SPACES + CMT_AREA_LIST + NL); + content_state_priority_code.append(_8SPACES + CMT_CONTENT_STATE_LIST + NL); + + /////////////////// Area/Zone Visibility Code Prepare @Start + List<List<Allocatable>> limitedAlloList = new ArrayList<>(); + ListHelper.extract(allocatableList, LIST_LIMIT, _list -> { + limitedAlloList.add(_list); + }); + + int visMethodNum = 0; + for (List<Allocatable> _list : limitedAlloList) { + method_code_Adding.append(getAllocatableVisibilityMethodString(_list, visMethodNum)); + allocatable_visibility_code.append(getAllocatableVisibilityMethodCallString(visMethodNum)); + visMethodNum++; + } + /////////////////// Area/Zone Visibility Code Prepare @End + + /////////////////// Area Zorder Code Prepare @Start + List<List<Area>> limitedAreaList = new ArrayList<>(); + ListHelper.extract(areaList, LIST_LIMIT, _list -> { + limitedAreaList.add(_list); + }); + + int zoMethodNum = 0; + for (List<Area> _list : limitedAreaList) { + method_code_Adding.append(getAreaZorderMethodString(_list, zoMethodNum)); + area_zorder_code.append(getAreaZorderMethodCallString(zoMethodNum)); + zoMethodNum++; + } + /////////////////// Area Zorder Code Prepare @End + + /////////////////// Content State Priority Code Prepare @Start + for (int i = 0; i < contentList.size(); i++) { + Content content = contentList.get(i); + for (ContentState cState : content.getStates()) { + contentStateList.add(cState); + } + } + List<List<ContentState>> limitedContentList = new ArrayList<>(); + ListHelper.extract(contentStateList, LIST_LIMIT, _list -> { + limitedContentList.add(_list); + }); + + int ctMethodNum = 0; + for (List<ContentState> _list : limitedContentList) { + method_code_Adding.append(getContentStateMethodString(_list, ctMethodNum)); + content_state_priority_code.append(getContentStateMethodCallString(ctMethodNum)); + ctMethodNum++; + } + + +// int num = 0; +// StringBuilder content_state_priority_code_main = new StringBuilder(); +// for (int i = 0; i < contentStateList.size(); i += LIST_LIMIT) { +// int toIdx = ((i + LIST_LIMIT) >= contentStateList.size() ? contentStateList.size() : (i + LIST_LIMIT)); +// StringBuilder contentStateMethod = getContentStateMethodString(contentStateList.subList(i, toIdx), num, content_state_priority_code_main); +// contentStateMethidList.add(contentStateMethod); +// num++; +// } +// +// content_state_priority_code.append(content_state_priority_code_main).append(NL); +// +// for (int j = 0; j < num; j++) { +// content_state_priority_code.append(_8SPACES + "createContentList" + j + "(contentList);" + NL); +// } +// for (int j = 0; j < num; j++) { +// content_state_priority_code.append(_8SPACES + "createConstrList" + j + "(contentList, constrList);" + NL); +// } +// for (int j = 0; j < num; j++) { +// content_state_priority_code.append(_8SPACES + "createConstrLabelList" + j + "(constrLabelList);" + NL); +// } +// for (StringBuilder method : contentStateMethidList) { +// method_code_Adding.append(method); +// } +// + /////////////////// Content State Priority Code Prepare @End + + template.area_zorder_code = area_zorder_code.toString(); + template.area_visibility_code = allocatable_visibility_code.toString(); + template.content_state_priority_code = content_state_priority_code.toString(); + template.method_code = method_code_Adding.toString(); + + // calculateAllocatableVisibilityMethidList + return template.getCompleteCode(); + } + + private String getContextString(Expression expression, int index, String listName, Class<?> clazz, Expression eContainer) { + String contextString = null; + if (expression instanceof MinValue) { + contextString = resolveExpression((MinValue) expression, index, listName, eContainer); + } else if (expression instanceof MaxValue) { + contextString = resolveExpression((MaxValue) expression, index, listName, eContainer); + } else if (expression instanceof StandardValue) { + contextString = resolveExpression((StandardValue) expression, index, listName, eContainer); + } else if (expression instanceof NoneValue) { + contextString = resolveExpression((NoneValue) expression, index, listName, eContainer); + } else if (expression instanceof IntegerValue) { + contextString = resolveExpression((IntegerValue) expression, index, listName, eContainer); + } else if (expression instanceof EqualToOperator) { + contextString = resolveExpression((EqualToOperator) expression, index, listName, clazz); + } else if (expression instanceof GreaterThanOperator) { + contextString = resolveExpression((GreaterThanOperator) expression, index, listName, clazz); + } else if (expression instanceof MuchGreaterThanOperator) { + contextString = resolveExpression((MuchGreaterThanOperator) expression, index, listName, clazz); + } else if (expression instanceof LowerThanOperator) { + contextString = resolveExpression((LowerThanOperator) expression, index, listName, clazz); + } else if (expression instanceof ThatOfOperator) { + contextString = resolveExpression((ThatOfOperator) expression, index, listName, clazz); + } else if (expression instanceof PlusOperator) { + contextString = resolveExpression((PlusOperator) expression, index, listName, clazz); + } else if (expression instanceof ComparisonAnd) { + contextString = resolveExpression((ComparisonAnd) expression, index, listName, clazz); + } else if (expression instanceof ObjectReference) { + contextString = resolveExpression((ObjectReference) expression, listName, clazz); + } else { + // TODO Specification not found + System.out.println("Expected Expression type is not supported yet!"); + } + return contextString; + } + + private StringBuilder getAllocatableVisibilityMethodCallString(int num) { + StringBuilder ret = new StringBuilder(); + ret.append(_8SPACES + FUNC_ALLO_LIST + num + OPEN + AREA_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_ALLO_VIS_CONSTR + num + OPEN + AREA_LIST_NAME + COMMA + CONSTR_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_ALLO_VIS_CONSTR_LBL + num + OPEN + CONSTR_LABEL_LIST_NAME + CLOSE + END + NL); + return ret; + } + + private StringBuilder getAllocatableVisibilityMethodString(List<Allocatable> allocatableLimitedList, int num) { + StringBuilder createAlloVisListMethod = new StringBuilder(); + String createAlloVisListMethodName = FUNC_ALLO_LIST + num; + StringBuilder createConstrListMethod = new StringBuilder(); + String createConstrListMethodName = FUNC_ALLO_VIS_CONSTR + num; + StringBuilder createConstrLabelListMethod = new StringBuilder(); + String createConstrLabelListMethodName = FUNC_ALLO_VIS_CONSTR_LBL + num; + + createAlloVisListMethod.append(_4SPACES + "private void " + createAlloVisListMethodName + "(List<Expr> " + AREA_LIST_NAME + ") {" + NL); + createConstrListMethod + .append(_4SPACES + "private void " + createConstrListMethodName + "(List<Expr> " + AREA_LIST_NAME + ", List<BoolExpr> " + CONSTR_LIST_NAME + ") {" + NL); + createConstrLabelListMethod.append(_4SPACES + "private void " + createConstrLabelListMethodName + "(List<BoolExpr> " + CONSTR_LABEL_LIST_NAME + ") {" + NL); + + int i = num * 1000; + for (Allocatable allocatable : allocatableLimitedList) { + /////////////////// Area List & Label List @Start + createAlloVisListMethod.append(_8SPACES + AREA_LIST_ADD + OPEN + EX_CTX_MK_INT_CONST + OPEN + STR_QUOTE + allocatable.getName() + STR_QUOTE + CLOSE + CLOSE + END + NL); + createConstrLabelListMethod + .append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + STR_QUOTE + allocatable.getName() + STR_QUOTE + CLOSE + CLOSE + END + NL); + + /////////////////// Area/Zone Visibility Code Prepare @Start + createConstrListMethod.append(_8SPACES + SL_COMMENT + allocatable.getName() + VISIBILITY + RBAModelEditorToolUtil.getExpressionText(allocatable.getVisibility()) + NL); + String visibilityContextString = getContextString(allocatable.getVisibility(), i, AREA_LIST_NAME, Allocatable.class, null); + if (visibilityContextString != null) { + createConstrListMethod.append(_8SPACES + CONSTR_LIST_ADD + OPEN + visibilityContextString + CLOSE + END + NL); + } + i++; + } + + createAlloVisListMethod.append(_4SPACES + "}" + NL + NL); + createConstrListMethod.append(_4SPACES + "}" + NL + NL); + createConstrLabelListMethod.append(_4SPACES + "}" + NL + NL); + + StringBuilder ret = new StringBuilder(); + ret.append(createAlloVisListMethod); + ret.append(createConstrListMethod); + ret.append(createConstrLabelListMethod); + + return ret; + } + + private StringBuilder getAreaZorderMethodCallString(int num) { + StringBuilder ret = new StringBuilder(); + ret.append(_8SPACES + FUNC_AREA_LIST + num + OPEN + AREA_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_AREA_ZORDR_CONSTR + num + OPEN + AREA_LIST_NAME + COMMA + CONSTR_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_AREA_ZORDR_CONSTR_LBL + num + OPEN + CONSTR_LABEL_LIST_NAME + CLOSE + END + NL); + return ret; + } + + private StringBuilder getAreaZorderMethodString(List<Area> areaLimitedList, int num) { + StringBuilder createAreaZodrListMethod = new StringBuilder(); + String createAreaZodrListMethodName = FUNC_AREA_LIST + num; + StringBuilder createConstrListMethod = new StringBuilder(); + String createConstrListMethodName = FUNC_AREA_ZORDR_CONSTR + num; + StringBuilder createConstrLabelListMethod = new StringBuilder(); + String createConstrLabelListMethodName = FUNC_AREA_ZORDR_CONSTR_LBL + num; + + createAreaZodrListMethod.append(_4SPACES + "private void " + createAreaZodrListMethodName + "(List<Expr> " + AREA_LIST_NAME + ") {" + NL); + createConstrListMethod + .append(_4SPACES + "private void " + createConstrListMethodName + "(List<Expr> " + AREA_LIST_NAME + ", List<BoolExpr> " + CONSTR_LIST_NAME + ") {" + NL); + createConstrLabelListMethod.append(_4SPACES + "private void " + createConstrLabelListMethodName + "(List<BoolExpr> " + CONSTR_LABEL_LIST_NAME + ") {" + NL); + + int i = num * 1000; + for (Area area : areaLimitedList) { + /////////////////// Area List & Label List @Start + createAreaZodrListMethod.append(_8SPACES + AREA_LIST_ADD + OPEN + EX_CTX_MK_INT_CONST + OPEN + STR_QUOTE + area.getName() + STR_QUOTE + CLOSE + CLOSE + END + NL); + createConstrLabelListMethod + .append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + STR_QUOTE + area.getName() + STR_QUOTE + CLOSE + CLOSE + END + NL); + + /////////////////// Area Zorder Code Prepare @Start + createConstrListMethod.append(_8SPACES + SL_COMMENT + area.getName() + ZORDER + RBAModelEditorToolUtil.getExpressionText(area.getZorder()) + NL); + String zorderContextString = getContextString(area.getZorder(), i, AREA_LIST_NAME, Area.class, null); + if (zorderContextString != null) { + createConstrListMethod.append(_8SPACES + CONSTR_LIST_ADD + OPEN + zorderContextString + CLOSE + END + NL); + } + i++; + } + + createAreaZodrListMethod.append(_4SPACES + "}" + NL + NL); + createConstrListMethod.append(_4SPACES + "}" + NL + NL); + createConstrLabelListMethod.append(_4SPACES + "}" + NL + NL); + + StringBuilder ret = new StringBuilder(); + ret.append(createAreaZodrListMethod); + ret.append(createConstrListMethod); + ret.append(createConstrLabelListMethod); + + return ret; + } + + private StringBuilder getContentStateMethodCallString(int num) { + StringBuilder ret = new StringBuilder(); + ret.append(_8SPACES + FUNC_CST_LIST + num + OPEN + CONTENT_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_CST_CONSTR + num + OPEN + CONTENT_LIST_NAME + COMMA + CONSTR_LIST_NAME + CLOSE + END + NL); + ret.append(_8SPACES + FUNC_CST_CONSTR_LBL + num + OPEN + CONSTR_LABEL_LIST_NAME + CLOSE + END + NL); + return ret; + } + + private StringBuilder getContentStateMethodString(List<ContentState> contentStateLimitedList, int num) { + StringBuilder createContentListMethod = new StringBuilder(); + String createContentListMethodName = "createContentList" + num; + StringBuilder createConstrListMethod = new StringBuilder(); + String createConstrListMethodName = "createConstrList" + num; + StringBuilder createConstrLabelListMethod = new StringBuilder(); + String createConstrLabelListMethodName = "createConstrLabelList" + num; + + createContentListMethod.append(_4SPACES + "private void " + createContentListMethodName + "(List<Expr> contentList) {" + NL); + createConstrListMethod.append(_4SPACES + "private void " + createConstrListMethodName + "(List<Expr> contentList, List<BoolExpr> constrList) {" + NL); + createConstrLabelListMethod.append(_4SPACES + "private void " + createConstrLabelListMethodName + "(List<BoolExpr> constrLabelList) {" + NL); + + int i = num * 1000; + for (ContentState contentState: contentStateLimitedList) { + Content content = (Content) contentState.eContainer(); + String content_cState_Name = content.getName() + NAME_SEPARATOR + contentState.getName(); + + /////////////////// ContentState List & Label List @Start + createContentListMethod.append(_8SPACES + CONTENT_LIST_ADD + OPEN + EX_CTX_MK_INT_CONST + OPEN + STR_QUOTE + content_cState_Name + STR_QUOTE + CLOSE + CLOSE + END + NL); + createConstrLabelListMethod.append(_8SPACES + CONSTR_LABEL_LIST_ADD + OPEN + EX_CTX_MK_BOOL_CONST + OPEN + STR_QUOTE + content_cState_Name + STR_QUOTE + CLOSE + CLOSE + END + NL); + + /////////////////// ContentState Code Prepare @Start + createConstrListMethod.append(_8SPACES + SL_COMMENT + content_cState_Name + CMT_CONTENT_STATE_PRIORITY_COMMENT_CONNECTOR + CMT_NAME_OPEN + contentState.getValue().getExpression() + + CMT_NAME_CLOSE + NL); + String contentContextString = getContextString(contentState.getValue(), i, CONTENT_LIST_NAME, Content.class, null); + if (contentContextString != null) { + createConstrListMethod.append(_8SPACES + CONSTR_LIST_ADD + OPEN + contentContextString + CLOSE + END + NL); + } + i++; + } + + createContentListMethod.append(_4SPACES + "}" + NL); + createConstrListMethod.append(_4SPACES + "}" + NL); + createConstrLabelListMethod.append(_4SPACES + "}" + NL); + + StringBuilder ret = new StringBuilder(); + ret.append(createContentListMethod); + ret.append(createConstrListMethod); + ret.append(createConstrLabelListMethod); + + return ret; + } + + private String resolveExpression(MinValue expression, int index, String listName, Expression eContainer) { + if ((eContainer instanceof ComparisonOperator && !(eContainer instanceof ComparisonAnd)) || eContainer instanceof PlusOperator) { + return EX_MIN; + } + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_MIN + CLOSE; + } + + private String resolveExpression(MaxValue expression, int index, String listName, Expression eContainer) { + if ((eContainer instanceof ComparisonOperator && !(eContainer instanceof ComparisonAnd)) || eContainer instanceof PlusOperator) { + return EX_MAX; + } + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_MAX + CLOSE; + } + + private String resolveExpression(StandardValue expression, int index, String listName, Expression eContainer) { + if ((eContainer instanceof ComparisonOperator && !(eContainer instanceof ComparisonAnd)) || eContainer instanceof PlusOperator) { + return EX_STD; + } + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_STD + CLOSE; + } + + private String resolveExpression(NoneValue expression, int index, String listName, Expression eContainer) { + if ((eContainer instanceof ComparisonOperator && !(eContainer instanceof ComparisonAnd)) || eContainer instanceof PlusOperator) { + return EX_NON; + } + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_NON + CLOSE; + } + + private String resolveExpression(IntegerValue expression, int index, String listName, Expression eContainer) { + String context = null; + if ((eContainer instanceof ComparisonOperator && !(eContainer instanceof ComparisonAnd)) || eContainer instanceof PlusOperator) { + context = EX_INT_EXPR + EX_CTX_MK_INT + OPEN + ((IntegerValue) expression).getValue() + CLOSE; + } else if (eContainer == null) { + // TODO may be mismatch with specification. need confirmation + context = EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_INT_EXPR + EX_CTX_MK_INT + OPEN + ((IntegerValue) expression).getValue() + + CLOSE + CLOSE; + } else { + // TODO may be new feature that was not specified yet for SortValueGeneration + System.out.println("Not supported yet."); + } + return context; + } + + private String resolveExpression(EqualToOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((EqualToOperator) expression).getOperand(); + String context = null; + if (operand.get(0) instanceof Operator) { + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof ObjectReference) { + context = resolveExpression((ObjectReference) operand.get(0), listName, clazz); + } else if (operand.get(0) instanceof ValueExpression) { + // TODO To confirm, specification not found + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof IfStatement) { + // TODO To confirm, specification not found + System.out.println("Not supported yet"); + } + context = (context == null) ? null : EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + context + CLOSE; + return context; + } + + private String resolveExpression(GreaterThanOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((GreaterThanOperator) expression).getOperand(); + String context = null; + if (operand.get(0) instanceof Operator) { + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof ObjectReference) { + context = resolveExpression((ObjectReference) operand.get(0), listName, clazz); + } else if (operand.get(0) instanceof ValueExpression) { + // TODO To confirm, specification not found + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof IfStatement) { + // TODO To confirm, specification not found + } + context = (context == null) ? null : EX_CTX_MK_GT + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + context + CLOSE; + return context; + } + + private String resolveExpression(MuchGreaterThanOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((MuchGreaterThanOperator) expression).getOperand(); + String context = null; + if (operand.get(0) instanceof Operator) { + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof ObjectReference) { + context = resolveExpression((ObjectReference) operand.get(0), listName, clazz); + } else if (operand.get(0) instanceof ValueExpression) { + // TODO To confirm, specification not found + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof IfStatement) { + // TODO To confirm, specification not found + } + context = (context == null) ? null + : EX_CTX_MK_GT + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + EX_INT_EXPR + EX_CTX_MK_ADD + OPEN + context + COMMA + EX_CTX_MK_INT + OPEN + + CONST_ADDED_VALUE + CLOSE + CLOSE + CLOSE; + return context; + } + + private String resolveExpression(LowerThanOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((LowerThanOperator) expression).getOperand(); + String context = null; + if (operand.get(0) instanceof Operator) { + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof ObjectReference) { + context = resolveExpression((ObjectReference) operand.get(0), listName, clazz); + } else if (operand.get(0) instanceof ValueExpression) { + // TODO To confirm, specification not found + context = getContextString(operand.get(0), index, listName, clazz, expression); + } else if (operand.get(0) instanceof IfStatement) { + // TODO To confirm, specification not found + } + context = (context == null) ? null : EX_CTX_MK_LT + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + context + CLOSE; + return context; + } + + private String resolveExpression(ThatOfOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((ThatOfOperator) expression).getOperand(); + if (operand.get(0) instanceof ObjectReference) { + if (expression.eContainer() instanceof RuleObject) { // Area, Content + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + resolveExpression((ObjectReference) operand.get(0), listName, clazz) + CLOSE; + } else { + return resolveExpression((ObjectReference) operand.get(0), listName, clazz); + } + } + return null; + } + + private String resolveExpression(ObjectReference expression, String listName, Class<?> clazz) { + if ((clazz == Allocatable.class && expression.getRefObject() instanceof Allocatable)) { + return EX_INT_EXPR + getListString(listName, allocatableList.indexOf(expression.getRefObject())); + } else if ((clazz == Area.class && expression.getRefObject() instanceof Area)) { + return EX_INT_EXPR + getListString(listName, areaList.indexOf(expression.getRefObject())); + } else if ((clazz == Content.class && expression.getRefObject() instanceof ContentState)) { + return EX_INT_EXPR + getListString(listName, contentStateList.indexOf(expression.getRefObject())); + } + return null; + } + + private String resolveExpression(PlusOperator expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((PlusOperator) expression).getOperand(); + StringBuilder builder = new StringBuilder(); + StringBuilder context = new StringBuilder(); + String operandContext = null; + + for (int i = 0; i < operand.size(); i++) { + if (i != 0) { + builder.append(EX_CTX_MK_ADD); + builder.append(OPEN); + context.append(COMMA); + if ((operandContext = getContextString(operand.get(i), index, listName, clazz, expression)) == null) { + return null; + } + context.append(operandContext); + context.append(CLOSE); + } else { + if ((operandContext = getContextString(operand.get(i), index, listName, clazz, expression)) == null) { + return null; + } + context.append(operandContext); + } + } + builder.append(context); + if (expression.eContainer() instanceof RuleObject) { // Area, Content + return EX_CTX_MK_EQ + OPEN + EX_INT_EXPR + getListString(listName, index) + COMMA + builder.toString() + CLOSE; + } else { + return builder.toString(); + } + } + + private String resolveExpression(ComparisonAnd expression, int index, String listName, Class<?> clazz) { + EList<Expression> operand = ((ComparisonAnd) expression).getOperand(); + if (operand.size() >= 2) { + StringBuilder beginContext = new StringBuilder(); + StringBuilder endContext = new StringBuilder(); + for (int i = 0; i < operand.size(); i++) { + String context = getContextString(operand.get(i), index, listName, clazz, null); + if (i == 0) { + beginContext.append(EX_CTX_MK_AND + OPEN); + endContext.append(context); + } else if (i == operand.size() - 1) { + endContext.append(COMMA).append(" ") // Include space or not, it is ok + .append(context).append(CLOSE); + } else { + beginContext.append(EX_CTX_MK_AND + OPEN); + endContext.append(COMMA).append(" ") // Include space or not, it is ok + .append(context).append(CLOSE); + } + } + return beginContext.toString() + endContext.toString(); + } + return null; // It may be rba model problem. + } + + private String getListString(String listName, int index) { + return listName + GET + OPEN + index + CLOSE; + } + + private interface ListHelper<T> extends Iterable<T> { + + public static <T> void extract(List<T> list, int size, Consumer<? super List<T>> bulkList) { + for (int i = 0; i < list.size(); i += size) { + List<T> _list = new ArrayList<>(list.subList(i, Integer.min(i + size, list.size()))); + bulkList.accept(_list); + } + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeTemplate.java b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeTemplate.java new file mode 100644 index 0000000..011c684 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueCodeTemplate.java @@ -0,0 +1,148 @@ +package rba.tool.editor.generator.z3; + +public class SortValueCodeTemplate { + + String area_zorder_code; + + String area_visibility_code; + + String content_state_priority_code; + + String method_code; + + private static final String NL = "\r\n"; + + String getCompleteCode() { + return "import groovy.transform.CompileStatic;" + NL + NL + + "import java.util.ArrayList;" + NL + + "import java.util.HashMap;" + NL + + "import java.util.List;" + NL + + "import java.util.Map;" + NL + NL + + + "import com.microsoft.z3.BoolExpr;" + NL + + "import com.microsoft.z3.Context;" + NL + + "import com.microsoft.z3.Expr;" + NL + + "import com.microsoft.z3.IntExpr;" + NL + + "import com.microsoft.z3.Solver;" + NL + + "import com.microsoft.z3.Status;" + NL + NL + + + "import rba.tool.core.z3.Z3CodeManager;" + NL + NL + + + "@CompileStatic" + NL + + "public class SortValueCalculation implements rba.tool.core.sort.ISortValueCalculation {" + NL + NL + + " Context ctx;" + NL + + " IntExpr std;" + NL + + " IntExpr min;" + NL + + " IntExpr max;" + NL + + " IntExpr non;" + NL + NL + + " BoolExpr stdConstr;" + NL + + " BoolExpr minConstr;" + NL + + " BoolExpr maxConstr;" + NL + + " BoolExpr nonConstr;" + NL + NL + + + " public void setUp() {" + NL + + " ctx = new Context();" + NL + + " std = ctx.mkIntConst(\"STANDARD\");" + NL + + " stdConstr = ctx.mkEq(std, ctx.mkInt(10));" + NL + NL + + + " min = ctx.mkIntConst(\"MIN_VALUE\");" + NL + + " minConstr = ctx.mkEq(min, ctx.mkInt(0));" + NL + NL + + + " max = ctx.mkIntConst(\"MAX_VALUE\");" + NL + + " maxConstr = ctx.mkEq(max, ctx.mkInt(9999));" + NL + NL + + + " non = ctx.mkIntConst(\"NONE_VALUE\");" + NL + + " nonConstr = ctx.mkEq(non, ctx.mkInt(-1));" + NL + + " }" + NL + NL + + " public void close() {" + NL + + " ctx.close();" + NL + + " }" + NL + NL + + + " /**" + NL + + " * Derived the value of Zorder" + NL + + " */" + NL + + " public Map<String, Integer> calculateArea_zorder() {" + NL + + " Solver s = ctx.mkSolver();" + NL + + " s.push();" + NL + NL + + " List<Expr> areaList = new ArrayList<Expr>();" + NL + + " List<BoolExpr> constrList = new ArrayList<BoolExpr>();" + NL + + " List<BoolExpr> constrLabelList = new ArrayList<BoolExpr>();" + NL + NL + + + area_zorder_code + NL + + + " s.add(stdConstr);" + NL + + " s.add(minConstr);" + NL + + " s.add(maxConstr);" + NL + + " s.add(nonConstr);" + NL + NL + + + " for (int i = 0; i < constrList.size(); i++) {" + NL + + " s.assertAndTrack(constrList.get(i), constrLabelList.get(i));" + NL + + " }" + NL + NL + + " Status st = s.check();" + NL + + " Map<String, Integer> map = Z3CodeManager.INSTNACE.setModel(s, areaList, st);" + NL + + " s.pop();" + NL + + " return map;" + NL + + " }" + NL + NL + + + " /**" + NL + + " * Derivation of Visibility value" + NL + + " */" + NL + + " public Map<String, Integer> calculateAllocatable_visibility() {" + NL + + " Solver s = ctx.mkSolver();" + NL + + " s.push();" + NL + NL + + + " List<Expr> areaList = new ArrayList<Expr>();" + NL + + " List<BoolExpr> constrList = new ArrayList<BoolExpr>();" + NL + + " List<BoolExpr> constrLabelList = new ArrayList<BoolExpr>();" + NL + NL + + + area_visibility_code + NL + + + " s.add(stdConstr);" + NL + + " s.add(minConstr);" + NL + + " s.add(maxConstr);" + NL + + " s.add(nonConstr);" + NL + NL + + + " for (int i = 0; i < constrList.size(); i++) {" + NL + + " s.assertAndTrack(constrList.get(i), constrLabelList.get(i));" + NL + + " }" + NL + NL + + + " Status st = s.check();" + NL + + " Map<String, Integer> map = Z3CodeManager.INSTNACE.setModel(s, areaList, st); \r\n" + NL + + " s.pop();" + NL + + " return map;" + NL + + " }" + NL + NL + + + " /**" + NL + + " * Derived the value of priority" + NL + + " */" + NL + + " public Map<String, Integer> calculateContentState_priority() {" + NL + + " Solver s = ctx.mkSolver();" + NL + + " s.push();" + NL + NL + + + " List<Expr> contentList = new ArrayList<Expr>();" + NL + + " List<BoolExpr> constrList = new ArrayList<BoolExpr>();" + NL + + " List<BoolExpr> constrLabelList = new ArrayList<BoolExpr>();" + NL + NL + + + content_state_priority_code + NL + + + " s.add(stdConstr);" + NL + + " s.add(minConstr);" + NL + + " s.add(maxConstr);" + NL + + " s.add(nonConstr);" + NL + NL + + + " for (int i = 0; i < constrList.size(); i++) {" + NL + + " s.assertAndTrack(constrList.get(i), constrLabelList.get(i));" + NL + + " }" + NL + NL + + + " Status st = s.check();" + NL + + " Map<String, Integer> map = Z3CodeManager.INSTNACE.setModel(s, contentList, st);" + NL + + " s.pop();" + NL + + " return map;" + NL + + " }" + NL + + + method_code + NL + + + + "}" + NL; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueGeneratorImpl.xtend b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueGeneratorImpl.xtend new file mode 100644 index 0000000..0ef3691 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/generator/z3/SortValueGeneratorImpl.xtend @@ -0,0 +1,46 @@ +package rba.tool.editor.generator.z3 + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext +import rba.tool.editor.model.manager.ResourceManager + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +class SortValueGeneratorImpl extends AbstractGenerator implements ISortValueGenerator { + + private static SortValueCodeGenerationSupporter generationSupporter = new SortValueCodeGenerationSupporter(); + + override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { + doGenerate(input.resourceSet, fsa, context); + } + + override beforeGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override afterGenerate(ResourceSet input, IFileSystemAccess2 fsa, IGeneratorContext context) { + } + + override void doGenerate(ResourceSet resourceSet, IFileSystemAccess2 fsa, IGeneratorContext context) { + fsa.generateFile("SortValueCalculation.java", resourceSet.compile); + } + + def compile(ResourceSet resourceSet) ''' + «val allAllocatables = ResourceManager.INSTANCE.getRbaAllocatables(resourceSet)» + + «val allAreas = ResourceManager.INSTANCE.getRbaAreas(resourceSet)» +««« «FOR area : allAreas» +««« «area.name» : [ «FOR content : area.contents»«content.name», «ENDFOR»] +««« «ENDFOR» + «val allContents = ResourceManager.INSTANCE.getRbaContents(resourceSet)» +««« «FOR content : allContents» +««« «content.name» : [ «FOR area : content.allocatable»«area.name», «ENDFOR»] +««« «ENDFOR» + «generationSupporter.generate(allContents, allAllocatables, allAreas)» + ''' +} diff --git a/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinker.xtend b/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinker.xtend new file mode 100644 index 0000000..2ceaf15 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinker.xtend @@ -0,0 +1,87 @@ +package rba.tool.editor.linking + +import java.util.ArrayList +import java.util.Iterator +import java.util.List +import javax.inject.Inject +import org.eclipse.emf.common.util.AbstractTreeIterator +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.linking.impl.DefaultLinkingService +import org.eclipse.xtext.linking.lazy.LazyLinker +import org.eclipse.xtext.nodemodel.INode +import rba.core.ObjectReference +import rba.tool.editor.rbaEditorModel.MemberFeatureReference +import rba.tool.editor.util.RBAModelEditorToolUtil + +class RBAModelLinker extends LazyLinker { + + @Inject extension DefaultLinkingService linkingService + + override protected clearReference(EObject obj, EReference ref) { + if(RBAModelEditorToolUtil.isSkippedSyntax(obj, ref)) { + return; + } + super.clearReference(obj, ref); + } + + override protected createProxy(EObject obj, INode node, EReference eRef) { + val EObject result = getLinkedObject(obj, node, eRef); + if(eRef.EOpposite !== null && (result !== null && result.eClass.EAllSuperTypes.contains(eRef.EReferenceType))) { + val Resource objResource = obj.eResource(); + val Resource rslResource = result.eResource(); + if(!equals(objResource.URI, rslResource.URI)) { + return result; + } + } + + return super.createProxy(obj, node, eRef); + } + + override protected getAllLinkableContents(EObject model) { + val AbstractTreeIterator<EObject> result = new AbstractTreeIterator<EObject>(model) { + override public Iterator<EObject> getChildren(Object object) { + val List<EObject> contents = new ArrayList<EObject>(); + if(object instanceof MemberFeatureReference) { + // do nothing + } else { + val temp = (object as EObject).eContents(); + for (eObject : temp) { + if(eObject instanceof MemberFeatureReference) { + contents.addAll(EcoreUtil2.getAllContentsOfType(eObject, ObjectReference)); + } + contents.add(eObject); + } + } + return contents.iterator(); + } + }; + + return result; + } + + def private EObject getLinkedObject(EObject obj, INode node, EReference eRef) { + val linkedObjects = linkingService.getLinkedObjects(obj, eRef, node); + if(linkedObjects.size == 1) { + val linkedObject = linkedObjects.get(0); + if(linkedObject.eIsProxy) { + return EcoreUtil.resolve(linkedObject, obj.eResource); + } else { + return linkedObject; + } + } + return null; + } + + def private boolean equals(URI uri1, URI uri2) { + if(uri1 === null || uri2 === null) { + return false; + } + + return uri1.equals(uri2); + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinkingService.xtend b/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinkingService.xtend new file mode 100644 index 0000000..f3d6a52 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/linking/RBAModelLinkingService.xtend @@ -0,0 +1,66 @@ +package rba.tool.editor.linking + +import com.google.inject.Inject +import java.util.Collections +import org.apache.log4j.Logger +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.linking.impl.DefaultLinkingService +import org.eclipse.xtext.linking.impl.IllegalNodeException +import org.eclipse.xtext.naming.IQualifiedNameConverter +import org.eclipse.xtext.nodemodel.INode +import rba.core.ObjectReference +import rba.core.Package +import rba.core.RBACorePackage +import rba.core.RuleObject + +class RBAModelLinkingService extends DefaultLinkingService { + + private static final Logger logger = Logger.getLogger(RBAModelLinkingService); + + @Inject + private IQualifiedNameConverter qualifiedNameConverter; + + override getLinkedObjects(EObject context, EReference ref, INode node) throws IllegalNodeException { + val requiredType = ref.getEReferenceType(); + if(requiredType === null) { + return Collections.<EObject>emptyList(); + } + val crossRefString = getCrossRefNodeAsString(node); + if(crossRefString === null || crossRefString.equals("")) { + return Collections.<EObject>emptyList(); + } + if(logger.isDebugEnabled()) { + logger.debug("before getLinkedObjects: node: '" + crossRefString + "'"); + } + + if(context instanceof ObjectReference && ref === RBACorePackage.Literals.OBJECT_REFERENCE__REF_OBJECT && crossRefString.equals("this")) { + val containers = EcoreUtil2.getAllContainers(context).filter [ c | + c instanceof RuleObject && c.eContainer instanceof Package + ].toList; + if(containers !== null && containers.size === 1) { + return Collections.singletonList(containers.get(0)); + } else { + return Collections.emptyList(); + } + } + + val scope = getScope(context, ref); + if(scope === null) { + throw new AssertionError( + "Scope provider " + scopeProvider.getClass().getName() + " must not return null for context " + context + ", reference " + ref + "! Consider to return IScope.NULLSCOPE instead."); + } + val qualifiedLinkName = qualifiedNameConverter.toQualifiedName(crossRefString); + val eObjectDescription = scope.getSingleElement(qualifiedLinkName); + if(logger.isDebugEnabled()) { + logger.debug("after getLinkedObjects: node: '" + crossRefString + "' result: " + eObjectDescription); + } + if(eObjectDescription === null) { + return Collections.emptyList(); + } + val result = eObjectDescription.getEObjectOrProxy(); + return Collections.singletonList(result); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/messages/Messages.java b/rba.tool.editor/src/rba/tool/editor/messages/Messages.java new file mode 100644 index 0000000..10f0394 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/messages/Messages.java @@ -0,0 +1,415 @@ +package rba.tool.editor.messages; + +import org.eclipse.osgi.util.NLS; + +public class Messages extends NLS { + + private static final String BUNDLE_NAME = "rba.tool.editor.messages.messages"; + + public static String CONDITION_BOOLEAN_TYPE_CHECK; + + public static String CONDITION_TPYE_EQUAL_CHECK; + + public static String PACKAGE_CHILD_EXISTENCE_CHECK; + + public static String DISPLAY_AREA_SIZE_CHECK; + + public static String DISPLAY_ROOT_CHECK; + + public static String COMPOSITE_AREA_CHECK; + + public static String VERTICAL_LAYOUT_CHECK; + + public static String HORIZONTAL_LAYOUT_CHECK; + + public static String FIXEDPOSITION_LAYOUT_CHECK; + + public static String POSITION_CONTAINER_COORDINATE_CHECK; + + public static String AREA_VISIBILITY_TYPE; + + public static String AREA_ZORDER_TYPE; + + public static String ALLOCATABLE_SIZE; + + public static String CONTENT_ALLOCATABLE_SIZE; + + public static String CONTENT_ALLOCATABLE_INVALID_TYPE; + + public static String CONTENT_ALLOCATABLE_DUPLICATE; + + public static String CONTENT_DISPLAY_SIZE_CHECK; + + public static String VISIBILITY_IS_REQUIRED; + + public static String HAS_AT_LEAST_ONE_STATE; + public static String ZORDER_IS_REQUIRED; + + public static String HAS_AT_LEAST_ONE_SIZE; + + public static String ORDER_IS_REQUIRED; + + public static String QUEUE_IS_REQUIRED; + + public static String MESSAGEAPP_ALLOCATABLE_SIZE; + + public static String MESSAGEAPP_STATES_SIZE; + + public static String CONTENTSTATE_TYPE; + + public static String CONSTRAINT_EXPRESSION_TYPE; + + public static String THATOF_OPERAND_SIZE; + + public static String THATOF_OPERAND_OBJECTREFERENCE; + + public static String THATOF_OPERAND_OBJECTREFERENCE_EQUAL; + + public static String THATOF_OPERAND_EXPRESSIONTYPE; + + public static String EQUALTO_OPERAND_SIZE_NULL; + + public static String EQUALTO_OPERAND_SIZE; + + public static String EQUALTO_OPERAND_TYPE; + + public static String GREATERTHAN_OPERAND_SIZE_NULL; + + public static String GREATERTHAN_OPERAND_SIZE; + + public static String GREATERTHAN_OPERAND_TYPE; + + public static String MUCHGREATERTHAN_OPERAND_SIZE_NULL; + + public static String MUCHGREATERTHAN_OPERAND_SIZE; + + public static String MUCHGREATERTHAN_OPERAND_TYPE; + + public static String LOWERTHAN_OPERAND_SIZE_NULL; + + public static String LOWERTHAN_OPERAND_SIZE; + + public static String LOWERTHAN_OPERAND_TYPE; + + public static String COMPARISONAND_OPERAND_SIZE; + + public static String COMPARISONAND_OPERAND_TYPE; + + public static String PLUS_OPERAND_SIZE; + + public static String PLUS_OPERAND_TYPE; + + public static String PLUS_OPERAND_TYPE_NOT_OPERATOR; + + public static String AND_OPERAND_SIZE; + + public static String AND_OPERAND_TYPE; + + public static String OR_OPERAND_SIZE; + + public static String OR_OPERAND_TYPE; + + public static String IMPLIES_OPERAND_SIZE; + + public static String IMPLIES_OPERAND_TYPE; + + public static String NOT_OPERAND_SIZE; + + public static String NOT_OPERAND_TYPE; + + public static String OPERANDS_MUST_BE_OBJECT; + + public static String FIRST_OPERAND_MUST_BE_OBJECT; + + public static String ISDISPLAYED_SIZE; + + public static String ISDISPLAYED_TYPE; + + public static String DISPLAYINGCONTENT_SIZE; + + public static String DISPLAYINGCONTENT_TYPE; + + public static String GETCONTENTSLIST_SIZE; + + public static String GETCONTENTSLIST_TYPE; + + public static String ISACTIVE_SIZE; + + public static String ISACTIVE_TYPE; + + public static String ISVISIBLE_SIZE; + + public static String ISVISIBLE_TYPE; + + public static String GETALLOCATABLES_SIZE; + + public static String GETALLOCATABLES_TYPE; + + public static String LAMBDAEXPRESSION_TYPE; + + public static String FORALL_OPERAND_SIZE; + + public static String FORALL_OPERAND_TYPE; + + public static String FORALL_LAMBDA_TYPE; + + public static String EXISTS_OPERAND_SIZE; + + public static String EXISTS_OPERAND_TYPE; + + public static String NAMEDELEMENT_NAME_DUPLICATE; + + public static String CIRCULAR_CONTAINMENT_DETECTE; + + public static String ISEQUALTO_OPERAND_SIZE; + + public static String ISEQUALTO_OPERAND_TYPE; + + public static String ISGREATERTHAN_OPERAND_SIZE; + + public static String ISGREATERTHAN_OPERAND_TYPE; + + public static String ISGREATERTHANEQUAL_OPERAND_SIZE; + + public static String ISGREATERTHANEQUAL_OPERAND_TYPE; + + public static String ISLOWERTHAN_OPERAND_SIZE; + + public static String ISLOWERTHAN_OPERAND_TYPE; + + public static String ISLOWERTHANEQUAL_OPERAND_SIZE; + + public static String ISLOWERTHANEQUAL_OPERAND_TYPE; + + public static String EXCLUSIVEOR_OPERAND_SIZE; + + public static String EXCLUSIVEOR_OPERAND_TYPE; + + public static String ISHIDDEN_SIZE; + + public static String ISHIDDEN_TYPE; + + public static String CONTENTVALUE_SIZE; + + public static String CONTENTVALUE_TYPE; + + public static String SET_OF_OPERAND_TYPE; + + public static String SET_OF_OPERAND_DUPLICATE; + + public static String ISON_SIZE; + + public static String ISON_TYPE; + + public static String ISDEFEATEDBY_OEPRAND_SIZE; + + public static String ISDEFEATEDBY_OEPRAND_0_TYPE; + + public static String ISDEFEATEDBY_OPERAND_0_CHECK; + + public static String ISDEFEATEDBY_OPERAND_1_CHECK; + + public static String DEFEATS_OPERAND_SIZE; + + public static String DEFEATS_OPERAND_0_TYPE; + + public static String DEFEATS_OPERAND_0_CHECK; + + public static String DEFEATS_OPERAND_1_CHECK; + + public static String ISDISAPPEARED_OPERAND_SIZE; + + public static String ISDISAPPEARED_OPERAND_0_TYPE; + + public static String ISDISAPPEARED_OPERAND_0_CHECK; + + public static String ISCANCELED_OPERAND_SIZE; + + public static String ISCANCELED_OPERAND_0_TYPE; + + public static String ISCANCELED_OPERAND_0_CHECK; + + public static String OFFSET_SIZE_DUPLICATE; + + public static String OFFSET_SIZE_AREA_REF; + + public static String AREASET_TARGET_SIZE; + + public static String AREASET_TARGET_DUPLICATE; + + public static String AREASET_TARGET_INCLUDE_SELF; + + public static String ALLOCATEDCONTENT_TYPE; + + public static String ONSCENE_OPERAND_SIZE_CHECK; + + public static String ONSCENE_OPERAND_TYPE_CHECK; + + public static String ONSCENE_ISGLOBALSCENE; + + public static String OFFSCENE_OPERAND_SIZE_CHECK; + + public static String OFFSCENE_OPERAND_TYPE_CHECK; + + public static String OFFSCENE_ISGLOBALSCENE; + + public static String SETPROPERTY_OPERAND_SIZE_CHECK; + + public static String SETPROPERTY_OPERAND_0_TYPE_CHECK; + + public static String SETPROPERTY_OPERAND_ISGLOBALSCENE; + + public static String SETPROPERTY_OPERAND_1_TYPE_CHECK; + + public static String SETPROPERTY_PROPERTY_NEGATIVE; + + public static String GETPROPERTY_OPERAND_SIZE_CHECK; + + public static String GETPROPERTY_OPERAND_TYPE_CHECK; + + public static String GETPROPERTY_OPERAND_ISGLOBALSCENE; + + public static String SCENE_GLOBAL; + + public static String SCENE_PROPERTY_NEGATIVE; + + public static String SOUND_ALLOCATABLE_SIZE; + + public static String SOUND_ALLOCATABLE_INVALID_TYPE; + + public static String SOUND_ALLOCATABLE_DUPLICATE; + + public static String ZONESET_TARGET_SIZE; + + public static String ZONESET_TARGET_INCLUDE_SELF; + + public static String ZONESET_TARGET_DUPLICATE; + + public static String ISSOUNDING_SIZE; + + public static String ISSOUNDING_TYPE; + + public static String ISOUTPUTTED_SIZE; + + public static String ISOUTPUTTED_TYPE; + + public static String ISMUTED_SIZE; + + public static String ISMUTED_TYPE; + + public static String ISATTENUATED_SIZE; + + public static String ISATTENUATED_TYPE; + + public static String OUTPUTTINGSOUND_SIZE; + + public static String OUTPUTTINGSOUND_TYPE; + + public static String VIEWCONTENTSET_TARGET_SIZE; + + public static String VIEWCONTENTSET_TARGET_DUPLICATE; + + public static String VIEWCONTENTSET_TARGET_INCLUDE_SELF; + + public static String VIEWCONTENTSET_ALLOCATABLE_INVALID_TYPE; + + public static String VIEWCONTENTSET_ALLOCATABLE_DUPLICATE; + + public static String SOUNDCONTENTSET_TARGET_SIZE; + + public static String SOUNDCONTENTSET_TARGET_DUPLICATE; + + public static String SOUNDCONTENTSET_TARGET_INCLUDE_SELF; + + public static String SOUNDCONTENTSET_ALLOCATABLE_INVALID_TYPE; + + public static String SOUNDCONTENTSET_ALLOCATABLE_DUPLICATE; + + public static String AREASET_TARGET_INVALID_TYPE; + + public static String VIEWCONTENTSET_TARGET_INVALID_TYPE; + + public static String ZONESET_TARGET_INVALID_TYPE; + + public static String SOUNDCONTENTSET_TARGET_INVALID_TYPE; + + public static String OPERAND_SIZE_ONE; + + public static String OPERAND_SIZE_TWO; + + public static String FIRST_OPERAND_MUST_CONTENT; + + public static String ARGUMENT_MUST_CONTENT; + + public static String OPERAND_CANNOT_USE_PRE; + + public static String ARGUMENT_CANNOT_USE_PRE; + + public static String ARGUMENT_MUST_ALLOCATABLE; + + public static String COMBINATION_OPERAND_ARGUMENT; + + public static String FIRST_OPERAND_MUST_ALLOCATABLE; + + public static String FIRST_OPERAND_MUST_VIEWCONTENT; + + public static String ARGUMENT_MUST_AREA; + + public static String FIRST_OPERAND_MUST_AREA; + + public static String ARGUMENT_MUST_VIEWCONTENT; + + public static String FIRST_OPERAND_MUST_SOUNDCONTENT; + + public static String ARGUMENT_MUST_ZONE; + + public static String FIRST_OPERAND_MUST_ZONE; + + public static String ARGUMENT_MUST_SOUNDCONTENT; + + public static String TARGET_MODEL_NAME_MISMATCH; + + public static String MIN_OP_OPERAND_SIZE; + + public static String MIN_OP_OPERAND_TYPE; + + public static String MAX_OP_OPERAND_SIZE; + + public static String MAX_OP_OPERAND_TYPE; + + public static String SELECT_OPERAND_SIZE; + + public static String SELECT_OPERAND_TYPE; + + public static String FIRST_OPERAND_MUST_FOR_ISTYPEOF; + + public static String SIZE_OPERAND_TYPE; + + public static String NAME_RESTRICTION; + + public static String PROJECT_SIZE_CHECK; + + public static String PROJECT_NAME_CHECK; + + public static String FIRST_OPERAND_MUST_CONTENT_OR_CONTENTSTATE; + + public static String BODY_MUST_OBJECT; + + public static String OPERANDS_CANNOT_USE_PRE; + + public static String MUST_BE_USE_IN; + + public static String SIZE_NEGATIVE; + + public static String ZONE_VISIBILITY_NEGATIVE; + + public static String ZONE_ATTENUATE_NEGATIVE; + + static { + // initialize resource bundle + NLS.initializeMessages(BUNDLE_NAME, Messages.class); + } + + private Messages() { + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/messages/messages.properties b/rba.tool.editor/src/rba/tool/editor/messages/messages.properties new file mode 100644 index 0000000..e1e6962 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/messages/messages.properties @@ -0,0 +1,201 @@ + +CONDITION_BOOLEAN_TYPE_CHECK=[IfStatement]: condition expression type is not BOOLEAN type. +CONDITION_TPYE_EQUAL_CHECK=[IfStatement]: The types of the then and else expressions do not match. Please define same type for then and else expressions. +PACKAGE_CHILD_EXISTENCE_CHECK=[Package '%s']: Child element is not defined +DISPLAY_AREA_SIZE_CHECK=[Display '%s' ]: A size exceeding the size of Display is defined in the Area below. +DISPLAY_ROOT_CHECK=[Display '%s']: Route area is not defined. Please describe CompositeArea. +COMPOSITE_AREA_CHECK=[CompositeArea '%s']: Layout is not defined. Please describe the layout +VERTICAL_LAYOUT_CHECK=[VerticalLayout]: Sub-Area is not defined. Please describe Sub-Area. +HORIZONTAL_LAYOUT_CHECK=[HorizontalLayout]: Sub-Area is not defined. Please describe subarea. +FIXEDPOSITION_LAYOUT_CHECK=[FixedPositionLayout]: Sub-Area is not defined. Please describe PositionContainer. +POSITION_CONTAINER_COORDINATE_CHECK=[PositionContainer]: The definition of PositionContainer's coordinates exceeds the size of Display. +AREA_VISIBILITY_TYPE=[Area '%s']: The type of constraint expression of visibility is invalid. Please return the value. +AREA_ZORDER_TYPE=[Area '%s']: The type of constraint expression of Z order is invalid. Please return the value. +CONTENT_ALLOCATABLE_SIZE=[ViewContent '%s']: \u00a0\u00a0 Displayable area is not defined. Please describe allocatable. +CONTENT_ALLOCATABLE_INVALID_TYPE=[ViewContent '%s']: The allocatable in allocatables is not a Area/AreaSet. +CONTENT_ALLOCATABLE_DUPLICATE=[ViewContent '%s']: The area in allocatables is duplicated. +CONTENT_DISPLAY_SIZE_CHECK=[ViewContent '%s']: A size exceeding the size of Display is defined. +VISIBILITY_IS_REQUIRED=[%s '%s']: visibility is required. +HAS_AT_LEAST_ONE_STATE=[%s '%s']: Must define at least one State. +ZORDER_IS_REQUIRED=[%s '%s]: zorder is required. +HAS_AT_LEAST_ONE_SIZE=[%s '%s']: Size or sizeReference must be defined at least one. +ORDER_IS_REQUIRED=[%s '%s']: order is required. +QUEUE_IS_REQUIRED=[%s '%s']: queue is required. +MESSAGEAPP_ALLOCATABLE_SIZE=[MessageApp '%s']: \u00a0 Displayable area is not defined. Please describe allocatable. +MESSAGEAPP_STATES_SIZE=[MessageApp '%s']: Content state is not defined. Please describe ContentState. +CONTENTSTATE_TYPE=[ContentState '%s']: Value type constraint expression is illegal. Please return the value. +CONSTRAINT_EXPRESSION_TYPE=[Constraint]: Constraint expression type is not BOOLEAN type. +THATOF_OPERAND_SIZE=[ThatOfOperator]: The number of operands is invalid. Only one operand can be defined. +THATOF_OPERAND_OBJECTREFERENCE=[ThatOfOperator]: The type of the operand is not an ObjectReference. +THATOF_OPERAND_OBJECTREFERENCE_EQUAL=[ThatOfOperator]: Operand type is invalid. Please specify the same type as the parent model element. +THATOF_OPERAND_EXPRESSIONTYPE=[ThatOfOperator]: You can only define[AREA / CONTENT_STATE\u300das the operand constraint expression type. +EQUALTO_OPERAND_SIZE_NULL=[EqualToOperator]: Operand is not defined. +EQUALTO_OPERAND_SIZE=[EqualToOperator]: The number of operands is invalid. Only one operand can be defined. +EQUALTO_OPERAND_TYPE=[EqualToOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. +GREATERTHAN_OPERAND_SIZE_NULL=[GreaterThanOperator]: Operand is not defined +GREATERTHAN_OPERAND_SIZE=[GreaterThanOperator]: The number of operands is invalid. Only one operand can be defined. +GREATERTHAN_OPERAND_TYPE=[GreaterThanOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns a value. +MUCHGREATERTHAN_OPERAND_SIZE_NULL=[MuchGreaterThanOperator]: Operand is not defined. +MUCHGREATERTHAN_OPERAND_SIZE=[MuchGreaterThanOperator]: The number of operands is invalid. Only one operand can be defined. +MUCHGREATERTHAN_OPERAND_TYPE=[MuchGreaterThanOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns a value. +LOWERTHAN_OPERAND_SIZE_NULL=[LowerThanOperator]: Operand is not defined. +LOWERTHAN_OPERAND_SIZE=[LowerThanOperator]: The number of operands is invalid. Only one operand can be defined. +LOWERTHAN_OPERAND_TYPE=[LowerThanOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns a value. +COMPARISONAND_OPERAND_SIZE=[ComparisonAnd]: The number of operands is invalid. Define two or more operands. +COMPARISONAND_OPERAND_TYPE=[ComparisonAnd]: The type of the operand is invalid. Please use the comparison operator. +PLUS_OPERAND_SIZE=[PlusOperator]: The number of operands is invalid. Define two or more operands. +PLUS_OPERAND_TYPE=[PlusOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns a value. +PLUS_OPERAND_TYPE_NOT_OPERATOR=[PlusOperator]: The operand constraint expression type is invalid.The operator can not be use. Please describe a constraint expression that returns a value. +AND_OPERAND_SIZE=[AndOperator]: The number of operands is invalid. Define two or more operands. +AND_OPERAND_TYPE=[AndOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns BOOLEAN type. +OR_OPERAND_SIZE=[OrOperator]: The number of operands is invalid. Define two or more operands. +OR_OPERAND_TYPE=[OrOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns BOOLEAN type. +IMPLIES_OPERAND_SIZE=[ImpliesOperator]: The number of operands is invalid. Define two or more operands. +IMPLIES_OPERAND_TYPE=[ImpliesOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns BOOLEAN type. +NOT_OPERAND_SIZE=[NotOperator]: The number of operands is invalid. Only one operand can be defined. +NOT_OPERAND_TYPE=[NotOperator]: The operand constraint expression type is invalid. Please describe a constraint expression that returns BOOLEAN type. +OPERANDS_MUST_BE_OBJECT=[%s]: You can only define [AREA / CONTENT / ZONE / SOUND / CONTENT_STATE] as the operand constraint expression type. +FIRST_OPERAND_MUST_BE_OBJECT=[%s]: You can not compare values.Please use '=' to compare values. +ISDISPLAYED_SIZE=[IsDisplayed]: The number of operands is invalid. Only one operand can be defined. +ISDISPLAYED_TYPE=[IsDisplayed]: The operand constraint expression type is invalid. describe a constraint expression that returns Area. +DISPLAYINGCONTENT_SIZE=[DisplayingContent]: The number of operands is invalid. Only one operand can be defined. +DISPLAYINGCONTENT_TYPE=[DisplayingContent]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Area. +GETCONTENTSLIST_SIZE= [GetContentsList]: The number of operands is invalid. Only one operand can be defined. +GETCONTENTSLIST_TYPE=[GetContentsList]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Area, Zone. +ISACTIVE_SIZE=[IsActive]: The number of operands is invalid. Only one operand can be defined. +ISACTIVE_TYPE=[IsActive]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Content. +ISVISIBLE_SIZE=[IsVisible]: The number of operands is invalid. Only one operand can be defined. +ISVISIBLE_TYPE=[IsVisible]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Content +GETALLOCATABLES_SIZE=[GetAllocatables]: The number of operands is invalid. Only one operand can be defined. +GETALLOCATABLES_TYPE=[GetAllocatables]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Content +LAMBDAEXPRESSION_TYPE=[LambdaExpression]: Variable constraint expression type and context constraint expression type: do not match. +FORALL_OPERAND_SIZE=[ForAllOperator]: The number of operands is invalid. Only one operand can be defined. +FORALL_OPERAND_TYPE=[ForAllOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones, SoundContents. +FORALL_LAMBDA_TYPE=[ForAllOperator]: Type of The lambda's body expression must be Boolean or Action Expression. +EXISTS_OPERAND_SIZE=[ExistsOperator]: The number of operands is invalid. Only one operand can be defined. +EXISTS_OPERAND_TYPE=[ExistsOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones, SoundContents. +NAMEDELEMENT_NAME_DUPLICATE=Duplicate name '%s' +CIRCULAR_CONTAINMENT_DETECTE=A cycle was detected in the target of '%s'. %s +ISEQUALTO_OPERAND_SIZE=[IsEqualToOperator]: The number of operands is invalid. Please define two operands. +ISEQUALTO_OPERAND_TYPE=[IsEqualToOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. Please use '==' to compare objects. +ISGREATERTHAN_OPERAND_SIZE=[IsGreaterThanOperator]: The number of operands is invalid. Please define two operands. +ISGREATERTHAN_OPERAND_TYPE=[IsGreaterThanOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. +ISGREATERTHANEQUAL_OPERAND_SIZE=[IsGreaterThanEqualOperator]: The number of operands is invalid. Please define two operands. +ISGREATERTHANEQUAL_OPERAND_TYPE=[IsGreaterThanEqualOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. +ISLOWERTHAN_OPERAND_SIZE=[IsLowerThanOperator]: The number of operands is invalid. Please define two operands. +ISLOWERTHAN_OPERAND_TYPE=[IsLowerThanOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. +ISLOWERTHANEQUAL_OPERAND_SIZE=[IsLowerThanEqualOperator]: The number of operands is invalid. Please define two operands. +ISLOWERTHANEQUAL_OPERAND_TYPE=[IsLowerThanEqualOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns a value. +EXCLUSIVEOR_OPERAND_SIZE=[ExclusiveOrOperator]: The number of operands is invalid. Define two or more operands. +EXCLUSIVEOR_OPERAND_TYPE=[ExclusiveOrOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns BOOLEAN type. +ISHIDDEN_SIZE=[IsHidden]: The number of operands is invalid. Only one operand can be defined. +ISHIDDEN_TYPE=[IsHidden]: The operand constraint expression type is invalid. Write a constraint expression that returns Area. +CONTENTVALUE_SIZE=[ContentValue]: The number of operands is invalid. Only one operand can be defined. +CONTENTVALUE_TYPE=[ContentValue]: The operand constraint expression type is invalid. Write a constraint expression that returns Area, Zone. +SET_OF_OPERAND_TYPE=[SetOfOperator]: The operand constraint expression type is invalid. Write a constraint expression that returns same elements. +SET_OF_OPERAND_DUPLICATE=[SetOfOperator]: The element in the target is duplicated. +ISON_TYPE=[IsOn]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Scene. +ISDEFEATEDBY_OEPRAND_SIZE=[IsDefeatedBy]: The number of operands is invalid. Please define two operands. +ISDEFEATEDBY_OEPRAND_0_TYPE=[IsDefeatedBy]: The operand constraint expression type is invalid. Write a constraint expression that returns Content. +ISDEFEATEDBY_OPERAND_0_CHECK=[IsDefeatedBy]: (pre)can not be used. +ISDEFEATEDBY_OPERAND_1_CHECK=[IsDefeatedBy]: You can not use (pre) as an argument. +DEFEATS_OPERAND_SIZE=[Defeats]: The number of operands is invalid. Please define two operands. +DEFEATS_OPERAND_0_TYPE=[Defeats]: The operand constraint expression type is invalid. Write a constraint expression that returns Content. +DEFEATS_OPERAND_0_CHECK=[Defeats]: (pre) can not be used. +DEFEATS_OPERAND_1_CHECK=[Defeats]: You can not use (pre) as an argument. +ISDISAPPEARED_OPERAND_SIZE=[IsDisappeared]: The number of operands is invalid. Please define one operand. +ISDISAPPEARED_OPERAND_0_TYPE=[IsDisappeared]: The operand constraint expression type is invalid. Write a constraint expression that returns Content. +ISDISAPPEARED_OPERAND_0_CHECK=[IsDisappeared]: (pre) can not be used. +ISCANCELED_OPERAND_SIZE=[IsCanceled]: The number of operands is invalid. Please define one operand. +ISCANCELED_OPERAND_0_TYPE=[IsCanceled]: The operand constraint expression type is invalid. Write a constraint expression that returns Content. +ISCANCELED_OPERAND_0_CHECK=[IsCanceled]: (pre) can not be used. +OFFSET_SIZE_DUPLICATE=[Offset]: The sizeReference has already been referenced from another Offset. Same size can not be used multiple. +OFFSET_SIZE_AREA_REF=[Offset]: The sizeReference using the Offset is not being referenced from the Area. Please refer to Size between the Offset and the Area. +AREASET_TARGET_SIZE=[AreaSet '%s']: \u00a0\u00a0 Includes area is not defined. Please describe target. +AREASET_TARGET_DUPLICATE=[AreaSet '%s']: The area in the target is duplicated. +AREASET_TARGET_INCLUDE_SELF=[AreaSet '%s']: The target contains iteself. +ALLOCATEDCONTENT_TYPE=[AllocatedContent]: The operand constraint expression type is invalid. Please describe a constraint expression that returns Area, Zone. +ONSCENE_OPERAND_SIZE_CHECK=[OnScene]: Please define one operand. +ONSCENE_OPERAND_TYPE_CHECK=[OnScene]: Describe the scene in the operand. +ONSCENE_ISGLOBALSCENE=[OnScene]: Please use the global scene. +OFFSCENE_OPERAND_SIZE_CHECK=[OffScene]: Please define one operand. +OFFSCENE_OPERAND_TYPE_CHECK=[OffScene]: Describe the scene in the operand. +OFFSCENE_ISGLOBALSCENE=[OffScene]: Please use the global scene. +SETPROPERTY_OPERAND_SIZE_CHECK=[SetProperty]: Please specify operand and argument. +SETPROPERTY_OPERAND_0_TYPE_CHECK=[SetProperty]: Write the scene property in the operand. +SETPROPERTY_OPERAND_ISGLOBALSCENE=[SetProperty]: Please use the global scene. +SETPROPERTY_OPERAND_1_TYPE_CHECK=[SetProperty]: Please write a numeric value for the argument. +SETPROPERTY_PROPERTY_NEGATIVE=[SetProperty]: The property is invalid. Please use a value greater than or equal to 0. +GETPROPERTY_OPERAND_SIZE_CHECK=[GetProperty]: Please define one operand. +GETPROPERTY_OPERAND_TYPE_CHECK=[GetProperty]: Describe the scene property in the operand. +GETPROPERTY_OPERAND_ISGLOBALSCENE=[GetProperty]: Use the global scene. +SCENE_GLOBAL=[Scene]: To define properties, set global: true. +SCENE_PROPERTY_NEGATIVE=[Scene]: The property is invalid. Please use a value greater than or equal to 0. +SOUND_ALLOCATABLE_SIZE=[SoundContent '%s']: \u00a0\u00a0 Displayable zone is not defined. Please describe allocatable. +SOUND_ALLOCATABLE_INVALID_TYPE=[SoundContent '%s']: The allocatable in allocatables is not a Zone/ZoneSet. +SOUND_ALLOCATABLE_DUPLICATE=[SoundContent '%s']: The zone in allocatables is duplicated. +ZONESET_TARGET_SIZE=[ZoneSet '%s']: \u00a0\u00a0 Includes zone is not defined. Please describe target. +ZONESET_TARGET_INCLUDE_SELF=[ZoneSet '%s']: The target contains iteself. +ZONESET_TARGET_DUPLICATE=[ZoneSet '%s']: The zone in the target is duplicated. +ISSOUNDING_SIZE=[IsSounding]: The number of operands is invalid. Only one operand can be defined. +ISSOUNDING_TYPE=[IsSounding]: The operand constraint expression type is invalid. Write a constraint expression that returns Sound. +ISOUTPUTTED_SIZE=[IsOutputted]: The number of operands is invalid. Only one operand can be defined. +ISOUTPUTTED_TYPE=[IsOutputted]: The operand constraint expression type is invalid. Write a constraint expression that returns Zone. +ISMUTED_SIZE=[IsMuted]: The number of operands is invalid. Only one operand can be defined. +ISMUTED_TYPE=[IsMuted]: The operand constraint expression type is invalid. Write a constraint expression that returns Zone. +ISATTENUATED_SIZE=[IsAttenuated]: The number of operands is invalid. Only one operand can be defined. +ISATTENUATED_TYPE=[IsAttenuated]: The operand constraint expression type is invalid. Write a constraint expression that returns Zone. +OUTPUTTINGSOUND_SIZE=[OutputtingSound]: The number of operands is invalid. Only one operand can be defined. +OUTPUTTINGSOUND_TYPE=[OutputtingSound]: The operand constraint expression type is invalid. Write a constraint expression that returns Zone. +ISON_SIZE=[IsOn]: The number of operands is invalid. Only one operand can be defined. +VIEWCONTENTSET_TARGET_SIZE=[ViewContentSet '%s']: \u00a0\u00a0 Includes view content is not defined. Please describe target. +VIEWCONTENTSET_TARGET_DUPLICATE=[ViewContentSet '%s']: The view content in the target is duplicated. +VIEWCONTENTSET_TARGET_INCLUDE_SELF=[ViewContentSet '%s']: The target contains iteself. +VIEWCONTENTSET_ALLOCATABLE_INVALID_TYPE=[ViewContentSet '%s']: The allocatable in allocatables is not a Area/AreaSet. +VIEWCONTENTSET_ALLOCATABLE_DUPLICATE=[ViewContentSet '%s']: The area in allocatables is duplicated. +SOUNDCONTENTSET_TARGET_SIZE=[SoundContentSet '%s']: \u00a0\u00a0 Includes sound content is not defined. Please describe target. +SOUNDCONTENTSET_TARGET_DUPLICATE=[SoundContentSet '%s']: The sound content in the target is duplicated. +SOUNDCONTENTSET_TARGET_INCLUDE_SELF=[SoundContentSet '%s']: The target contains iteself. +SOUNDCONTENTSET_ALLOCATABLE_INVALID_TYPE=[SoundContentSet '%s']: The allocatable in allocatables is not a Zone/ZoneSet. +SOUNDCONTENTSET_ALLOCATABLE_DUPLICATE=[SoundContentSet '%s']: The zone in allocatables is duplicated. +AREASET_TARGET_INVALID_TYPE=[AreaSet '%s']: The area in target is not a Area/AreaSet. +VIEWCONTENTSET_TARGET_INVALID_TYPE=[ViewContentSet '%s']: The content in target is not a ViewContent/ViewContentSet. +ZONESET_TARGET_INVALID_TYPE=[ZoneSet '%s']: The zone in target is not a Zone/ZoneSet. +SOUNDCONTENTSET_TARGET_INVALID_TYPE=[SoundContentSet '%s']: The content in target is not a SoundContent/SoundContentSet. +OPERAND_SIZE_ONE=[%s]: The number of operands is invalid. The argument can not be specified. +OPERAND_SIZE_TWO=[%s]: The number of operands is invalid. Please define two operands. +FIRST_OPERAND_MUST_CONTENT=[%s]: The first operand is invalid. Specify a ViewContent, SoundContent. +ARGUMENT_MUST_CONTENT=[%s]: The argument operand is invalid. Specify a ViewContent, SoundContent. +OPERAND_CANNOT_USE_PRE=[%s]: (pre) can not be used to first operand. +ARGUMENT_CANNOT_USE_PRE=[%s]: (pre) can not be used to the argument. +ARGUMENT_MUST_ALLOCATABLE=[%s]: The argument operand is invalid. Specify a Area, a Zone. +COMBINATION_OPERAND_ARGUMENT=[%s]: The operand and the argument are invalid combination. Specify together an Area and a ViewContent, or a Zone and a SoundContent. +FIRST_OPERAND_MUST_ALLOCATABLE=[%s]: The first operand is invalid. Specify a Area, a Zone. +FIRST_OPERAND_MUST_VIEWCONTENT=[%s]: The first operand is invalid. Specify a ViewContent. +ARGUMENT_MUST_AREA=[%s]: The argument operand is invalid. Specify a Area. +FIRST_OPERAND_MUST_AREA=[%s]: The first operand is invalid. Specify a Area. +ARGUMENT_MUST_VIEWCONTENT=[%s]: The argument operand is invalid. Specify a ViewContent. +FIRST_OPERAND_MUST_SOUNDCONTENT=[%s]: The first operand is invalid. Specify a SoundContent. +ARGUMENT_MUST_ZONE=[%s]: The argument operand is invalid. Specify a Zone. +FIRST_OPERAND_MUST_ZONE=[%s]: The first operand is invalid. Specify a Zone. +ARGUMENT_MUST_SOUNDCONTENT=[%s]: The argument operand is invalid. Specify a SoundContent. +ALLOCATABLE_SIZE=[%s]: allocatable is not defined. Please describe allocatable. +MIN_OP_OPERAND_SIZE=[MinOperator]: The number of operands is invalid. Only one operand can be defined. +MIN_OP_OPERAND_TYPE=[MinOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones. +MAX_OP_OPERAND_SIZE=[MaxOperator]: The number of operands is invalid. Only one operand can be defined. +MAX_OP_OPERAND_TYPE=[MaxOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones. +SELECT_OPERAND_SIZE=[SelectOperator]: The number of operands is invalid. Only one operand can be defined. +SELECT_OPERAND_TYPE=[SelectOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones. +FIRST_OPERAND_MUST_FOR_ISTYPEOF=[%s]: The first operand is invalid. Specify any of them [ViewContent,SoundContent,Area,Zone]. +SIZE_OPERAND_TYPE=[SizeOperator]: The operand type is invalid. Please describe a Set(AreaSet, ViewContentSet, ZoneSet, SoundContentSet), or set of Areas, Contents, Zones. +TARGET_MODEL_NAME_MISMATCH=[%s]: [%s] is expected. +NAME_RESTRICTION=[%s '%s']: This name has been reserved. +PROJECT_SIZE_CHECK=[Project]: Only one Project can be defined. +PROJECT_NAME_CHECK=[Project]: No need to define a project name. +FIRST_OPERAND_MUST_CONTENT_OR_CONTENTSTATE=[%s]: The first operand is invalid. Specify a ViewContent, SoundContent or ContentState. +BODY_MUST_OBJECT=[%s]: The body statement is invalid. Specify below.\nValue\nBoolean\nArea\nContent\nSet_of_Area\nSet_of_Content\nScene\nZone\nSet_of_Zone\nSound\nSet_of_Sound\nContentState\nTimer +OPERANDS_CANNOT_USE_PRE=[%s]: (pre) can not be used to operands. +MUST_BE_USE_IN=[%s]: must be use in %s. +SIZE_NEGATIVE=[Size]: The width or height is invalid. Please use a value greater than or equal to 0. +ZONE_VISIBILITY_NEGATIVE=[Zone]: The visibility is invalid. Please use a value greater than or equal to 0. +ZONE_ATTENUATE_NEGATIVE=[Zone]: The attenuate is invalid. Please use a value greater than or equal to 0.
\ No newline at end of file diff --git a/rba.tool.editor/src/rba/tool/editor/model/manager/GlobalIndexResourceSorter.java b/rba.tool.editor/src/rba/tool/editor/model/manager/GlobalIndexResourceSorter.java new file mode 100644 index 0000000..559e9d5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/model/manager/GlobalIndexResourceSorter.java @@ -0,0 +1,36 @@ +package rba.tool.editor.model.manager; + +import java.util.Comparator; + +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.resource.Resource; + +public class GlobalIndexResourceSorter implements Comparator<Resource> { + + int sort(URI o1, URI o2) { + /* first compare folder */ + int size1 = o1.segmentCount() - 1; + int size2 = o2.segmentCount() - 1; + for (int i = 0; i < size1 && i < size2; i++) { + int result = o1.segment(i).toLowerCase().compareTo(o2.segment(i).toLowerCase()); + if (result != 0) { + return result; + } + } + + if (size1 == size2) { + /* order of name that last segment(file). */ + return o1.lastSegment().toLowerCase().compareTo(o2.lastSegment().toLowerCase()); + } else if (size1 > size2) { + /* prioritize folder over file */ + return -1; + } else { + return 1; + } + } + + @Override + public int compare(Resource o1, Resource o2) { + return sort(o1.getURI(), o2.getURI()); + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/model/manager/ResourceManager.xtend b/rba.tool.editor/src/rba/tool/editor/model/manager/ResourceManager.xtend new file mode 100644 index 0000000..856eada --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/model/manager/ResourceManager.xtend @@ -0,0 +1,209 @@ +package rba.tool.editor.model.manager + +import com.google.common.collect.Iterables +import java.util.List +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.xbase.lib.Functions.Function1 +import rba.core.Allocatable +import rba.core.Constraint +import rba.core.Content +import rba.core.Expression +import rba.core.ExpressionType +import rba.core.NamedElement +import rba.core.Package +import rba.core.Scene +import rba.core.SetOfOperator +import rba.core.State +import rba.core.Variable +import rba.sound.SoundContent +import rba.sound.SoundContentSet +import rba.sound.Zone +import rba.sound.ZoneSet +import rba.tool.editor.rbaEditorModel.TopLevel +import rba.view.Area +import rba.view.AreaSet +import rba.view.Display +import rba.view.PositionContainer +import rba.view.Size +import rba.view.ViewContent +import rba.view.ViewContentSet +import rba.core.Tag +import rba.core.Stereotype + +class ResourceManager { + + public static ResourceManager INSTANCE = new ResourceManager(); + + private Function1<? super Expression, Boolean> pseudoViewConstraintPredicate = [ e | + e.type === ExpressionType.CONTENT || e.type === ExpressionType.SET_OF_CONTENT || e.type === ExpressionType.AREA || e.type === ExpressionType.SET_OF_AREA + ]; + + private Function1<? super Expression, Boolean> pseudoSoundConstraintPredicate = [ e | + e.type === ExpressionType.SOUND || e.type === ExpressionType.SET_OF_SOUND || e.type === ExpressionType.ZONE || e.type === ExpressionType.SET_OF_ZONE + ]; + + private Function1<? super Expression, Boolean> generalConstraintPredicate = [ e | + e.type === ExpressionType.SCENE || e.type === ExpressionType.PROPERTY || e.type === ExpressionType.BOOLEAN || e.type === ExpressionType.VALUE || + e.type === ExpressionType.LAMBDA + ]; + + private new() { + } + + def private <T> List<T> filter(ResourceSet set, Class<T> filterClass) { + return set.resources.sort.map(r|r.allContents.toIterable.filter(filterClass)).flatten.toList; + } + + def private List<Resource> sort(List<Resource> list) { + return list.sortWith(new GlobalIndexResourceSorter()); + } + + def public List<NamedElement> getNamedElement(ResourceSet resourceSet) { + val elements = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(NamedElement)).flatten; + return elements.toList; + } + + def public List<Allocatable> getRbaAllocatables(ResourceSet resourceSet) { + val allAllocatables = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Allocatable)).flatten; + return allAllocatables.toList; + } + + def public List<Area> getRbaAreas(ResourceSet resourceSet) { + val allAreas = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Area)).flatten; + return allAreas.toList; + } + + def public List<Zone> getRbaZones(ResourceSet resourceSet) { + return filter(resourceSet, Zone); + } + + def public List<AreaSet> getRbaAreaSets(ResourceSet resourceSet) { + val allAreaSets = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(AreaSet)).flatten; + return allAreaSets.toList; + } + + def public List<ZoneSet> getRbaZoneSets(ResourceSet resourceSet) { + val allZoneSets = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(ZoneSet)).flatten; + return allZoneSets.toList; + } + + def public List<Content> getRbaContents(ResourceSet resourceSet) { + val allContents = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Content)).flatten; + return allContents.toList; + } + + def public List<ViewContent> getRbaViewContents(ResourceSet resourceSet) { + val allContents = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(ViewContent)).flatten; + return allContents.toList; + } + + def public List<ViewContentSet> getRbaViewContentSets(ResourceSet resourceSet) { + val allContentSets = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(ViewContentSet)).flatten; + return allContentSets.toList; + } + + def public List<SoundContentSet> getRbaSoundContentSets(ResourceSet resourceSet) { + val allContentSets = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(SoundContentSet)).flatten; + return allContentSets.toList; + } + + def public List<SoundContent> getRbaSoundContents(ResourceSet resourceSet) { + return filter(resourceSet, SoundContent); + } + + def public List<State> getRbaState(ResourceSet resourceSet) { + val allStates = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(State)).flatten; + return allStates.toList; + } + + def public List<Scene> getRbaScenes(ResourceSet resourceSet) { + val allScenes = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Scene)).flatten; + return allScenes.toList; + } + + def public List<Size> getRbaSizes(ResourceSet resourceSet) { + val allSizes = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Size)).flatten; + return allSizes.toList; + } + + def public List<Display> getRbaDisplays(ResourceSet resourceSet) { + val allDisplays = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Display)).flatten; + return allDisplays.toList; + } + + def public List<PositionContainer> getRbaPositionContainers(ResourceSet resourceSet) { + val allPositionContainers = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(PositionContainer)).flatten; + return allPositionContainers.toList; + } + + def public List<Package> getRbaPackages(ResourceSet resourceSet) { + val allPackages = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Package)).flatten; + return allPackages.toList; + } + + def public List<Package> getRbaRootPackages(ResourceSet resourceSet) { + val allPackages = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Package).filter(package|package.eContainer instanceof TopLevel)).flatten; + return allPackages.toList; + } + + def public List<Constraint> getRbaConstraints(ResourceSet resourceSet) { + val allConstraints = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Constraint)).flatten; + return allConstraints.toList; + } + + def public List<Constraint> getRbaOnlineConstraints(ResourceSet resourceSet) { + val allOnlineConstraints = getRbaConstraints(resourceSet).filter(c|c.runtime === true); + return allOnlineConstraints.toList; + } + + def public List<Constraint> getRbaOfflineConstraints(ResourceSet resourceSet) { + val allOfflineConstraints = getRbaConstraints(resourceSet).reject(c|c.runtime === true); + return allOfflineConstraints.toList; + } + + def public List<Constraint> getRbaViewConstraints(ResourceSet resourceSet) { + val allOnlineconstraints = getRbaOnlineConstraints(resourceSet); + val allPseudoViewConstraints = allOnlineconstraints.filter(c|EcoreUtil2.getAllContentsOfType(c, Expression).exists(pseudoViewConstraintPredicate)); + val allGeneralConstraints = allOnlineconstraints.filter(c|EcoreUtil2.getAllContentsOfType(c, Expression).forall(generalConstraintPredicate)); + val allViewConstraints = Iterables.concat(allPseudoViewConstraints, allGeneralConstraints).toList; + val allOrderedViewConstraints = allOnlineconstraints.filter(c|allViewConstraints.contains(c)); + return allOrderedViewConstraints.toList; + } + + def public List<Constraint> getRbaSoundConstraints(ResourceSet resourceSet) { + val allOnlineconstraints = getRbaOnlineConstraints(resourceSet); + val allPseudoSoundConstraints = allOnlineconstraints.filter(c|EcoreUtil2.getAllContentsOfType(c, Expression).exists(pseudoSoundConstraintPredicate)); + val allGeneralConstraints = allOnlineconstraints.filter(c|EcoreUtil2.getAllContentsOfType(c, Expression).forall(generalConstraintPredicate)); + val allSoundConstraints = Iterables.concat(allPseudoSoundConstraints, allGeneralConstraints).toList; + val allOrderedSoundConstraints = allOnlineconstraints.filter(c|allSoundConstraints.contains(c)); + return allOrderedSoundConstraints.toList; + } + + def public List<Variable> getRbaVariables(ResourceSet resourceSet) { + val allVariables = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Variable)).flatten; + return allVariables.toList; + } + + def public List<SetOfOperator> getRbaSetOfOperators(ResourceSet resourceSet) { + val allSetOfOperators = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(SetOfOperator)).flatten; + return allSetOfOperators.toList; + } + + def public List<Tag> getRbaTags(ResourceSet resourceSet) { + val allSetOfOperators = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Tag)).flatten; + return allSetOfOperators.toList; + } + + def public List<Stereotype> getRbaStereotypes(ResourceSet resourceSet) { + val allSetOfOperators = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(Stereotype)).flatten; + return allSetOfOperators.toList; + } + + def public List<EObject> getRbaAllContents(ResourceSet resourceSet) { + val allContents = resourceSet.resources.sort.map(r|r.allContents.toIterable.filter(EObject)).flatten; + return allContents.toList; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/naming/RBAModelSimpleNameProvider.xtend b/rba.tool.editor/src/rba/tool/editor/naming/RBAModelSimpleNameProvider.xtend new file mode 100644 index 0000000..325d4d5 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/naming/RBAModelSimpleNameProvider.xtend @@ -0,0 +1,62 @@ +package rba.tool.editor.naming + +import com.google.inject.Inject +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.naming.IQualifiedNameConverter +import org.eclipse.xtext.naming.IQualifiedNameProvider +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.util.SimpleAttributeResolver +import rba.core.AbstractProperty +import rba.core.ContentState +import rba.core.Package +import rba.core.State +import rba.view.Size + +class RBAModelSimpleNameProvider extends IQualifiedNameProvider.AbstractImpl { + + @Inject private IQualifiedNameConverter qualifiedNameConverter + + override getFullyQualifiedName(EObject obj) { + val String name = SimpleAttributeResolver.NAME_RESOLVER.apply(obj); + if (name === null || name.length() === 0) + return null; + val QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(name); + + if (obj instanceof ContentState || obj instanceof State) { + val EObject parent = obj.eContainer; + if (parent === null) { + return null; + } + val QualifiedName parentQualifiedName = getFullyQualifiedName(obj.eContainer); + if (parentQualifiedName === null || parentQualifiedName.empty) { + return null; + } + return parentQualifiedName.append(qualifiedName); + } else if (obj instanceof Size) { + val EObject parent = obj.eContainer; + if (parent === null) { + return null; + } + if (!(parent instanceof Package)) { + val QualifiedName parentQualifiedName = getFullyQualifiedName(obj.eContainer); + if (parentQualifiedName === null || parentQualifiedName.empty) { + return null; + } + return parentQualifiedName.append(qualifiedName); + } + } else if (obj instanceof AbstractProperty) { + val EObject parent = obj.eContainer; + if (parent === null) { + return null; + } + val QualifiedName parentQualifiedName = getFullyQualifiedName(obj.eContainer); + if (parentQualifiedName === null || parentQualifiedName.empty) { + return null; + } + return parentQualifiedName.append(qualifiedName); + } + + return qualifiedName; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/resource/IRBAModelResourceLoader.xtend b/rba.tool.editor/src/rba/tool/editor/resource/IRBAModelResourceLoader.xtend new file mode 100644 index 0000000..8f7812d --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/resource/IRBAModelResourceLoader.xtend @@ -0,0 +1,11 @@ +package rba.tool.editor.resource + +import org.eclipse.core.resources.IProject +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.resource.ResourceSet + +interface IRBAModelResourceLoader { + + def void loadAndResolveResource(ResourceSet resourceSet, URI[] URIs, IProject project); + +} diff --git a/rba.tool.editor/src/rba/tool/editor/resource/RBAModelEObjectDescription.xtend b/rba.tool.editor/src/rba/tool/editor/resource/RBAModelEObjectDescription.xtend new file mode 100644 index 0000000..d9d5d8e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/resource/RBAModelEObjectDescription.xtend @@ -0,0 +1,24 @@ +package rba.tool.editor.resource + +import java.util.Map +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.resource.EObjectDescription + +class RBAModelEObjectDescription extends EObjectDescription { + + private final int[] additionalInfo; + + new(QualifiedName qualifiedName, EObject element, Map<String, String> userData) { + this(qualifiedName, element, userData, newIntArrayOfSize(2)); + } + + new(QualifiedName qualifiedName, EObject element, Map<String, String> userData, int[] additionalInfo) { + super(qualifiedName, element, userData); + this.additionalInfo = additionalInfo ?: newIntArrayOfSize(2); + } + + def public int[] getAdditionalInfo() { + return this.additionalInfo; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/resource/RBAModelLocationInFileProvider.xtend b/rba.tool.editor/src/rba/tool/editor/resource/RBAModelLocationInFileProvider.xtend new file mode 100644 index 0000000..6deab29 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/resource/RBAModelLocationInFileProvider.xtend @@ -0,0 +1,17 @@ +package rba.tool.editor.resource + +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.xtext.resource.DefaultLocationInFileProvider +import rba.tool.editor.util.RBAModelEditorToolUtil + +class RBAModelLocationInFileProvider extends DefaultLocationInFileProvider { + + override getFullTextRegion(EObject owner, EStructuralFeature feature, int indexInList) { + if (RBAModelEditorToolUtil.isSkippedSyntax(owner, feature)) { + return null; + } + super.getFullTextRegion(owner, feature, indexInList); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/IExpressionScope.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/IExpressionScope.xtend new file mode 100644 index 0000000..12f7ca4 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/IExpressionScope.xtend @@ -0,0 +1,22 @@ +package rba.tool.editor.scoping + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.scoping.IScope + +interface IExpressionScope { + + enum Anchor { + UNKNOWN, + CONSTRAINT + } + + def IScope getFeatureScope(EObject model, IExpressionScope.Anchor anchor); + + IExpressionScope NULL = new NullExpressionScope(); + + class NullExpressionScope implements IExpressionScope { + override getFeatureScope(EObject model, IExpressionScope.Anchor anchor) { + return IScope.NULLSCOPE; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelExpressionScope.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelExpressionScope.xtend new file mode 100644 index 0000000..90bdf3b --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelExpressionScope.xtend @@ -0,0 +1,22 @@ +package rba.tool.editor.scoping + +import com.google.inject.Inject +import com.google.inject.Singleton +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.scoping.IScope +import rba.tool.editor.scoping.internal.RBAModelMemberFieldScopes +import rba.tool.editor.scoping.internal.RBAModelMemberOperationScopes + +@Singleton +class RBAModelExpressionScope implements IExpressionScope { + + @Inject private RBAModelMemberFieldScopes filedScopeCreator; + @Inject private RBAModelMemberOperationScopes operationScopeCreator; + + override getFeatureScope(EObject model, IExpressionScope.Anchor anchor) { + var IScope result = filedScopeCreator.createFeatureScope(model); + result = operationScopeCreator.createFeatureScope(model, anchor, result); + return result; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelImportedNamespaceAwareLocalScopeProvider.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelImportedNamespaceAwareLocalScopeProvider.xtend new file mode 100644 index 0000000..3dad349 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelImportedNamespaceAwareLocalScopeProvider.xtend @@ -0,0 +1,42 @@ +package rba.tool.editor.scoping + +import java.util.Iterator +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.xtext.resource.IEObjectDescription +import org.eclipse.xtext.scoping.Scopes +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider +import org.eclipse.xtext.scoping.impl.MultimapBasedSelectable +import org.eclipse.xtext.xbase.lib.Functions.Function1 +import rba.core.RBACorePackage +import rba.core.Variable + +class RBAModelImportedNamespaceAwareLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider { + + private Function1<? super IEObjectDescription, Boolean> variableFilter = [ description | + description.EClass !== RBACorePackage.Literals.VARIABLE + ]; + + override protected getResourceScope(Resource res, EReference reference) { + val context = res.getContents().get(0); + var globalScope = getGlobalScope(res, reference, variableFilter); + val normalizers = getImplicitImports(isIgnoreCase(reference)); + if(!normalizers.isEmpty()) { + globalScope = createImportScope(globalScope, normalizers, null, reference.getEReferenceType(), isIgnoreCase(reference)); + } + return getResourceScope(globalScope, context, reference); + } + + override protected internalGetAllDescriptions(Resource resource) { + val allContents = new Iterable<EObject>() { + override Iterator<EObject> iterator() { + return EcoreUtil.getAllContents(resource, false).filter(c|!(c instanceof Variable)); + } + }; + val allDescriptions = Scopes.scopedElementsFor(allContents, qualifiedNameProvider); + return new MultimapBasedSelectable(allDescriptions); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelScopeProvider.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelScopeProvider.xtend new file mode 100644 index 0000000..8fe190f --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/RBAModelScopeProvider.xtend @@ -0,0 +1,85 @@ +/* + * generated by Xtext 2.12.0 + */ +package rba.tool.editor.scoping + +import java.util.ArrayList +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.scoping.Scopes +import rba.core.AbstractProperty +import rba.core.ComplexExpression +import rba.core.Content +import rba.core.ContentState +import rba.core.Expression +import rba.core.LambdaExpression +import rba.core.ObjectReference +import rba.core.RBACorePackage +import rba.core.Scene +import rba.core.State +import rba.tool.editor.rbaEditorModel.MemberFeatureReference + +/** + * This class contains custom scoping description. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping + * on how and when to use it. + */ +class RBAModelScopeProvider extends AbstractRBAModelScopeProvider { + + override getScope(EObject context, EReference reference) { + val scope = super.getScope(context, reference); + + if(reference == RBACorePackage.Literals.OBJECT_REFERENCE__REF_OBJECT) { + if(context instanceof MemberFeatureReference) { + var Expression expression = (context as MemberFeatureReference).operand.get(0); + if(expression !== null) { + if(!(expression instanceof ObjectReference)) { + return IScope.NULLSCOPE; + } + val rootElement = (expression as ObjectReference).refObject; + if(rootElement instanceof Scene) { + val candidates = EcoreUtil2.getAllContentsOfType(rootElement, AbstractProperty); + return Scopes.scopeFor(candidates); + } else if(rootElement instanceof Content) { + val candidates = #[ContentState].map(clazz|EcoreUtil2.getAllContentsOfType(rootElement, clazz).filter(c|c.eContainer === rootElement)).flatten; + return Scopes.scopeFor(candidates); + } else if(rootElement instanceof State) { + val candidates = EcoreUtil2.getAllContentsOfType(rootElement, State).filter(c|c.eContainer === rootElement); + return Scopes.scopeFor(candidates); + } + } + } else if(context instanceof ObjectReference) { + val candidates = EcoreUtil2.getAllContainers(context).filter(Expression).map [ container | + val list = new ArrayList<EObject>(); + if(container instanceof LambdaExpression) { + val lambda = container as LambdaExpression; + if(lambda.x !== null) + list.add(lambda.x); + if(lambda.letStatements !== null && lambda.letStatements.size > 0) + list.addAll(lambda.letStatements.map(l|l.variable)); + if(lambda.bodyText !== null && lambda.bodyText.letStatements !== null && lambda.bodyText.letStatements.size > 0) + list.addAll(lambda.bodyText.letStatements.map(l|l.variable)); + } else if(container instanceof ComplexExpression) { + val complex = container as ComplexExpression; + if(complex.letStatements !== null && complex.letStatements.size > 0) + list.addAll(complex.letStatements.map(l|l.variable)); + } else { + if(container.letStatements !== null && container.letStatements.size > 0) + list.addAll(container.letStatements.map(l|l.variable)); + } + return list; + ].flatten + + if(candidates.size > 0) { + return Scopes.scopeFor(candidates, scope); + } + } + } + + return scope; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/internal/IMemberFeatureScopes.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/internal/IMemberFeatureScopes.xtend new file mode 100644 index 0000000..5d6bba7 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/internal/IMemberFeatureScopes.xtend @@ -0,0 +1,12 @@ +package rba.tool.editor.scoping.internal + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.scoping.IScope +import rba.tool.editor.scoping.IExpressionScope + +interface IMemberFeatureScopes { + + def IScope createFeatureScope(EObject model); + + def IScope createFeatureScope(EObject model, IExpressionScope.Anchor anchor, IScope outer); +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberFieldScopes.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberFieldScopes.xtend new file mode 100644 index 0000000..a2c9b6f --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberFieldScopes.xtend @@ -0,0 +1,31 @@ +package rba.tool.editor.scoping.internal + +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.scoping.Scopes +import rba.core.AbstractProperty +import rba.core.Content +import rba.core.ContentState +import rba.core.Scene +import rba.core.State +import rba.tool.editor.scoping.IExpressionScope + +class RBAModelMemberFieldScopes implements IMemberFeatureScopes { + + override createFeatureScope(EObject model) { + createFeatureScope(model, IExpressionScope.Anchor.UNKNOWN, IScope.NULLSCOPE); + } + + override createFeatureScope(EObject model, IExpressionScope.Anchor anchor, IScope outer) { + if (model instanceof Scene) { + return Scopes.scopeFor(EcoreUtil2.getAllContentsOfType(model, AbstractProperty), outer); + } else if (model instanceof Content) { + return Scopes.scopeFor(EcoreUtil2.getAllContentsOfType(model, ContentState), outer); + } else if (model instanceof State) { + return Scopes.scopeFor(EcoreUtil2.getAllContentsOfType(model, State), outer); + } else { + return outer; + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationRegistry.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationRegistry.xtend new file mode 100644 index 0000000..b641362 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationRegistry.xtend @@ -0,0 +1,68 @@ +package rba.tool.editor.scoping.internal + +import com.google.inject.Inject +import com.google.inject.Singleton +import java.util.Collections +import java.util.Map +import java.util.Set +import java.util.regex.Matcher +import java.util.regex.Pattern +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.GrammarUtil +import org.eclipse.xtext.IGrammarAccess +import org.eclipse.xtext.Keyword +import org.eclipse.xtext.generator.parser.antlr.FirstSetComputer +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.resource.IEObjectDescription +import rba.core.ExpressionType +import rba.core.Operator +import rba.core.RuleObject +import rba.tool.editor.resource.RBAModelEObjectDescription +import rba.tool.editor.scoping.IExpressionScope + +@Singleton +class RBAModelMemberOperationRegistry { + + private static Map<String, String> EMPTY_USERDATA = Collections.<String, String>emptyMap(); + private static Pattern pattern = Pattern.compile("^ConfigurationParserRule_([A-Za-z]+)OperatorFor([A-Za-z]+)$"); + private static String DESCRIPTION_KEY = "%s_%s"; + private static String QUALIFIED_NAME = "%s()"; + + private final Map<String, Set<IEObjectDescription>> operations = newLinkedHashMap(); + + @Inject + public new(IGrammarAccess grammarAccess) { + registerOperations(grammarAccess); + } + + def protected void registerOperations(IGrammarAccess grammarAccess) { + val multipleOperandParserRule = GrammarUtil.findRuleForName(grammarAccess.getGrammar(), "ConfigurationParserRule_OperatorWithMultipleOperand"); + val multipleOperandConfiguration = FirstSetComputer.getFirstSet(multipleOperandParserRule.alternatives).filter(Keyword).toList; + val allConfigurations = GrammarUtil.allRules(grammarAccess.getGrammar()).filter(r|pattern.matcher(r.name).find); + for (configuration : allConfigurations) { + val Matcher matcher = pattern.matcher(configuration.name); + if (matcher.find) { + val descriptionKey = String.format(DESCRIPTION_KEY, matcher.group(1), matcher.group(2)).toUpperCase; + val descriptionEntries = newHashSet(); + val keywords = FirstSetComputer.getFirstSet(configuration.alternatives).filter(Keyword); + for (keyword : keywords) { + descriptionEntries.add( + new RBAModelEObjectDescription(QualifiedName.create(String.format(QUALIFIED_NAME, keyword.value)), null, EMPTY_USERDATA, + #[if (multipleOperandConfiguration.contains(keyword)) -1 else 0, -50])); + } + operations.put(descriptionKey, descriptionEntries); + } + } + } + + def public Set<IEObjectDescription> getOperations(EObject model, IExpressionScope.Anchor anchor) { + var ExpressionType expressionType = ExpressionType.BOOLEAN; + if (model instanceof RuleObject) { + expressionType = (model as RuleObject).expressionType; + } else if (model instanceof Operator) { + expressionType = (model as Operator).underlyingType; + } + return operations.get(String.format(DESCRIPTION_KEY, expressionType.getName(), anchor.name)); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationScopes.xtend b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationScopes.xtend new file mode 100644 index 0000000..da833ec --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/scoping/internal/RBAModelMemberOperationScopes.xtend @@ -0,0 +1,27 @@ +package rba.tool.editor.scoping.internal + +import com.google.inject.Inject +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.scoping.impl.SimpleScope +import rba.tool.editor.scoping.IExpressionScope + +class RBAModelMemberOperationScopes implements IMemberFeatureScopes { + + private RBAModelMemberOperationRegistry operationRegistry; + + @Inject + new(RBAModelMemberOperationRegistry operationRegistry) { + this.operationRegistry = operationRegistry; + } + + override createFeatureScope(EObject model) { + return createFeatureScope(model, IExpressionScope.Anchor.UNKNOWN, IScope.NULLSCOPE); + } + + override createFeatureScope(EObject model, IExpressionScope.Anchor anchor, IScope outer) { + val descriptions = operationRegistry.getOperations(model, anchor); + return new SimpleScope(outer, descriptions ?: newHashSet()); + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/util/ExtensionModuleManager.java b/rba.tool.editor/src/rba/tool/editor/util/ExtensionModuleManager.java new file mode 100644 index 0000000..966acf0 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/util/ExtensionModuleManager.java @@ -0,0 +1,63 @@ +package rba.tool.editor.util; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.Platform; + +import com.google.inject.Module; + +public class ExtensionModuleManager { + public static final ExtensionModuleManager INSTANCE = new ExtensionModuleManager(); + + private static final String EXTENSION_POINT = "rba.tool.editor.rbaToolEditorExtensionModule"; //$NON-NLS-1$ + + private static final String EXTENSION_POINT_ELEMENT = "extensionModule"; //$NON-NLS-1$ + + private static final String EXTENSION_POINT_ELEMENT_ATTRIBUTE = "class"; //$NON-NLS-1$ + + private List<Module> constraintProviders; + + private ExtensionModuleManager() { + } + + public List<Module> getExtensionModules() { + if (constraintProviders == null) { + constraintProviders = new ArrayList<Module>(); + init(); + } + return constraintProviders; + } + + private void init() { + IExtensionRegistry registry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = registry.getExtensionPoint(EXTENSION_POINT); // $NON-NLS-1$ + IExtension[] extensions = extensionPoint.getExtensions(); + + List<Module> providerList = new ArrayList<Module>(); + for (int i = 0; i < extensions.length; i++) { + IConfigurationElement[] elements = extensions[i].getConfigurationElements(); + for (int j = 0; j < elements.length; j++) { + IConfigurationElement element = elements[j]; + String elementName = element.getName(); + if (elementName.equalsIgnoreCase(EXTENSION_POINT_ELEMENT)) { // $NON-NLS-1$ + try { + Object provider = element.createExecutableExtension(EXTENSION_POINT_ELEMENT_ATTRIBUTE); // $NON-NLS-1$ + if (provider instanceof Module) { + Module factory = (Module) provider; + providerList.add(factory); + } + } catch (CoreException e) { + // do nothing + } + } + } + } + constraintProviders.addAll(providerList); + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorNameUtil.xtend b/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorNameUtil.xtend new file mode 100644 index 0000000..e7b7321 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorNameUtil.xtend @@ -0,0 +1,11 @@ +package rba.tool.editor.util + +class RBAModelEditorNameUtil { + public static val MODEL_FOLDER_NAME = "model" + public static val BUILD_FOLDER_NAME = ".applied" + public static val BUILD_TEMP_FOLDER_NAME = "temp" + public static val TEMPLATE_FOLDER_NAME = "extension" + + public static val MODEL_FILE_EXT = "rba" + public static val TEMPLATE_FILE_EXT = "ext" +} diff --git a/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorToolUtil.xtend b/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorToolUtil.xtend new file mode 100644 index 0000000..1055423 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/util/RBAModelEditorToolUtil.xtend @@ -0,0 +1,40 @@ +package rba.tool.editor.util + +import java.util.Collection +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.emf.ecore.EValidator +import rba.core.AbstractAllocatable +import rba.core.AbstractContent +import rba.core.Expression +import rba.core.RBACorePackage + +class RBAModelEditorToolUtil { + + def public static String getExpressionText(Expression expression) { + return if (expression !== null) expression.getExpressionText() else "[Invalid_Expression]"; + } + + def public static boolean isSkippedSyntax(EObject obj, EStructuralFeature feature) { + // AbstractAllocatable -> contents + if (obj instanceof AbstractAllocatable && feature == RBACorePackage.Literals.ABSTRACT_ALLOCATABLE__CONTENTS) { + return true; + } + // AbstractAllocatable -> group + if (obj instanceof AbstractAllocatable && feature == RBACorePackage.Literals.ABSTRACT_ALLOCATABLE__ALLOCATABLE_GROUP) { + return true; + } + // AbstractContent -> group + if (obj instanceof AbstractContent && feature == RBACorePackage.Literals.ABSTRACT_CONTENT__CONTENT_GROUP) { + return true; + } + return false; + } + + def public static boolean isValidated(Object context, EValidator validator) { + if (context instanceof Collection<?>) { + return (context as Collection<?>).contains(validator); + } + return false; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/CircularContainmentValidationHelper.xtend b/rba.tool.editor/src/rba/tool/editor/validation/CircularContainmentValidationHelper.xtend new file mode 100644 index 0000000..ba4205a --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/CircularContainmentValidationHelper.xtend @@ -0,0 +1,294 @@ +package rba.tool.editor.validation + +import com.google.common.collect.Maps +import com.google.common.collect.Sets +import com.google.inject.Inject +import java.util.LinkedHashSet +import java.util.Map +import java.util.Set +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.resource.IEObjectDescription +import org.eclipse.xtext.resource.IResourceServiceProvider +import org.eclipse.xtext.resource.impl.EObjectDescriptionLookUp +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider +import org.eclipse.xtext.service.OperationCanceledManager +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.ValidationMessageAcceptor +import org.eclipse.xtext.xbase.lib.Functions.Function1 +import rba.core.AbstractAllocatable +import rba.core.AbstractContent +import rba.core.AllocatableSet +import rba.core.ContentSet +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.model.manager.ResourceManager + +class CircularContainmentValidationHelper { + + private final static Function1<? super IEObjectDescription, Boolean> containmentPredicate = [ d | + d.EObjectOrProxy instanceof AbstractAllocatable || d.EObjectOrProxy instanceof AbstractContent + ]; + + private final static Function1<? super EObject, Boolean> containerPredicate = [ eObject | + eObject instanceof AllocatableSet || eObject instanceof ContentSet + ]; + + @Inject + private IResourceServiceProvider.Registry resourceServiceProviderRegistry = IResourceServiceProvider.Registry.INSTANCE; + + @Inject + private ResourceDescriptionsProvider resourceDescriptionsProvider; + + @Inject + private OperationCanceledManager operationCanceledManager = new OperationCanceledManager(); + + private String CIRCULAR_CONTAINMENT_DETECTE = Messages.CIRCULAR_CONTAINMENT_DETECTE; + + def public void checkCircularContainment(Resource resource, CancelIndicator cancelIndicator, ValidationMessageAcceptor acceptor) { + val resourceServiceProvider = resourceServiceProviderRegistry.getResourceServiceProvider(resource.getURI()); + if (resourceServiceProvider === null) { + return; + } + + val clusterToNames = Maps.newHashMap(); + val resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resource.resourceSet); + var descriptionLookUp = new EObjectDescriptionLookUp(resourceDescriptions.exportedObjects.filter(containmentPredicate).toList); + + val descriptions = getAllObjectDescriptions(resource, descriptionLookUp); + val currentIter = descriptions.iterator(); + if (!currentIter.hasNext()) { + return; + } + + initDescriptionForCircularContainment(resource.resourceSet, descriptionLookUp, clusterToNames, acceptor); + + while (currentIter.hasNext()) { + val objectDescription = currentIter.next(); + checkDescriptionForCircularContainment(resource.resourceSet, descriptionLookUp, objectDescription, clusterToNames, acceptor); + operationCanceledManager.checkCanceled(cancelIndicator); + } + } + + def private Iterable<IEObjectDescription> getAllObjectDescriptions(Resource resource, EObjectDescriptionLookUp descriptionLookUp) { + val allObjectDescriptions = resource.allContents.toIterable.filter(containerPredicate).map(o|findEObjectDescription(o, descriptionLookUp)); + return allObjectDescriptions; + } + + def protected void initDescriptionForCircularContainment(ResourceSet resourceSet, EObjectDescriptionLookUp descriptionLookUp, + Map<EClass, Map<QualifiedName, Set<IEObjectDescription>>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + initDescriptionForAllocatableSet(resourceSet, descriptionLookUp, clusterTypeToName, acceptor); + initDescriptionForContentSet(resourceSet, descriptionLookUp, clusterTypeToName, acceptor); + } + + def protected void initDescriptionForAllocatableSet(ResourceSet resourceSet, EObjectDescriptionLookUp descriptionLookUp, + Map<EClass, Map<QualifiedName, Set<IEObjectDescription>>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + val allocatableSetDescriptionsMap = Maps.newHashMap(); + clusterTypeToName.put(RBACorePackage.Literals.ALLOCATABLE_SET, allocatableSetDescriptionsMap); + + ResourceManager.INSTANCE.getRbaAreaSets(resourceSet).forEach [ areaSet | + if (!areaSet.target.isEmpty) { + val IEObjectDescription eObjectDescription = findEObjectDescription(areaSet, descriptionLookUp); + if (eObjectDescription !== null) { + val targets = Sets.newLinkedHashSet(); + var IEObjectDescription targetDescription; + for (target : areaSet.target) { + targetDescription = findEObjectDescription(target, descriptionLookUp); + if (targetDescription !== null) { + targets.add(targetDescription); + } + } + allocatableSetDescriptionsMap.put(eObjectDescription.qualifiedName, targets); + } + } + ]; + ResourceManager.INSTANCE.getRbaZoneSets(resourceSet).forEach [ zoneSet | + if (!zoneSet.target.isEmpty) { + val IEObjectDescription eObjectDescription = findEObjectDescription(zoneSet, descriptionLookUp); + if (eObjectDescription !== null) { + val targets = Sets.newLinkedHashSet(); + var IEObjectDescription targetDescription; + for (target : zoneSet.target) { + targetDescription = findEObjectDescription(target, descriptionLookUp); + if (targetDescription !== null) { + targets.add(targetDescription); + } + } + allocatableSetDescriptionsMap.put(eObjectDescription.qualifiedName, targets); + } + } + ]; + } + + def protected void initDescriptionForContentSet(ResourceSet resourceSet, EObjectDescriptionLookUp descriptionLookUp, + Map<EClass, Map<QualifiedName, Set<IEObjectDescription>>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + val allocatableSetDescriptionsMap = Maps.newHashMap(); + clusterTypeToName.put(RBACorePackage.Literals.CONTENT_SET, allocatableSetDescriptionsMap); + + ResourceManager.INSTANCE.getRbaViewContentSets(resourceSet).forEach [ viewContentSet | + if (!viewContentSet.target.isEmpty) { + val IEObjectDescription eObjectDescription = findEObjectDescription(viewContentSet, descriptionLookUp); + if (eObjectDescription !== null) { + val targets = Sets.newLinkedHashSet(); + var IEObjectDescription targetDescription; + for (target : viewContentSet.target) { + targetDescription = findEObjectDescription(target, descriptionLookUp); + if (targetDescription !== null) { + targets.add(targetDescription); + } + } + allocatableSetDescriptionsMap.put(eObjectDescription.qualifiedName, targets); + } + } + ]; + ResourceManager.INSTANCE.getRbaSoundContentSets(resourceSet).forEach [ soundContentSet | + if (!soundContentSet.target.isEmpty) { + val IEObjectDescription eObjectDescription = findEObjectDescription(soundContentSet, descriptionLookUp); + if (eObjectDescription !== null) { + val targets = Sets.newLinkedHashSet(); + var IEObjectDescription targetDescription; + for (target : soundContentSet.target) { + targetDescription = findEObjectDescription(target, descriptionLookUp); + if (targetDescription !== null) { + targets.add(targetDescription); + } + } + allocatableSetDescriptionsMap.put(eObjectDescription.qualifiedName, targets); + } + } + ]; + } + + def private IEObjectDescription findEObjectDescription(EObject eObject, EObjectDescriptionLookUp descriptionLookUp) { + val candidates = descriptionLookUp.getExportedObjectsByObject(eObject); + if (!candidates.isEmpty) { + return candidates.get(0); + } + return null; + } + + def protected void checkDescriptionForCircularContainment(ResourceSet resourceSet, EObjectDescriptionLookUp descriptionLookUp, IEObjectDescription description, + Map<EClass, Map<QualifiedName, Set<IEObjectDescription>>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + val object = description.getEObjectOrProxy(); + val eClass = object.eClass(); + val qualifiedName = description.getName(); + val clusterType = getAssociatedClusterType(eClass); + if (clusterType === null) { + return; + } + + val nameToDescription = clusterTypeToName.get(clusterType); + if (nameToDescription.containsKey(qualifiedName)) { + val targetsDescription = nameToDescription.get(qualifiedName); + + val filtedTargets = targetsDescription.filter(d|!description.qualifiedName.equals(d.qualifiedName) && nameToDescription.containsKey(d.qualifiedName)); + for (target : filtedTargets) { + val index = filtedTargets.toList.indexOf(target); + val cycleConsistsElement = Sets.newLinkedHashSet(#[target.qualifiedName.toString]); + checkCircularContainment(resourceSet, description, target, nameToDescription, cycleConsistsElement, acceptor, index); + } + } + } + + def protected void checkCircularContainment(ResourceSet resourceSet, IEObjectDescription rootDescription, IEObjectDescription description, + Map<QualifiedName, Set<IEObjectDescription>> nameToDescription, LinkedHashSet<String> cycleConsistsElement, ValidationMessageAcceptor acceptor, int index) { + val targetsDescription = nameToDescription.get(description.qualifiedName); + val filtedTargets = targetsDescription.filter(d|!description.qualifiedName.equals(d.qualifiedName) && nameToDescription.containsKey(d.qualifiedName)); + if (filtedTargets === null) { + return; + } + + for (target : filtedTargets.filter(d|d.qualifiedName.equals(rootDescription.qualifiedName))) { + createCircularContainmentError(resourceSet, rootDescription, index, acceptor, appendCycleConsists(cycleConsistsElement, target.qualifiedName.toString())); + } + + for (target : filtedTargets.filter(d|!d.qualifiedName.equals(rootDescription.qualifiedName))) { + val subCycleConsistsElement = Sets.newLinkedHashSet(cycleConsistsElement); + if (!subCycleConsistsElement.add(target.qualifiedName.toString())) { + return; + } + + checkCircularContainment(resourceSet, rootDescription, target, nameToDescription, subCycleConsistsElement, acceptor, index); + } + } + + def protected void createCircularContainmentError(ResourceSet resourceSet, IEObjectDescription description, int index, ValidationMessageAcceptor acceptor, + LinkedHashSet<String> cycleConsists) { + var object = description.getEObjectOrProxy(); + if (object.eIsProxy) { + object = EcoreUtil2.resolve(object, resourceSet); + if (object.eIsProxy) { + return; + } + } + + val feature = getContainmentFeature(object); + if (feature !== null) { + acceptor.acceptError(getCircularContainmentErrorMessage(description, cycleConsists), object, feature, index, getErrorCode()); + } + } + + def private LinkedHashSet<String> appendCycleConsists(LinkedHashSet<String> cycleConsists, String... args) { + val LinkedHashSet<String> newCycleConsists = Sets.newLinkedHashSet(cycleConsists); + if (args !== null && args.length > 0) { + newCycleConsists.addAll(args); + } + return newCycleConsists; + } + + def String getCircularContainmentErrorMessage(IEObjectDescription description, LinkedHashSet<String> cycleConsists) { + val qualifiedName = description.getQualifiedName().toString(); + val shortName = String.valueOf(if (qualifiedName !== null && qualifiedName !== "") qualifiedName else "<unnamed>"); + return String.format(CIRCULAR_CONTAINMENT_DETECTE, shortName, cycleConsists.toString()); + } + + def protected boolean isContainerInformationHelpful(IEObjectDescription description, EObject container, String containerTypeLabel, EStructuralFeature containerNameFeature) { + return containerTypeLabel !== null && containerNameFeature !== null; + } + + def protected boolean isContainerInformationHelpful(IEObjectDescription description, String shortName) { + return true; + } + + def protected EObject getContainerForErrorMessage(EObject object) { + return object.eContainer(); + } + + def protected String getTypeLabel(EClass eClass) { + return eClass.getName(); + } + + def protected EStructuralFeature getContainmentFeature(EObject object) { + switch (object) { + AllocatableSet: + return RBACorePackage.Literals.ALLOCATABLE_SET__TARGET + ContentSet: + return RBACorePackage.Literals.CONTENT_SET__TARGET + default: + return null + } + } + + def protected EClass getAssociatedClusterType(EClass eClass) { + val superTypes = eClass.getESuperTypes(); + if (superTypes.isEmpty()) { + return null; + } + if (superTypes.contains(RBACorePackage.Literals.ALLOCATABLE_SET)) { + return RBACorePackage.Literals.ALLOCATABLE_SET; + } + if (superTypes.contains(RBACorePackage.Literals.CONTENT_SET)) { + return RBACorePackage.Literals.CONTENT_SET; + } + return null; + } + + def protected String getErrorCode() { + return null; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/ContentAllocatableListValidationHelper.xtend b/rba.tool.editor/src/rba/tool/editor/validation/ContentAllocatableListValidationHelper.xtend new file mode 100644 index 0000000..d9f1911 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/ContentAllocatableListValidationHelper.xtend @@ -0,0 +1,105 @@ +package rba.tool.editor.validation + +import com.google.inject.Inject +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl +import org.eclipse.xtext.resource.IResourceServiceProvider +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider +import org.eclipse.xtext.service.OperationCanceledManager +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.validation.ValidationMessageAcceptor +import rba.core.AbstractContent +import rba.core.RBACorePackage +import rba.sound.SoundContent +import rba.tool.editor.messages.Messages +import rba.tool.editor.resource.IRBAModelResourceLoader +import rba.view.ViewContent + +class ContentAllocatableListValidationHelper { + + @Inject + private IResourceServiceProvider.Registry resourceServiceProviderRegistry = IResourceServiceProvider.Registry.INSTANCE; + + @Inject + private ResourceDescriptionsProvider resourceDescriptionsProvider; + + @Inject + private IRBAModelResourceLoader resourceLoader; + + @Inject + private ResourceSetImpl resourceSet; + + @Inject + private OperationCanceledManager operationCanceledManager = new OperationCanceledManager(); + + private String CONTENT_ALLOCATABLE_SIZE = Messages.CONTENT_ALLOCATABLE_SIZE; + + private String SOUND_ALLOCATABLE_SIZE = Messages.SOUND_ALLOCATABLE_SIZE; + + def public void checkCrossReferenceEmpty(Resource resource, CancelIndicator cancelIndicator, ValidationMessageAcceptor acceptor) { + val resourceServiceProvider = resourceServiceProviderRegistry.getResourceServiceProvider(resource.getURI()); + if (resourceServiceProvider === null) { + return; + } + + demandGetResources(resource.getURI()); + if (resourceSet === null) { + return; + } + + val loadedResource = resourceSet.getResource(resource.getURI(), false); + if (loadedResource !== null) { + checkForAbstractContent_getAllocatableList(loadedResource, cancelIndicator, acceptor); + } + } + + def private void demandGetResources(URI uri) { + if (!resourceSet.resources.isEmpty()) { + resourceSet.resources.clear(); + } + + val projectName = if (uri.segmentCount > 2) URI.decode(uri.segment(1)) else ""; + val resourceDescriptions = resourceDescriptionsProvider.createResourceDescriptions(); + val URIs = resourceDescriptions.allResourceDescriptions.map(d|d.URI).filter(u|projectName.equals(if (u.segmentCount > 2) URI.decode(u.segment(1)) else null)); + resourceLoader.loadAndResolveResource(resourceSet, URIs, null); + } + + def protected void checkForAbstractContent_getAllocatableList(Resource resource, CancelIndicator cancelIndicator, ValidationMessageAcceptor acceptor) { + resource.allContents.toIterable.filter(ViewContent).forEach [ viewContent | + if (viewContent.allocatableList.isEmpty) { + val feature = getContainmentFeature(viewContent); + if (feature !== null) { + acceptor.acceptError(String.format(CONTENT_ALLOCATABLE_SIZE, viewContent.name), viewContent, feature, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + getErrorCode()); + } + } + operationCanceledManager.checkCanceled(cancelIndicator); + ]; + resource.allContents.toIterable.filter(SoundContent).forEach [ soundContent | + if (soundContent.allocatableList.isEmpty) { + val feature = getContainmentFeature(soundContent); + if (feature !== null) { + acceptor.acceptError(String.format(SOUND_ALLOCATABLE_SIZE, soundContent.name), soundContent, feature, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + getErrorCode()); + } + } + operationCanceledManager.checkCanceled(cancelIndicator); + ]; + } + + def protected EStructuralFeature getContainmentFeature(EObject object) { + switch (object) { + AbstractContent: + return RBACorePackage.Literals.ABSTRACT_CONTENT__ALLOCATABLE + default: + return null + } + } + + def protected String getErrorCode() { + return null; + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/RBADiagnostician.java b/rba.tool.editor/src/rba/tool/editor/validation/RBADiagnostician.java new file mode 100644 index 0000000..de1685e --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/RBADiagnostician.java @@ -0,0 +1,22 @@ +package rba.tool.editor.validation; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.Diagnostician; + +import rba.core.NamedElement; +import rba.core.RBACorePackage; + +public class RBADiagnostician extends Diagnostician { + + @Override + public String getObjectLabel(EObject eObject) { + + EClass eClass = eObject.eClass(); + if (RBACorePackage.Literals.NAMED_ELEMENT.isSuperTypeOf(eClass)) { + return ((NamedElement)eObject).getName(); + } else { + return eClass.getName(); + } + } +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidator.xtend new file mode 100644 index 0000000..d9c71d8 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidator.xtend @@ -0,0 +1,39 @@ +package rba.tool.editor.validation + +import java.util.Map +import org.eclipse.emf.common.util.DiagnosticChain +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.emf.ecore.util.EObjectValidator +import org.eclipse.xtext.validation.CompositeEValidator + +class RBAModelCompositeEValidator extends CompositeEValidator { + + override protected initDefaults() { + if (isUseEObjectValidator()) { + this.addValidator(new EObjectValidator() { + override validate_EveryProxyResolves(EObject eObject, DiagnosticChain diagnostics, Map<Object, Object> context) { + // don't check, we have our own implementation, which creates nicer messages + return true; + } + + override validate_NoCircularContainment(EObject eObject, DiagnosticChain diagnostics, Map<Object, Object> context) { + // don't check + return true; + } + + override validate_EveryBidirectionalReferenceIsPaired(EObject eObject, DiagnosticChain diagnostics, Map<Object, Object> context) { + // don't check + return true; + } + + override validate_BidirectionalReferenceIsPaired(EObject eObject, EReference eReference, EReference eOpposite, DiagnosticChain diagnostics, + Map<Object, Object> context) { + // don't check + return true; + } + }); + } + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidatorProvider.xtend b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidatorProvider.xtend new file mode 100644 index 0000000..c6cfd32 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelCompositeEValidatorProvider.xtend @@ -0,0 +1,25 @@ +package rba.tool.editor.validation + +import com.google.inject.Inject +import com.google.inject.Provider +import org.eclipse.xtext.service.OperationCanceledManager +import org.eclipse.xtext.validation.CompositeEValidator +import org.eclipse.xtext.validation.CompositeEValidator.EValidatorEqualitySupport +import org.eclipse.xtext.xbase.lib.util.ReflectExtensions + +class RBAModelCompositeEValidatorProvider implements Provider<CompositeEValidator> { + + @Inject extension ReflectExtensions; + + @Inject private Provider<EValidatorEqualitySupport> equalitySupportProvider; + + @Inject private OperationCanceledManager operationCanceledManager; + + override get() { + val CompositeEValidator compositeValidator = new RBAModelCompositeEValidator() + compositeValidator.equalitySupportProvider = equalitySupportProvider; + compositeValidator.set("operationCanceledManager", operationCanceledManager) + return compositeValidator; + } + +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/RBAModelValidator.xtend b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelValidator.xtend new file mode 100644 index 0000000..ea1f815 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/RBAModelValidator.xtend @@ -0,0 +1,194 @@ +/* + * generated by Xtext 2.12.0 + */ +package rba.tool.editor.validation + +import org.eclipse.xtext.validation.ComposedChecks +import rba.tool.editor.validation.validators.AllocatedContentValidator +import rba.tool.editor.validation.validators.AndOperatorValidator +import rba.tool.editor.validation.validators.AreaSetValidator +import rba.tool.editor.validation.validators.AreaValidator +import rba.tool.editor.validation.validators.ComparisonAndOperatorValidator +import rba.tool.editor.validation.validators.CompositeAreaValidator +import rba.tool.editor.validation.validators.ConstraintValidator +import rba.tool.editor.validation.validators.ContentStateValidator +import rba.tool.editor.validation.validators.ContentValueValidator +import rba.tool.editor.validation.validators.DisplayValidator +import rba.tool.editor.validation.validators.DisplayingContentValidator +import rba.tool.editor.validation.validators.EqualToOperatorValidatior +import rba.tool.editor.validation.validators.ExistsOperatorValidator +import rba.tool.editor.validation.validators.FixedPositionLayoutValidator +import rba.tool.editor.validation.validators.ForAllOperatorValidator +import rba.tool.editor.validation.validators.GetAllocatablesValidator +import rba.tool.editor.validation.validators.GetContentsListValidator +import rba.tool.editor.validation.validators.GetPropertyValidator +import rba.tool.editor.validation.validators.GreaterThanOperatorValidator +import rba.tool.editor.validation.validators.HasComeEarlierThanValidator +import rba.tool.editor.validation.validators.HasComeLaterThanValidator +import rba.tool.editor.validation.validators.HorizontalLayoutValidator +import rba.tool.editor.validation.validators.IfStatementValidator +import rba.tool.editor.validation.validators.ImpliesOperatorValidator +import rba.tool.editor.validation.validators.IntegerPropertyValidator +import rba.tool.editor.validation.validators.IsActiveValidator +import rba.tool.editor.validation.validators.IsAttenuatedValidator +import rba.tool.editor.validation.validators.IsCanceledValidator +import rba.tool.editor.validation.validators.IsDisappearedValidator +import rba.tool.editor.validation.validators.IsEqualToOperatorValidator +import rba.tool.editor.validation.validators.IsGreaterThanEqualOperatorValidator +import rba.tool.editor.validation.validators.IsGreaterThanOperatorValidator +import rba.tool.editor.validation.validators.IsHiddenValidator +import rba.tool.editor.validation.validators.IsLowerThanEqualOperatorValidator +import rba.tool.editor.validation.validators.IsLowerThanOperatorValidator +import rba.tool.editor.validation.validators.IsMutedValidator +import rba.tool.editor.validation.validators.IsOnValidator +import rba.tool.editor.validation.validators.IsOutputtedValidator +import rba.tool.editor.validation.validators.IsSoundingValidator +import rba.tool.editor.validation.validators.IsVisibleValidator +import rba.tool.editor.validation.validators.LambdaExpressionValidator +import rba.tool.editor.validation.validators.LowerThanOperatorValidator +import rba.tool.editor.validation.validators.MuchGreaterThanOperatorValidator +import rba.tool.editor.validation.validators.NamedElementValidator +import rba.tool.editor.validation.validators.NotOperatorValidator +import rba.tool.editor.validation.validators.ObjectCompareValidator +import rba.tool.editor.validation.validators.OffSceneValidator +import rba.tool.editor.validation.validators.OffsetValidator +import rba.tool.editor.validation.validators.OnSceneValidator +import rba.tool.editor.validation.validators.OrOperatorValidator +import rba.tool.editor.validation.validators.OutputtingSoundValidator +import rba.tool.editor.validation.validators.PackageValidator +import rba.tool.editor.validation.validators.PlusOperatorValidator +import rba.tool.editor.validation.validators.PositionContainerValidator +import rba.tool.editor.validation.validators.SceneValidator +import rba.tool.editor.validation.validators.SetOfOperatorValidator +import rba.tool.editor.validation.validators.SetPropertyValidator +import rba.tool.editor.validation.validators.SoundContentSetValidator +import rba.tool.editor.validation.validators.SoundContentValidator +import rba.tool.editor.validation.validators.StateValueValidator +import rba.tool.editor.validation.validators.ThatOfOperatorValidator +import rba.tool.editor.validation.validators.VerticalLayoutValidator +import rba.tool.editor.validation.validators.ViewContentSetValidator +import rba.tool.editor.validation.validators.ViewContentValidator +import rba.tool.editor.validation.validators.ZoneSetValidator +import rba.tool.editor.validation.validators.ObjectCompareNotValidator +import rba.tool.editor.validation.validators.IsAllocatedToValidator +import rba.tool.editor.validation.validators.IsChangedValidator +import rba.tool.editor.validation.validators.IsTranslatedToValidator +import rba.tool.editor.validation.validators.IsDisplayedOnValidator +import rba.tool.editor.validation.validators.IsChangedDisplayValidator +import rba.tool.editor.validation.validators.IsTranslatedViewToValidator +import rba.tool.editor.validation.validators.IsOutputtedOnValidator +import rba.tool.editor.validation.validators.IsChangedOutputValidator +import rba.tool.editor.validation.validators.IsTranslatedSoundToValidator +import rba.tool.editor.validation.validators.HideLowerPriorityValidator +import rba.tool.editor.validation.validators.MuteLowerPriorityValidator +import rba.tool.editor.validation.validators.MinOperatorValidator +import rba.tool.editor.validation.validators.MaxOperatorValidator +import rba.tool.editor.validation.validators.SelectOperatorValidator +import rba.tool.editor.validation.validators.IsTypeOfValidator +import rba.tool.editor.validation.validators.SizeOperatorValidator +import rba.tool.editor.validation.validators.ActiveStateValidator +import rba.tool.editor.validation.validators.ZoneValidator +import rba.tool.editor.validation.validators.ProjectValidator +import rba.tool.editor.validation.validators.ContentValidator +import rba.tool.editor.validation.validators.ActiveContentsValidator +import rba.tool.editor.validation.validators.LetStatementValidator +import rba.tool.editor.validation.validators.SizeValidator + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +@ComposedChecks(validators=#[ + NamedElementValidator, + IfStatementValidator, + PackageValidator, + DisplayValidator, + CompositeAreaValidator, + FixedPositionLayoutValidator, + PositionContainerValidator, + AreaValidator, + VerticalLayoutValidator, + HorizontalLayoutValidator, + ViewContentValidator, + ContentStateValidator, + ComparisonAndOperatorValidator, + ConstraintValidator, + ThatOfOperatorValidator, + EqualToOperatorValidatior, + GreaterThanOperatorValidator, + MuchGreaterThanOperatorValidator, + LowerThanOperatorValidator, + PlusOperatorValidator, + AndOperatorValidator, + OrOperatorValidator, + ImpliesOperatorValidator, + NotOperatorValidator, + ObjectCompareValidator, + DisplayingContentValidator, + GetContentsListValidator, + IsActiveValidator, + IsVisibleValidator, + GetAllocatablesValidator, + LambdaExpressionValidator, + ForAllOperatorValidator, + ExistsOperatorValidator, + IsEqualToOperatorValidator, + IsGreaterThanOperatorValidator, + IsGreaterThanEqualOperatorValidator, + IsLowerThanOperatorValidator, + IsLowerThanEqualOperatorValidator, + IsHiddenValidator, + ContentValueValidator, + SetOfOperatorValidator, + IsOnValidator, + IsDisappearedValidator, + IsCanceledValidator, + OffsetValidator, + AreaSetValidator, + ViewContentSetValidator, + SoundContentSetValidator, + AllocatedContentValidator, + OnSceneValidator, + OffSceneValidator, + SetPropertyValidator, + GetPropertyValidator, + SceneValidator, + IntegerPropertyValidator, + SoundContentValidator, + ContentValidator, + ZoneSetValidator, + IsSoundingValidator, + IsOutputtedValidator, + IsMutedValidator, + IsAttenuatedValidator, + OutputtingSoundValidator, + HasComeEarlierThanValidator, + HasComeLaterThanValidator, + StateValueValidator, + ObjectCompareNotValidator, + IsAllocatedToValidator, + IsChangedValidator, + IsTranslatedToValidator, + IsDisplayedOnValidator, + IsChangedDisplayValidator, + IsTranslatedViewToValidator, + IsOutputtedOnValidator, + IsChangedOutputValidator, + IsTranslatedSoundToValidator, + HideLowerPriorityValidator, + MuteLowerPriorityValidator, + ActiveContentsValidator, + MinOperatorValidator, + MaxOperatorValidator, + SelectOperatorValidator, + IsTypeOfValidator, + SizeOperatorValidator, + ActiveStateValidator, + ZoneValidator, + ProjectValidator, + LetStatementValidator, + SizeValidator +]) +class RBAModelValidator extends AbstractRBAModelValidator { +} diff --git a/rba.tool.editor/src/rba/tool/editor/validation/UniqueNameValidationHelper.xtend b/rba.tool.editor/src/rba/tool/editor/validation/UniqueNameValidationHelper.xtend new file mode 100644 index 0000000..dc5ef18 --- /dev/null +++ b/rba.tool.editor/src/rba/tool/editor/validation/UniqueNameValidationHelper.xtend @@ -0,0 +1,211 @@ +package rba.tool.editor.validation + +import com.google.common.collect.Maps +import com.google.inject.Inject +import java.util.Map +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.resource.IEObjectDescription +import org.eclipse.xtext.resource.IResourceDescriptionsProvider +import org.eclipse.xtext.resource.IResourceServiceProvider +import org.eclipse.xtext.service.OperationCanceledManager +import org.eclipse.xtext.util.CancelIndicator +import org.eclipse.xtext.util.SimpleAttributeResolver +import org.eclipse.xtext.validation.ValidationMessageAcceptor +import rba.core.RBACorePackage +import rba.tool.editor.messages.Messages +import rba.tool.editor.rbaEditorModel.RbaEditorModelPackage +import java.util.List +import java.util.Arrays +import rba.core.impl.ProjectImpl + +class UniqueNameValidationHelper { + + @Inject + private IResourceServiceProvider.Registry resourceServiceProviderRegistry = IResourceServiceProvider.Registry.INSTANCE; + + @Inject + private IResourceDescriptionsProvider resourceDescriptionsProvider; + + @Inject + private OperationCanceledManager operationCanceledManager = new OperationCanceledManager(); + + private static final List<String> RESTRICTED_NAMES = Arrays.asList( + "AnyAreasOfContent", + "AnyContentsOfArea", + "NullExpression" + ); + + private String NAMEDELEMENT_NAME_DUPLICATE = Messages.NAMEDELEMENT_NAME_DUPLICATE; + + def public void checkUniqueNames(Resource resource, CancelIndicator cancelIndicator, ValidationMessageAcceptor acceptor) { + val resourceServiceProvider = resourceServiceProviderRegistry.getResourceServiceProvider(resource.getURI()); + if(resourceServiceProvider === null) { + return; + } + + val manager = resourceServiceProvider.getResourceDescriptionManager(); + if(manager !== null) { + val description = manager.getResourceDescription(resource); + if(description !== null) { + val descriptions = description.getExportedObjects(); + val currentIter = descriptions.iterator(); + if(!currentIter.hasNext()) { + return; + } + val clusterToNames = Maps.newHashMap(); + + val containerManager = resourceServiceProvider.getContainerManager(); + val resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resource.getResourceSet()); + for (container : containerManager.getVisibleContainers(description, resourceDescriptions)) { + val siblingsResourceDescriptions = container.resourceDescriptions.filter(r|r.URI.toString !== description.URI.toString); + val siblingsObjectDescriptions = siblingsResourceDescriptions.map(srd|srd.exportedObjects.filter[obj| + obj.EClass !== RBACorePackage.Literals.TAG && obj.EClass !== RbaEditorModelPackage.Literals.CTAG + ]).flatten; + for (siblingsObjectDescription : siblingsObjectDescriptions) { + initDescriptionForDuplicatedName(siblingsObjectDescription, clusterToNames, acceptor); + } + } + + while(currentIter.hasNext()) { + val objectDescription = currentIter.next(); + checkDescriptionForDuplicatedName(objectDescription, clusterToNames, acceptor); + operationCanceledManager.checkCanceled(cancelIndicator); + } + } + } + } + + def protected void initDescriptionForDuplicatedName(IEObjectDescription description, Map<EClass, Map<QualifiedName, IEObjectDescription>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + val object = description.getEObjectOrProxy(); + val eClass = object.eClass(); + val qualifiedName = description.getName(); + val clusterType = getAssociatedClusterType(eClass); + if(clusterType === null) { + return; + } + + val nameToDescription = clusterTypeToName.get(clusterType); + if(nameToDescription === null) { + val newNameToDescription = Maps.newHashMap(); + newNameToDescription.put(qualifiedName, description); + clusterTypeToName.put(clusterType, newNameToDescription); + } else if(!nameToDescription.containsKey(qualifiedName)) { + nameToDescription.put(qualifiedName, description); + } + } + + def protected void checkDescriptionForDuplicatedName(IEObjectDescription description, Map<EClass, Map<QualifiedName, IEObjectDescription>> clusterTypeToName, ValidationMessageAcceptor acceptor) { + val object = description.getEObjectOrProxy(); + val eClass = object.eClass(); + if(eClass === RBACorePackage.Literals.VARIABLE) { + return; + } + + if(eClass === RBACorePackage.Literals.TAG || eClass === RbaEditorModelPackage.Literals.CTAG) { + return; + } + + val qualifiedName = description.getName(); + val clusterType = getAssociatedClusterType(eClass); + if(clusterType === null) { + return; + } + + val nameToDescription = clusterTypeToName.get(clusterType); + if(nameToDescription === null) { + val newNameToDescription = Maps.newHashMap(); + newNameToDescription.put(qualifiedName, description); + clusterTypeToName.put(clusterType, newNameToDescription); + } else { + if(nameToDescription.containsKey(qualifiedName)) { + val prevDescription = nameToDescription.get(qualifiedName); + + if(prevDescription !== null && !(prevDescription.getEObjectOrProxy() instanceof ProjectImpl)) { + createDuplicateNameError(prevDescription, clusterType, acceptor); + nameToDescription.put(qualifiedName, null); + } + createDuplicateNameError(description, clusterType, acceptor); + } else if(isNamingRestricted(qualifiedName)){ + createNamingRestrictionError(description, clusterType, acceptor, qualifiedName) + } else { + nameToDescription.put(qualifiedName, description); + } + } + } + + def protected void createDuplicateNameError(IEObjectDescription description, EClass clusterType, ValidationMessageAcceptor acceptor) { + val object = description.getEObjectOrProxy(); + if(object.eIsProxy) { + return; + } + + val feature = getNameFeature(object); + acceptor.acceptError(getDuplicateNameErrorMessage(description), object, feature, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, getErrorCode()); + } + + def String getDuplicateNameErrorMessage(IEObjectDescription description) { + val qualifiedName = description.getQualifiedName().toString(); + val shortName = String.valueOf(if(qualifiedName !== null && qualifiedName !== "") qualifiedName else "<unnamed>"); + return String.format(NAMEDELEMENT_NAME_DUPLICATE, shortName); + } + + def protected boolean isContainerInformationHelpful(IEObjectDescription description, EObject container, String containerTypeLabel, EStructuralFeature containerNameFeature) { + return containerTypeLabel !== null && containerNameFeature !== null; + } + + def protected boolean isContainerInformationHelpful(IEObjectDescription description, String shortName) { + return true; + } + + def protected EObject getContainerForErrorMessage(EObject object) { + return object.eContainer(); + } + + def protected String getTypeLabel(EClass eClass) { + return eClass.getName(); + } + + def protected EStructuralFeature getNameFeature(EObject object) { + return SimpleAttributeResolver.NAME_RESOLVER.getAttribute(object); + } + + def protected EClass getAssociatedClusterType(EClass eClass) { + val superTypes = eClass.getESuperTypes(); + if(superTypes.isEmpty()) { + return null; + } + if(superTypes.contains(RBACorePackage.Literals.NAMED_ELEMENT)) { + return RBACorePackage.Literals.NAMED_ELEMENT; + } + return getAssociatedClusterType(superTypes.get(0)); + } + + def protected String getErrorCode() { + return null; + } + + def protected boolean isNamingRestricted(QualifiedName qualifiedName){ + if ( qualifiedName.getSegments().size() > 0 ) { + val i = qualifiedName.getSegments().size() - 1; + if( RESTRICTED_NAMES.contains(qualifiedName.getSegments().get(i).toString) ) { + return true; + } + } + return false; + } + + def protected void createNamingRestrictionError(IEObjectDescription description, EClass clusterType, + ValidationMessageAcceptor acceptor, QualifiedName qualifiedName) { + val object = description.getEObjectOrProxy(); + if (object.eIsProxy) { + return; + } + val feature = getNameFeature(object); + val errorMessage = String.format(Messages.NAME_RESTRICTION, object.eClass.name, qualifiedName.toString) + acceptor.acceptError(errorMessage, object, feature, ValidationMessageAcceptor.INSIGNIFICANT_INDEX,getErrorCode()); + } +} 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<AbstractAllocatable> + 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<String> 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<Area> 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<Area> 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<Expression> 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<Area> 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<RuleObject> + 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<AbstractContent> + 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<AbstractAllocatable> + 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<String> errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkSOUND(SoundContent soundContent) { + var hash = new HashSet<AbstractAllocatable> + 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<Expression> operands, String operatorName,
+ Consumer<String> 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<Expression> operands, String operatorName,
+ Consumer<String> 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<String> 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<AbstractContent> + 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<AbstractAllocatable> + 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<String> errorToName = [msg|error(msg, RBACorePackage.Literals.NAMED_ELEMENT__NAME, 0)]; + + @Check(NORMAL) + def checkContent(ViewContent viewContent) { + var hash = new HashSet<AbstractAllocatable> + 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<AbstractAllocatable> + 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<String> 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; + } + +} |