private void SerializeValue(SerializationContext context, RosBinaryWriter writer, RosType rosType, Type type,
object value)
{
if (rosType.IsBuiltIn)
{
writer.WriteBuiltInType(rosType, value);
}
else
{
var typeInfo = context.MessageTypeRegistry.GetOrCreateMessageTypeInfo(type);
IRosMessageFormatter formatter = this;
// If this serializer cannot serialize the object search for serializer who can do it
if (!CanSerialize(typeInfo))
{
formatter = context.MessageFormatters.FindFormatterFor(typeInfo);
if (formatter == null)
{
throw new NotSupportedException($"No formatter for message {typeInfo} found.");
}
}
formatter.Serialize(context, writer, typeInfo, value);
}
}
public void Serialize(SerializationContext context, RosBinaryWriter writer, IRosMessageTypeInfo messageTypeInfo,
object o)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (o == null)
{
throw new ArgumentNullException(nameof(o));
}
if (!(messageTypeInfo is DescriptorBasedMessageTypeInfo messageInfo))
{
throw new NotSupportedException("MessageTypeInfo is no DescriptorBasedMessageTypeInfo");
}
var fields = messageInfo.MessageDescriptor.Fields;
foreach (var field in fields)
{
try
{
var value = field.GetValue(o);
if (field.RosType.IsArray)
{
SerializeArray(context, writer, field.RosType, field.Type, value);
}
else
{
SerializeValue(context, writer, field.RosType, field.Type, value);
}
}
catch (Exception e)
{
if (e is RosFieldSerializationException rosException)
{
rosException.AddLeadingRosIdentifier(field.RosIdentifier);
throw;
}
else
{
throw new RosFieldSerializationException(RosFieldSerializationException.SerializationOperation.Serialize, field.RosIdentifier, e);
}
}
}
}
public void Serialize(object message, Stream output)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var messageTypeInfo = MessageTypeRegistry.GetOrCreateMessageTypeInfo(message.GetType());
var formatter = GetFormatter(messageTypeInfo);
var context = new SerializationContext(output, MessageFormatters, MessageTypeRegistry);
var writer = new RosBinaryWriter(output);
formatter.Serialize(context, writer, messageTypeInfo, message);
}
private void SerializeArray(SerializationContext context, RosBinaryWriter writer, RosType rosType, Type memberType,
object value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var collection = value as ICollection;
if (collection == null)
{
throw new InvalidCastException("Value does not implement System.ICollection.");
}
var elementCount = collection.Count;
if (rosType.IsFixedSizeArray)
{
if (rosType.ArraySize != elementCount)
{
throw new InvalidOperationException(
$"Expected array size of {rosType.ArraySize} but found array size of {elementCount}.");
}
}
else
{
writer.Write(elementCount);
}
if (elementCount == 0)
{
return;
}
var elementType = GetGenericElementType(memberType);
var index = -1;
foreach (var item in collection)
{
index++;
try
{
SerializeValue(context, writer, rosType, elementType, item);
}
catch (Exception e)
{
var indexString = $"[{index}]";
if (e is RosFieldSerializationException rosException)
{
rosException.AddLeadingRosIdentifier(indexString);
throw;
}
else
{
throw new RosFieldSerializationException(RosFieldSerializationException.SerializationOperation.Serialize, indexString, e);
}
}
}
}
