Robotics Service Bus

using System;

namespace Rsb.Converter

{

    internal class ByteConverter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "bytes";

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

        {

            if (data.Item1 != WIRE_SCHEMA)

            {

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

            }

            return data.Item2;

        }

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

        {

            return new Tuple<string, byte[]>(WIRE_SCHEMA, (byte[]) data);

        }

    }

}

using System;

using System.Collections.Generic;

namespace Rsb.Converter

{

    public class DefaultConverterRepository

    {

        private static readonly DefaultConverterRepository instance = new DefaultConverterRepository();

        private List<Tuple<PredicateConverterSelection<string>.Predicate, IConverter>> listenerConverterList = new List<Tuple<PredicateConverterSelection<string>.Predicate, IConverter>>();

        private PredicateConverterSelection<string> listenerConverterSelector = null;

        public PredicateConverterSelection<string> ListenerConverterSelector { get => listenerConverterSelector; }

        private List<Tuple<PredicateConverterSelection<Type>.Predicate, IConverter>> informerConverterList = new List<Tuple<PredicateConverterSelection<Type>.Predicate, IConverter>>();

        private PredicateConverterSelection<Type> informerConverterSelector = null;

        public PredicateConverterSelection<Type> InformerConverterSelector { get => informerConverterSelector; }

        private readonly Tuple<string, IConverter>[] defaultConverter = {

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

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

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

            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>("bool", new BoolConverter()),

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

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

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

            //new Tuple<string, IConverter>("scope", new NullConverter()),

        };

        private readonly Dictionary<string, Type> defaultTypeNames = new Dictionary<string, Type>

        {

            {"void", typeof(Null)},

            {"double", typeof(double)},

            {"float", typeof(float)},

            {"int32", typeof(int)},

            {"int64", typeof(long)},

            {"uint32", typeof(uint)},

            {"uint64", typeof(ulong)},

            { "bool", typeof(bool)},

            {"utf-8-string", typeof(string)},

            {"bytes", typeof(byte[])},

            {"scope", typeof(Scope)}

        };

        // Explicit static constructor to tell C# compiler

        // not to mark type as beforefieldinit

        static DefaultConverterRepository()

        {

        }

        private DefaultConverterRepository()

        {

            foreach (var type in defaultConverter) {

                listenerConverterList.Add(

                    new Tuple<PredicateConverterSelection<string>.Predicate, IConverter>(

                        new IsExactMatch<string>(type.Item1),

                        type.Item2

                        ));

                // will just send utf8

                if (type.Item1.Equals("ascii-string")) {

                    continue;

                }

                informerConverterList.Add(

                    new Tuple<PredicateConverterSelection<Type>.Predicate, IConverter>(

                        new IsExactMatch<Type>(defaultTypeNames[type.Item1]),

                        type.Item2

                        ));

            }

            listenerConverterSelector = new PredicateConverterSelection<string>(listenerConverterList);

            informerConverterSelector = new PredicateConverterSelection<Type>(informerConverterList);

        }

        public static DefaultConverterRepository Instance

        {

            get

            {

                return instance;

            }

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class DoubleConverter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "double";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

using System;

namespace Rsb.Converter 

{

    internal class FloatConverter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "float";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class Int32Converter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "int32";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class Int64Converter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "int64";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class NullConverter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "void";

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

        {

            if (data.Item1 != WIRE_SCHEMA)

            {

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

            }

            return null;

        }

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

        {

            return new Tuple<string, byte[]>(WIRE_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;

            }

        }

    } 

}

using System;

namespace Rsb.Converter

{

    internal class StringConverter : IConverter

    {

        private System.Text.Encoding Encoding;

        private bool isUTF8;

        private static readonly string WIRE_SCHEMA_UTF8 = "utf-8-string";

        private static readonly string WIRE_SCHEMA_ASCII = "ascii-string";

        public StringConverter(bool utf8 = true) {

            this.isUTF8 = utf8;

            if (utf8)

            {

                Encoding = new System.Text.UTF8Encoding();

            }

            else {

                Encoding = new System.Text.ASCIIEncoding();

            }

        }

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

        {

            if (

                (isUTF8  && data.Item1 != WIRE_SCHEMA_UTF8) ||

                (!isUTF8 && data.Item1 != WIRE_SCHEMA_ASCII) )

            {

                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[]>(isUTF8 ? WIRE_SCHEMA_UTF8 : WIRE_SCHEMA_ASCII, Encoding.GetBytes(data.ToString()));

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class UInt32Converter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "uint32";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

using System;

namespace Rsb.Converter

{

    internal class UInt64Converter : IConverter

    {

        private static readonly string WIRE_SCHEMA = "uint64";

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

        {

            if (data.Item1 != WIRE_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 Tuple<string, byte[]> Serialize(object data)

        {

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

        }

    }

}

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

    <Compile Include="Rsb\Converter\DefaultConverterRepository.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" />