static ImageLoader()
 {
     string baseDir = Path.Combine (Environment.GetFolderPath (Environment.SpecialFolder.Personal), "..");
     _cacheDir = Path.Combine (baseDir, "tmp/");
     _queue = new Processor<GetImageRequest>(Download);
     _requests = new Dictionary<GetImageRequest, Action<UpdateImage>>();
 }

 public void CanDisplayHelp()
 {
     const string text = "Supplies a value for tests.";
     var proc = new Processor(defaultArgument: "--test");
     proc.Handle("--test").Describe(text);
     Assert.That(proc.Help(), Is.StringContaining(text));
 }

        static void Main()
        {
            Components mcardVLC = new MotherBoard("VLC", (decimal)185.98);
            Components vcardRadeon = new GraphicsCard("Radeon", (decimal)102.34, "the best grafic card forever");
            Components vcardGeForce = new GraphicsCard("GeForce", (decimal)154.45, "is not worth");

            Components procIntel = new Processor("Intel", (decimal)346.563, "can be better");
            Components procAMD = new Processor("AMD", (decimal)405.239, "always the best");
            Components procMac = new Processor("IOS", 2000m, "It is okaaaay");

            Computer mac = new Computer("Mac", new List<Components>() { mcardVLC, vcardRadeon, vcardGeForce });
            Computer windows = new Computer("Windows");
            windows.Components.Add(procIntel);
            windows.Components.Add(procAMD);
            windows.Components.Add(procMac);
            //Console.WriteLine(windows);

            Computer linux = new Computer("Linux", new List<Components>() { mcardVLC, vcardGeForce, vcardRadeon, procAMD, procIntel, procMac });

            List<Computer> computers = new List<Computer>() { mac, windows, linux };

            computers.OrderBy(p => p.TotalPrice).ToList().ForEach(p => Console.WriteLine(p.ToString()));


            //or

            //computers.OrderBy(a => a.TotalPrice);

            //foreach (var computer in computers)
            //{
            //    Console.WriteLine(computer);
            //}
        }

 public SocketServer(FitSocket socket, Processor<Cell> service, ProgressReporter reporter, bool suiteSetUpIsAnonymous)
 {
     this.service = service;
     this.reporter = reporter;
     this.socket = socket;
     IMaybeProcessingSuiteSetup = suiteSetUpIsAnonymous;
 }

		protected override void OnStart(string[] args)
		{
			Core.Data.GainLogger.Write("Application started");

			_processor = new Processor();
			_processor.Start();
		}

    public void AddChangedFile()
    {
        var fileName = Path.GetTempFileName();
        try
        {
            var expected = File.GetLastWriteTimeUtc(fileName);
            var loggerMock = new Mock<BuildLogger>();
            loggerMock.Setup(x => x.LogDebug(It.IsAny<string>()));

            var processor = new Processor
                            {
                                Logger = loggerMock.Object,
                                ConfigFiles = new List<string>
                                              {
                                                  fileName
                                              }
                            };
            processor.CheckForWeaversXmlChanged();
            File.SetLastWriteTimeUtc(fileName, DateTime.Now.AddHours(1));
            processor.CheckForWeaversXmlChanged();

            loggerMock.Verify();

            Assert.AreEqual(expected, Processor.TimeStamps.First().Value);
        }
        finally
        {
            File.Delete(fileName);
            Processor.TimeStamps.Clear();
        }
    }

 public void Execute(Processor processor, params string[] parameters)
 {
     if (parameters.Length > 0)
     {
         if (parameters[0].Equals("start", StringComparison.InvariantCultureIgnoreCase))
         {
             if (parameters.Length > 1)
             {
                 processor.StartBeacon(parameters[1]);
             }
             else
             {
                 processor.StartBeacon();
             }
         }
         else if (parameters[0].Equals("stop", StringComparison.InvariantCultureIgnoreCase))
         {
             processor.StopBeacon();
         }
     }
     else
     {
         Console.WriteLine("Parameters: start/stop [friendly name]");
     }
 }

        // For viewing previous weeks processing
        public WeeklyProcessor(Processor ProcA, Processor ProcB)
        {
            FormType = 2;
            weeksProcessData = Global.Util.DeepClone<Processor>(ProcA);
            PreviousWeekProc = Global.Util.DeepClone<Processor>(ProcB);
            InitializeComponent();
            dataGridView_Previous.DataSource = PreviousWeekProc.Portfolio.Stocks;
            dataGridView_Current.DataSource = weeksProcessData.Portfolio.Stocks;

            dataGridView_Universe.AutoGenerateColumns = false;
            dataGridView_Universe.DataSource = weeksProcessData.Universe.TrendsUniverseContents;
            DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn();
            col.DataPropertyName = "Symbol";
            dataGridView_Universe.Columns.Add(col);

            textBox_StockPick.Text = weeksProcessData.StockPick;
            button_Finish.Text = "Return";

            foreach (Control ctrl in this.tableLayoutPanel1.Controls)
            {
                if (ctrl is Button)
                    ctrl.Enabled = false;
            }
            button_Finish.Enabled = true;
            RefreshLabels();
        }

 public TThreadedServer(Processor processor, ServerTransport serverTransport)
     : this(processor, serverTransport,
          new TransportFactory(), new TransportFactory(),
          new BinaryProtocol.Factory(), new BinaryProtocol.Factory(),
          DEFAULT_MAX_THREADS, DefaultLogDelegate)
 {
 }

        public void FormatCollector(Dictionary<string, string> parameters, Dictionary<string, string> collectorDict, System.Xml.Linq.XElement collectorElement, Type collectorType, Processor processor)
        {
            CollectorHelpers.IsCollectorFormatterValid(collectorType, "NasuTek.Monitoring.Service.BuiltIn.Collectors.FileCollector");

            switch (collectorType.FullName)
            {
                case "NasuTek.Monitoring.Service.BuiltIn.Collectors.FileCollector":
                    {
                        string[] files = collectorDict["Files"].Split(',');
                        var dictRet = new Dictionary<string, Dictionary<string, string>>();

                        foreach (var file in files)
                        {
                            var xmlDoc = XDocument.Load(file);
                            foreach (var xmlRefVal in collectorElement.Elements("XmlRefToKeyValue"))
                            {
                                processor.AddDomain(xmlRefVal.Attribute("domain").Value, Path.GetFileName(file));

                                XElement ele = xmlDoc.XPathSelectElement(xmlRefVal.Attribute("name").Value);
                                if (ele != null)
                                    processor.GetDomain(xmlRefVal.Attribute("domain").Value, Path.GetFileName(file))[xmlRefVal.Attribute("domain_key").Value] = ele.Value;
                            }
                        }
                    }
                    break;
            }
        }

        public ProcessorMT(Processor processor, int cThreads)
        {
            this.processor = processor;

            //(1) setting up threads to compute the best splits
            this.cThreads = (cThreads > MAX_THREADS) ? MAX_THREADS : cThreads;
            this.cThreads = (this.cThreads > processor.cJobs) ? processor.cJobs : this.cThreads;

            this.processorThreadObjs = new ProcessorThreadObj[this.cThreads];
            this.processorThreads = new Thread[this.cThreads];

            this.StartEvents = new ManualResetEvent[this.cThreads];
            this.DoneEvents = new ManualResetEvent[this.cThreads];

            for (int i = 0; i < this.cThreads; i++)
            {
                ProcessorThread processorThread = processor.CreatePerThread();

                this.StartEvents[i] = new ManualResetEvent(false);
                this.DoneEvents[i] = new ManualResetEvent(true);

                ProcessorThreadObj processorThreadObj = new ProcessorThreadObj(StartEvents[i], DoneEvents[i], processorThread);
                this.processorThreadObjs[i] = processorThreadObj;

                ThreadStart threadStart = new ThreadStart(processorThreadObj.Process);
                Thread thread = new Thread(threadStart);
                this.processorThreads[i] = thread;

                thread.Start();
            }
        }

 private void RunProcessor(API.Request request, Processor processor, string processorName)
 {
     API.Response response = null;
     try
     {
         // Threadpooling
         response = processor.process(request);
     }
     catch (Exception e)
     {
         Logger.Error("Failed to process message with processor " + processor.GetType() + " : " + e.Message, e);
         try
         {
             Type responseType = Type.GetType("Gwupe.Cloud.Messaging.Response." + processorName + "Rs");
             response = (API.Response) responseType.GetConstructor(Type.EmptyTypes).Invoke(new object[] {});
             response.error = "UNKNOWN_ERROR";
             response.errorMessage = e.Message;
         }
         catch (Exception exception)
         {
             Logger.Error("Failed to determine return type for " + processorName);
             response = new ErrorRs
                 {
                     errorMessage = "Failed to determine return type for " + processorName,
                     error = "INTERNAL_SERVER_ERROR"
                 };
         }
     }
     finally
     {
         SendResponse(response, request);
     }
 }

        public string Transform(string baseDir, string sourceXml, string releaseType, string version)
        {
            var sourceXsl = SchematronBuilder.CheckForNewerSchematron(baseDir, releaseType, version);

            // Create a Processor instance.
            var processor = new Processor();

            var result = new StringBuilder();

            var xmlDocumentBuilder = processor.NewDocumentBuilder();
            xmlDocumentBuilder.BaseUri = new Uri(baseDir);

            var xsltCompiler = processor.NewXsltCompiler();
            xsltCompiler.ErrorList = new ArrayList();
            var xmlToValidate = xmlDocumentBuilder.Build(new StringReader(sourceXml));
            var compiledXsl = xsltCompiler.Compile(new XmlTextReader(sourceXsl));
            var xmlValidator = compiledXsl.Load();

            // Set the root node of the source document to be the initial context node.
            xmlValidator.InitialContextNode = xmlToValidate;

            // BaseOutputUri is only necessary for xsl:result-document.
            xmlValidator.BaseOutputUri = new Uri(Path.Combine(baseDir, "output.xml"));

            var validationSerializer = new Serializer();

            using (var resultsWriter = new StringWriter(result))
            {
                validationSerializer.SetOutputWriter(resultsWriter);
                xmlValidator.Run(validationSerializer);
            }

            return result.ToString();
        }

        public void ToProcessors()
        {
            string xElementProcessors =
                "<processors>" + "\r\n  " +
                "<processor ID=\"0\" Name=\"ATMega128\">" + "\r\n    " +
                "<eepromSize>0x1000</eepromSize>" + "\r\n    " +
                "<flashSize>0x20000</flashSize>" + "\r\n    " +
                "<bootStartAddress>0x1E000</bootStartAddress>" + "\r\n    " +
                "<bootEndAddress>0x1FFFF</bootEndAddress>" + "\r\n  " +
                "</processor>" + "\r\n  " +
                "<processor ID=\"1\" Name=\"ATMega2560\">" + "\r\n    " +
                "<eepromSize>0x1000</eepromSize>" + "\r\n    " +
                "<flashSize>0x40000</flashSize>" + "\r\n    " +
                "<bootStartAddress>0x3E000</bootStartAddress>" + "\r\n    " +
                "<bootEndAddress>0x3FFFF</bootEndAddress>" + "\r\n  " +
                "</processor>" + "\r\n" +
                "</processors>";

            XElement xElement = XElement.Parse(xElementProcessors);
            var processors = xElement.ToProcessors(XNamespace.None).ToList();

            Assert.AreEqual(2, processors.Count);

            Processor expectedProcessor1 = new Processor(0, "ATMega128",
                0x1000, 0x20000, 0x1E000, 0x1FFFF);
            Processor expectedProcessor2 = new Processor(1, "ATMega2560",
                0x1000, 0x40000, 0x3E000, 0x3FFFF);

            Assert.IsTrue(expectedProcessor1.Equals(processors[0]));
            Assert.IsTrue(expectedProcessor2.Equals(processors[1]));
        }

        public void ExecuteReport(Dictionary<string, string> parameters, Processor processor)
        {
            foreach (var domain in processor.GetAllDomains())
            {
                Console.WriteLine("Domain: " + domain.Key);

                if (domain.Value.ContainsKey("Global"))
                {
                    foreach (var value in domain.Value["Global"])
                    {
                        Console.WriteLine("\tKey: " + value.Key);
                        Console.WriteLine("\t\tValue: " + value.Value);
                    }
                }

                foreach (var subdomain in domain.Value.Where(v => v.Key != "Global"))
                {
                    Console.WriteLine("\tSubdomain: " + subdomain.Key);
                    foreach (var value in subdomain.Value)
                    {
                        Console.WriteLine("\t\tKey: " + value.Key);
                        Console.WriteLine("\t\t\tValue: " + value.Value);
                    }
                }
            }
        }

 /// <summary>
 /// Image Processing
 /// </summary>
 /// <param name="image">image</param>
 public static void ImageProcessing([QueueTrigger("imaging")] string img)
 {
     var connectionString = CloudConfigurationManager.GetSetting("StorageAccount");
     var image = JsonConvert.DeserializeObject<ImageQueued>(img);
     var processor = new Processor(new DataStore(connectionString), versions.Images);
     processor.Process(image).Wait();
 }

        public void Evaluate()
        {
            var processor = new Processor();

            var result = processor.Evaluate(@"//Nothing but a comment");
            Assert.IsNull(result.Result);
        }

        public async Task Process()
        {
            var bytes = File.ReadAllBytes(Environment.CurrentDirectory + @"\icon.png");

            var versions = this.Versions();
            var version = versions.Values.First();

            var queued = new ImageQueued
            {
                Identifier = Guid.NewGuid(),
                OriginalExtension = Naming.DefaultExtension,
                
            };
            queued.FileNameFormat = queued.Identifier.ToString() + "_{0}.{1}";

            await this.container.Save(string.Format("{0}_original.jpeg", queued.Identifier), bytes);

            var store = new DataStore(connectionString);

            var processor = new Processor(new DataStore(connectionString), versions);
            await processor.Process(queued);

            var data = await this.container.Get(string.Format("{0}_test.gif", queued.Identifier));
            Assert.IsNotNull(data);

            var entities = await this.table.QueryByRow<ImageEntity>("test");
            var entity = entities.FirstOrDefault();

            Assert.IsNotNull(entity);
            Assert.AreEqual(version.Format.MimeType, entity.MimeType);
            Assert.AreEqual(string.Format(Naming.PathFormat, this.container.Name, entity.FileName), entity.RelativePath);
        }

    public void GenXML()
    {
        String sourceUri = Server.MapPath("5648.xml");
        String xqUri = Server.MapPath("graph.xq");

        using (FileStream sXml = File.OpenRead(sourceUri))
        {
            using (FileStream sXq = File.OpenRead(xqUri))
            {
                Processor processor = new Processor();
                XQueryCompiler compiler = processor.NewXQueryCompiler();
                compiler.BaseUri = sourceUri;
                XQueryExecutable exp = compiler.Compile(sXq);
                XQueryEvaluator eval = exp.Load();

                DocumentBuilder loader = processor.NewDocumentBuilder();
                loader.BaseUri = new Uri(sourceUri);
                XdmNode indoc = loader.Build(new FileStream(sourceUri, FileMode.Open, FileAccess.Read));

                eval.ContextItem = indoc;
                Serializer qout = new Serializer();
                qout.SetOutputProperty(Serializer.METHOD, "xml");
                qout.SetOutputProperty(Serializer.INDENT, "yes");
                qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
                qout.SetOutputWriter(Response.Output);
                eval.Run(qout);
            }
        }
    }

        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="SplitColorSpaceChannelsForm"/> class.
        /// </summary>
        /// <param name="processor">The SBIP processor.</param>
        public SplitColorSpaceChannelsForm(Processor processor)
        {
            InitializeComponent();

            Processor = processor;
            filter = new SplitColorSpaceChannels {ColorSpace = ColorSpaceEnum.HSB};
        }