public TagOperation(string outKey, string tag, IParameters parameters, bool decode, bool encode)
     : base(string.Empty, outKey) {
     _tag = tag;
     _parameters = parameters;
     _decode = decode;
     _encode = encode;
 }

        /// <summary>
        /// Identify this class as one that handles Blob parameters
        /// </summary>
        /// <param name="parameters">List of parameters</param>
        /// <returns>True if this class handles the specified parameters</returns>
        public bool CanHandle(IParameters parameters)
        {
            if (parameters == null)
                throw new ArgumentNullException(nameof(parameters));

            return parameters.MethodType == MethodType.Blob;
        }

 public AverageOperation(string outKey, string outType, IParameters parameters)
     : base(string.Empty, outKey) {
     _outType = outType;
     _parameters = parameters;
     _typeSafe = parameters.ToEnumerable().All(kv => kv.Value.SimpleType.Equals(outType));
     Name = string.Format("Average ({0})", outKey);
 }

        public static object RealTargets(IParameters buildParameters)
        {
            var version = buildParameters.Required<string>("version");

            var git = new GitCheckout {
                Repository = "git://github.com/refractalize/bounce.git",
                Directory = "tmp2",
            };
            var solution = new VisualStudioSolution {
                SolutionPath = "Bounce.sln",
            };
            var frameworkProject = solution.Projects["Bounce.Framework"];

            var downloadsDir = new CleanDirectory {
                Path = "Downloads",
            };

            var frameworkZip = new ZipFile {
                Directory = frameworkProject.WhenBuilt(() => Path.GetDirectoryName(frameworkProject.OutputFile.Value)),
                ZipFileName = downloadsDir.Files[version.WhenBuilt(() => string.Format("Bounce.Framework.{0}.zip", version.Value))],
            };

            var downloads = new All(frameworkZip, new GitTag {Directory = ".", Tag = version.WhenBuilt(() => "v" + version.Value)});

            return new {
                Tests = new NUnitTests {
                    DllPaths = solution.Projects.Select(p => p.OutputFile),
                },
                Downloads = downloads,
            };
        }

        /// <summary>
        ///     Generate the scripts.
        /// </summary>
        internal static bool Do()
        {
            _log = Program.GetInstance<IBLogger>();
            _params = Program.GetInstance<IParameters>();

            var frmConn = (NpgsqlConnection) _params[Constants.PgConnection];
            PostgresSchemaTables.CreateTables();

            var tblDict = ((Dictionary<string, DataTable>) _params[Constants.PgTables]);
            var schemaTable = tblDict[Constants.PgSchemaTable];

            if (schemaTable.Rows.Count == 0)
            {
                _log.Write('E', Constants.LogTsType, "There are no records to be processed.");
                return false;
            }

            GenerateSchemaScript(schemaTable);

            var typeTable = tblDict[Constants.PgTypeTable];
            var seqTable = tblDict[Constants.PgSeqTable];
            var fkTable = tblDict[Constants.PgFkTable];

            GenerateTableScripts(schemaTable, seqTable, frmConn);
            GenerateBuildIndexes(frmConn);
            GenerateFkConstraints(fkTable);

            if (typeTable.Rows.Count > 0 || seqTable.Rows.Count > 0)
                GenerateTypeScripts(typeTable, seqTable);

            return true;
        }

 /// <summary>
 /// Constructs the MSBuild runner
 /// </summary>
 /// <param name="parameters">User defined parameters for bari</param>
 public MSBuild(IParameters parameters)
     : base("msbuild40", 
            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), @"Microsoft.NET\Framework\v4.0.30319\"), 
            "MSBuild.exe", new Uri("http://www.microsoft.com/en-us/download/details.aspx?id=17851"))
 {
     this.parameters = parameters;
 }

        //---------------------------------------------------------------------
        
        public override void LoadParameters(string dataFile,
                                            ICore mCore)
        {
            modelCore = mCore;

            // Add local event handler for cohorts death due to age-only
            // disturbances.
            Cohort.AgeOnlyDeathEvent += CohortKilledByAgeOnlyDisturbance;

            HarvestMgmtLib.Main.InitializeLib(modelCore);
            HarvestExtensionMain.SiteHarvestedEvent += SiteHarvested;
            Landis.Library.BiomassHarvest.Main.InitializeLib(modelCore);

            ParametersParser parser = new ParametersParser(modelCore.Species);

            HarvestMgmtLib.IInputParameters baseParameters = Landis.Data.Load<IInputParameters>(dataFile, parser);
            parameters = baseParameters as IParameters;
            if (parser.RoundedRepeatIntervals.Count > 0)
            {
                ModelCore.UI.WriteLine("NOTE: The following repeat intervals were rounded up to");
                ModelCore.UI.WriteLine("      ensure they were multiples of the harvest timestep:");
                ModelCore.UI.WriteLine("      File: {0}", dataFile);
                foreach (RoundedInterval interval in parser.RoundedRepeatIntervals)
                    ModelCore.UI.WriteLine("      At line {0}, the interval {1} rounded up to {2}",
                                 interval.LineNumber,
                                 interval.Original,
                                 interval.Adjusted);
            }

        }

        //private static StreamWriter log;
        //---------------------------------------------------------------------
        public static void Initialize(IParameters parameters)
        {
            FuncType            = parameters.SppFunctionalType;
            NTolerance          = parameters.NTolerance;
            GDDmin              = parameters.GDDmin;
            GDDmax              = parameters.GDDmax;
            MinJanTemp          = parameters.MinJanTemp;
            MaxDrought          = parameters.MaxDrought;
            LeafLongevity       = parameters.LeafLongevity;
            Epicormic           = parameters.Epicormic;
            LeafLignin          = parameters.LeafLignin;
            WoodLignin          = parameters.WoodLignin ;
            CoarseRootLignin    = parameters.CoarseRootLignin ;
            FineRootLignin      = parameters.FineRootLignin ;
            LeafCN              = parameters.LeafCN;
            WoodCN              = parameters.WoodCN;
            CoarseRootCN        = parameters.CoarseRootCN;
            LeafLitterCN        = parameters.FoliageLitterCN;
            FineRootLitterCN    = parameters.FineRootLitterCN;
            NLimits = new Species.AuxParm<double>(Model.Core.Species);

            Establishment.Initialize();

            // The initial set of establishment probabilities:
            EstablishProbability = Establishment.GenerateNewEstablishProbabilities(parameters.Timestep);
            Reproduction.ChangeEstablishProbabilities(Util.ToArray<double>(SpeciesData.EstablishProbability));

            ChangeParameters(parameters);
        }

        public static object GetTargets(IParameters parameters)
        {
            var git = new GitCheckout {
                Repository = @"C:\Users\Public\Documents\Development\BigSolution.git",
                Directory = "one"
            };
            var solution = new VisualStudioSolution {
                SolutionPath = git.Files["BigSolution.sln"]
            };
            var webProject = solution.Projects[parameters.Default("proj", "BigSolution")];
            var serviceName = parameters.Default("svc", "BigWindowsService");
            var service = solution.Projects[serviceName];

            return new {
                WebSite = new Iis7WebSite {
                    Directory = webProject.ProjectDirectory,
                    Name = "BigWebSite",
                    Port = 5001
                },
                Tests = new NUnitTests {
                    DllPaths = solution.Projects.Select(p => p.OutputFile)
                },
                Service = new WindowsService {
                    BinaryPath = service.OutputFile,
                    Name = serviceName,
                    DisplayName = "Big Windows Service",
                    Description = "a big windows service demonstrating the bounce build framework"
                },
                Zip = new ZipFile {
                    Directory = webProject.WhenBuilt(() => Path.GetDirectoryName(webProject.OutputFile.Value)),
                    ZipFileName = "web.zip"
                },
            };
        }

 /// <summary>
 /// Constructs the MSBuild runner
 /// </summary>
 /// <param name="parameters">User defined parameters for bari</param>
 public XBuild(IParameters parameters)
     : base("xbuild", 
            "",
            "xbuild.bat", new Uri("http://www.go-mono.com/mono-downloads/download.html"))
 {
     this.parameters = parameters;
 }

		//---------------------------------------------------------------------

		public Parameters(IParameters parameters)
		{
			name        = parameters.Name;
			description = parameters.Description;
			mapCode     = parameters.MapCode;
			active      = parameters.Active;
		}

        public MailOperation(MailConnection connection, IParameters parameters)
            : base(string.Empty, string.Empty) {
            _connection = connection;
            _parameters = parameters;
            
            _hasCc = parameters.ContainsName("cc");
            _ccKey = _hasCc ? parameters.GetKeyByName("cc") : string.Empty;

            _hasBcc = parameters.ContainsName("bcc");
            _bccKey = _hasBcc ? parameters.GetKeyByName("bcc") : string.Empty;

            _hasSubject = parameters.ContainsName("subject");
            _subjectKey = _hasSubject ? parameters.GetKeyByName("subject") : string.Empty;

            if (!parameters.ContainsName("from")) {
                throw new TransformalizeException(Logger, EntityName, "Mail transform requires parameter named from.");
            }
            _fromKey = parameters.GetKeyByName("from");

            if (!parameters.ContainsName("to")) {
                throw new TransformalizeException(Logger, EntityName, "Mail transform requires parameter named to.");
            }
            _toKey = parameters.GetKeyByName("to");

            if (!parameters.ContainsName("body")) {
                throw new TransformalizeException(Logger, EntityName, "Mail transform requires parameter named body.");
            }
            _bodyKey = parameters.GetKeyByName("body");

            Name = "Mail";
        }

        //---------------------------------------------------------------------
        public static void Initialize(IParameters parameters)
        {
            string logFileName   = "Century-succession-log.csv";
            UI.WriteLine("   Opening Century-succession log file \"{0}\" ...", logFileName);
            try {
                log = Data.CreateTextFile(logFileName);
            }
            catch (Exception err) {
                string mesg = string.Format("{0}", err.Message);
                throw new System.ApplicationException(mesg);
            }

            log.AutoFlush = true;
            log.Write("Time, Ecoregion, NumSites,");
            log.Write("NEEC, SOMTC, AGB, ");
            log.Write("AG_NPPC, BG_NPPC, LitterfallC, FRootLitterC, ");
            log.Write("MineralN, TotalN, GrossMineralization, ");
            log.Write("C:LeafFRoot, C:WoodCRoot, C:DeadWood, C:DeadCRoot, ");
            log.Write("C:SurfStruc, C:SurfMeta, C:SoilStruc, C:SoilMeta, ");
            log.Write("C:SOM1surf, C:SOM1soil, C:SOM2, C:SOM3, ");
            log.Write("N:CohortLeaf, N:CohortWood, N:DeadWood, N:DeadRoot, ");
            log.Write("N:SurfStruc, N:SurfMeta, N:SoilStruc, N:SoilMeta, ");
            log.Write("N:SOM1surf, N:SOM1soil, N:SOM2, N:SOM3, ");
            log.Write("SurfStrucNetMin, SurfMetaNetMin, SoilStrucNetMin, SoilMetaNetMin, ");
            log.Write("SOM1surfNetMin, SOM1soilNetMin, SOM2NetMin, SOM3NetMin, ");
            log.Write("StreamC, StreamN, FireEfflux");
            log.WriteLine("");
        }

        public DefaultSuiteFactory(IParameters parameters, [SuiteRoot] IFileSystemDirectory suiteRoot, ICommandEnumerator commandEnumerator)
        {
            targetGoal = parameters.Goal;
            this.suiteRoot = suiteRoot;

            ignoreTargetGoal = !commandEnumerator.NeedsExplicitTargetGoal(parameters.Command);
        }

        //---------------------------------------------------------------------
        public static void Initialize(IParameters parameters)
        {
            MinRelativeBiomass  = parameters.MinRelativeBiomass;
            B_MAX               = new Ecoregions.AuxParm<int>(Model.Core.Ecoregions);

            ChangeParameters(parameters);
        }

        public FileCalculation(FileQueue fileQueue, IParameters parameters)
        {
            if (fileQueue == null)
                throw new ArgumentNullException("fileQueue", "Queue can't be null");
            if (parameters == null)
                throw new ArgumentNullException("parameters", "Parameters can't be null");

            Queue = fileQueue;
            Parameters = parameters;

            var statisticLog = System.IO.Path.Combine(Parameters.GetParameter("CalculationLogs"), "log.xml");
            if (System.IO.File.Exists(statisticLog))
            {
                List<FileCalculationInfo> res = null;
                typeof(List<FileCalculationInfo>).DeserializeFromXML(System.IO.File.ReadAllText(statisticLog), out res);
                if (res != null)
                    infoLog.AddRange(res);
                infoLog.ForEach(il =>
                {
                    if (il.Status == FileCalculationStatus.InAction)
                    {
                        il.Error = "Задание прервано";
                        il.Status = FileCalculationStatus.Error;
                    }
                });
            }
        }

        public static object Targets(IParameters parameters)
        {
            var stage = parameters.Required<string>("stage");
            var machine = parameters.Required<string>("machine");

            var deployService = new Copy {
                FromPath = "service",
                ToPath = machine.WhenBuilt(m => String.Format(@"c:\deployments\install\{0}\service", m)),
            };
            var deployWeb = new Copy {
                FromPath = "web",
                ToPath = machine.WhenBuilt(m => String.Format(@"c:\deployments\install\{0}\web", m)),
            };

            var remoteMachineOne = GetRemoteMachine(stage, machine, "one");
            var remoteMachineTwo = GetRemoteMachine(stage, machine, "two");

            Task<IEnumerable<RemoteMachine>> serviceMachines = new[] {remoteMachineOne, remoteMachineTwo};
            Task<IEnumerable<RemoteMachine>> webMachines = new[] {remoteMachineTwo};

            var deployArchive = new StagedDeployArchive(stage, "archive");
            var service = deployArchive.Add("service", "service", deployService).WithRemoteDeploy(serviceMachines.SelectTasks(m => m.DeployTargets("Service")));
            var web = deployArchive.Add("web", "web", deployWeb).WithRemoteDeploy(webMachines.SelectTasks(m => m.DeployTargets("Web")));

            return new {
                Service = service,
                Web = web,
            };
        }

 public GeoCodeOperation(string inKey, string outKey, int sleep, bool useHttps, IParameters parameters)
     : base(inKey, outKey) {
     _sleep = sleep;
     _parameters = parameters.ToEnumerable().Select(kv => kv.Value).ToArray();
     _service = new GoogleLocationService(useHttps);
     _useParameters = parameters.Count > 1;
     Name = string.Format("GeoCode ({0})", outKey);
 }

        public SphereEmitter(IParameters parameters)
            : base(parameters)
        {
            _particlesToEmit = new SoAData(200);

            _Radius = Parameters.GetParameterDelegate<float>("Radius");
            _EmitRingOnly = Parameters.GetParameterDelegate<bool>("EmitRingOnly");
        }

 /// <summary>
 /// Defines the external tool
 /// </summary>
 /// <param name="name">Name of the tool</param>
 /// <param name="defaultInstallLocation">Default install location where the external tool can be found</param>
 /// <param name="exeName">Executable file name</param>
 /// <param name="manualUri">URI where the user can start solving the problem if the tool is missing</param>
 /// <param name="isDotNETProcess">If <c>true</c> the process will be executed with mono when not running on MS CLR</param>
 /// <param name="parameters">Application parameters</param>
 public ManuallyInstallableExternalTool(string name, string defaultInstallLocation, string exeName, Uri manualUri, bool isDotNETProcess, IParameters parameters)
     : base(name, parameters)
 {
     this.defaultInstallLocation = defaultInstallLocation;
     this.exeName = exeName;
     this.manualUri = manualUri;
     isDotNetProcess = isDotNETProcess;
 }