protected internal virtual void registerValueTypes(ProcessEngineConfigurationImpl processEngineConfiguration)
{
ValueTypeResolver resolver = processEngineConfiguration.ValueTypeResolver;
resolver.addType(JSON);
resolver.addType(XML);
}
public override void initializeValue(VariableSerializers serializers)
{
TypedValue typedValue = wrappedQueryValue.TypedValue;
ValueTypeResolver resolver = Context.ProcessEngineConfiguration.ValueTypeResolver;
ICollection <ValueType> concreteTypes = resolver.getSubTypes(typedValue.Type);
foreach (ValueType type in concreteTypes)
{
if (type.canConvertFromTypedValue(typedValue))
{
TypedValue convertedValue = type.convertFromTypedValue(typedValue);
SingleQueryVariableValueCondition aggregatedValue = new SingleQueryVariableValueCondition(wrappedQueryValue);
aggregatedValue.initializeValue(serializers, convertedValue);
aggregatedValues.Add(aggregatedValue);
}
}
}
/// <summary>
/// Merges flags from source and copies them into dest, arguments in dest are not modified, new values are created
/// </summary>
/// <param name="source">Source values</param>
/// <param name="dest">Values, where to copy flags</param>
/// <returns>Values from dest argument with new flags</returns>
public static IEnumerable <Value> CopyFlags(IEnumerable <Value> source, IEnumerable <Value> dest)
{
List <Value> result = new List <Value>();
Flags newFlag = GetFlags(source);
foreach (Value value in dest)
{
if (ValueTypeResolver.CanBeDirty(value))
{
result.Add(value.SetInfo(newFlag));
}
else
{
result.Add(value);
}
}
return(result);
}
/// <summary>
/// Check type of one argument and reports warnings if they doesn't match.
/// </summary>
/// <param name="flow">FlowController</param>
/// <param name="memoryEntry">Values of argument</param>
/// <param name="argument">Information about argument</param>
/// <param name="argumentNumber">Number of argument</param>
/// <param name="functionName">Name of function</param>
/// <param name="warnings">List of warnings, for inserting warnings</param>
private static void CheckArgumentTypes(FlowController flow, MemoryEntry memoryEntry, NativeFunctionArgument argument, int argumentNumber, string functionName, List <AnalysisWarning> warnings)
{
bool argumentMatches = true;
foreach (Value value in memoryEntry.PossibleValues)
{
if (value is AnyValue || value is UndefinedValue)
{
continue;
}
switch (argument.Type)
{
case "mixed":
break;
case "int":
case "integer":
//TODO: workaround: type declarations in .xml files specifies the arguments that should be of type number by type int
// fix declarations in xml files!!
//if (!(ValueTypeResolver.IsInt(value) || ValueTypeResolver.IsLong(value)))
if (!(ValueTypeResolver.IsInt(value) || ValueTypeResolver.IsLong(value) || ValueTypeResolver.IsFloat(value)))
{
argumentMatches = false;
}
break;
case "float":
case "number":
if (!(ValueTypeResolver.IsInt(value) || ValueTypeResolver.IsLong(value) || ValueTypeResolver.IsFloat(value)))
{
argumentMatches = false;
}
break;
case "string":
case "char":
if (!ValueTypeResolver.IsString(value))
{
argumentMatches = false;
}
break;
case "array":
if (!ValueTypeResolver.IsArray(value))
{
argumentMatches = false;
}
break;
case "object":
if (!ValueTypeResolver.IsObject(value))
{
argumentMatches = false;
}
break;
case "bool":
case "boolean":
if (!ValueTypeResolver.IsBool(value))
{
argumentMatches = false;
}
break;
case "resource":
case "resouce":
if (!(value is AnyResourceValue))
{
argumentMatches = false;
}
break;
case "callable":
case "callback":
if (!ValueTypeResolver.IsString(value) && !(value is FunctionValue))
{
argumentMatches = false;
}
break;
case "void":
throw new Exception("Void is not a type of argument");
default:
if (!ValueTypeResolver.IsObject(value))
{
argumentMatches = false;
}
break;
}
}
if (argumentMatches == false)
{
warnings.Add(new AnalysisWarning(NativeAnalyzerUtils.GetCallerScript(flow.OutSet), "Wrong type of argument number " + argumentNumber + " in function " + functionName + ", expecting " + argument.Type, flow.CurrentPartial, flow.CurrentProgramPoint, AnalysisWarningCause.WRONG_ARGUMENTS_TYPE));
}
}
public virtual ProcessEngineConfiguration setValueTypeResolver(ValueTypeResolver valueTypeResolver)
{
this.valueTypeResolver = valueTypeResolver;
return(this);
}
public virtual TypedValue toTypedValue(ProcessEngine processEngine, ObjectMapper objectMapper)
{
ValueTypeResolver valueTypeResolver = processEngine.ProcessEngineConfiguration.ValueTypeResolver;
if (string.ReferenceEquals(type, null))
{
if (valueInfo != null && valueInfo[ValueType.VALUE_INFO_TRANSIENT] is bool?)
{
return(Variables.untypedValue(value, (bool?)valueInfo[ValueType.VALUE_INFO_TRANSIENT]));
}
return(Variables.untypedValue(value));
}
ValueType valueType = valueTypeResolver.typeForName(fromRestApiTypeName(type));
if (valueType == null)
{
throw new RestException(Status.BAD_REQUEST, string.Format("Unsupported value type '{0}'", type));
}
else
{
if (valueType is PrimitiveValueType)
{
PrimitiveValueType primitiveValueType = (PrimitiveValueType)valueType;
Type javaType = primitiveValueType.JavaType;
object mappedValue = null;
try
{
if (value != null)
{
if (javaType.IsAssignableFrom(value.GetType()))
{
mappedValue = value;
}
else
{
// use jackson to map the value to the requested java type
mappedValue = objectMapper.readValue("\"" + value + "\"", javaType);
}
}
return(valueType.createValue(mappedValue, valueInfo));
}
catch (Exception e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new InvalidRequestException(Status.BAD_REQUEST, e, string.Format("Cannot convert value '{0}' of type '{1}' to java type {2}", value, type, javaType.FullName));
}
}
else if (valueType is SerializableValueType)
{
if (value != null && !(value is string))
{
throw new InvalidRequestException(Status.BAD_REQUEST, "Must provide 'null' or String value for value of SerializableValue type '" + type + "'.");
}
return(((SerializableValueType)valueType).createValueFromSerialized((string)value, valueInfo));
}
else if (valueType is FileValueType)
{
if (value is string)
{
value = Base64.decodeBase64((string)value);
}
return(valueType.createValue(value, valueInfo));
}
else
{
return(valueType.createValue(value, valueInfo));
}
}
}
