protected internal virtual TypedValueSerializer determineSerializer(VariableSerializers serializers, TypedValue value)
{
TypedValueSerializer serializer = serializers.findSerializerForValue(value);
if (serializer.Type == ValueType.BYTES)
{
throw new ProcessEngineException("Variables of type ByteArray cannot be used to query");
}
else if (serializer.Type == ValueType.FILE)
{
throw new ProcessEngineException("Variables of type File cannot be used to query");
}
else if (serializer is JPAVariableSerializer)
{
if (wrappedQueryValue.Operator != QueryOperator.EQUALS)
{
throw new ProcessEngineException("JPA entity variables can only be used in 'variableValueEquals'");
}
}
else
{
if (!serializer.Type.PrimitiveValueType)
{
throw new ProcessEngineException("Object values cannot be used to query");
}
}
return(serializer);
}
/// <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 virtual TypedValue setValue(TypedValue value)
{
// determine serializer to use
serializer = Serializers.findSerializerForValue(value, Context.ProcessEngineConfiguration.FallbackSerializerFactory);
serializerName = serializer.Name;
if (value is UntypedValueImpl)
{
// type has been detected
value = serializer.convertToTypedValue((UntypedValueImpl)value);
}
// set new value
writeValue(value, valueFields);
// cache the value
cachedValue = value;
// ensure that we serialize the object on command context flush
// if it can be implicitly changed
if (notifyOnImplicitUpdates && isMutableValue(cachedValue))
{
Context.CommandContext.registerCommandContextListener(this);
}
return(value);
}
public virtual VariableSerializers join(VariableSerializers other)
{
DefaultVariableSerializers copy = new DefaultVariableSerializers();
// "other" serializers override existing ones if their names match
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (TypedValueSerializer<?> thisSerializer : serializerList)
foreach (TypedValueSerializer <object> thisSerializer in serializerList)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: TypedValueSerializer<?> serializer = other.getSerializerByName(thisSerializer.getName());
TypedValueSerializer <object> serializer = other.getSerializerByName(thisSerializer.Name);
if (serializer == null)
{
serializer = thisSerializer;
}
copy.addSerializer(serializer);
}
// add all "other" serializers that did not exist before to the end of the list
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (TypedValueSerializer<?> otherSerializer : other.getSerializers())
foreach (TypedValueSerializer <object> otherSerializer in other.Serializers)
{
if (!copy.serializerMap.ContainsKey(otherSerializer.Name))
{
copy.addSerializer(otherSerializer);
}
}
return(copy);
}
public virtual void initializeValue(VariableSerializers serializers, TypedValue typedValue)
{
TypedValueSerializer serializer = determineSerializer(serializers, typedValue);
if (typedValue is UntypedValueImpl)
{
// type has been detected
typedValue = serializer.convertToTypedValue((UntypedValueImpl)typedValue);
}
serializer.writeValue(typedValue, this);
this.type = serializer.Name;
}
public virtual int getSerializerIndexByName(string serializerName)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: TypedValueSerializer<?> serializer = serializerMap.get(serializerName);
TypedValueSerializer <object> serializer = serializerMap[serializerName];
if (serializer != null)
{
return(getSerializerIndex(serializer));
}
else
{
return(-1);
}
}
protected internal virtual void ensureSerializerInitialized()
{
if (!string.ReferenceEquals(serializerName, null) && serializer == null)
{
serializer = Serializers.getSerializerByName(serializerName);
if (serializer == null)
{
serializer = getFallbackSerializer(serializerName);
}
if (serializer == null)
{
throw LOG.serializerNotDefinedException(this);
}
}
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: public TypedValueSerializer<?> findSerializerForValue(org.camunda.bpm.engine.variable.value.TypedValue value, VariableSerializerFactory fallBackSerializerFactory)
public virtual TypedValueSerializer <object> findSerializerForValue(TypedValue value, VariableSerializerFactory fallBackSerializerFactory)
{
string defaultSerializationFormat = Context.ProcessEngineConfiguration.DefaultSerializationFormat;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<TypedValueSerializer<?>> matchedSerializers = new java.util.ArrayList<TypedValueSerializer<?>>();
IList <TypedValueSerializer <object> > matchedSerializers = new List <TypedValueSerializer <object> >();
ValueType type = value.Type;
if (type != null && type.Abstract)
{
throw new ProcessEngineException("Cannot serialize value of abstract type " + type.Name);
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (TypedValueSerializer<?> serializer : serializerList)
foreach (TypedValueSerializer <object> serializer in serializerList)
{
if (type == null || serializer.Type.Equals(type))
{
// if type is null => ask handler whether it can handle the value
// OR if types match, this handler can handle values of this type
// => BUT we still need to ask as the handler may not be able to handle ALL values of this type.
if (serializer.canHandle(value))
{
matchedSerializers.Add(serializer);
if (serializer.Type.PrimitiveValueType)
{
break;
}
}
}
}
if (matchedSerializers.Count == 0)
{
if (fallBackSerializerFactory != null)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: TypedValueSerializer<?> serializer = fallBackSerializerFactory.getSerializer(value);
TypedValueSerializer <object> serializer = fallBackSerializerFactory.getSerializer(value);
if (serializer != null)
{
return(serializer);
}
}
throw new ProcessEngineException("Cannot find serializer for value '" + value + "'.");
}
else if (matchedSerializers.Count == 1)
{
return(matchedSerializers[0]);
}
else
{
// ambiguous match, use default serializer
if (!string.ReferenceEquals(defaultSerializationFormat, null))
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (TypedValueSerializer<?> typedValueSerializer : matchedSerializers)
foreach (TypedValueSerializer <object> typedValueSerializer in matchedSerializers)
{
if (defaultSerializationFormat.Equals(typedValueSerializer.SerializationDataformat))
{
return(typedValueSerializer);
}
}
}
// no default serialization dataformat defined or default dataformat cannot serialize this value => use first serializer
return(matchedSerializers[0]);
}
}
public virtual VariableSerializers removeSerializer <T1>(TypedValueSerializer <T1> serializer)
{
serializerList.Remove(serializer);
serializerMap.Remove(serializer.Name);
return(this);
}
public virtual int getSerializerIndex <T1>(TypedValueSerializer <T1> serializer)
{
return(serializerList.IndexOf(serializer));
}
public virtual DefaultVariableSerializers addSerializer <T1>(TypedValueSerializer <T1> serializer, int index)
{
serializerList.Insert(index, serializer);
serializerMap[serializer.Name] = serializer;
return(this);
}
public virtual DefaultVariableSerializers addSerializer <T1>(TypedValueSerializer <T1> serializer)
{
return(addSerializer(serializer, serializerList.Count));
}
