Robotics Service Bus

            Console.WriteLine("\nConverter test:");

            var defaultInConverters = buildConverterSelection(new List<Tuple<String, IConverter>> {

                new Tuple<string, IConverter>("ascii-string",                        new StringConverter(false)                        ),

                new Tuple<string, IConverter>("utf-8-string",                        new StringConverter(true)                         ),

                new Tuple<string, IConverter>("int32",                               new Int32Converter()                              ),

                new Tuple<string, IConverter>("int64",                               new Int64Converter()                              ),

                new Tuple<string, IConverter>("uint32",                              new UInt32Converter()                             ),

                new Tuple<string, IConverter>("uint64",                              new UInt64Converter()                             ),

                new Tuple<string, IConverter>("float",                               new FloatConverter()                              ),

                new Tuple<string, IConverter>("double",                              new DoubleConverter()                             ),

                new Tuple<string, IConverter>("bool",                                new BoolConverter()                               ),

                new Tuple<string, IConverter>("bytes",                               new ByteConverter()                               ),

                new Tuple<string, IConverter>("void",                                new NullConverter()                               ),

                new Tuple<string, IConverter>("." + JointAngles.Descriptor.FullName, new ProtocolBufferConverter(JointAngles.Descriptor))

            });

            var defaultOutConverters = buildConverterSelection(new List<Tuple<Type, IConverter>> {

                new Tuple<Type, IConverter>(typeof(string),                          new StringConverter(true)                         ),

                new Tuple<Type, IConverter>(typeof(int),                             new Int32Converter()                              ),

                new Tuple<Type, IConverter>(typeof(long),                            new Int64Converter()                              ),

                new Tuple<Type, IConverter>(typeof(uint),                            new UInt32Converter()                             ),

                new Tuple<Type, IConverter>(typeof(ulong),                           new UInt64Converter()                             ),

                new Tuple<Type, IConverter>(typeof(float),                           new FloatConverter()                              ),

                new Tuple<Type, IConverter>(typeof(double),                          new DoubleConverter()                             ),

                new Tuple<Type, IConverter>(typeof(bool),                            new BoolConverter()                               ),

                new Tuple<Type, IConverter>(typeof(byte[]),                          new ByteConverter()                               ),

                new Tuple<Type, IConverter>(typeof(Null),                            new NullConverter()                               ),

                new Tuple<Type, IConverter>(typeof(JointAngles),                     new ProtocolBufferConverter(JointAngles.Descriptor))

            });

            Informer repoInformer = new Informer("/test/repo", new OutConnector(new BusClientConnection(host, port), defaultOutConverters));

            Listener repoListener = new Listener(new InPushConnector(new BusClientConnection(host, port), new Scope("/"), defaultInConverters));

            repoListener.EventReceived += (e) => {

                Console.WriteLine("Event: {0}\nData: {1}", e, e.Data);

            };

            repoListener.Activate();

            repoInformer.Activate();

            //test string

            repoInformer.Send("Teest");

            //test bool

            repoInformer.Send(true);

            //test int

            repoInformer.Send(42);

            //test long (int64

            repoInformer.Send((long)42);

            //test for uint32 

            repoInformer.Send((uint)4242);

            //test for uint64

            repoInformer.Send((ulong)4242);

            //test double

            repoInformer.Send(4.2);

            //test float

            repoInformer.Send((float)4.2);

            //test byte[]

            byte[] test = { 12, 13, 14, 255 };

            repoInformer.Send(test);

            //test void

            repoInformer.Send(Null.Instance);

            // protobuf type

            var jointAngles = new JointAngles();

            for (int i = 0; i < 5; i++)

            {

                jointAngles.Angles.Add(i);

                repoInformer.Send(jointAngles);

            }

            repoInformer.Deactivate();

            Console.ReadKey();

            repoListener.Deactivate();

        }

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("bool", typeof(bool));

			if (data.Item1 != SIGNATURE.Schema)

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

			return new Tuple<string, byte[]>(SIGNATURE.Schema, ((bool)data) ? new byte[] { 1 } : new byte[] { 0 });

using System;

namespace Rsb.Converter

{

    public class ByteConverter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("bytes", typeof(byte[]));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            return data.Item2;

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, (byte[]) data);

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Rsb.Converter

{

    public class ConverterSignature

    {

        private String schema;

        private Type dataType;

        public String Schema { get => schema; }

        public Type DataType { get => dataType; }

        public ConverterSignature(String schema, Type dataType)

        {

            this.schema = schema;

            this.dataType = dataType;

        }

        public override int GetHashCode()

        {

            int prime = 31;

            int result = 1;

            result = prime * result + this.dataType.GetHashCode();

            result = prime * result + this.schema.GetHashCode();

            return result;

        }

        public override bool Equals(Object obj)

        {

            if (this == obj)

            {

                return true;

            }

            if (obj == null)

            {

                return false;

            }

            ConverterSignature rhs = obj as ConverterSignature;

            if (rhs == null) {

                return false;

            }

            if (!this.dataType.Equals(rhs.dataType))

            {

                return false;

            }

            if (!this.schema.Equals(rhs.schema))

            {

                return false;

            }

            return true;

        }

        public override String ToString()

        {

            return "ConverterSignature [schema=" + this.schema + ", datatype="

                    + this.dataType + "]";

        }

    }

}

using System;

namespace Rsb.Converter

{

    public class DoubleConverter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("double", typeof(double));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 8)

            {

                throw new ConversionException("Data of type double must have length 8. Received: " + data.Item2.Length);

            }

            return BitConverter.ToDouble(data.Item2, 0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((double)data));

        }

    }

}

using System;

namespace Rsb.Converter 

{

    public class FloatConverter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("float", typeof(float));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 4)

            {

                throw new ConversionException("Data of type float must have length 4. Received: " + data.Item2.Length);

            }

            return BitConverter.ToSingle(data.Item2, 0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((float)data));

        }

    }

}

        ConverterSignature GetSignature();

using System;

namespace Rsb.Converter

{

    public class Int32Converter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("int32", typeof(int));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 4)

            {

                throw new ConversionException("Data of type int32 must have length 4. Received: " + data.Item2.Length);

            }

            return BitConverter.ToInt32(data.Item2,0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((int) data));

        }

    }

}

using System;

namespace Rsb.Converter

{

    public class Int64Converter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("int64", typeof(long));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 8)

            {

                throw new ConversionException("Data of type int64 must have length 8. Received: " + data.Item2.Length);

            }

            return BitConverter.ToInt64(data.Item2, 0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((long)data));

        }

    }

}

using System;

namespace Rsb.Converter

{

    public class NullConverter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("void", typeof(Null));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            return null;

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, new byte[0]);

        }

    }

    public sealed class Null {

        private static readonly Null instance = new Null();

        // Explicit static constructor to tell C# compiler

        // not to mark type as beforefieldinit

        static Null()

        {

        }

        private Null()

        {

        }

        public static Null Instance

        {

            get

            {

                return instance;

            }

        }

    } 

}

    public class ProtocolBufferConverter : IConverter 

    {

        private ConverterSignature SIGNATURE;

        private MessageDescriptor descriptor;

        public ProtocolBufferConverter(MessageDescriptor descriptor)

        {

            SIGNATURE = new ConverterSignature("." + descriptor.FullName, descriptor.ClrType);

            this.descriptor = descriptor;

        }

			if (data.Item1 != SIGNATURE.Schema)

				throw new ConversionException("Cannot deserialize data of type " + data.Item1 + ". Expecting " + SIGNATURE.Schema);

			return new Tuple<string, byte[]>(SIGNATURE.Schema, message.ToByteArray());

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

    }

using System;

namespace Rsb.Converter

{

    public class StringConverter : IConverter

    {

        private System.Text.Encoding Encoding;

        private ConverterSignature SIGNATURE;

        public StringConverter(bool utf8 = true) {

            if (utf8)

            {

                Encoding = new System.Text.UTF8Encoding();

                SIGNATURE = new ConverterSignature("utf-8-string", typeof(string));

            }

            else {

                Encoding = new System.Text.ASCIIEncoding();

                SIGNATURE = new ConverterSignature("ascii-string", typeof(string));

            }

        }

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            return Encoding.GetString(data.Item2);

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, Encoding.GetBytes(data.ToString()));

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

    }

}

using System;

namespace Rsb.Converter

{

    public class UInt32Converter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("uint32", typeof(uint));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 4)

            {

                throw new ConversionException("Data of type uint32 must have length 4. Received: " + data.Item2.Length);

            }

            return BitConverter.ToUInt32(data.Item2, 0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((uint)data));

        }

    }

}

using System;

namespace Rsb.Converter

{

    public class UInt64Converter : IConverter

    {

        private static readonly ConverterSignature SIGNATURE = new ConverterSignature("uint64", typeof(ulong));

        public object Deserialize(Tuple<string, byte[]> data)

        {

            if (data.Item1 != SIGNATURE.Schema)

            {

                throw new ConversionException("Unexpected wire schema for deserialization: " + data.Item1);

            }

            if (data.Item2.Length != 8)

            {

                throw new ConversionException("Data of type uint64 must have length 8. Received: " + data.Item2.Length);

            }

            return BitConverter.ToUInt64(data.Item2, 0);

        }

        public ConverterSignature GetSignature()

        {

            return SIGNATURE;

        }

        public Tuple<string, byte[]> Serialize(object data)

        {

            return new Tuple<string, byte[]>(SIGNATURE.Schema, BitConverter.GetBytes((ulong)data));

        }

    }

}

    <Compile Include="Rsb\Converter\ByteConverter.cs" />

    <Compile Include="Rsb\Converter\ConverterSignature.cs" />

    <Compile Include="Rsb\Converter\DoubleConverter.cs" />

    <Compile Include="Rsb\Converter\FloatConverter.cs" />

    <Compile Include="Rsb\Converter\Int32Converter.cs" />

    <Compile Include="Rsb\Converter\Int64Converter.cs" />

    <Compile Include="Rsb\Converter\NullConverter.cs" />

    <Compile Include="Rsb\Converter\StringConverter.cs" />

    <Compile Include="Rsb\Converter\UInt32Converter.cs" />

    <Compile Include="Rsb\Converter\UInt64Converter.cs" />