private void handleRangeEnumeration( final Object lwm2mObject, final Property property, final Item item ) { if (property.getConstraintRule() != null) { final EList<Constraint> constraints = property.getConstraintRule().getConstraints(); final StringBuilder rangeSb = new StringBuilder(); for( final Constraint constraint : constraints ) { final ConstraintIntervalType type = constraint.getType(); final String constraintValues = constraint.getConstraintValues(); if( type == ConstraintIntervalType.MIN ) { rangeSb.append( constraintValues ).append( '-' ); } else if( type == ConstraintIntervalType.MAX ) { rangeSb.append( constraintValues ); } else if( type == ConstraintIntervalType.STRLEN ) { rangeSb.append( "0-" ).append( constraintValues ).append( " bytes" ); } else { final String errMsg = unsupportedValueForPropertyMsg( "ConstraintIntervalType <" + type + ">", property, lwm2mObject ); throw new IllegalArgumentException( errMsg ); } } item.setRangeEnumeration( rangeSb.toString() ); } }
public boolean isMimeConstraint(final String primitiveTypeName, final Constraint constraint) { boolean _and = false; ConstraintIntervalType _type = constraint.getType(); String _literal = _type.getLiteral(); boolean _equals = Objects.equal("MIMETYPE", _literal); if (!_equals) { _and = false; } else { boolean _equals_1 = Objects.equal("byte", primitiveTypeName); _and = _equals_1; } return _and; }
@Override public boolean evaluateValueType(final PrimitiveType type, final Constraint constraint) { boolean _xblockexpression = false; { try { String _constraintValues = constraint.getConstraintValues(); Integer.parseInt(_constraintValues); } catch (final Throwable _t) { if (_t instanceof NumberFormatException) { final NumberFormatException ex = (NumberFormatException)_t; String _message = ex.getMessage(); ScalarValueValidator.logger.info(_message); this.setErrorMessage(DatatypeSystemMessage.ERROR_CONSTRAINT_VALUE_INT); return false; } else { throw Exceptions.sneakyThrow(_t); } } _xblockexpression = true; } return _xblockexpression; } }
public final boolean checkPropertyConstraints(final PrimitiveType type, final Constraint cons) { boolean _xblockexpression = false; { String _literal = type.getLiteral(); String[] arr = this.valueTypeMap.get(_literal); boolean _or = false; boolean _equals = Objects.equal(arr, null); if (_equals) { _or = true; } else { final String[] _converted_arr = (String[])arr; ConstraintIntervalType _type = cons.getType(); String _literal_1 = _type.getLiteral(); boolean _contains = ((List<String>)Conversions.doWrapArray(_converted_arr)).contains(_literal_1); boolean _not = (!_contains); _or = _not; } if (_or) { this.setErrorMessage(DatatypeSystemMessage.ERROR_CONSTRAINTTYPE_INVALID); return false; } _xblockexpression = true; } return _xblockexpression; }
boolean _xblockexpression = false; String rawValue = constraint.getConstraintValues(); String typeStr = type.getLiteral(); boolean _matched = false;
@Override public String getContent(final Constraint constraint, final InvocationContext invocationContext) { StringConcatenation _builder = new StringConcatenation(); { ConstraintIntervalType _type = constraint.getType(); String _jsonConstraint = this.getJsonConstraint(_type); boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(_jsonConstraint); boolean _not = (!_isNullOrEmpty); if (_not) { ConstraintIntervalType _type_1 = constraint.getType(); String _jsonConstraint_1 = this.getJsonConstraint(_type_1); _builder.append(_jsonConstraint_1, ""); String _constraintValues = constraint.getConstraintValues(); _builder.append(_constraintValues, ""); } } return _builder.toString(); }
@Check public void checkDuplicatedConstraint(final Property feature) { HashSet<String> set = new HashSet<String>(); ConstraintRule _constraintRule = feature.getConstraintRule(); EList<Constraint> list = _constraintRule.getConstraints(); for (int i = 0; (i < ((Object[])Conversions.unwrapArray(list, Object.class)).length); i++) { { Constraint con = list.get(i); ConstraintIntervalType _type = con.getType(); String _literal = _type.getLiteral(); boolean _add = set.add(_literal); boolean _not = (!_add); if (_not) { this.error(DatatypeSystemMessage.ERROR_DUPLICATED_CONSTRAINT, con, DatatypePackage.Literals.CONSTRAINT__TYPE); } } } }
ConstraintIntervalType _type = constraint.getType(); boolean _equals = Objects.equal(_type, ConstraintIntervalType.MIN); if (_equals) { return constraint.getConstraintValues();
public void verifyConstraintForType(final PrimitivePropertyType primitivePropertyType, final Constraint constraint, final boolean isMultiplcity) { PrimitiveType _type = primitivePropertyType.getType(); boolean _isValidConstraintType = this.isValidConstraintType(_type, constraint); boolean _not = (!_isValidConstraintType); if (_not) { String _errorMessage = this.propertyValidator.getErrorMessage(); this.error(_errorMessage, constraint, DatatypePackage.Literals.CONSTRAINT__TYPE); } else { ConstraintIntervalType _type_1 = constraint.getType(); ConstraintValueValidator validator = ConstraintValidatorFactory.getValueValidator(_type_1); PrimitiveType _type_2 = primitivePropertyType.getType(); boolean _isValidConstraintValue = this.isValidConstraintValue(validator, _type_2, constraint); boolean _not_1 = (!_isValidConstraintValue); if (_not_1) { String _errorMessage_1 = validator.getErrorMessage(); this.error(_errorMessage_1, constraint, DatatypePackage.Literals.CONSTRAINT__CONSTRAINT_VALUES); } } PrimitiveType _type_3 = primitivePropertyType.getType(); String _name = _type_3.getName(); boolean _isMimeConstraint = this.isMimeConstraint(_name, constraint); if (_isMimeConstraint) { if ((!isMultiplcity)) { this.error(DatatypeSystemMessage.ERROR_MIMETYPE_FOR_BYTE, constraint, DatatypePackage.Literals.CONSTRAINT__TYPE); } } }
ConstraintIntervalType _type = constraint.getType(); boolean _equals = Objects.equal(_type, ConstraintIntervalType.MAX); if (_equals) { return constraint.getConstraintValues();
/** * Contexts: * Constraint returns Constraint * * Constraint: * (type=ConstraintIntervalType constraintValues=IntervalType) */ protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, DatatypePackage.Literals.CONSTRAINT__TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatatypePackage.Literals.CONSTRAINT__TYPE)); if (transientValues.isValueTransient(semanticObject, DatatypePackage.Literals.CONSTRAINT__CONSTRAINT_VALUES) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatatypePackage.Literals.CONSTRAINT__CONSTRAINT_VALUES)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getConstraintAccess().getTypeConstraintIntervalTypeEnumRuleCall_0_0(), semanticObject.getType()); feeder.accept(grammarAccess.getConstraintAccess().getConstraintValuesIntervalTypeParserRuleCall_1_0(), semanticObject.getConstraintValues()); feeder.finish(); }