Robotics Service Bus

        static readonly SocketOptions options = new SocketOptions("localhost", 30010, true);

            var listener = new Listener(new SocketInPushConnector(new BusClientConnection(options), inConverters));

            var informer = new Informer("/test/narf", new SocketOutConnector(new BusClientConnection(options),

            DefaultConverterRepository.Instance.AddConverter(new ProtocolBufferConverter(JointAngles.Descriptor));

            var futureEcho = remote.CallAsync<string, string>("echo", "Async");

    }

using System;

using System.Collections.Generic;

using System.Text;

namespace Rsb.Config

{

    /**

     * Like the Java version but...

     *  - no Introspection

     *  - no receivingStrategy!

     */

    public class ParticipantConfig

    {

        public Dictionary<String, TransportConfig> TransportsByName

        {

            get;

        } = new Dictionary<String, TransportConfig>();

        public HashSet<TransportConfig> EnabledTransports

        {

            get

            {

                HashSet<TransportConfig> enabledTransports =

                        new HashSet<TransportConfig>();

                foreach (TransportConfig config in this.TransportsByName.Values)

                {

                    if (config.Enabled)

                    {

                        enabledTransports.Add(config);

                    }

                }

                return enabledTransports;

            }

        }

        public bool HasTransport(String name)

        {

            return this.TransportsByName.ContainsKey(name);

        }

        public TransportConfig GetOrCreateTransport(String transportName)

        {

            if (this.TransportsByName.ContainsKey(transportName))

            {

                return this.TransportsByName[transportName];

            }

            else

            {

                TransportConfig newTransport =

                        new TransportConfig(transportName);

                this.TransportsByName[transportName] = newTransport;

                return newTransport;

            }

        }

        public ParticipantConfig Copy()

        {

            ParticipantConfig copy = new ParticipantConfig();

            foreach (var transportName in this.TransportsByName.Keys)

            {

                copy.TransportsByName[transportName] = TransportsByName[transportName].Copy();

            }

            return copy;

        }

        public override String ToString()

        {

            StringBuilder builder = new StringBuilder(57);

            builder.Append(GetType().Name);

            builder.Append("[transports={");

            bool first = true;

            foreach (var transport in TransportsByName.Values)

            {

                if (first)

                {

                    first = false;

                }

                else

                {

                    builder.Append(",");

                }

                builder.Append(transport.ToString());

            }

            builder.Append("}]");

            return builder.ToString();

        }

        public override int GetHashCode()

        {

            int result = 17 * this.TransportsByName.GetHashCode();

            return result;

        }

        public override bool Equals(object obj)

        {

            if (!(obj.GetType().Equals(typeof(ParticipantConfig))))

            {

                return false;

            }

            ParticipantConfig other = (ParticipantConfig)obj;

            return this.TransportsByName.Equals(other.TransportsByName);

        }

    }

}

using Rsb.Transport;

using Rsb.Util;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Rsb.Config

{

    /**

     * like java implementation but...

     * - without introspection

     */

    public class ParticipantConfigCreator

    {

        public ParticipantConfig Create(Properties properties)

        {

            ParticipantConfig config = new ParticipantConfig();

            Reconfigure(config, properties);

            return config;

        }

        public void Reconfigure(ParticipantConfig config, Properties properties)

        {

            foreach (String transportName in TransportRegistry.Instance.AvailableTransportNames)

            {

                String transportPropPrefix = "transport." + transportName;

                Properties transportProps = properties

                        .Filter(transportPropPrefix);

                HashSet<String> handledKeys = new HashSet<String>();

                TransportConfig transportConfig = config

                        .GetOrCreateTransport(transportName);

                String enabledKey = transportPropPrefix + ".enabled";

                transportConfig.Enabled = transportProps.GetProperty(

                            enabledKey, transportConfig.Enabled).AsBoolean();

                handledKeys.Add(enabledKey);

                transportProps.Remove(handledKeys);

                transportConfig.Options.Merge(transportProps);

            }

        }

    }

}

using Rsb.Converter;

using Rsb.Util;

using System;

using System.Text;

namespace Rsb.Config

{

    public class TransportConfig

    {

        public String Name { get; private set; }

        public bool Enabled { get; set; }

        public Properties Options { get; set; }

        private IConverterRepository _converter;

        public IConverterRepository Converters

        {

            get

            {

                if (_converter == null)

                {

                    return DefaultConverterRepository.Instance;

                }

                else

                {

                    return _converter;

                }

            }

            set

            {

                _converter = value;

            }

        }

        public TransportConfig(String name, bool enabled, Properties options, IConverterRepository converters)

        {

            this.Name = name;

            this.Enabled = enabled;

            this.Options = options;

            this.Converters = converters;

        }

        public TransportConfig(String name) : this(name, false, new Properties(), null)

        {

        }

        public override String ToString()

        {

            StringBuilder builder = new StringBuilder(42);

            builder.Append(GetType().Name);

            builder.Append("[name='");

            builder.Append(this.Name);

            builder.Append("', enabled=");

            builder.Append(this.Enabled);

            builder.Append(", options=");

            builder.Append(this.Options);

            builder.Append(", converters=");

            builder.Append(this.Converters);

            builder.Append(']');

            return builder.ToString();

        }

        public TransportConfig Copy()

        {

            TransportConfig copy = new TransportConfig(Name);

            copy.Enabled = this.Enabled;

            copy.Converters = this.Converters;

            foreach (var key in Options.GetAvailableKeys())

            {

                copy.Options.SetProperty(key, Options.GetProperty(key).AsString());

            }

            return copy;

        }

        public override int GetHashCode()

        {

            int prime = 31;

            int result = 1;

            result =

                    prime * result

                          + ((this.Converters == null) ? 0 : this.Converters.GetHashCode());

            result = prime * result + (this.Enabled ? 1231 : 1237);

            result =

                    prime * result

                            + ((this.Name == null) ? 0 : this.Name.GetHashCode());

            result =

                    prime

                            * result

                            + ((this.Options == null) ? 0 : this.Options.GetHashCode());

            return result;

        }

        public override bool Equals(object obj)

        {

            if (this == obj)

            {

                return true;

            }

            if (obj == null)

            {

                return false;

            }

            if (!(obj.GetType().Equals(typeof(TransportConfig))))

            {

                return false;

            }

            TransportConfig other = (TransportConfig)obj;

            if (this.Converters == null)

            {

                if (other.Converters != null)

                {

                    return false;

                }

            }

            else

            {

                if (!this.Converters.Equals(other.Converters))

                {

                    return false;

                }

            }

            if (this.Enabled != other.Enabled)

            {

                return false;

            }

            if (this.Name == null)

            {

                if (other.Name != null)

                {

                    return false;

                }

            }

            else if (!this.Name.Equals(other.Name))

            {

                return false;

            }

            if (this.Options == null)

            {

                if (other.Options != null)

                {

                    return false;

                }

            }

            else if (!this.Options.Equals(other.Options))

            {

                return false;

            }

            return true;

        }

    }

}

    public class DefaultConverterRepository : IConverterRepository

                AddConverter(converter);

        public void AddConverter(IConverter converter)

using System;

namespace Rsb.Converter

{

    public interface IConverterRepository

    {

        PredicateConverterSelection<string> DeserializationConverterSelector { get; }

        PredicateConverterSelection<Type> SerializationConverterSelector { get; }

        void AddConverter(IConverter converter);

    }

}

using Rsb.Util;

using System;

using Rsb.Config;

using Rsb.Transport;

using System.Collections.Generic;

        private Properties properties = new Properties();

        private ParticipantConfig defaultConfig = new ParticipantConfig();

            TransportRegistry.Instance.RegisterTransport("socket", new SocketFactory());

            new ConfigLoader().Load(this.properties);

            new ParticipantConfigCreator().Reconfigure(this.defaultConfig, this.properties);

        public Informer CreateInformer(Scope scope)

        {

            List<IOutConnector> connectors = new List<IOutConnector>();

            foreach (TransportConfig config in defaultConfig.EnabledTransports)

            {

                connectors.Add(TransportRegistry.Instance.GetFactory(config.Name).CreateOutConnector<Type>(config.Options, config.Converters.SerializationConverterSelector));

            }

            // only one transport can be used right now. Actually, only one transport exists right now...

            return new Informer(scope, connectors[0]);

        public Informer CreateInformer(string scope)

        {

            List<IInPushConnector> connectors = new List<IInPushConnector>();

            foreach (TransportConfig config in defaultConfig.EnabledTransports)

            {

                IInPushConnector connector = TransportRegistry.Instance.GetFactory(config.Name).CreateInPushConnector<string>(config.Options, config.Converters.DeserializationConverterSelector);

                connector.SetScope(scope);

                connectors.Add(connector);

            }

            // only one transport can be used right now. Actually, only one transport exists right now...

            return new Listener(connectors[0]);

        public Listener CreateListener(string scope)

        {

        private IOutConnector connector;

        public Informer(string scope, IOutConnector connector)

        public Informer(Scope scope, IOutConnector connector)

using System;

using System.Collections.Generic;

namespace Rsb.Transport

{

    public class ConnectorInfo

    {

        public String Name { get; private set; }

        public HashSet<String> Schemas { get; private set; }

        public HashSet<String> Options { get; private set; }

        public bool IsRemote { get; private set; }

        public ConnectorInfo(String name,

                             HashSet<String> schemas,

                             HashSet<String> options,

                             bool remote)

        {

            this.Name = name;

            this.Schemas = schemas;

            this.Options = options;

            this.IsRemote = remote;

        }

    }

}

using Rsb.Util;

using Rsb.Util;

namespace Rsb.Transport

{

    public interface IOutConnector : IActivatable

    {

        void Push(Event theEvent);

    }

}

using Rsb.Converter;

using Rsb.Util;

using System;

namespace Rsb.Transport

{

    public interface ITransportFactory

    {

        ConnectorInfo GetInfo();

        IOutConnector CreateOutConnector<KeyType>(Properties properties, IConverterSelectionStrategy<KeyType> converters);

        IInPushConnector CreateInPushConnector<KeyType>(Properties properties, IConverterSelectionStrategy<KeyType> converters);

    }

}

        private bool noDelay;

        public BusClientConnection(SocketOptions options)

            this.host = options.Host;

            this.port = options.Port;

            this.noDelay = options.TcpNoDelay;

            this.client.NoDelay = noDelay;

namespace Rsb.Transport.Socket

{

    public enum ServerMode

    {

        YES,

        NO,

        AUTO

    }

}

using System;

using System.Collections.Generic;

using Rsb.Converter;

using Rsb.Util;

namespace Rsb.Transport.Socket

{

    public class SocketFactory : ITransportFactory

    {

        private static readonly String SCHEMA = "socket";

        private static readonly String SERVER_MODE_NO = "0";

        private static readonly String SERVER_MODE_YES = "1";

        private static readonly String SERVER_MODE_AUTO = "auto";

        private static readonly String PORT_KEY = "transport.socket.port";

        private static readonly int DEFAULT_PORT = 55555;

        private static readonly String HOST_KEY = "transport.socket.host";

        private static readonly String DEFAULT_HOST = "localhost";

        private static readonly String NODELAY_KEY = "transport.socket.tcpnodelay";

        private static readonly bool DEFAULT_NODELAY = true;

        private static readonly String SERVER_MODE_KEY = "transport.socket.server";

        private static readonly String DEFAULT_SERVER_MODE = SERVER_MODE_NO;

        public IInPushConnector CreateInPushConnector<KeyType>(Properties properties, IConverterSelectionStrategy<KeyType> converters)

        {

            ServerMode mode = ParseServerMode(properties);

            return new SocketInPushConnector(

                new BusClientConnection(ParseSocketOptions(properties)), (IConverterSelectionStrategy<string>)converters);

        }

        public IOutConnector CreateOutConnector<KeyType>(Properties properties, IConverterSelectionStrategy<KeyType> converters)

        {

            return new SocketOutConnector(new BusClientConnection(ParseSocketOptions(properties)), (IConverterSelectionStrategy<Type>)converters);

        }

        public ConnectorInfo GetInfo()

        {

            HashSet<String> schemas = new HashSet<String>

            {

                SCHEMA

            };

            HashSet<String> options = new HashSet<String>

            {

                "host",

                "port",

                "server",

                "tcpnodelay"

            };

            return new ConnectorInfo(SCHEMA, schemas, options, true);

        }

        private SocketOptions ParseSocketOptions(Properties properties)

        {

            int port = properties.GetProperty(PORT_KEY, DEFAULT_PORT).AsInteger();

            if (port < 0)

            {

                throw new ArgumentException("Port must be a number >= 0");

            }

            String address = properties.GetProperty(HOST_KEY, DEFAULT_HOST).AsString();

            bool tcpNoDelay = properties.GetProperty(NODELAY_KEY, DEFAULT_NODELAY).AsBoolean();

            return new SocketOptions(address, port, tcpNoDelay);

        }

        private ServerMode ParseServerMode(Properties properties)

        {

            String serverModeString =

                        properties.GetProperty(SERVER_MODE_KEY, DEFAULT_SERVER_MODE)

                                .AsString();

            ServerMode serverMode;

            if (SERVER_MODE_NO.Equals(serverModeString))

            {

                serverMode = ServerMode.NO;

            }

            /* NOT IMPLEMENTED YET

            else if (SERVER_MODE_AUTO.Equals(serverModeString))

            {

                serverMode = ServerMode.AUTO;

            }

            else if (SERVER_MODE_YES.Equals(serverModeString))

            {

                serverMode = ServerMode.YES;

            }

            */

            else

            {

                throw new NotSupportedException(String.Format(

                        "Unsupported server mode '{0}'", serverModeString));

            }

            return serverMode;

        }

    }

}

    /**

     * ServerMode will not be evaluated.

     * Server mode does actually not exist!

     */

    public class SocketInPushConnector : IInPushConnector

        private static readonly log4net.ILog LOGGER = log4net.LogManager.GetLogger(typeof(SocketInPushConnector));

        private Scope scope = new Scope("/"); // default

        public SocketInPushConnector(BusClientConnection connection, IConverterSelectionStrategy<string> inConverters)

            //serverMode ignored

using System;

namespace Rsb.Transport.Socket

{

    public class SocketOptions

    {

        public String Host { get; set; }

        public int Port { get; set; }

        public bool TcpNoDelay { get; set; }

        public SocketOptions(String host, int port, bool tcpNoDelay)

        {

            this.Host = host;

            this.Port = port;

            this.TcpNoDelay = tcpNoDelay;

        }

    }

}

    /**

     * ServerMode will not be evaluated.

     * Server mode does actually not exist!

     */

    public class SocketOutConnector : IOutConnector

        private static readonly log4net.ILog LOGGER = log4net.LogManager.GetLogger(typeof(SocketOutConnector));

        public SocketOutConnector(BusClientConnection connection, IConverterSelectionStrategy<Type> outConverters)

using System;

using System.Collections.Generic;

using System.Linq;

namespace Rsb.Transport

{

    public class TransportRegistry

    {

        private static readonly TransportRegistry instance = new TransportRegistry();

        private Dictionary<String, ITransportFactory> factories = new Dictionary<string, ITransportFactory>();

        public List<String> AvailableTransportNames

        {

            get

            {

                return factories.Keys.ToList();

            }

        }

        // Explicit static constructor to tell C# compiler

        // not to mark type as beforefieldinit

        static TransportRegistry()

        {

        }

        private TransportRegistry()

        {

        }

        public static TransportRegistry Instance

        {

            get

            {

                return instance;

            }

        }

        public bool HasTransport(String name)

        {

            return factories.ContainsKey(name);

        }

        public ITransportFactory GetFactory(String name)

        {

            if (!factories.ContainsKey(name))

            {

                throw new ArgumentException("No transport with name '" + name + "' available.");

            }

            return factories[name];

        }

        public void RegisterTransport(String name, ITransportFactory factory)

        {

            lock (factories)

            {

                if (String.IsNullOrEmpty(name))

                {

                    throw new ArgumentException("Transport name must not be null or empty.");

                }

                if (factories.ContainsKey(name))

                {

                    throw new ArgumentNullException("There is already a transport with name '" + name + "'.");

                }

                if (factory == null)

                {

                    throw new ArgumentNullException("Factory instance must not be null.");

                }

                factories.Add(name, factory);

            }

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Rsb.Util

{

    public class ConfigLoader

    {

        private static readonly String CONFIG_DEBUG_VARIABLE = "RSB_CONFIG_DEBUG";

        private static readonly log4net.ILog LOG = log4net.LogManager.GetLogger(typeof(ConfigLoader));

        private static void WriteDebug1(String output, params object[] refs)

        {

            Console.WriteLine("  " + output, refs);

        }

        private static void WriteDebug2(String output, params object[] refs)

        {

            Console.WriteLine("     " + output, refs);

        }

        private static readonly String CONFIG_FILES_VARIABLE = "RSB_CONFIG_FILES";

        // const - to be able to be used in switch causes

        // const can't be static

        private const String CONFIG_FILE_KEY_SYSTEM = "%system";

        private const String CONFIG_FILE_KEY_PREFIX = "%prefix";

        private const String CONFIG_FILE_KEY_USER = "%user";

        private const String CONFIG_FILE_KEY_PWD = "%pwd";

        private static readonly String ENV_SEPARATOR = "_";

        private static readonly String KEY_SEPARATOR = ".";

        private static readonly String ALL_USER = @"\Users\Public";

        private static readonly String CONFIG_DIRECTORY = ".config"; // C# is more a win thing, thus instead of */etc/*, *\.config\* is considered

        private static readonly String CONFIG_FILE_NAME = "rsb.conf";

        private List<String> configFilePaths = new List<String>(new String[] {

                CONFIG_FILE_KEY_SYSTEM,

                CONFIG_FILE_KEY_USER,

                CONFIG_FILE_KEY_PWD

            }.AsEnumerable());

        private List<String> readFiles = new List<String>();

        private string prefix;

        private string root;

        private string environmentPrefix;

        private bool debug;

        public ConfigLoader(String systemPrefix, String environmentPrefix)

        {

            String customPaths = Environment.GetEnvironmentVariable(CONFIG_FILES_VARIABLE);

            if (customPaths != null)

            {

                configFilePaths = (List<String>)customPaths.Split(':').AsEnumerable();

            }

            this.root = Environment.GetEnvironmentVariable("HOMEDRIVE");

            this.prefix = systemPrefix;

            this.environmentPrefix = environmentPrefix;

            this.debug = (Environment.GetEnvironmentVariable(CONFIG_DEBUG_VARIABLE) != null);

        }

        public ConfigLoader() : this("\\", "RSB_")

        {

        }

        public Properties Load(Properties properties)

        {

            LOG.DebugFormat("Loading properties into {0}", properties);

            this.LoadFiles(properties);

            this.LoadEnv(properties);

            return properties;

        }

        private void LoadFiles(Properties properties)

        {

            LOG.DebugFormat("Loading properties for config files into {0}", properties);

            if (this.debug)

            {

                WriteDebug1("1. Configuration files");

            }

            int index = 1;

            readFiles.Clear();

            foreach (String path in configFilePaths)

            {

                ResolveAndLoadFile(index++, path, properties);

            }

        }

        private void ResolveAndLoadFile(int index, String path, Properties properties)

        {

            switch (path)

            {

                case CONFIG_FILE_KEY_SYSTEM:

                    LoadFile(index,

                        Path.GetFullPath(Path.Combine(root, ALL_USER, CONFIG_DIRECTORY, CONFIG_FILE_NAME)),

                        "System wide config file",

                        properties);

                    break;

                case CONFIG_FILE_KEY_PREFIX:

                    LoadFile(index,

                        Path.GetFullPath(Path.Combine(root, prefix, CONFIG_DIRECTORY, CONFIG_FILE_NAME)),

                        "Prefix wide config file",

                        properties);

                    break;

                case CONFIG_FILE_KEY_USER:

                    LoadFile(index,

                        Path.GetFullPath(Path.Combine(root, Environment.GetEnvironmentVariable("HOMEPATH"), CONFIG_DIRECTORY, CONFIG_FILE_NAME)),

                        "User config file",

                        properties);

                    break;

                case CONFIG_FILE_KEY_PWD:

                    LoadFile(index,

                        Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), CONFIG_FILE_NAME)),

                        "Current directory file",

                        properties);

                    break;

                default:

                    LoadFile(index,

                        path,

                        "User specified config file",

                        properties);

                    break;

            }

        }

        private Properties LoadFile(int index, String path, String description, Properties properties)

        {

            LOG.DebugFormat("Loading properties from {0} into {1} if available", path, properties);

            try

            {

                bool exists = File.Exists(path);

                bool read = readFiles.Contains(path);

                if (this.debug)

                {

                    WriteDebug2("{0}. {1} \"{2}\" {3}", index, description, path, exists ? ("exists" + (read ? " and is already read" : "")) : "does not exist");

                }

                if (exists)

                {

                    LOG.DebugFormat("{0} does exist, loading.", path);

                    if (!read)

                    {

                        this.LoadFile(path, properties);

                    }

                }

            }

            catch (IOException ex)

            {

                LOG.Error(String.Format("Caught IOException trying to read {0}.", path), ex);

            }

            return properties;

        }

        private Properties LoadFile(string path, Properties properties)

        {

            LOG.DebugFormat("Loading properties from file {0} into {1}", path, properties);

            StreamReader reader = new StreamReader(path);

            try

            {

                String section = "";

                while (!reader.EndOfStream)

                {

                    String line = reader.ReadLine();

                    int index = line.IndexOf('#');

                    if (index != -1)

                    {

                        line = line.Substring(0, index);

                    }

                    line = line.Trim();

                    if ("".Equals(line))

                    {

                        continue;

                    }

                    if (line.StartsWith("[") && line.EndsWith("]"))

                    {

                        section = line.Substring(1, line.Length - 2);

                        continue;

                    }

                    index = line.IndexOf('=');

                    if (index == -1)

                    {

                        LOG.WarnFormat("Illegal line in configuration file: `{0}`", line);

                        continue;

                    }

                    String key =

                            section + KEY_SEPARATOR

                                    + line.Substring(0, index).Trim();

                    String value = line.Substring(index + 1).Trim();

                    LOG.DebugFormat("Parsed key {0} to be {1}. Setting in result object.", key, value);

                    properties.SetProperty(key, value);

                }

            }

            finally

            {

                reader.Close();

                readFiles.Add(path);

            }

            return properties;

        }

        private Properties LoadEnv(Properties properties)

        {

            LOG.DebugFormat("Loading properties from environment into {0}", properties);

            if (this.debug)

            {

                WriteDebug1("2. Environment variables with prefix RSB_");

            }

            foreach (var keyRaw in Environment.GetEnvironmentVariables().Keys)

            {

                String key = (String)keyRaw;

                if (key.StartsWith(this.environmentPrefix))

                {

                    String value = Environment.GetEnvironmentVariable(key);

                    String propsKey =

                            key.Substring(this.environmentPrefix.Length)

                                    .Replace(ENV_SEPARATOR, KEY_SEPARATOR).ToLower(new System.Globalization.CultureInfo("us-US"));

                    if (this.debug)

                    {

                        WriteDebug2("{0} (mapped to {1}) -> {2}", key, propsKey, value);

                    }

                    LOG.DebugFormat("Parsed from map: {0} = {1}", propsKey, value);

                    properties.SetProperty(propsKey, value);

                }

            }

            return properties;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Text;

namespace Rsb.Util

{

    public class Properties

    {

        private Dictionary<String, Property> propertiesByName =

            new Dictionary<String, Property>();

        public Properties()

        {

        }

        public void Reset()

        {

            propertiesByName.Clear();

        }

        public Property GetProperty(String key)

        {

            if (this.propertiesByName.ContainsKey(key))

            {

                return this.propertiesByName[key];

            }

            else

            {

                throw new ArgumentException(

                        "Trying to get unknown property '" + key

                                + "' in Properties.getProperty()");

            }

        }

        public Property GetProperty<TargetType>(String key, TargetType defaultValue)

        {

            try

            {

                return GetProperty(key);

            }

            catch (ArgumentException e)

            {

                return new Property(defaultValue.ToString());

            }

        }

        public void SetProperty(String key, String value)

        {

            this.propertiesByName[key.Trim()] = new Property(value);

        }

        public HashSet<String> GetAvailableKeys()

        {

            return new HashSet<String>(this.propertiesByName.Keys);

        }

        public bool HasProperty(String key)

        {

            return this.propertiesByName.ContainsKey(key);

        }

        public Properties Filter(String desiredPrefix)

        {

            Properties filtered = new Properties();

            foreach (String key in this.propertiesByName.Keys)

            {

                if (key.Equals(desiredPrefix)

                        || key.StartsWith(desiredPrefix + "."))

                {

                    filtered.SetProperty(key, propertiesByName[key].AsString());

                }

            }

            return filtered;

        }

        public void Remove(IEnumerable<String> keys)

        {

            foreach (String key in keys)

            {

                this.propertiesByName.Remove(key);

            }

        }

        public void Remove(String key)

        {

            this.propertiesByName.Remove(key);

        }

        public void Merge(Properties properties)

        {

            foreach (String key in properties.propertiesByName.Keys)

            {

                this.propertiesByName[key] = new Property(properties.propertiesByName[key].AsString());

            }

        }

        /*

        public Iterator<Entry<String, Property>> iterator()

        {

            return this.propertiesByName.entrySet().iterator();

        }*/

        public override String ToString()

        {

            StringBuilder builder = new StringBuilder();

            builder.Append(this.GetType().Name);

            builder.Append("[");

            foreach (var k in propertiesByName.Keys)

            {

                builder.Append(k);

                builder.Append("=");

                builder.Append(propertiesByName[k]);

                builder.Append(";");

            }

            builder.Append(']');

            return builder.ToString();

        }

        public override int GetHashCode()

        {

            int prime = 31;

            int result = 1;

            result =

                    prime

                            * result