public virtual TypedValue getTypedValue(bool deserializeValue) { if (cachedValue != null && cachedValue is SerializableValue && Context.CommandContext != null) { SerializableValue serializableValue = (SerializableValue)cachedValue; if (deserializeValue && !serializableValue.Deserialized) { // clear cached value in case it is not deserialized and user requests deserialized value cachedValue = null; } } if (cachedValue == null && string.ReferenceEquals(errorMessage, null)) { try { cachedValue = Serializer.readValue(valueFields, deserializeValue); if (notifyOnImplicitUpdates && isMutableValue(cachedValue)) { Context.CommandContext.registerCommandContextListener(this); } } catch (Exception e) { // intercept the error message this.errorMessage = e.Message; throw e; } } return(cachedValue); }
public SerializableValue PickChild(SerializableValue target, string language = TranslationManager.DefaultLanguage) { if (!(target is IStringConverter stringConverter)) { throw new NotSupportedException($"Unable to pick child {target} from Vector3: only string is supported"); } var name = stringConverter.ConvertToString(language); switch (name) { case "X": return(new WriteBackReferenceValue(new FloatValue { value = value.x }, WriteXBack)); case "Y": return(new WriteBackReferenceValue(new FloatValue { value = value.y }, WriteYBack)); case "Z": return(new WriteBackReferenceValue(new FloatValue { value = value.z }, WriteZBack)); default: throw new NotSupportedException($"Unable to pick child {name} from Vector2: unrecognized command {name}"); } }
protected internal override bool canWriteValue(TypedValue typedValue) { if (!(typedValue is SerializableValue) && !(typedValue is UntypedValueImpl)) { return(false); } if (typedValue is SerializableValue) { SerializableValue serializableValue = (SerializableValue)typedValue; string requestedDataFormat = serializableValue.SerializationDataFormat; if (!serializableValue.Deserialized) { // serialized object => dataformat must match return(serializationDataFormat.Equals(requestedDataFormat)); } else { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final boolean canSerialize = typedValue.getValue() == null || canSerializeValue(typedValue.getValue()); bool canSerialize = typedValue.Value == null || canSerializeValue(typedValue.Value); return(canSerialize && (string.ReferenceEquals(requestedDataFormat, null) || serializationDataFormat.Equals(requestedDataFormat))); } } else { return(typedValue.Value == null || canSerializeValue(typedValue.Value)); } }
public static void fromTypedValue(VariableValueDto dto, TypedValue typedValue, bool preferSerializedValue) { ValueType type = typedValue.Type; if (type != null) { string typeName = type.Name; dto.Type = toRestApiTypeName(typeName); dto.ValueInfo = type.getValueInfo(typedValue); } if (typedValue is SerializableValue) { SerializableValue serializableValue = (SerializableValue)typedValue; if (serializableValue.Deserialized && !preferSerializedValue) { dto.Value = serializableValue.Value; } else { dto.Value = serializableValue.ValueSerialized; } } else if (typedValue is FileValue) { //do not set the value for FileValues since we don't want to send megabytes over the network without explicit request } else { dto.Value = typedValue.Value; } }
/// <summary> /// 尝试将可序列化值解析为布尔值 /// </summary> /// <param name="value">目标内存值</param> /// <returns></returns> public static bool TryParse(SerializableValue value) { switch (value) { case IBooleanConverter booleanConverter: return(booleanConverter.ConvertToBoolean()); case IFloatConverter floatConverter: return(!floatConverter.ConvertToFloat().Equals(0.0F)); case IIntegerConverter integerConverter: return(integerConverter.ConvertToInteger() != 0); case IStringConverter stringConverter: var upperValue = stringConverter.ConvertToString().ToUpper(); if (upperValue == "F" || upperValue == "FALSE") { return(false); } if (int.TryParse(upperValue, out var intValue) && intValue == 0) { return(false); } return(!(float.TryParse(upperValue, out var floatValue) && floatValue.Equals(0.0F))); default: return(value != null); } }
/// <inheritdoc /> public SerializableValue PickChild(SerializableValue name) { if (!(name is IStringConverter stringConverter)) { throw new NotSupportedException($"Unable to get feature in integer value with feature id {name}: only string feature name is accepted"); } var target = stringConverter.ConvertToString(); switch (target) { case "ToBoolean": return(new BooleanValue { Value = ConvertToBoolean() }); case "ToNegative": return(new IntegerValue { Value = -Value }); case "ToFloat": return(new FloatValue { Value = ConvertToFloat() }); case "ToString": return(new StringValue { Value = ConvertToString() }); default: throw new NotSupportedException($"Unable to get feature in integer value: unsupported feature {target}"); } }
/// <summary> /// 尝试将可序列化值解析为32为整数值 /// </summary> /// <param name="value">目标内存值</param> /// <returns></returns> public static int TryParse(SerializableValue value) { switch (value) { case IIntegerConverter intTarget: return(intTarget.ConvertToInteger()); case IFloatConverter floatTarget: return(Mathf.RoundToInt(floatTarget.ConvertToFloat())); case IStringConverter stringTarget: var stringValue = stringTarget.ConvertToString(); if (int.TryParse(stringValue, out var intValue)) { return(intValue); } if (float.TryParse(stringValue, out var floatValue)) { return(Mathf.RoundToInt(floatValue)); } throw new NotSupportedException($"Unable to convert {stringValue} to integer: unsupported string format"); case IBooleanConverter boolTarget: return(boolTarget.ConvertToBoolean() ? 1 : 0); default: throw new NotSupportedException($"Unable to convert {value} to integer: unsupported format"); } }
/// <inheritdoc /> public SerializableValue DivideWith(SerializableValue target) { switch (target) { case IIntegerConverter intTarget: return(new StringValue { Value = DivideString(Value, intTarget.ConvertToInteger()) }); case IFloatConverter floatTarget: return(new StringValue { Value = DivideString(Value, Mathf.RoundToInt(floatTarget.ConvertToFloat())) }); case IStringConverter _: throw new NotSupportedException("Unable to divide string constant with string constant"); case IBooleanConverter boolTarget: return(new StringValue { Value = boolTarget.ConvertToBoolean() ? Value : "" }); default: throw new NotSupportedException($"Unable to divide string constant with unsupported value {target}"); } }
public SerializableValue DivideWith(SerializableValue target, string language = TranslationManager.DefaultLanguage) { switch (target) { case IIntegerConverter intTarget: return(new StringValue { value = DivideString(value, intTarget.ConvertToInteger(language)) }); case IFloatConverter floatTarget: return(new StringValue { value = DivideString(value, Mathf.RoundToInt(floatTarget.ConvertToFloat(language))) }); case IStringConverter stringConverter: throw new NotSupportedException($"Unable to divide string {value} with {stringConverter.ConvertToString(language)}: string cannot divide with string"); case IBooleanConverter boolTarget: return(new StringValue { value = boolTarget.ConvertToBoolean(language) ? value : "" }); default: throw new NotSupportedException($"Unable to multiply {value} with {target}: type unrecognized"); } }
/// <summary> /// Checks, if Java serialization will be used and if it is allowed to be used. </summary> /// <param name="variableName"> </param> /// <param name="value"> </param> protected internal virtual void checkJavaSerialization(string variableName, TypedValue value) { ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration; if (value is SerializableValue && !processEngineConfiguration.JavaSerializationFormatEnabled) { SerializableValue serializableValue = (SerializableValue)value; // if Java serialization is prohibited if (!serializableValue.Deserialized) { string javaSerializationDataFormat = Variables.SerializationDataFormats.JAVA.Name; string requestedDataFormat = serializableValue.SerializationDataFormat; if (string.ReferenceEquals(requestedDataFormat, null)) { // check if Java serializer will be used //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.variable.serializer.TypedValueSerializer serializerForValue = org.camunda.bpm.engine.impl.persistence.entity.util.TypedValueField.getSerializers().findSerializerForValue(serializableValue, processEngineConfiguration.getFallbackSerializerFactory()); TypedValueSerializer serializerForValue = TypedValueField.Serializers.findSerializerForValue(serializableValue, processEngineConfiguration.FallbackSerializerFactory); if (serializerForValue != null) { requestedDataFormat = serializerForValue.SerializationDataformat; } } if (javaSerializationDataFormat.Equals(requestedDataFormat)) { throw ProcessEngineLogger.CORE_LOGGER.javaSerializationProhibitedException(variableName); } } } }
public override int GetHashCode() { unchecked { return(((SerializableValue != null ? SerializableValue.GetHashCode() : 0) * 397) ^ (LogicalValue != null ? LogicalValue.GetHashCode() : 0)); } }
public SerializableValue PickChild(SerializableValue target, string language = TranslationManager.DefaultLanguage) { if (!(target is IStringConverter stringConverter)) { throw new NotSupportedException($"Unable to pick child {target} from Vector2: only string is supported"); } var name = stringConverter.ConvertToString(language); switch (name) { case "R": return(new IntegerValue { value = value.r }); case "G": return(new IntegerValue { value = value.g }); case "B": return(new IntegerValue { value = value.b }); case "A": case "Alpha": return(new IntegerValue { value = value.a }); case "FloatR": return(new FloatValue { value = R }); case "FloatG": return(new FloatValue { value = G }); case "FloatB": return(new FloatValue { value = B }); case "FloatA": case "FloatAlpha": return(new FloatValue { value = Alpha }); case "Hex": return(new StringValue { value = ConvertToString(language) }); } throw new NotSupportedException($"Unable to pick child {name} from Color: unrecognized command {name}"); }
override public string Serialize(SerializableValue Value) { var dtVal = Convert.ToDateTime(Value.Object); var sVal = dtVal.ToString(Options?.DateTimeFormat ?? "s"); return(sVal); }
override public string Serialize(SerializableValue Value) { var iVal = Convert.ToInt32(Value.Object); var sVal = iVal.ToString(new string('0', Value.Length)); if (sVal.Length > Value.Length) throw new InvalidOperationException(); return sVal; }
public void OnAfterDeserialize() { type = SerializableValue.SerializableTypeCodeToType(defaultValue.TypeCode); if (type == null) { Debug.LogError("Not Found TypeName:" + defaultValue.TypeCode); } }
override public string Serialize(SerializableValue Value) { if ((bool)Value.Object) { return("1"); } return("0"); }
public SerializableValue AddWith(SerializableValue target, string language = TranslationManager.DefaultLanguage) { var targetString = target is IStringConverter stringTarget?stringTarget.ConvertToString(language) : target.ToString(); return(new StringValue { value = $"{value}{targetString}" }); }
/// <inheritdoc /> public SerializableValue AddWith(SerializableValue target, string language) { var targetString = target is IStringConverter stringTarget?stringTarget.ConvertToString(language) : target.ToString(); return(new StringValue { Value = $"{Value}{targetString}" }); }
public bool EqualsWith(SerializableValue target, string language = TranslationManager.DefaultLanguage) { try { return(value.Equals(TryParse(target, language))); } catch { return(false); } }
/// <inheritdoc /> public SerializableValue SubtractWith(SerializableValue target, string language) { var targetString = target is IStringConverter stringTarget?stringTarget.ConvertToString(language) : target.ToString(); return(new StringValue { Value = Value.Replace(targetString, "") }); }
/// <inheritdoc /> public bool EqualsWith(SerializableValue target) { try { return(Value == TryParse(target)); } catch { return(false); } }
public SerializableValue SubtractWith(SerializableValue target, string language = TranslationManager.DefaultLanguage) { var targetString = target is IStringConverter stringTarget?stringTarget.ConvertToString(language) : target.ToString(); return(new StringValue { value = value.Replace(targetString, "") }); }
override public bool Deserialize(string Block, SerializableValue Value) { if (!int.TryParse(Block, out int iVal)) { iVal = -1; } Value.Object = iVal; //Value.Type. return(true); }
public VariableInfo(string name, Type type, object defaultValue) { this.name = name; this.type = type; this.defaultValue = new SerializableValue(type) { Value = defaultValue }; }
override public bool Deserialize(string Block, SerializableValue Value) { decimal dVal = Convert.ToDecimal(Block); int Div = (int)Math.Pow(10, Value.Decimals); Value.Object = dVal / Div; return(true); }
/// <inheritdoc /> public bool EqualsWith(SerializableValue target) { switch (target) { case IStringConverter stringConverter: return(stringConverter.ConvertToString() == Value); default: return(false); } }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { //var typeCodeProperty = property.FindPropertyRelative("typeCode"); //var stringValueProperty = property.FindPropertyRelative("stringValue"); //var objectValueProperty = property.FindPropertyRelative("objectValue"); //var curveValueProperty = property.FindPropertyRelative("curveValue"); var sv = property.GetObjectOfProperty() as SerializableValue; ValueField(position, sv.Value, SerializableValue.SerializableTypeCodeToType(sv.TypeCode)); }
private static async Task ShowWindow(SerializableValue time) { float showValue; try { showValue = FloatValue.TryParse(time); } catch { showValue = 0.0F; } await MessageService.ProcessAsync(Message <float> .Create(showValue, MessageIntegration.Mask, MessageIntegration.ShowDialogueBox)); }
private static async Task HideWindow(SerializableValue time, string language) { float hideValue; try { hideValue = FloatValue.TryParse(time, language); } catch { hideValue = 0.0F; } await MessageService.ProcessAsync(Message <float> .Create(MessageIntegration.Mask, MessageIntegration.HideDialogueBox, hideValue)); }
public bool EqualsWith(SerializableValue target, string language = TranslationManager.DefaultLanguage) { switch (target) { case IStringConverter stringConverter: return(stringConverter.ConvertToString(language) == value); default: return(false); } }