public override T readValue(ValueFields valueFields, bool deserializeObjectValue)
{
sbyte[] serializedByteValue = readSerializedValueFromFields(valueFields);
string serializedStringValue = getSerializedStringValue(serializedByteValue);
if (deserializeObjectValue)
{
object deserializedObject = null;
if (serializedByteValue != null)
{
try
{
deserializedObject = deserializeFromByteArray(serializedByteValue, valueFields);
}
catch (Exception e)
{
throw new ProcessEngineException("Cannot deserialize object in variable '" + valueFields.Name + "': " + e.Message, e);
}
}
T value = createDeserializedValue(deserializedObject, serializedStringValue, valueFields);
return(value);
}
else
{
return(createSerializedValue(serializedStringValue, valueFields));
}
}
public virtual void writeValue(ObjectValue objectValue, ValueFields valueFields)
{
EntityManagerSession entityManagerSession = Context.CommandContext.getSession(typeof(EntityManagerSession));
if (entityManagerSession == null)
{
throw new ProcessEngineException("Cannot set JPA variable: " + typeof(EntityManagerSession) + " not configured");
}
else
{
// Before we set the value we must flush all pending changes from the entitymanager
// If we don't do this, in some cases the primary key will not yet be set in the object
// which will cause exceptions down the road.
entityManagerSession.flush();
}
object value = objectValue.Value;
if (value != null)
{
string className = mappings.getJPAClassString(value);
string idString = mappings.getJPAIdString(value);
valueFields.TextValue = className;
valueFields.TextValue2 = idString;
}
else
{
valueFields.TextValue = null;
valueFields.TextValue2 = null;
}
}
public override FileValue readValue(ValueFields valueFields, bool deserializeValue)
{
string fileName = valueFields.TextValue;
if (string.ReferenceEquals(fileName, null))
{
// ensure file name is not null
fileName = "";
}
FileValueBuilder builder = Variables.fileValue(fileName);
if (valueFields.ByteArrayValue != null)
{
builder.file(valueFields.ByteArrayValue);
}
// to ensure the same array size all the time
if (!string.ReferenceEquals(valueFields.TextValue2, null))
{
string[] split = Arrays.copyOf(valueFields.TextValue2.Split(MIMETYPE_ENCODING_SEPARATOR, NR_OF_VALUES_IN_TEXTFIELD2), NR_OF_VALUES_IN_TEXTFIELD2);
string mimeType = returnNullIfEmptyString(split[0]);
string encoding = returnNullIfEmptyString(split[1]);
builder.mimeType(mimeType);
builder.encoding(encoding);
}
return(builder.create());
}
protected internal virtual void writeToValueFields(ObjectValue value, ValueFields valueFields, sbyte[] serializedValue)
{
string objectTypeName = getObjectTypeName(value, valueFields);
valueFields.ByteArrayValue = serializedValue;
valueFields.TextValue2 = objectTypeName;
}
public override ObjectValue readValue(ValueFields valueFields, bool deserializeObjectValue)
{
if (!string.ReferenceEquals(valueFields.TextValue, null) && !string.ReferenceEquals(valueFields.TextValue2, null))
{
object jpaEntity = mappings.getJPAEntity(valueFields.TextValue, valueFields.TextValue2);
return(Variables.objectValue(jpaEntity).create());
}
return(Variables.objectValue(null).create());
}
public override IntegerValue readValue(ValueFields valueFields)
{
int?intValue = null;
if (valueFields.LongValue != null)
{
intValue = Convert.ToInt32(valueFields.LongValue.Value);
}
return(Variables.integerValue(intValue));
}
public override DateValue readValue(ValueFields valueFields)
{
long? longValue = valueFields.LongValue;
DateTime dateValue = null;
if (longValue != null)
{
dateValue = new DateTime(longValue);
}
return(Variables.dateValue(dateValue));
}
public virtual void writeValue(BooleanValue variableValue, ValueFields valueFields)
{
long?longValue = null;
bool?boolValue = variableValue.Value;
if (boolValue != null)
{
longValue = boolValue ? TRUE : FALSE;
}
valueFields.LongValue = longValue;
}
public override BooleanValue readValue(ValueFields valueFields)
{
bool?boolValue = null;
long?longValue = valueFields.LongValue;
if (longValue != null)
{
boolValue = longValue.Equals(TRUE);
}
return(Variables.booleanValue(boolValue));
}
public override ShortValue readValue(ValueFields valueFields)
{
long? longValue = valueFields.LongValue;
short?shortValue = null;
if (longValue != null)
{
shortValue = Convert.ToInt16(longValue.Value);
}
return(Variables.shortValue(shortValue));
}
public virtual void writeValue(DateValue typedValue, ValueFields valueFields)
{
DateTime dateValue = typedValue.Value;
if (dateValue != null)
{
valueFields.LongValue = dateValue.Ticks;
}
else
{
valueFields.LongValue = null;
}
}
public virtual void writeValue(IntegerValue variableValue, ValueFields valueFields)
{
int?value = variableValue.Value;
if (value != null)
{
valueFields.LongValue = ((int?)value).Value;
valueFields.TextValue = value.ToString();
}
else
{
valueFields.LongValue = null;
valueFields.TextValue = null;
}
}
public virtual void writeValue(ShortValue value, ValueFields valueFields)
{
short?shortValue = value.Value;
if (shortValue != null)
{
valueFields.LongValue = shortValue.Value;
valueFields.TextValue = value.ToString();
}
else
{
valueFields.LongValue = null;
valueFields.TextValue = null;
}
}
public virtual void writeValue(LongValue value, ValueFields valueFields)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final System.Nullable<long> longValue = value.getValue();
long?longValue = value.Value;
valueFields.LongValue = longValue;
if (longValue != null)
{
valueFields.TextValue = longValue.ToString();
}
else
{
valueFields.TextValue = null;
}
}
protected internal virtual string getObjectTypeName(ObjectValue value, ValueFields valueFields)
{
string objectTypeName = value.ObjectTypeName;
if (string.ReferenceEquals(objectTypeName, null) && !value.Deserialized && value.ValueSerialized != null)
{
throw new ProcessEngineException("Cannot write serialized value for variable '" + valueFields.Name + "': no 'objectTypeName' provided for non-null value.");
}
// update type name if the object is deserialized
if (value.Deserialized && value.Value != null)
{
objectTypeName = getTypeNameForDeserialized(value.Value);
}
return(objectTypeName);
}
public virtual void writeValue(FileValue value, ValueFields valueFields)
{
sbyte[] data = ((FileValueImpl)value).ByteArray;
valueFields.ByteArrayValue = data;
valueFields.TextValue = value.Filename;
if (value.MimeType == null && value.Encoding != null)
{
valueFields.TextValue2 = MIMETYPE_ENCODING_SEPARATOR + value.Encoding;
}
else if (value.MimeType != null && value.Encoding == null)
{
valueFields.TextValue2 = value.MimeType + MIMETYPE_ENCODING_SEPARATOR;
}
else if (value.MimeType != null && value.Encoding != null)
{
valueFields.TextValue2 = value.MimeType + MIMETYPE_ENCODING_SEPARATOR + value.Encoding;
}
}
public override void writeValue(T value, ValueFields valueFields)
{
string serializedStringValue = value.ValueSerialized;
sbyte[] serializedByteValue = null;
if (value.Deserialized)
{
object objectToSerialize = value.Value;
if (objectToSerialize != null)
{
// serialize to byte array
try
{
serializedByteValue = serializeToByteArray(objectToSerialize);
serializedStringValue = getSerializedStringValue(serializedByteValue);
}
catch (Exception e)
{
throw new ProcessEngineException("Cannot serialize object in variable '" + valueFields.Name + "': " + e.Message, e);
}
}
}
else
{
if (!string.ReferenceEquals(serializedStringValue, null))
{
serializedByteValue = getSerializedBytesValue(serializedStringValue);
}
}
// write value and type to fields.
writeToValueFields(value, valueFields, serializedByteValue);
// update the ObjectValue to keep it consistent with value fields.
updateTypedValue(value, serializedStringValue);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected Object deserializeFromByteArray(byte[] object, ValueFields valueFields) throws Exception
protected internal override object deserializeFromByteArray(sbyte[] @object, ValueFields valueFields)
{
string objectTypeName = readObjectNameFromFields(valueFields);
return(deserializeFromByteArray(@object, objectTypeName));
}
public virtual void writeValue(BytesValue variableValue, ValueFields valueFields)
{
valueFields.ByteArrayValue = variableValue.Value;
}
public override BytesValue readValue(ValueFields valueFields)
{
return(Variables.byteArrayValue(valueFields.ByteArrayValue));
}
/// <summary>
/// Deserialize the object from a byte array.
/// </summary>
/// <param name="object"> the object to deserialize </param>
/// <param name="valueFields"> the value fields </param>
/// <returns> the deserialized object </returns>
/// <exception cref="exception"> in case the object cannot be deserialized </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected abstract Object deserializeFromByteArray(byte[] object, ValueFields valueFields) throws Exception;
protected internal abstract object deserializeFromByteArray(sbyte[] @object, ValueFields valueFields);
protected internal virtual sbyte[] readSerializedValueFromFields(ValueFields valueFields)
{
return(valueFields.ByteArrayValue);
}
public override StringValue readValue(ValueFields valueFields)
{
return(Variables.stringValue(valueFields.TextValue));
}
protected internal override ObjectValue createSerializedValue(string serializedStringValue, ValueFields valueFields)
{
string objectTypeName = readObjectNameFromFields(valueFields);
return(new ObjectValueImpl(null, serializedStringValue, serializationDataFormat, objectTypeName, false));
}
protected internal override ObjectValue createDeserializedValue(object deserializedObject, string serializedStringValue, ValueFields valueFields)
{
string objectTypeName = readObjectNameFromFields(valueFields);
return(new ObjectValueImpl(deserializedObject, serializedStringValue, serializationDataFormat, objectTypeName, true));
}
protected internal abstract T createDeserializedValue(object deserializedObject, string serializedStringValue, ValueFields valueFields);
protected internal virtual string readObjectNameFromFields(ValueFields valueFields)
{
return(valueFields.TextValue2);
}
protected internal abstract T createSerializedValue(string serializedStringValue, ValueFields valueFields);
public virtual void writeValue(StringValue variableValue, ValueFields valueFields)
{
valueFields.TextValue = variableValue.Value;
}
protected internal abstract void writeToValueFields(T value, ValueFields valueFields, sbyte[] serializedValue);
