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);
}
}
