public virtual ITypedValue SetValue(ITypedValue value)
{
// determine serializer to use
serializer = Serializers.FindSerializerForValue(value,
Context.ProcessEngineConfiguration.FallbackSerializerFactory);
serializerName = serializer.Name;
if (value is UntypedValueImpl)
{
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 (isNotifyOnImplicitUpdates && IsMutableValue(cachedValue))
{
Context.CommandContext.RegisterCommandContextListener(this);
}
return(value);
}
public virtual IVariableSerializers Join(IVariableSerializers other)
{
var copy = new DefaultVariableSerializers();
// "other" serializers override existing ones if their names match
foreach (var thisSerializer in serializerMap.Values)
{
ITypedValueSerializer 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
foreach (ITypedValueSerializer otherSerializer in other.Serializers)
{
if (!copy.serializerMap.ContainsKey(otherSerializer.Name))
{
copy.AddSerializer(otherSerializer);
}
}
return(copy);
}
protected internal virtual void EnsureSerializerInitialized()
{
if ((serializerName != null) && (serializer == null))
{
serializer = Serializers.GetSerializerByName(serializerName);
if (serializer == null)
{
serializer = GetFallbackSerializer(serializerName);
}
if (serializer == null)
{
throw Log.SerializerNotDefinedException(this);
}
}
}
public virtual ITypedValueSerializer FindSerializerForValue(ITypedValue value,
IVariableSerializerFactory fallBackSerializerFactory)
{
var defaultSerializationFormat = Context.ProcessEngineConfiguration.DefaultSerializationFormat;
IList <ITypedValueSerializer> matchedSerializers =
new List <ITypedValueSerializer>();
IValueType type = value.Type;
if (type != null && type.IsAbstract)
{
throw new ProcessEngineException("Cannot serialize value of abstract type " + type.Name);
}
foreach (var serializer in serializerMap.Values)
{
if (type == null || serializer.Type.Equals(type))
{
if (serializer.CanHandle(value))
{
matchedSerializers.Add(serializer);
if (serializer.Type.IsPrimitiveValueType)
{
break;
}
}
}
}
if (matchedSerializers.Count == 0)
{
if (fallBackSerializerFactory != null)
{
ITypedValueSerializer serializer = fallBackSerializerFactory.GetSerializer <ITypedValue>(value);
if (serializer != null)
{
return(serializer);
}
}
throw new ProcessEngineException("Cannot find serializer for value '" + value + "'.");
}
if (matchedSerializers.Count == 1)
{
return(matchedSerializers[0]);
}
// ambiguous match, use default serializer
if (!ReferenceEquals(defaultSerializationFormat, null))
{
foreach (var 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 IVariableSerializers RemoveSerializer(ITypedValueSerializer serializer)
{
serializerMap.Remove(serializer.Name);
return(this);
}
public virtual IVariableSerializers AddSerializer(ITypedValueSerializer serializer, int index)
{
serializerMap[serializer.Name] = serializer;
return(this);
}
public virtual IVariableSerializers AddSerializer(ITypedValueSerializer serializer)
{
return(AddSerializer(serializer, serializerMap.Count));
}
