public static RenderPackage? LoadFromXml(ComputeContext computeContext, KernelXmlFile kernelXml, IParameterSet oldParameterSetCache) { var kernel = RenderKernel.Create(computeContext, kernelXml.Files.Select(File.ReadAllText).ToArray()); if (kernel == null) return null; var controls = kernelXml.ControlsFunc(); if (oldParameterSetCache != null && controls.GetType() == oldParameterSetCache.GetType()) controls = oldParameterSetCache; return new RenderPackage(kernel, controls); }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig config, IParameterSet parameters, ParameterSetter setter) { CoalesceMacroConfig realConfig = config as CoalesceMacroConfig; if (realConfig == null) { throw new InvalidCastException("Unable to cast config as a CoalesceMacroConfig"); } object targetValue = null; if (vars.TryGetValue(realConfig.SourceVariableName, out object currentSourceValue) && !Equals(currentSourceValue ?? string.Empty, realConfig.DefaultValue ?? string.Empty)) { targetValue = currentSourceValue; } else { if (!vars.TryGetValue(realConfig.FallbackVariableName, out targetValue)) { environmentSettings.Host.LogDiagnosticMessage("Unable to find a variable to fall back to called " + realConfig.FallbackVariableName, "Authoring", realConfig.SourceVariableName, realConfig.DefaultValue); targetValue = realConfig.DefaultValue; } } Parameter pd = new Parameter { IsVariable = true, Name = config.VariableName }; vars[config.VariableName] = targetValue?.ToString(); setter(pd, targetValue?.ToString()); }
public InterpolationCrossover(IRandom random, IParameterSet parameterSet, IList <IConflictDetector> conflictDetectors) : base(random, parameterSet, conflictDetectors) { }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { EvaluateMacroConfig config = rawConfig as EvaluateMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig"); } ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator, Cpp2StyleEvaluatorDefinition.Evaluate); byte[] data = Encoding.UTF8.GetBytes(config.Value); int len = data.Length; int pos = 0; IProcessorState state = new GlobalRunSpec.ProcessorState(environmentSettings, vars, data, Encoding.UTF8); bool result = evaluator(state, ref len, ref pos, out bool faulted); Parameter p; if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam)) { // If there is an existing parameter with this name, it must be reused so it can be referenced by name // for other processing, for example: if the parameter had value forms defined for creating variants. // When the param already exists, use its definition, but set IsVariable = true for consistency. p = (Parameter)existingParam; p.IsVariable = true; } else { p = new Parameter { IsVariable = true, Name = config.VariableName }; } vars[config.VariableName] = result.ToString(); setter(p, result.ToString()); }
private static IReadOnlyList <IOperationProvider> SetupOperations(IEngineEnvironmentSettings environmentSettings, IParameterSet parameters, IGlobalRunConfig runConfig) { // default operations List <IOperationProvider> operations = new List <IOperationProvider>(); operations.AddRange(runConfig.Operations); // replacements if (runConfig.Replacements != null) { foreach (IReplacementTokens replaceSetup in runConfig.Replacements) { IOperationProvider replacement = ReplacementConfig.Setup(environmentSettings, replaceSetup, parameters); if (replacement != null) { operations.Add(replacement); } } } if (runConfig.VariableSetup.Expand) { operations?.Add(new ExpandVariables(null)); } return(operations); }
// Warning: if there are unknown macro "types", they are quietly ignored here. // This applies to both the regular and deferred macros. internal IEnumerable <IOperationProvider> ProcessMacros(IEngineEnvironmentSettings environmentSettings, IReadOnlyList <IMacroConfig> macroConfigs, IVariableCollection variables, IParameterSet parameters) { EnsureMacros(environmentSettings.Components); EnsureDeferredMacros(environmentSettings.Components); ParameterSetter setter = (p, value) => { ((RunnableProjectGenerator.ParameterSet)parameters).AddParameter(p); parameters.ResolvedValues[p] = RunnableProjectGenerator.InternalConvertParameterValueToType(environmentSettings, p, value, out bool valueResolutionError); // TODO: consider checking the valueResolutionError and act on it, if needed. // Should be safe to ignore, params should be verified by the time this occurs. }; IList <IMacroConfig> allMacroConfigs = new List <IMacroConfig>(macroConfigs); IList <GeneratedSymbolDeferredMacroConfig> deferredConfigList = new List <GeneratedSymbolDeferredMacroConfig>(); // run the macros that are already setup, stash the deferred ones for afterwards foreach (IMacroConfig config in allMacroConfigs) { if (config is GeneratedSymbolDeferredMacroConfig deferredConfig) { deferredConfigList.Add(deferredConfig); continue; } if (_macroObjects.TryGetValue(config.Type, out IMacro macroObject)) { macroObject.EvaluateConfig(environmentSettings, variables, config, parameters, setter); } } List <Tuple <IMacro, IMacroConfig> > deferredConfigs = new List <Tuple <IMacro, IMacroConfig> >(); // Set up all deferred macro configurations - this must be done separately from running them // as certain generation types may require (like generating port numbers) that a shared resource // be held in a particular state to influence the production of other values foreach (GeneratedSymbolDeferredMacroConfig deferredConfig in deferredConfigList) { IDeferredMacro deferredMacroObject; if (_deferredMacroObjects.TryGetValue(deferredConfig.Type, out deferredMacroObject)) { deferredConfigs.Add(Tuple.Create((IMacro)deferredMacroObject, deferredMacroObject.CreateConfig(environmentSettings, deferredConfig))); } } foreach (Tuple <IMacro, IMacroConfig> config in deferredConfigs) { config.Item1.EvaluateConfig(environmentSettings, variables, config.Item2, parameters, setter); } return(Array.Empty <IOperationProvider>()); }
public Task <ICreationResult> CreateAsync(IEngineEnvironmentSettings environmentSettings, ITemplate templateData, IParameterSet parameters, IComponentManager componentManager, string targetDirectory) { RunnableProjectTemplate template = (RunnableProjectTemplate)templateData; ProcessMacros(environmentSettings, componentManager, template.Config.OperationConfig, parameters); IVariableCollection variables = VariableCollection.SetupVariables(environmentSettings, parameters, template.Config.OperationConfig.VariableSetup); template.Config.Evaluate(parameters, variables, template.ConfigFile); IOrchestrator basicOrchestrator = new Core.Util.Orchestrator(); RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator); GlobalRunSpec runSpec = new GlobalRunSpec(template.TemplateSourceRoot, componentManager, parameters, variables, template.Config.OperationConfig, template.Config.SpecialOperationConfig, template.Config.LocalizationOperations, template.Config.PlaceholderFilename); foreach (FileSource source in template.Config.Sources) { runSpec.SetupFileSource(source); string target = Path.Combine(targetDirectory, source.Target); orchestrator.Run(runSpec, template.TemplateSourceRoot.DirectoryInfo(source.Source), target); } // todo: add anything else we'd want to report to the broker return(Task.FromResult <ICreationResult>(new CreationResult() { PostActions = PostAction.ListFromModel(environmentSettings, template.Config.PostActionModel, variables), PrimaryOutputs = CreationPath.ListFromModel(environmentSettings, template.Config.PrimaryOutputs, variables) })); }
public void Render(ComputeBuffer<Vector4> buffer, ComputeCommandQueue queue, IParameterSet parameters, Size windowSize, int numBlocks, Size coordinates, int bufferWidth = 0) { lock (_kernelLock) { if (_kernel == null) return; var size = new long[] { windowSize.Width, windowSize.Height }; var localSize = Threadsize(queue); var offset = new long[size.Length]; var offsetCoords = new long[] { coordinates.Width, coordinates.Height }; if (numBlocks > 0) { for (var i = 0; i < size.Length; i++) size[i] = numBlocks * localSize[i]; for (var i = 0; i < size.Length; i++) offset[i] = size[i] * offsetCoords[i]; } var globalSize = GlobalLaunchsizeFor(localSize, size); var kernelNumArgs = 0; _kernel.SetMemoryArgument(kernelNumArgs++, buffer); _kernel.SetValueArgument(kernelNumArgs++, bufferWidth); _kernel.SetValueArgument(kernelNumArgs++, windowSize.Width); _kernel.SetValueArgument(kernelNumArgs++, windowSize.Height); parameters.ApplyToKernel(_kernel, _useDouble, ref kernelNumArgs); queue.Execute(_kernel, offset, globalSize, localSize, null); } }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { ConstantMacroConfig config = rawConfig as ConstantMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as ConstantMacroConfig"); } Parameter p; if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam)) { // If there is an existing parameter with this name, it must be reused so it can be referenced by name // for other processing, for example: if the parameter had value forms defined for creating variants. // When the param already exists, use its definition, but set IsVariable = true for consistency. p = (Parameter)existingParam; p.IsVariable = true; } else { p = new Parameter { IsVariable = true, Name = config.VariableName }; } vars[config.VariableName] = config.Value; setter(p, config.Value); }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { string value; if (!(rawConfig is RegexMatchMacroConfig config)) { throw new InvalidCastException("Couldn't cast the rawConfig as RegexMatchMacroConfig"); } if (!vars.TryGetValue(config.SourceVariable, out object working)) { value = parameters.TryGetRuntimeValue(environmentSettings, config.SourceVariable, out object resolvedValue, true) ? resolvedValue.ToString() : string.Empty; } else { value = working?.ToString() ?? string.Empty; } bool result = false; try { result = Regex.IsMatch(value, config.Pattern); } catch (ArgumentException ex) { environmentSettings.Host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_InvalidRegex, config.Pattern), "Authoring", ex.ToString()); } Parameter p; if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam)) { // If there is an existing parameter with this name, it must be reused so it can be referenced by name // for other processing, for example: if the parameter had value forms defined for creating variants. // When the param already exists, use its definition, but set IsVariable = true for consistency. p = (Parameter)existingParam; p.IsVariable = true; if (string.IsNullOrEmpty(p.DataType)) { p.DataType = config.DataType; } } else { p = new Parameter { IsVariable = true, Name = config.VariableName, DataType = config.DataType }; } vars[config.VariableName] = result; setter(p, result.ToString()); }
public void Evaluate(string variableName, IVariableCollection vars, JObject def, IParameterSet parameters, ParameterSetter setter) { string evaluatorName = def.ToString("evaluator"); ConditionEvaluator evaluator = EvaluatorSelector.Select(evaluatorName); byte[] data = Encoding.UTF8.GetBytes(def.ToString("action")); int len = data.Length; int pos = 0; IProcessorState state = new GlobalRunSpec.ProcessorState(vars, data, Encoding.UTF8); bool res = evaluator(state, ref len, ref pos); Parameter p = new Parameter { IsVariable = true, Name = variableName }; setter(p, res.ToString()); }
public SwapTwoRangeMutation(IRandom random, IParameterSet parameterSet, IList <INeighborhoodConflictDetector> conflictDetectors) : base(random, parameterSet, conflictDetectors) { }
public Order1Crossover(IRandom random, IParameterSet parameterSet, IList <IConflictDetector> conflictDetectors = null) : base(random, parameterSet, conflictDetectors) { }
public EliminateSectionMutation(IRandom random, IParameterSet parameterSet, IList <INeighborhoodConflictDetector> conflictDetectors) : base(random, parameterSet, conflictDetectors) { }
public IReadOnlyDictionary <string, IReadOnlyList <IFileChange2> > GetFileChanges(string targetBaseDir, IParameterSet parameters = null, IVariableCollection variables = null) { if (parameters == null) { parameters = new MockParameterSet(); } if (variables == null) { variables = new VariableCollection(); } IRunnableProjectConfig runnableConfig = TemplateConfigTestHelpers.ConfigFromSource(_environment, SourceMountPoint); IFileSystemInfo configFileInfo = TemplateConfigTestHelpers.ConfigFileSystemInfo(SourceMountPoint, _configFile); runnableConfig.Evaluate(parameters, variables, configFileInfo); MockGlobalRunSpec runSpec = new MockGlobalRunSpec(); IDirectory sourceDir = SourceMountPoint.DirectoryInfo("/"); IOrchestrator basicOrchestrator = new Core.Util.Orchestrator(); RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator); Dictionary <string, IReadOnlyList <IFileChange2> > changesByTarget = new Dictionary <string, IReadOnlyList <IFileChange2> >(); foreach (FileSourceMatchInfo source in runnableConfig.Sources) { TemplateConfigTestHelpers.SetupFileSourceMatchersOnGlobalRunSpec(runSpec, source); IReadOnlyList <IFileChange2> changes = orchestrator.GetFileChanges(runSpec, sourceDir, targetBaseDir, source.Target); changesByTarget[source.Target] = changes; } return(changesByTarget); }
public ICreationEffects GetCreationEffects(IEngineEnvironmentSettings environmentSettings, ITemplate templateData, IParameterSet parameters, IComponentManager componentManager, string targetDirectory) { RunnableProjectTemplate template = (RunnableProjectTemplate)templateData; ProcessMacros(environmentSettings, componentManager, template.Config.OperationConfig, parameters); IVariableCollection variables = VariableCollection.SetupVariables(environmentSettings, parameters, template.Config.OperationConfig.VariableSetup); template.Config.Evaluate(parameters, variables, template.ConfigFile); IOrchestrator basicOrchestrator = new Core.Util.Orchestrator(); RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator); GlobalRunSpec runSpec = new GlobalRunSpec(template.TemplateSourceRoot, componentManager, parameters, variables, template.Config.OperationConfig, template.Config.SpecialOperationConfig, template.Config.LocalizationOperations, template.Config.IgnoreFileNames); List <IFileChange> changes = new List <IFileChange>(); foreach (FileSourceMatchInfo source in template.Config.Sources) { runSpec.SetupFileSource(source); string target = Path.Combine(targetDirectory, source.Target); changes.AddRange(orchestrator.GetFileChanges(runSpec, template.TemplateSourceRoot.DirectoryInfo(source.Source), target)); } return(new CreationEffects() { FileChanges = changes, CreationResult = GetCreationResult(environmentSettings, template, variables) }); }
public IReadOnlyDictionary <string, string> GetRenames(string sourceDir, string targetBaseDir, IParameterSet parameters, IReadOnlyList <IReplacementTokens> symbolBasedRenames) { IFileSystemInfo configFileInfo = TemplateConfigTestHelpers.ConfigFileSystemInfo(SourceMountPoint, _configFile); parameters.TryGetParameterDefinition("name", out ITemplateParameter nameParam); object resolvedNameValue = parameters.ResolvedValues[nameParam]; return(FileRenameGenerator.AugmentFileRenames(_environment, _sourceBaseDir, configFileInfo, sourceDir, ref targetBaseDir, resolvedNameValue, parameters, new Dictionary <string, string>(), symbolBasedRenames)); }
public void Evaluate(IParameterSet parameters, IVariableCollection rootVariableCollection, IFileSystemInfo configFile) { List <FileSource> sources = new List <FileSource>(); bool stable = Symbols == null; Dictionary <string, bool> computed = new Dictionary <string, bool>(); while (!stable) { stable = true; foreach (KeyValuePair <string, ISymbolModel> symbol in Symbols) { if (symbol.Value.Type == "computed") { ComputedSymbol sym = (ComputedSymbol)symbol.Value; bool value = CppStyleEvaluatorDefinition.EvaluateFromString(EnvironmentSettings, sym.Value, rootVariableCollection); stable &= computed.TryGetValue(symbol.Key, out bool currentValue) && currentValue == value; rootVariableCollection[symbol.Key] = value; computed[symbol.Key] = value; } else if (symbol.Value.Type == "bind") { if (parameters.TryGetRuntimeValue(EnvironmentSettings, symbol.Value.Binding, out object bindValue) && bindValue != null) { rootVariableCollection[symbol.Key] = RunnableProjectGenerator.InferTypeAndConvertLiteral(bindValue.ToString()); } } } } // evaluate the file glob (specials) conditions // the result is needed for SpecialOperationConfig foreach (ICustomFileGlobModel fileGlobModel in SpecialCustomSetup) { fileGlobModel.EvaluateCondition(EnvironmentSettings, rootVariableCollection); } parameters.ResolvedValues.TryGetValue(NameParameter, out object resolvedNameParamValue); // evaluate the conditions and resolve the paths for the PrimaryOutputs foreach (ICreationPathModel pathModel in PrimaryOutputs) { pathModel.EvaluateCondition(EnvironmentSettings, rootVariableCollection); if (pathModel.ConditionResult && resolvedNameParamValue != null) { if (SourceName != null) { // this path will be included in the outputs, replace the name (same thing we do to other file paths) pathModel.PathResolved = pathModel.PathOriginal.Replace(SourceName, (string)resolvedNameParamValue); } else { pathModel.PathResolved = pathModel.PathOriginal; } } } foreach (ExtendedFileSource source in Sources) { if (!string.IsNullOrEmpty(source.Condition) && !CppStyleEvaluatorDefinition.EvaluateFromString(EnvironmentSettings, source.Condition, rootVariableCollection)) { continue; } List <string> includePattern = JTokenToCollection(source.Include, SourceFile, IncludePatternDefaults).ToList(); List <string> excludePattern = JTokenToCollection(source.Exclude, SourceFile, ExcludePatternDefaults).ToList(); List <string> copyOnlyPattern = JTokenToCollection(source.CopyOnly, SourceFile, CopyOnlyPatternDefaults).ToList(); Dictionary <string, string> renames = new Dictionary <string, string>(source.Rename ?? RenameDefaults); if (source.Modifiers != null) { foreach (SourceModifier modifier in source.Modifiers) { if (string.IsNullOrEmpty(modifier.Condition) || CppStyleEvaluatorDefinition.EvaluateFromString(EnvironmentSettings, modifier.Condition, rootVariableCollection)) { includePattern.AddRange(JTokenToCollection(modifier.Include, SourceFile, new string[0])); excludePattern.AddRange(JTokenToCollection(modifier.Exclude, SourceFile, new string[0])); copyOnlyPattern.AddRange(JTokenToCollection(modifier.CopyOnly, SourceFile, new string[0])); if (modifier.Rename != null) { foreach (JProperty property in modifier.Rename.Properties()) { renames[property.Name] = property.Value.Value <string>(); } } } } } Dictionary <string, string> coreRenames = new Dictionary <string, string>(renames); string sourceTargetName = source.Target ?? "./"; if (resolvedNameParamValue != null && SourceName != null) { string targetName = ((string)resolvedNameParamValue).Trim(); foreach (KeyValuePair <string, string> entry in coreRenames) { string outRel = entry.Value.Replace(SourceName, targetName); renames[entry.Key] = outRel; } foreach (IFileSystemInfo entry in configFile.Parent.Parent.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)) { string tmpltRel = entry.PathRelativeTo(configFile.Parent.Parent); string outRel = tmpltRel.Replace(SourceName, targetName); renames[tmpltRel] = outRel; } sourceTargetName = sourceTargetName.Replace(SourceName, targetName); } sources.Add(new FileSource { CopyOnly = copyOnlyPattern.ToArray(), Exclude = excludePattern.ToArray(), Include = includePattern.ToArray(), Source = source.Source ?? "./", Target = sourceTargetName, Rename = renames }); } if (Sources.Count == 0) { IReadOnlyList <string> includePattern = IncludePatternDefaults; IReadOnlyList <string> excludePattern = ExcludePatternDefaults; IReadOnlyList <string> copyOnlyPattern = CopyOnlyPatternDefaults; Dictionary <string, string> renames = new Dictionary <string, string>(); if (SourceName != null) { if (parameters.ResolvedValues.TryGetValue(NameParameter, out object resolvedValue)) { foreach (IFileSystemInfo entry in configFile.Parent.Parent.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)) { string tmpltRel = entry.PathRelativeTo(configFile.Parent.Parent); string outRel = tmpltRel.Replace(SourceName, (string)resolvedValue); renames[tmpltRel] = outRel; } } } sources.Add(new FileSource { CopyOnly = copyOnlyPattern, Exclude = excludePattern, Include = includePattern, Source = "./", Target = "./", Rename = renames }); } _sources = sources; }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { GeneratePortNumberConfig config = rawConfig as GeneratePortNumberConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig"); } config.Socket?.Dispose(); Parameter p; if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam)) { // If there is an existing parameter with this name, it must be reused so it can be referenced by name // for other processing, for example: if the parameter had value forms defined for creating variants. // When the param already exists, use its definition, but set IsVariable = true for consistency. p = (Parameter)existingParam; p.IsVariable = true; if (string.IsNullOrEmpty(p.DataType)) { p.DataType = config.DataType; } } else { p = new Parameter { IsVariable = true, Name = config.VariableName, DataType = config.DataType }; } vars[config.VariableName] = config.Port.ToString(); setter(p, config.Port.ToString()); }
public async Task <TemplateCreationResult> InstantiateAsync(ITemplateInfo templateInfo, string name, string fallbackName, string outputPath, IReadOnlyDictionary <string, string> inputParameters, bool skipUpdateCheck, bool forceCreation, string baselineName) { // SettingsLoader.LoadTemplate is where the loc info should be read!!! // templateInfo knows enough to get at the loc, if any ITemplate template = _environmentSettings.SettingsLoader.LoadTemplate(templateInfo, baselineName); try { if (template == null) { return(new TemplateCreationResult("Could not load template", CreationResultStatus.NotFound, templateInfo.Name)); } string realName = name ?? fallbackName ?? template.DefaultName; if (string.IsNullOrEmpty(realName)) { return(new TemplateCreationResult("--name", CreationResultStatus.MissingMandatoryParam, template.Name)); } // there should never be param errors here. If there are, the template is malformed, or the host gave an invalid value. IParameterSet templateParams = SetupDefaultParamValuesFromTemplateAndHost(template, realName, out IReadOnlyList <string> defaultParamsWithInvalidValues); ResolveUserParameters(template, templateParams, inputParameters, out IReadOnlyList <string> userParamsWithInvalidValues); if (AnyParametersWithInvalidDefaultsUnresolved(defaultParamsWithInvalidValues, userParamsWithInvalidValues, inputParameters, out IReadOnlyList <string> defaultsWithUnresolvedInvalidValues) || userParamsWithInvalidValues.Count > 0) { string message = string.Join(", ", new CombinedList <string>(userParamsWithInvalidValues, defaultsWithUnresolvedInvalidValues)); return(new TemplateCreationResult(message, CreationResultStatus.InvalidParamValues, template.Name)); } bool missingParams = CheckForMissingRequiredParameters(templateParams, out IList <string> missingParamNames); if (missingParams) { return(new TemplateCreationResult(string.Join(", ", missingParamNames), CreationResultStatus.MissingMandatoryParam, template.Name)); } if (template.IsNameAgreementWithFolderPreferred && string.IsNullOrEmpty(outputPath)) { outputPath = name; } ICreationResult creationResult = null; string targetDir = outputPath ?? _environmentSettings.Host.FileSystem.GetCurrentDirectory(); try { _paths.CreateDirectory(targetDir); Stopwatch sw = Stopwatch.StartNew(); IComponentManager componentManager = _environmentSettings.SettingsLoader.Components; IReadOnlyList <IFileChange> changes = template.Generator.GetCreationEffects(_environmentSettings, template, templateParams, componentManager, targetDir).FileChanges; IReadOnlyList <IFileChange> destructiveChanges = changes.Where(x => x.ChangeKind != ChangeKind.Create).ToList(); if (!forceCreation && destructiveChanges.Count > 0) { if (!_environmentSettings.Host.OnPotentiallyDestructiveChangesDetected(changes, destructiveChanges)) { return(new TemplateCreationResult("Cancelled", CreationResultStatus.Cancelled, template.Name)); } } creationResult = await template.Generator.CreateAsync(_environmentSettings, template, templateParams, componentManager, targetDir).ConfigureAwait(false); sw.Stop(); _environmentSettings.Host.LogTiming("Content generation time", sw.Elapsed, 0); return(new TemplateCreationResult(string.Empty, CreationResultStatus.Success, template.Name, creationResult, targetDir)); } catch (ContentGenerationException cx) { string message = cx.Message; if (cx.InnerException != null) { message += Environment.NewLine + cx.InnerException.Message; } return(new TemplateCreationResult(message, CreationResultStatus.CreateFailed, template.Name)); } catch (Exception ex) { return(new TemplateCreationResult(ex.Message, CreationResultStatus.CreateFailed, template.Name)); } } finally { ReleaseMountPoints(template); } }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { ConstantMacroConfig config = rawConfig as ConstantMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as ConstantMacroConfig"); } Parameter p = new Parameter { IsVariable = true, Name = config.VariableName }; setter(p, config.Value); }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { GuidMacroConfig config = rawConfig as GuidMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as GuidMacroConfig"); } if (!string.IsNullOrEmpty(config.Format)) { Guid g = Guid.NewGuid(); string value = char.IsUpper(config.Format[0]) ? g.ToString(config.Format[0].ToString()).ToUpperInvariant() : g.ToString(config.Format[0].ToString()).ToLowerInvariant(); Parameter p = new Parameter { IsVariable = true, Name = config.VariableName }; vars[config.VariableName] = value; setter(p, value); } else { Guid g = Guid.NewGuid(); string guidFormats = GuidMacroConfig.DefaultFormats; for (int i = 0; i < guidFormats.Length; ++i) { string value = char.IsUpper(guidFormats[i]) ? g.ToString(guidFormats[i].ToString()).ToUpperInvariant() : g.ToString(guidFormats[i].ToString()).ToLowerInvariant(); Parameter p = new Parameter { IsVariable = true, Name = config.VariableName + "-" + guidFormats[i] }; vars[config.VariableName] = value; setter(p, value); } Parameter pd = new Parameter { IsVariable = true, Name = config.VariableName }; vars[config.VariableName] = g.ToString("D"); setter(pd, g.ToString("D")); } }
public void EvaluateDeferredConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig; if (deferredConfig == null) { throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig"); } if (!deferredConfig.Parameters.TryGetValue("value", out JToken valueToken)) { throw new ArgumentNullException("value"); } string value = valueToken.ToString(); IMacroConfig realConfig = new ConstantMacroConfig(deferredConfig.VariableName, value); EvaluateConfig(environmentSettings, vars, realConfig, parameters, setter); }
public void Evaluate(string variableName, IVariableCollection vars, JObject def, IParameterSet parameters, ParameterSetter setter) { string format = def.ToString("action"); bool utc = def.ToBool("utc"); DateTime time = utc ? DateTime.UtcNow : DateTime.Now; string value = time.ToString(format); Parameter p = new Parameter { IsVariable = true, Name = variableName }; setter(p, value); }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { EvaluateMacroConfig config = rawConfig as EvaluateMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig"); } ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator); byte[] data = Encoding.UTF8.GetBytes(config.Value); int len = data.Length; int pos = 0; IProcessorState state = new GlobalRunSpec.ProcessorState(environmentSettings, vars, data, Encoding.UTF8); bool result = evaluator(state, ref len, ref pos, out bool faulted); Parameter p = new Parameter { IsVariable = true, Name = config.VariableName }; setter(p, result.ToString()); }
public RenderPackage(RenderKernel kernel, IParameterSet parameters) { _kernel = kernel; _parameters = parameters; }
/// <summary> /// Enumerates all the named parameters and properties of an <see cref="IParameterSet"/>. /// </summary> /// <param name="parameters">The parameter set.</param> /// <returns> /// All the named parameters. /// </returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="parameters"/> is <c>null</c>.</exception> public static IEnumerable <MemberDescription> Parameters(this IParameterSet parameters) => Parameters(parameters.ThrowIfNull(nameof(parameters)).GetType());
private static void ValidateGuidMacroCreatedParametersWithResolvedValues(string variableName, IParameterSet parameters) { ITemplateParameter setParam; Assert.True(parameters.TryGetParameterDefinition(variableName, out setParam)); Guid paramValue = Guid.Parse((string)parameters.ResolvedValues[setParam]); // check that all the param name variants were created, and their values all resolve to the same guid. string guidFormats = GuidMacroConfig.DefaultFormats; for (int i = 0; i < guidFormats.Length; ++i) { string otherFormatParamName = variableName + "-" + guidFormats[i]; ITemplateParameter testParam; Assert.True(parameters.TryGetParameterDefinition(otherFormatParamName, out testParam)); Guid testValue = Guid.Parse((string)parameters.ResolvedValues[testParam]); Assert.Equal(paramValue, testValue); } }
public void Evaluate(string variableName, IVariableCollection vars, JObject def, IParameterSet parameters, ParameterSetter setter) { switch (def["action"].ToString()) { case "new": int low = def.ToInt32("low"); int high = def.ToInt32("high", int.MaxValue); Random rnd = new Random(); int val = rnd.Next(low, high); string value = val.ToString(); Parameter p = new Parameter { IsVariable = true, Name = variableName }; setter(p, value); break; } }
// Returns a list of operations which contains the custom operations and the default operations. // If there are custom Conditional operations, don't include the default Conditionals. // // Note: we may need a more robust filtering mechanism in the future. private static IReadOnlyList <IOperationProvider> ResolveOperations(IGlobalRunConfig runConfig, IDirectory templateRoot, IVariableCollection variables, IParameterSet parameters) { IReadOnlyList <IOperationProvider> customOperations = SetupCustomOperations(runConfig.CustomOperations, templateRoot, variables); IReadOnlyList <IOperationProvider> defaultOperations = SetupOperations(parameters, runConfig); List <IOperationProvider> operations = new List <IOperationProvider>(customOperations); if (customOperations.Any(x => x is Conditional)) { operations.AddRange(defaultOperations.Where(op => !(op is Conditional))); } else { operations.AddRange(defaultOperations); } return(operations); }
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter) { string value = null; CaseChangeMacroConfig config = rawConfig as CaseChangeMacroConfig; if (config == null) { throw new InvalidCastException("Couldn't cast the rawConfig as CaseChangeMacroConfig"); } if (!vars.TryGetValue(config.SourceVariable, out object working)) { if (RuntimeValueUtil.TryGetRuntimeValue(parameters, environmentSettings, config.SourceVariable, out object resolvedValue, true)) { value = resolvedValue.ToString(); } else { value = string.Empty; } }
// Note the deferred-config macros (generated) are part of the runConfig.Macros // and not in the ComputedMacros. // Possibly make a separate property for the deferred-config macros private static void ProcessMacros(IEngineEnvironmentSettings environmentSettings, IComponentManager componentManager, IGlobalRunConfig runConfig, IParameterSet parameters) { if (runConfig.Macros != null) { IVariableCollection varsForMacros = VariableCollection.SetupVariables(environmentSettings, parameters, runConfig.VariableSetup); MacrosOperationConfig macroProcessor = new MacrosOperationConfig(); macroProcessor.ProcessMacros(environmentSettings, componentManager, runConfig.Macros, varsForMacros, parameters); } if (runConfig.ComputedMacros != null) { IVariableCollection varsForMacros = VariableCollection.SetupVariables(environmentSettings, parameters, runConfig.VariableSetup); MacrosOperationConfig macroProcessor = new MacrosOperationConfig(); macroProcessor.ProcessMacros(environmentSettings, componentManager, runConfig.ComputedMacros, varsForMacros, parameters); } }
public UniformCrossover(IRandom random, IParameterSet parameterSet, IList <IConflictDetector> conflictDetectors) : base(random, parameterSet, conflictDetectors) { }
public void Draw(Action<ComputeBuffer<Vector4>, ComputeCommandQueue, IParameterSet, Size> renderer, IParameterSet parameters, Size windowSize) { if (_disposed) throw new ObjectDisposedException(ToString()); GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); GL.Finish(); _queue.AcquireGLObjects(new[] { _openCl }, null); renderer(_openCl, _queue, parameters, windowSize); _queue.ReleaseGLObjects(new[] { _openCl }, null); _queue.Finish(); GL.BindBuffer(BufferTarget.PixelUnpackBuffer, _pub); GL.BindTexture(TextureTarget.Texture2D, _texture); GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, _width, _height, PixelFormat.Rgba, PixelType.Float, IntPtr.Zero); GL.Begin(PrimitiveType.Quads); GL.TexCoord2(0f, 1f); GL.Vertex3(0f, 0f, 0f); GL.TexCoord2(0f, 0f); GL.Vertex3(0f, 1f, 0f); GL.TexCoord2(1f, 0f); GL.Vertex3(1f, 1f, 0f); GL.TexCoord2(1f, 1f); GL.Vertex3(1f, 0f, 0f); GL.End(); }
public void Render(ComputeBuffer<Vector4> buffer, ComputeCommandQueue queue, IParameterSet parameters, Size windowSize) { Render(buffer, queue, parameters, windowSize, 0, new Size(0, 0)); }