/// <summary>
 /// Parameterized Constructor.
 /// </summary>
 public MessageProcessor(IMessageReceiver receiver,
     IMessageExecutor executor)
 {
     this.receiver = receiver;
     this.executor = executor;
     this.broker = MessageBrokerFactory.Instance.GetOrCreate("message");
 }

        public static IMessageReceiver removeReciever(IMessageReceiver group, IMessageReceiver remove)
        {
            if (group == null)
                throw new Exception("Receiver not found!");

            if (remove == group)
                return null;
            else if (group is DoubleReceiver)
            {
                DoubleReceiver dual = (DoubleReceiver)group;
                IMessageReceiver newone = removeReciever(dual.one, remove);
                IMessageReceiver newtwo = removeReciever(dual.two, remove);
                if (newone != null && newtwo != null)
                {
                    dual.one = newone;
                    dual.two = newtwo;
                    return dual;
                }
                else if (newone != null)
                    return newone;
                else if (newtwo != null)
                    return newtwo;
                else
                    return null;
            }
            else
                return group;
        }

 public ServiceBusCollector(IMessageReceiver messageReceiver)
 {
     receiverCancellationTokenSource = new CancellationTokenSource();
     receiveWaitTime = TimeSpan.FromMinutes(1);
     receiver = messageReceiver;
     stopped = new ManualResetEventSlim(false);
 }

        public static IMessageReceiver addReceiver(IMessageReceiver group, IMessageReceiver add)
        {
            if (group == null)
                return add;

            return new DoubleReceiver(add, group);
        }

 public void CreateBus()
 {
     m_Sender = Substitute.For<IMessageSender>();
     m_Receiver = Substitute.For<IMessageReceiver>();
     m_Bus = new MessageBus(m_Sender,
                            m_Receiver);
 }

 internal void RemoveReceiver(IMessageReceiver r)
 {
     lock (inbox)
     {
         inbox.Remove(r);
     }
 }

        /// <param name="instanceId">The unique name of this worker.</param>
        /// <param name="messageReceiver">The receiver set up to listen for incoming trigger update notifications.</param>
        /// <param name="notificationBuffer">The buffer to which the worker will write all received trigger update notifications.</param>
        public TriggerNotificationQueueMonitor(string instanceId, IMessageReceiver messageReceiver, BlockingCollection<TriggerUpdateNotification> notificationBuffer) : base(instanceId, messageReceiver)
        {
            if (notificationBuffer == null)
                throw new ArgumentNullException("notificationBuffer");

            _notificationBuffer = notificationBuffer;
        }

 /// <summary> 
 /// Create a new coderack
 /// </summary> 
 public Coderack(IMessageReceiver receiver)
 {
     codelets = new SalienceTree<Codelet>();
     isEvaluating = new DescriptorCodelet(this, "evaluating");
     isCompleting = new DescriptorCodelet(this, "completing");
     watching = false;
     this.receiver = receiver;
 }

 public static void RegisterReceiver(IMessageReceiver Receiver)
 {
     if (!Receivers.Contains(Receiver))
     {
       Receivers.Add(Receiver);
       Debug.Log("Added new Message Receiver");
     }
 }

        public TransactionMonitorWorker(string instanceId, IMessageReceiver messageReceiver, IAuditRepository repository)
            : base(instanceId, messageReceiver)
        {
            if(repository == null)
                throw new ArgumentNullException("repository");

            _repository = repository;
            _deserializer = new TransactionEventConverter();
        }

        // Add the plugins actions and data source
        public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver)
        {
            env.SetDataSource(PartTypeSourceName, new Sentence(new List<KeyValuePair<string, string>>()));
            env.AddAction(new StringParseHandler(env));
            env.AddAction(new EnumerableParseHandler());
            env.AddAction(new ParaphraseHandler(env));

            return InitializeResult.Success();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="NmqMessageServer"/> class.
        /// </summary>
        /// <param name="messageReceiver">The message receiver.</param>
        /// <param name="port">The port.</param>
        internal NmqMessageServer(IMessageReceiver messageReceiver, int port)
        {
            tokenSource = new CancellationTokenSource();

            this.port = port;
            this.messageReceiver = messageReceiver;
            context = NetMQContext.Create();
            responseQueue = new NmqResponseQueue(context, port);
        }

 public CommandProcessor(
     IMessageReceiver messageReceiver,
     ICommandRouter commandRouter,
     ITextSerializer serializer)
 {
     _messageReceiver = messageReceiver;
     _commandRouter = commandRouter;
     _serializer = serializer;
 }

        public WorkloadQueueMonitor(string instanceId, IMessageReceiver messageReceiver, IMessagePublisher statusPublisher, int httpWorkerCount) 
            : base(instanceId, messageReceiver)
        {
            if(statusPublisher == null)
                throw new ArgumentNullException("statusPublisher");

            _batchQueue = new ConcurrentQueue<WorkloadBatchMessage>();
            _httpWorkerCount = httpWorkerCount;
            _statusPublisher = statusPublisher;
        }

        protected QueueMonitorWorker(string instanceId, IMessageReceiver messageReceiver)
        {
            if (instanceId == null)
                throw new ArgumentNullException("instanceId");
            if (messageReceiver == null)
                throw new ArgumentNullException("messageReceiver");

            InstanceId = instanceId;
            Receiver = messageReceiver;
        }

        public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver)
        {
            // Data files contained in [datadrectory]/wordnet
            string basedir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "morpho" + Path.DirectorySeparatorChar;

            InitializeNouns(env, basedir);
            InitializeVerbs(env, basedir);

            return InitializeResult.Success();
        }

		public WndProcRouter (Control control, IMessageReceiver receiver)
		{
			if (control == null)
				throw new ArgumentNullException ("control");
			if (receiver == null)
				throw new ArgumentNullException ("receiver");
			
			_oldTarget = control.WindowTarget;
			_control = control;
			_receiver = receiver;
		}

 public ChangeZoneMsg(
     IMessageSender sender, 
     IMessageReceiver receiver,
     Entity entity,
     string destZone,
     Point destPosition,
     int sendTime)
     : base(MessageType.ChangeZone, sender, receiver, sendTime)
 {
     Entity = entity;
     DestZone = destZone;
     DestPosition = destPosition;
 }

        // Add the plugins actions and data source
        public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver)
        {
            // Data files contained in [datadrectory]/parser
            string parserdir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "parser" + Path.DirectorySeparatorChar;
            POSTagger tagger = new POSTagger(parserdir + "lexicon_all", parserdir + "ruleset", assembly, null);

            env.SetDataSource<string, string[]>(LanguageNet.Grammarian.POSTagger.PartsSourceName, tagger);
            env.AddAction(new EnumerableTagHandler(tagger));
            env.AddAction(new PhraseResolveHandler(tagger));
            env.AddAction(new StringTagHandler(tagger));

            return InitializeResult.Success();
        }

 public void CreateBus()
 {
     m_Sender = Substitute.For<IMessageSender>();
     m_Receiver = Substitute.For<IMessageReceiver>();
     m_MessageList = Substitute.For<IMessageRegistrationList>();
     m_MessageList.Messages.Returns(new List<Type>
     {
         typeof(TestMessage)
     });
     m_Bus = new MessageBus(m_Sender,
                            m_Receiver,
                            m_MessageList);
 }