public void Open(Lifetime lifetime, IShellLocks shellLocks, ChangeManager changeManager, ISolution solution, DocumentManager documentManager, IActionManager actionManager, ICommandProcessor commandProcessor, TextControlChangeUnitFactory changeUnitFactory, JetPopupMenus jetPopupMenus)
    {
      Debug.Assert(!IsOpened);

      _solution = solution;
      DocumentManager = documentManager;
      _jetPopupMenus = jetPopupMenus;
      changeManager.Changed2.Advise(lifetime, Handler);
      lifetime.AddAction(Close);
      var expandAction = actionManager.Defs.TryGetActionDefById(GotoDeclarationAction.ACTION_ID);
      if (expandAction != null)
      {
        var postfixHandler = new GotoDeclarationHandler(lifetime, shellLocks, commandProcessor, changeUnitFactory, this);

        lifetime.AddBracket(
          FOpening: () => actionManager.Handlers.AddHandler(expandAction, postfixHandler),
          FClosing: () => actionManager.Handlers.RemoveHandler(expandAction, postfixHandler));
      }
      
      var findUsagesAction = actionManager.Defs.GetActionDef<FindUsagesAction>();
      var findUsagesHandler = new FindUsagesHandler(lifetime, shellLocks, commandProcessor, changeUnitFactory, this);

      lifetime.AddBracket(
        FOpening: () => actionManager.Handlers.AddHandler(findUsagesAction, findUsagesHandler),
        FClosing: () => actionManager.Handlers.RemoveHandler(findUsagesAction, findUsagesHandler));
    }

        public JavaScriptRunner(IFeedback<LogEntry> log, ICommandProcessor commandProcessor, IEntityContextConnection entityContextConnection)
        {
            if (log == null)
                throw new ArgumentNullException("log");

            if (commandProcessor == null)
                throw new ArgumentNullException("commandProcessor");

            if (entityContextConnection == null)
                throw new ArgumentNullException("entityContextConnection");

            Log = log;
            CommandProcessor = commandProcessor;
            EntityContextConnection = entityContextConnection;
            log.Source = "JavaScript Runner";

            JintEngine = new Jint.Engine(cfg =>
            {
                cfg.AllowClr();
                cfg.AllowDebuggerStatement(JavascriptDebugEnabled);
            });
            //JintEngine.Step += async (s, info) =>
            //{
            //    await Log.ReportInfoFormatAsync(CancellationToken.None, "{1} {2}",
            //         info.CurrentStatement.Source.Start.Line,
            //         info.CurrentStatement.Source.Code.Replace(Environment.NewLine, ""));
            //};

        }

 public TransmitPipe(ILoggerFactoryAdapter loggerFactoryAdapter, IConfiguration configuration, ICommandProcessor commandProcessor, IRegisterContainer registerContainer, GpioPin cePin)
 {
     _configuration = configuration;
     _commandProcessor = commandProcessor;
     _registerContainer = registerContainer;
     _logger = loggerFactoryAdapter.GetLogger(GetType());
     _cePin = cePin;
 }

        protected CommandBase(
            ICommandProcessor ParentCommandProcessor,
            ITerminal  Terminal)
        {
            _CommandProcessor = ParentCommandProcessor;

            _Terminal = Terminal;
        }

 public FindUsagesHandler(Lifetime lifetime, IShellLocks shellLocks, ICommandProcessor commandProcessor, TextControlChangeUnitFactory changeUnitFactory, XXLanguageXXSolution nitraSolution)
 {
   _lifetime = lifetime;
   _shellLocks = shellLocks;
   _commandProcessor = commandProcessor;
   _changeUnitFactory = changeUnitFactory;
   _nitraSolution = nitraSolution;
 }

		public void RegisterProcessor (CommandType type, ICommandProcessor processor)
		{
			if (processors.ContainsKey (type))
				throw new ArgumentException (string.Format ("Command processor for type {0} is already registered", type));

			if (processor != null)
				processors [type] = processor;
		}

 public ArduinoDetails(IRadio radio, ILoggerFactoryAdapter loggerFactory, IConfiguration configuration, ICommandProcessor commandProcessor, IRegisterContainer registerContainer)
 {
     _radio = radio;
     _logger = loggerFactory.GetLogger(GetType());
     _configuration = configuration;
     _commandProcessor = commandProcessor;
     _registerContainer = registerContainer;
 }

        public static FFprobeSerializerResult Serialize(ICommandProcessor processor)
        {
            if (processor.Status == CommandProcessorStatus.Faulted)
            {
                return null;
            }

            var standardOutputString = processor.StdOut;
            var serializerResult = FFprobeSerializerResult.Create();

            var serializers = new List<IFFprobeSerializer>
                {
                    new FFprobeStreamSerializer(),
                    new FFprobeFormatSerializer()
                };

            serializers.ForEach(serializer =>
                {
                    var serializerStartIndex = 0;

                    while (serializerStartIndex > -1)
                    {
                        var searchingStartTag = string.Format("[{0}]", serializer.Tag);
                        var searchingEndTag = string.Format("[/{0}]", serializer.Tag);

                        var startTagIndex = standardOutputString.IndexOf(searchingStartTag, serializerStartIndex, StringComparison.OrdinalIgnoreCase);
                        if (startTagIndex == -1)
                        {
                            break;
                        }

                        var endTagIndex = standardOutputString.IndexOf(searchingEndTag, startTagIndex + 1, StringComparison.OrdinalIgnoreCase);
                        if (endTagIndex == -1)
                        {
                            break;
                        }

                        var startAt = startTagIndex + searchingStartTag.Length;
                        var lengthOf = endTagIndex - startAt;
                        var unserializedValueString = standardOutputString.Substring(startAt, lengthOf);

                        var rawSerializedValues = FFprobeGeneralSerializer.Serialize(unserializedValueString);

                        var serializedValues = serializer.Serialize(rawSerializedValues);

                        if (serializedValues != null)
                        {
                            var serializerResultItem = FFprobeSerializerResultItem.Create(serializer.Tag, serializedValues);

                            serializerResult.Results.Add(serializerResultItem);
                        }

                        serializerStartIndex = endTagIndex;
                    }
                });

            return serializerResult;
        }

 public ProductsController(IProductTasks productTasks, ICategoryTasks categoryTasks, IProductsQuery productsQuery, 
     ICommandProcessor commandProcessor, ICaptchaTasks captchaTasks)
 {
     _productTasks = productTasks;
     _categoryTasks = categoryTasks;
     _productsQuery = productsQuery;
     _commandProcessor = commandProcessor;
     _captchaTasks = captchaTasks;
 }

        public void Register(ICommandProcessor commandProcessor)
        {
            var cmd = commandProcessor.Key.ToUpper();

            if (_processors.ContainsKey(cmd))
                throw new Exception(string.Format("The processor for command '{0}' is already registered", cmd));

            _processors.Add(cmd, commandProcessor);
        }

 public static void OnSuccessAction(ICommandFactory factory, ICommand command, ICommandProcessor results)
 {
     //results.StdOut
     // - contains the results ffmpeg command line
     System.Console.ForegroundColor = System.ConsoleColor.DarkMagenta;
     System.Console.WriteLine("Succcess");
     System.Console.WriteLine(results.StdOut);
     System.Console.ForegroundColor = System.ConsoleColor.White;
 }

 protected PipeRegisterBase(ILoggerFactoryAdapter loggerFactoryAdapter, ICommandProcessor commandProcessor, byte address, byte length, byte[] defaultValue, byte pipeNumber, string name = "") :
     base(loggerFactoryAdapter, commandProcessor, length, address, defaultValue, name)
 {
     PipeNumber = pipeNumber;
     Name = string.Format("{0}{1}{2}",
                         GetType().Name,
                         PipeNumber,
                         string.IsNullOrEmpty(name) ? "" : string.Format(" ({0})", name));
     Logger = loggerFactoryAdapter.GetLogger(Name);
 }

 /// <summary>
 /// Initializes a new instance of the BullsAndCowsGame class.
 /// </summary>
 /// <param name="randomNumberProvider">The randomNumberProvider used to generate random numbers.</param>
 /// <param name="scoreboard">The scoreboard used to hold player's scores.</param>
 /// <param name="printer">The printer used for printing messages and different objects.</param>
 /// <param name="commandProcessor">The first command processor in the chain of responsibility.</param>
 public BullsAndCowsGame(
     IRandomNumberProvider randomNumberProvider,
     ScoreBoard scoreboard,
     IPrinter printer,
     ICommandProcessor commandProcessor)
 {
     this.RandomNumberProvider = randomNumberProvider;
     this.ScoreBoard = scoreboard;
     this.Printer = printer;
     this.CommandProcessor = commandProcessor;
 }

 public ReceivePipe(ILoggerFactoryAdapter loggerFactoryAdapter, IConfiguration configuration, ICommandProcessor commandProcessor, IRegisterContainer registerContainer, IReceivePipeCollection parent, int pipeId)
 {
     if (PipeId > 5)
         throw new ArgumentOutOfRangeException(nameof(pipeId), "Invalid PipeId number for this Pipe");
     _logger = loggerFactoryAdapter.GetLogger(string.Format("{0}{1}", GetType().Name, pipeId));
     _configuration = configuration;
     _commandProcessor = commandProcessor;
     _registerContainer = registerContainer;
     _parent = parent;
     PipeId = pipeId;
 }

        public static ContainerMetadata Serialize(ICommandProcessor processor)
        {
            if (processor.Status == CommandProcessorStatus.Faulted)
            {
                return null;
            }

            var standardOutputString = processor.StdOut;

            return JsonConvert.DeserializeObject<ContainerMetadata>(standardOutputString);
        }

     public ExpandPostfixTemplateHandler(
 [NotNull] TextControlChangeUnitFactory changeUnitFactory,
 [NotNull] PostfixTemplatesManager templatesManager,
 [NotNull] ILookupWindowManager lookupWindowManager,
 [NotNull] ICommandProcessor commandProcessor)
     {
         myChangeUnitFactory = changeUnitFactory;
         myLookupWindowManager = lookupWindowManager;
         myCommandProcessor = commandProcessor;
         myTemplatesManager = templatesManager;
     }

        public CreateRecommendationModule(ICommandProcessor commandProcessor)
        {
            Contract.Requires(commandProcessor != null);
            
            this.CommandProcessor = commandProcessor;
            
            this.Get[To.CreateRecommendation] = this.HandleGet;

            this.Post[From.CreateRecommendation, runAsync: true] = this.HandlePostWithCsrfValidation;
            
        }

 public AddressPipeRegister(ILoggerFactoryAdapter loggerFactoryAdapter, ICommandProcessor commandProcessor, byte address, byte[] defaultValue, byte pipeNumber, string name = "") :
         base(loggerFactoryAdapter, commandProcessor, address, (byte)(pipeNumber <= 1 ? 5 : 1), defaultValue, pipeNumber, name)
 {
     bool transmitPipe = Address == RegisterAddresses.TX_ADDR;
     Name = string.Format("{0}{1}{2}{3}",
                          transmitPipe ? "Transmit" : "Receive",
                          GetType().Name,
                          transmitPipe ? "" : PipeNumber.ToString(),
                          string.IsNullOrEmpty(name) ? "" : string.Format(" ({0})", name));
     Logger = loggerFactoryAdapter.GetLogger(Name);
 }

 protected RegisterBase(ILoggerFactoryAdapter loggerFactoryAdapter, ICommandProcessor commandProcessor, int length, byte address, byte[] defaultValue, string name = "")
 {
     Logger = loggerFactoryAdapter.GetLogger(GetType());
     _syncRoot = new object();
     Buffer = new byte[length];
     Name = GetType().Name + (string.IsNullOrEmpty(name) ? "" : string.Format(" ({0})", name));
     CommandProcessor = commandProcessor;
     Length = length;
     Address = address;
     DefaultValue = defaultValue;
     IsDirty = false;
 }

        public Configuration(ILoggerFactoryAdapter loggerFactoryAdapter, ICommandProcessor commandProcessor, IRegisterContainer registerContainer)
        {
            _logger = loggerFactoryAdapter.GetLogger(GetType());
            _commandProcessor = commandProcessor;
            _registerContainer = registerContainer;
            _payloadWidth = Constants.MaxPayloadWidth;

            // Attempt to set DataRate to 250Kbps to determine if this is a plus model
            DataRates oldDataRate = DataRate;
            DataRate = DataRates.DataRate250Kbps;
            _isPlusModel = DataRate == DataRates.DataRate250Kbps;
            DataRate = oldDataRate;

        }