| @GenModel(fileExtensions="type", modelDirectory="/org.eclipse.osbp.dsl.common.xtext/emf-gen", editDirectory="/org.eclipse.osbp.dsl.common.xtext.edit/src", extensibleProviderFactory="true") |
| @GenModel(modelName="Types") |
| @GenModel(prefix="OSBPTypes") |
| @GenModel(suppressEMFModelTags="true") |
| @GenModel(loadInitialization="false") |
| @GenModel(literalsInterface="true") |
| @GenModel(copyrightText="Copyright (c) 2011, 2016 - Lunifera GmbH (Wien), Loetz GmbH&Co.KG (Heidelberg) |
| All rights reserved. This program and the accompanying materials |
| are made available under the terms of the Eclipse Public License 2.0 |
| which accompanies this distribution, and is available at |
| https://www.eclipse.org/legal/epl-2.0/ |
| |
| SPDX-License-Identifier: EPL-2.0 |
| |
| Based on ideas from Xtext, Xtend, Xcore |
| |
| Contributors: |
| Florian Pirchner - Initial implementation |
| ") |
| @Ecore(nsURI="http://osbp.eclipse.org/dsl/common/types/v1") |
| @Ecore(nsPrefix="types") |
| @Ecore(rootPackage="types") |
| package org.eclipse.osbp.dsl.semantic.common.types |
| |
| import org.eclipse.emf.common.util.EList |
| import org.eclipse.emf.ecore.EObject |
| import org.eclipse.emf.ecore.InternalEObject |
| import org.eclipse.osbp.dsl.semantic.common.helper.Bounds |
| import org.eclipse.osbp.xtext.oxtype.resource.EcoreUtil3 |
| import org.eclipse.xtext.common.types.JvmFormalParameter |
| import org.eclipse.xtext.common.types.JvmTypeReference |
| import org.eclipse.xtext.xbase.XExpression |
| import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation |
| import org.eclipse.xtext.xtype.XImportSection |
| |
| class LCommonModel extends LLazyResolver { |
| contains XImportSection importSection |
| contains LTypedPackage[] packages |
| } |
| |
| class LLazyResolver { |
| op EObject eResolveProxy(InternalEObject proxy) { |
| return EcoreUtil3.resolve(proxy, this.eResource()?.resourceSet); |
| } |
| } |
| |
| class LPackage extends LLazyResolver { |
| String name |
| } |
| |
| class LTypedPackage extends LPackage { |
| contains LType[] types |
| op String getResourceSimpleName() { |
| val resource = eResource |
| if (resource === null) { |
| return "" |
| } |
| |
| return resource.URI.lastSegment + " - " + name |
| } |
| } |
| |
| class LImport { |
| String importedNamespace |
| } |
| |
| class LType extends LAnnotationTarget { |
| String name |
| contains LAnnotationTarget annotationInfo |
| /** |
| * Delegates the annotation request to the target element. |
| */ |
| op AnnotationList getResolvedAnnotations() { |
| if (annotationInfo !== null) { |
| annotationInfo.annotations |
| } else { |
| annotations |
| } |
| } |
| } |
| |
| class LAnnotationDef extends LLazyResolver { |
| boolean exclude |
| contains XAnnotation ^annotation |
| } |
| |
| class LAnnotationTarget extends LLazyResolver { |
| contains LAnnotationDef[] annotations |
| } |
| |
| class LScalarType extends LType { |
| } |
| |
| class LDataType extends LScalarType { |
| contains JvmTypeReference jvmTypeReference |
| boolean asPrimitive |
| boolean date |
| boolean asBlob |
| int length |
| LDateType dateType |
| /** |
| * Attention: synthetic must only be used inside the same resource |
| */ |
| // is used to prepare datatypes during linking |
| boolean syntheticFlag |
| // defines what target type should be prepared by the synthetic datatype. May be any string. |
| String syntheticSelector |
| // is used to target a feature in the current entity |
| refers LFeature syntheticTypeReference |
| // used to target a feature in the current entity, but avoids resolving cross refernces too early. |
| // for instance if the feature is contained in a superclass |
| refers LType syntheticType |
| // key value pairs |
| contains LKeyAndValue[*] properties |
| // constraints for the datatype |
| contains LDatatypeConstraint[*] constraints |
| } |
| |
| enum LDateType { |
| DATE |
| , TIME |
| , TIMESTAMP |
| } |
| |
| class LEnum extends LScalarType { |
| contains LEnumLiteral[] literals |
| } |
| |
| class LEnumLiteral extends LLazyResolver { |
| String name |
| boolean ^default |
| boolean ^null |
| int value |
| String stringValue |
| } |
| |
| class LStateClass extends LScalarType { |
| contains LState [] states |
| } |
| |
| class LState extends LType { |
| } |
| |
| class LClass extends LType { |
| boolean ^abstract |
| boolean serializable |
| String shortName |
| op boolean isNormalAttribute(LFeature f) { |
| if(!(f instanceof LAttribute)) { |
| return false |
| } |
| var attr = f as LAttribute |
| if(attr.id || attr.uuid || attr.version || attr.attributeHidden) { |
| return false |
| } |
| var isNotFilter = f.annotationInfo.annotations.filter[ |
| org.eclipse.osbp.runtime.common.annotations.CreateAt.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.CreateBy.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.UpdateAt.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.UpdateBy.name.equals(it.annotation.annotationType.qualifiedName) |
| ].empty |
| var isNotHist = f.annotationInfo.annotations.filter[ |
| org.eclipse.osbp.runtime.common.annotations.HistValidUntil.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.HistIsCurrent.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.HistIsCustomVersion.name.equals(it.annotation.annotationType.qualifiedName) || |
| org.eclipse.osbp.runtime.common.annotations.HistDomainKey.name.equals(it.annotation.annotationType.qualifiedName) |
| ].empty |
| return isNotFilter && isNotHist |
| } |
| op boolean isHistCurrentAttribute(LFeature f) { |
| if(!(f instanceof LAttribute)) { |
| return false |
| } |
| var attr = f as LAttribute |
| return !(f.annotationInfo.annotations.filter[ |
| org.eclipse.osbp.runtime.common.annotations.HistIsCurrent.name.equals(it.annotation.annotationType.qualifiedName) |
| ].empty) |
| } |
| |
| } |
| |
| interface LFeaturesHolder { |
| /** |
| * Returns the features of the holder |
| */ |
| op FeaturesList getFeatures() |
| /** |
| * Returns all features of the holder and from super types |
| */ |
| op FeaturesList getAllFeatures() |
| } |
| |
| interface LFeature extends LAnnotationTarget { |
| String name |
| contains LMultiplicity multiplicity |
| contains LAnnotationTarget annotationInfo |
| /** |
| * Delegates the annotation request to the target element. |
| */ |
| op AnnotationList getResolvedAnnotations() { |
| if (annotationInfo !== null) { |
| annotationInfo.annotations |
| } else { |
| annotations |
| } |
| } |
| } |
| |
| interface LReference extends LFeature { |
| boolean lazy |
| boolean cascadeMergePersist |
| boolean cascadeRemove |
| boolean cascadeRefresh |
| contains LKeyAndValue[*] properties |
| // constraints for the datatype |
| contains LDatatypeConstraint[*] constraints |
| // could be grouped for ui |
| boolean isGrouped |
| String groupName |
| // ui should use a grid |
| boolean asGrid |
| // ui should use a table |
| boolean asTable |
| // ui should enable sidekick to create owner data |
| boolean sideKick |
| /** |
| * refs are never rendered by a presentation logic |
| */ |
| boolean referenceHidden |
| /** |
| * refs are always readonly for a presentation logic |
| */ |
| boolean referenceReadOnly |
| } |
| |
| interface LAttribute extends LFeature { |
| boolean ^id |
| boolean uuid |
| boolean version |
| boolean lazy |
| boolean ^transient |
| boolean ^derived |
| boolean dirty |
| /** |
| * The domainKey is a human readable value for a dto or entity |
| */ |
| boolean domainKey |
| /** |
| * The domainKey is the human readable description for a dto or entity |
| */ |
| boolean domainDescription |
| /** |
| * This keyword allows for generic filter dialogs in the UI based on eq, gt, lt,.. |
| */ |
| boolean filtering |
| /** |
| * This keyword allows for generic filter dialogs in the UI based on eq, gt, lt,.. |
| */ |
| boolean rangeFiltering |
| /** |
| * Attributes marked with uniqueEntry must be checked against the database, |
| * whether they already exist in the database with a different id |
| */ |
| boolean uniqueEntry |
| |
| /** |
| * Attributes are never rendered by a presentation logic |
| */ |
| boolean attributeHidden |
| /** |
| * Attributes are always readonly for a presentation logic |
| */ |
| boolean attributeReadOnly |
| /* |
| * Attributes always get this extra styling |
| */ |
| String extraStyle |
| |
| contains XExpression derivedGetterExpression |
| refers LScalarType ^type |
| contains LKeyAndValue[*] properties |
| // constraints for the datatype |
| contains LDatatypeConstraint[*] constraints |
| // could be grouped for ui |
| boolean isGrouped |
| String groupName |
| } |
| |
| class LKeyAndValue { |
| String key |
| String value |
| } |
| |
| class LOperation extends LAnnotationTarget { |
| contains LModifier modifier |
| contains JvmTypeReference ^type |
| contains JvmFormalParameter[] params |
| contains XExpression body |
| /** |
| * Method to generalize naming conventions for annotation access |
| */ |
| op AnnotationList getResolvedAnnotations() { |
| annotations |
| } |
| } |
| |
| class LModifier extends LLazyResolver { |
| boolean final |
| boolean ^static |
| LVisibility visibility |
| } |
| |
| enum LVisibility { |
| PACKAGE = 0 |
| PRIVATE = 1 |
| PROTECTED = 2 |
| PUBLIC = 3 |
| } |
| |
| class LMultiplicity { |
| LLowerBound lower |
| LUpperBound upper |
| derived String toMultiplicityString get { |
| return Bounds.createFor(this).toBoundsString |
| } |
| } |
| |
| enum LLowerBound { |
| NULL = 0 |
| MANY = 1 |
| OPTIONAL = 2 |
| ATLEASTONE = 3 |
| ZERO = 4 |
| ONE = 5 |
| } |
| |
| enum LUpperBound { |
| NULL = 0 |
| MANY = 1 |
| ONE = 2 |
| } |
| |
| interface LConstraint extends LLazyResolver{ |
| } |
| |
| /** |
| * ResultFilters are used to filter the possible results for a reference. |
| * May be used by UI to filter unwanted entries. |
| */ |
| class LResultFilters extends LLazyResolver { |
| contains LResultFilter[*] resultFilters |
| } |
| |
| interface LResultFilter extends LConstraint { |
| } |
| |
| class LAttributeMatchingConstraint extends LResultFilter { |
| refers LAttribute attribute |
| LComparatorType comparatorType |
| String matchingValue |
| refers LEnumLiteral matchingLiteral |
| } |
| |
| enum LComparatorType { |
| EQUALS as '==' |
| GREATER as '>' |
| LOWER as '<' |
| GREATER_EQ as '>=' |
| LOWER_EQ as '<=' |
| NOT_EQ as '<>' |
| } |
| |
| /** |
| * DatatypeConstraints are used to create javax.validation constraint annotations. |
| */ |
| interface LDatatypeConstraint extends LConstraint { |
| String msgCode |
| String msgI18nKey |
| LConstraintSeverity severity |
| /** |
| * Returns true, if the constraint can be used for primitive datatypes. |
| */ |
| op boolean isForPrimitives() |
| } |
| |
| enum LConstraintSeverity { |
| INFO |
| , WARNING |
| , ERROR |
| } |
| |
| interface LStringConstraint extends LDatatypeConstraint { |
| } |
| |
| interface LNumericConstraint extends LDatatypeConstraint { |
| } |
| |
| interface LDecimalConstraint extends LDatatypeConstraint { |
| } |
| |
| interface LDateConstraint extends LDatatypeConstraint { |
| } |
| |
| interface LBooleanConstraint extends LDatatypeConstraint { |
| } |
| |
| interface LBlobConstraint extends LDatatypeConstraint { |
| } |
| |
| class LDtCAssertFalse extends LBooleanConstraint { |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCAssertTrue extends LBooleanConstraint { |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCDecimalMax extends LDecimalConstraint { |
| float max |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCDecimalMin extends LDecimalConstraint { |
| float min |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCDigits extends LDecimalConstraint { |
| int intDigits |
| int fractionDigits |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCFuture extends LDateConstraint { |
| op boolean isForPrimitives() { |
| return false |
| } |
| } |
| |
| class LDtCPast extends LDateConstraint { |
| op boolean isForPrimitives() { |
| return false |
| } |
| } |
| |
| class LDtCNumericMax extends LNumericConstraint { |
| int max |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCNumericMin extends LNumericConstraint { |
| int min |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCNotNull extends LBlobConstraint, LDateConstraint, LStringConstraint, |
| LBooleanConstraint, LDecimalConstraint, LNumericConstraint { |
| op boolean isForPrimitives() { |
| return false |
| } |
| } |
| |
| class LDtCNull extends LBlobConstraint, LDateConstraint, LStringConstraint, |
| LBooleanConstraint, LDecimalConstraint, LNumericConstraint { |
| op boolean isForPrimitives() { |
| return false |
| } |
| } |
| |
| class LDtCRegEx extends LStringConstraint { |
| String pattern |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| class LDtCSize extends LStringConstraint { |
| int min |
| int max |
| op boolean isForPrimitives() { |
| return true |
| } |
| } |
| |
| type OperationsList wraps java.util.List<LOperation> |
| |
| type FeaturesList wraps java.util.List<? extends LFeature> |
| |
| type AnnotationList wraps EList<LAnnotationDef> |
| |
| type InternalEObject wraps InternalEObject |
| |
| |