| /** |
| * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Florian Pirchner - Initial implementation |
| */ |
| package org.eclipse.osbp.dsl.common.xtext.jvmmodel; |
| |
| import com.google.common.base.Objects; |
| import com.google.inject.Inject; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.function.Consumer; |
| import javax.validation.Valid; |
| import javax.validation.constraints.AssertFalse; |
| import javax.validation.constraints.AssertTrue; |
| import javax.validation.constraints.DecimalMax; |
| import javax.validation.constraints.DecimalMin; |
| import javax.validation.constraints.Digits; |
| import javax.validation.constraints.Future; |
| import javax.validation.constraints.Max; |
| import javax.validation.constraints.Min; |
| import javax.validation.constraints.NotNull; |
| import javax.validation.constraints.Null; |
| import javax.validation.constraints.Past; |
| import javax.validation.constraints.Pattern; |
| import javax.validation.constraints.Size; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.osbp.dsl.common.xtext.extensions.AnnotationExtension; |
| import org.eclipse.osbp.dsl.semantic.common.types.LAnnotationDef; |
| import org.eclipse.osbp.dsl.semantic.common.types.LAnnotationTarget; |
| import org.eclipse.osbp.dsl.semantic.common.types.LAttribute; |
| import org.eclipse.osbp.dsl.semantic.common.types.LConstraintSeverity; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDataType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDatatypeConstraint; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCAssertFalse; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCAssertTrue; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCDecimalMax; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCDecimalMin; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCDigits; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCFuture; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCNotNull; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCNull; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCNumericMax; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCNumericMin; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCPast; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCRegEx; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDtCSize; |
| import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue; |
| import org.eclipse.osbp.dsl.semantic.common.types.LOperation; |
| import org.eclipse.osbp.dsl.semantic.common.types.LReference; |
| import org.eclipse.osbp.dsl.semantic.common.types.LScalarType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LType; |
| import org.eclipse.osbp.runtime.common.annotations.BeanOnTab; |
| import org.eclipse.osbp.runtime.common.annotations.Dirty; |
| import org.eclipse.osbp.runtime.common.annotations.Properties; |
| import org.eclipse.osbp.runtime.common.annotations.Property; |
| import org.eclipse.osbp.runtime.common.validation.ErrorSeverity; |
| import org.eclipse.osbp.runtime.common.validation.InfoSeverity; |
| import org.eclipse.osbp.runtime.common.validation.WarningSeverity; |
| import org.eclipse.xtext.common.types.JvmAnnotationReference; |
| import org.eclipse.xtext.common.types.JvmAnnotationValue; |
| import org.eclipse.xtext.common.types.JvmField; |
| import org.eclipse.xtext.common.types.JvmGenericType; |
| import org.eclipse.xtext.common.types.JvmMember; |
| import org.eclipse.xtext.common.types.JvmOperation; |
| import org.eclipse.xtext.common.types.JvmTypeReference; |
| import org.eclipse.xtext.common.types.util.TypeReferences; |
| import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation; |
| import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder; |
| import org.eclipse.xtext.xbase.lib.CollectionLiterals; |
| import org.eclipse.xtext.xbase.lib.Conversions; |
| import org.eclipse.xtext.xbase.lib.Extension; |
| import org.eclipse.xtext.xbase.lib.Functions.Function1; |
| import org.eclipse.xtext.xbase.lib.IterableExtensions; |
| import org.eclipse.xtext.xbase.lib.StringExtensions; |
| |
| /** |
| * This class is responsible to generate the Annotations defined in the entity model |
| */ |
| @SuppressWarnings("all") |
| public class AnnotationCompiler { |
| @Inject |
| @Extension |
| private JvmTypesBuilder _jvmTypesBuilder; |
| |
| @Inject |
| @Extension |
| private AnnotationExtension _annotationExtension; |
| |
| @Inject |
| @Extension |
| private TypeReferences _typeReferences; |
| |
| public void processAnnotation(final LAnnotationTarget annotationTarget, final JvmMember jvmMember) { |
| this.internalProcessAnnotation(annotationTarget, jvmMember); |
| } |
| |
| protected void _internalProcessAnnotation(final LType bean, final JvmGenericType jvmType) { |
| final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> { |
| boolean _isExclude = it.isExclude(); |
| return Boolean.valueOf((!_isExclude)); |
| }; |
| final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> { |
| return it.getAnnotation(); |
| }; |
| this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(bean.getResolvedAnnotations(), _function), _function_1), jvmType); |
| } |
| |
| protected void _internalProcessAnnotation(final LReference ref, final JvmField jvmType) { |
| final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> { |
| boolean _isExclude = it.isExclude(); |
| return Boolean.valueOf((!_isExclude)); |
| }; |
| final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> { |
| return it.getAnnotation(); |
| }; |
| this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(ref.getResolvedAnnotations(), _function), _function_1), jvmType); |
| } |
| |
| protected void _internalProcessAnnotation(final LAttribute att, final JvmField jvmType) { |
| final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> { |
| boolean _isExclude = it.isExclude(); |
| return Boolean.valueOf((!_isExclude)); |
| }; |
| final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> { |
| return it.getAnnotation(); |
| }; |
| this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(att.getResolvedAnnotations(), _function), _function_1), jvmType); |
| } |
| |
| public void toDatatypeBasedConstraintAnnotations(final LAttribute att, final JvmField jvmType) { |
| LScalarType _type = att.getType(); |
| if ((_type instanceof LDataType)) { |
| LScalarType _type_1 = att.getType(); |
| final LDataType dt = ((LDataType) _type_1); |
| EList<LDatatypeConstraint> _constraints = dt.getConstraints(); |
| for (final LDatatypeConstraint c : _constraints) { |
| this.toConstraintAnnotation(c, jvmType); |
| } |
| } |
| } |
| |
| protected List<LKeyAndValue> mergeKeyAndValues(final LAttribute att) { |
| final ArrayList<LKeyAndValue> keyAndValues = CollectionLiterals.<LKeyAndValue>newArrayList(); |
| this.addDatatypeKeyAndValues(att, keyAndValues); |
| keyAndValues.addAll(att.getProperties()); |
| this.removeDuplicateKeys(keyAndValues); |
| return keyAndValues; |
| } |
| |
| protected List<LKeyAndValue> mergeKeyAndValues(final LReference ref) { |
| final ArrayList<LKeyAndValue> keyAndValues = CollectionLiterals.<LKeyAndValue>newArrayList(); |
| keyAndValues.addAll(ref.getProperties()); |
| this.removeDuplicateKeys(keyAndValues); |
| return keyAndValues; |
| } |
| |
| protected void removeDuplicateKeys(final List<LKeyAndValue> result) { |
| int _size = result.size(); |
| boolean _equals = (_size == 0); |
| if (_equals) { |
| return; |
| } |
| final ArrayList<String> keys = CollectionLiterals.<String>newArrayList(); |
| int _size_1 = result.size(); |
| int _minus = (_size_1 - 1); |
| final ListIterator<LKeyAndValue> iter = result.listIterator(_minus); |
| while (iter.hasPrevious()) { |
| { |
| final LKeyAndValue temp = iter.previous(); |
| boolean _contains = keys.contains(temp.getKey()); |
| if (_contains) { |
| iter.remove(); |
| } else { |
| String _key = temp.getKey(); |
| keys.add(_key); |
| } |
| } |
| } |
| } |
| |
| protected boolean addDatatypeKeyAndValues(final LAttribute att, final List<LKeyAndValue> result) { |
| boolean _xifexpression = false; |
| LScalarType _type = att.getType(); |
| if ((_type instanceof LDataType)) { |
| boolean _xblockexpression = false; |
| { |
| LScalarType _type_1 = att.getType(); |
| final LDataType dt = ((LDataType) _type_1); |
| _xblockexpression = result.addAll(dt.getProperties()); |
| } |
| _xifexpression = _xblockexpression; |
| } |
| return _xifexpression; |
| } |
| |
| protected void toPropertiesAnnotation(final EObject context, final List<LKeyAndValue> keyValues, final JvmField field) { |
| if ((Objects.equal(keyValues, null) || (keyValues.size() == 0))) { |
| return; |
| } |
| final ArrayList<JvmAnnotationReference> innerAnnotations = CollectionLiterals.<JvmAnnotationReference>newArrayList(); |
| final Consumer<LKeyAndValue> _function = (LKeyAndValue it) -> { |
| final JvmAnnotationReference innerAnno = this._jvmTypesBuilder.toAnnotation(context, Property.class); |
| this._annotationExtension.addAnnAttr(innerAnno, it, "key", it.getKey()); |
| this._annotationExtension.addAnnAttr(innerAnno, it, "value", it.getValue()); |
| innerAnnotations.add(innerAnno); |
| }; |
| keyValues.forEach(_function); |
| final JvmAnnotationReference mainAnno = this._jvmTypesBuilder.toAnnotation(context, Properties.class); |
| this._annotationExtension.addAnnAttr(mainAnno, context, "properties", |
| innerAnnotations.<JvmAnnotationReference>toArray(new JvmAnnotationReference[((Object[])Conversions.unwrapArray(innerAnnotations, Object.class)).length])); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, mainAnno); |
| } |
| |
| /** |
| * Annotation to tell validator, that nested properties should be validated too |
| */ |
| protected void toValidAnnotation(final EObject context, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(context, Valid.class); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void toBeanOnTabAnnotation(final EObject context, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(context, BeanOnTab.class); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| /** |
| * Annotation for the dirty state |
| */ |
| public void toDirtyAnnotation(final EObject context, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(context, Dirty.class); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected boolean _isValidAllowed(final Void voidx) { |
| return false; |
| } |
| |
| protected boolean _isValidAllowed(final LDataType type) { |
| boolean _isAsPrimitive = type.isAsPrimitive(); |
| if (_isAsPrimitive) { |
| return false; |
| } |
| JvmTypeReference _jvmTypeReference = type.getJvmTypeReference(); |
| String _qualifiedName = null; |
| if (_jvmTypeReference!=null) { |
| _qualifiedName=_jvmTypeReference.getQualifiedName(); |
| } |
| boolean _isPrimitiveJvmType = this.isPrimitiveJvmType(_qualifiedName); |
| if (_isPrimitiveJvmType) { |
| return false; |
| } |
| return true; |
| } |
| |
| protected boolean _isValidAllowed(final LScalarType type) { |
| return false; |
| } |
| |
| public boolean isPrimitiveJvmType(final String value) { |
| boolean _equals = Objects.equal(value, null); |
| if (_equals) { |
| return false; |
| } |
| boolean _matched = false; |
| String _name = Integer.class.getName(); |
| if (Objects.equal(value, _name)) { |
| _matched=true; |
| return true; |
| } |
| if (!_matched) { |
| String _name_1 = Integer.TYPE.getName(); |
| if (Objects.equal(value, _name_1)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_2 = Boolean.class.getName(); |
| if (Objects.equal(value, _name_2)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_3 = Boolean.TYPE.getName(); |
| if (Objects.equal(value, _name_3)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_4 = Short.class.getName(); |
| if (Objects.equal(value, _name_4)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_5 = Short.TYPE.getName(); |
| if (Objects.equal(value, _name_5)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_6 = Long.class.getName(); |
| if (Objects.equal(value, _name_6)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_7 = Long.TYPE.getName(); |
| if (Objects.equal(value, _name_7)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_8 = Double.class.getName(); |
| if (Objects.equal(value, _name_8)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_9 = Double.TYPE.getName(); |
| if (Objects.equal(value, _name_9)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_10 = Float.class.getName(); |
| if (Objects.equal(value, _name_10)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_11 = Float.TYPE.getName(); |
| if (Objects.equal(value, _name_11)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_12 = Character.class.getName(); |
| if (Objects.equal(value, _name_12)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_13 = Character.TYPE.getName(); |
| if (Objects.equal(value, _name_13)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_14 = Byte.class.getName(); |
| if (Objects.equal(value, _name_14)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_15 = Byte.TYPE.getName(); |
| if (Objects.equal(value, _name_15)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_16 = Boolean.class.getName(); |
| if (Objects.equal(value, _name_16)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_17 = Boolean.TYPE.getName(); |
| if (Objects.equal(value, _name_17)) { |
| _matched=true; |
| return true; |
| } |
| } |
| if (!_matched) { |
| String _name_18 = String.class.getName(); |
| if (Objects.equal(value, _name_18)) { |
| _matched=true; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCAssertFalse constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, AssertFalse.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected JvmAnnotationValue handlePayloadAndMessages(final LDatatypeConstraint constraint, final JvmAnnotationReference anno) { |
| JvmAnnotationValue _xblockexpression = null; |
| { |
| LConstraintSeverity _severity = constraint.getSeverity(); |
| if (_severity != null) { |
| switch (_severity) { |
| case INFO: |
| this._annotationExtension.addAnnAttr(anno, constraint, "payload", this._typeReferences.getTypeForName(InfoSeverity.class, constraint)); |
| break; |
| case WARNING: |
| this._annotationExtension.addAnnAttr(anno, constraint, "payload", this._typeReferences.getTypeForName(WarningSeverity.class, constraint)); |
| break; |
| case ERROR: |
| this._annotationExtension.addAnnAttr(anno, constraint, "payload", this._typeReferences.getTypeForName(ErrorSeverity.class, constraint)); |
| break; |
| default: |
| break; |
| } |
| } |
| final StringBuilder b = new StringBuilder(); |
| boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(constraint.getMsgI18nKey()); |
| boolean _not = (!_isNullOrEmpty); |
| if (_not) { |
| b.append(constraint.getMsgI18nKey()); |
| } |
| boolean _isNullOrEmpty_1 = StringExtensions.isNullOrEmpty(constraint.getMsgCode()); |
| boolean _not_1 = (!_isNullOrEmpty_1); |
| if (_not_1) { |
| b.append(":"); |
| b.append(constraint.getMsgCode()); |
| } |
| JvmAnnotationValue _xifexpression = null; |
| boolean _isNullOrEmpty_2 = StringExtensions.isNullOrEmpty(b.toString()); |
| boolean _not_2 = (!_isNullOrEmpty_2); |
| if (_not_2) { |
| String _string = b.toString(); |
| String _plus = ("{" + _string); |
| String _plus_1 = (_plus + "}"); |
| _xifexpression = this._annotationExtension.addAnnAttr(anno, constraint, "message", _plus_1); |
| } |
| _xblockexpression = _xifexpression; |
| } |
| return _xblockexpression; |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCAssertTrue constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, AssertTrue.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCNotNull constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, NotNull.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCNull constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Null.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCFuture constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Future.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCPast constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Past.class); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCSize constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Size.class); |
| int _min = constraint.getMin(); |
| boolean _greaterEqualsThan = (_min >= 0); |
| if (_greaterEqualsThan) { |
| this._annotationExtension.addAnnAttr(anno, constraint, "min", Integer.valueOf(constraint.getMin())); |
| } |
| int _max = constraint.getMax(); |
| boolean _greaterThan = (_max > 0); |
| if (_greaterThan) { |
| this._annotationExtension.addAnnAttr(anno, constraint, "max", Integer.valueOf(constraint.getMax())); |
| } |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCDigits constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Digits.class); |
| int _intDigits = constraint.getIntDigits(); |
| boolean _greaterEqualsThan = (_intDigits >= 0); |
| if (_greaterEqualsThan) { |
| this._annotationExtension.addAnnAttr(anno, constraint, "integer", Integer.valueOf(constraint.getIntDigits())); |
| } |
| int _fractionDigits = constraint.getFractionDigits(); |
| boolean _greaterThan = (_fractionDigits > 0); |
| if (_greaterThan) { |
| this._annotationExtension.addAnnAttr(anno, constraint, "fraction", Integer.valueOf(constraint.getFractionDigits())); |
| } |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCDecimalMax constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, DecimalMax.class); |
| this._annotationExtension.addAnnAttr(anno, constraint, "value", Float.valueOf(constraint.getMax()).toString()); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCDecimalMin constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, DecimalMin.class); |
| this._annotationExtension.addAnnAttr(anno, constraint, "value", Float.valueOf(constraint.getMin()).toString()); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCNumericMax constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Max.class); |
| this._annotationExtension.addAnnAttr(anno, constraint, "value", Integer.valueOf(constraint.getMax())); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCNumericMin constraint, final JvmField field) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Min.class); |
| this._annotationExtension.addAnnAttr(anno, constraint, "value", Integer.valueOf(constraint.getMin())); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| |
| protected void _toConstraintAnnotation(final LDtCRegEx constraint, final JvmField field) { |
| if (((!Objects.equal(constraint.getPattern(), null)) && (!constraint.getPattern().isEmpty()))) { |
| final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(constraint, Pattern.class); |
| this._annotationExtension.addAnnAttr(anno, constraint, "regexp", constraint.getPattern()); |
| this.handlePayloadAndMessages(constraint, anno); |
| EList<JvmAnnotationReference> _annotations = field.getAnnotations(); |
| this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, anno); |
| } |
| } |
| |
| protected void _internalProcessAnnotation(final LOperation member, final JvmOperation jvmOperation) { |
| final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> { |
| boolean _isExclude = it.isExclude(); |
| return Boolean.valueOf((!_isExclude)); |
| }; |
| final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> { |
| return it.getAnnotation(); |
| }; |
| this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(member.getResolvedAnnotations(), _function), _function_1), jvmOperation); |
| } |
| |
| protected void internalProcessAnnotation(final LAnnotationTarget att, final JvmMember jvmType) { |
| if (att instanceof LAttribute |
| && jvmType instanceof JvmField) { |
| _internalProcessAnnotation((LAttribute)att, (JvmField)jvmType); |
| return; |
| } else if (att instanceof LReference |
| && jvmType instanceof JvmField) { |
| _internalProcessAnnotation((LReference)att, (JvmField)jvmType); |
| return; |
| } else if (att instanceof LOperation |
| && jvmType instanceof JvmOperation) { |
| _internalProcessAnnotation((LOperation)att, (JvmOperation)jvmType); |
| return; |
| } else if (att instanceof LType |
| && jvmType instanceof JvmGenericType) { |
| _internalProcessAnnotation((LType)att, (JvmGenericType)jvmType); |
| return; |
| } else { |
| throw new IllegalArgumentException("Unhandled parameter types: " + |
| Arrays.<Object>asList(att, jvmType).toString()); |
| } |
| } |
| |
| public boolean isValidAllowed(final LScalarType type) { |
| if (type instanceof LDataType) { |
| return _isValidAllowed((LDataType)type); |
| } else if (type != null) { |
| return _isValidAllowed(type); |
| } else if (type == null) { |
| return _isValidAllowed((Void)null); |
| } else { |
| throw new IllegalArgumentException("Unhandled parameter types: " + |
| Arrays.<Object>asList(type).toString()); |
| } |
| } |
| |
| protected void toConstraintAnnotation(final LDatatypeConstraint constraint, final JvmField field) { |
| if (constraint instanceof LDtCAssertFalse) { |
| _toConstraintAnnotation((LDtCAssertFalse)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCAssertTrue) { |
| _toConstraintAnnotation((LDtCAssertTrue)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCDecimalMax) { |
| _toConstraintAnnotation((LDtCDecimalMax)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCDecimalMin) { |
| _toConstraintAnnotation((LDtCDecimalMin)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCDigits) { |
| _toConstraintAnnotation((LDtCDigits)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCFuture) { |
| _toConstraintAnnotation((LDtCFuture)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCNotNull) { |
| _toConstraintAnnotation((LDtCNotNull)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCNull) { |
| _toConstraintAnnotation((LDtCNull)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCNumericMax) { |
| _toConstraintAnnotation((LDtCNumericMax)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCNumericMin) { |
| _toConstraintAnnotation((LDtCNumericMin)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCPast) { |
| _toConstraintAnnotation((LDtCPast)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCRegEx) { |
| _toConstraintAnnotation((LDtCRegEx)constraint, field); |
| return; |
| } else if (constraint instanceof LDtCSize) { |
| _toConstraintAnnotation((LDtCSize)constraint, field); |
| return; |
| } else { |
| throw new IllegalArgumentException("Unhandled parameter types: " + |
| Arrays.<Object>asList(constraint, field).toString()); |
| } |
| } |
| } |
