private PrintOptions LoadPrintConfiguration(TomlTable configTable) { PrintOptions options = new PrintOptions(); if (configTable != null && configTable.ContainsKey("PrintOptions")) { TomlTable settings = configTable.Get <TomlTable>("PrintOptions"); if (settings.ContainsKey("Orientation")) { options.Orientation = (FilmOrientation)settings.Get <TomlInt>("Orientation").Value; } if (settings.ContainsKey("Size")) { options.FilmSize = (FilmSize)settings.Get <TomlInt>("Size").Value; } if (settings.ContainsKey("Magnification")) { options.MagnificationType = (MagnificationType)settings.Get <TomlInt>("Magnification").Value; } if (settings.ContainsKey("Medium")) { options.MediumType = (MediumType)settings.Get <TomlInt>("Medium").Value; } } return(options); }
internal static IRunControlTask Create(TomlTable taskSpec, IAppState appState, IAppService appService) { RequireTrue( taskSpec.ContainsKey("samples_file"), "File sampling task spec has missing path to samples file" ); RequireTrue( taskSpec.ContainsKey("outputs"), "File sampling task spec has missing outputs" ); var name = taskSpec["name"].Get <string>(); RequireNotNullEmptyWhiteSpace(name, "Invalid task name"); var pathToSamplesFile = taskSpec["samples_file"].Get <string>(); RequireFile(pathToSamplesFile, "Invalid samples_file"); Arr <(string Parameter, Arr <double> Correlations)> correlation = default; if (taskSpec.ContainsKey("correlation")) { var correlationSpec = taskSpec["correlation"] as TomlTableArray; RequireNotNull(correlationSpec, "Expecting correlation specified as table array"); correlation = correlationSpec.Items .Cast <TomlTable>() .Select(tt => ( Parameter: tt["name"].Get <string>(), Correlations: tt["values"].Get <double[]>().ToArr())) .ToArr(); } var outputSpecs = taskSpec["outputs"] as TomlArray; RequireNotNull( outputSpecs, "Distribution sampling task spec has missing or misspecified outputs" ); RequireTrue( outputSpecs.Length > 0, "Distribution sampling task spec has empty outputs" ); var outputNames = outputSpecs.To <string>().ToArr(); return(new FileSamplingTask( name, pathToSamplesFile, correlation, outputNames, appState, appService )); }
// Seriously, f**k this TOML Library. // WHY DOESN'T IT SUPPORT GENERICS public TomlObject SetValueInternal <T>(string key, T value, string comment) { TomlObject field; if (value is bool) { bool v = (bool)(object)value; field = _settings.ContainsKey(key) ? _settings.Update(key, v) : field = _settings.Add(key, v); } else if (value is string) { string v = (string)(object)value; field = _settings.ContainsKey(key) ? _settings.Update(key, v) : field = _settings.Add(key, v); } else if (value is int) { int v = (int)(object)value; field = _settings.ContainsKey(key) ? _settings.Update(key, v) : field = _settings.Add(key, v); } else if (value is float) { float v = (float)(object)value; field = _settings.ContainsKey(key) ? _settings.Update(key, v) : field = _settings.Add(key, v); } else { throw new NotSupportedException(); } AttatchComments(field, comment); Flush(); return(field); }
public static GeneratorConfig GetGeneratorConfig(string tomlFile) { TomlTable config = Toml.ReadFile(tomlFile); var gConfig = new GeneratorConfig(); gConfig.Id = config.Get <String>("Id"); gConfig.Type = config.Get <String>("Type"); gConfig.BrokerHostName = config.ContainsKey("BrokerHostName") ? config.Get <String>("BrokerHostName") : null; gConfig.OutputFilePath = config.ContainsKey("OutputFilePath") ? config.Get <String>("OutputFilePath") : null; gConfig.Description = config.Get <String>("Description"); gConfig.DateTimeFormat = config.Get <String>("DateTimeFormat"); gConfig.Seed = config.ContainsKey("Seed") ? config.Get <int>("Seed") : -1; gConfig.Duration = config.ContainsKey("Duration") ? config.Get <long>("Duration") : -1; return(gConfig); }
public CredentialManager() { if (File.Exists(upmconfigFile)) { var upmconfig = Toml.Parse(File.ReadAllText(upmconfigFile)); if (upmconfig.HasErrors) { Debug.LogError("Cannot load upmconfig, invalid format"); return; } TomlTable table = upmconfig.ToModel(); if (table != null && table.ContainsKey("npmAuth")) { TomlTable auth = (TomlTable)table["npmAuth"]; if (auth != null) { foreach (var registry in auth) { NPMCredential cred = new NPMCredential(); cred.url = registry.Key; TomlTable value = (TomlTable)registry.Value; cred.token = (string)value["token"]; cred.alwaysAuth = (bool)value["alwaysAuth"]; credentials.Add(cred.url, cred); } } } } }
public override void SetConfig(TomlTable toml) { base.SetConfig(toml); if (toml.ContainsKey("socks")) { server = toml.Get <AddrPort>("socks"); } }
public static T GetOr <T>(this TomlTable table, string key, T @default = default) where T : struct { if (!table.ContainsKey(key)) { return(@default); } return(table[key] as T? ?? @default); }
public static T MaybeGet <T>(this TomlTable table, string key) where T : class { if (!table.ContainsKey(key)) { return(null); } return(table[key] as T); }
public bool HasSetting(string spec) { List <bool> exists = new List <bool>(); string[] parts = spec.Split(','); foreach (string p in parts) { string trimmedParts = p.Trim(); string[] set = trimmedParts.Split('='); if (set.Length == 2) { string trimmedName = set[0].Trim(); string trimmedVal = set[1].Trim(); exists.Add(_toml.ContainsKey(trimmedName)); } } return(exists.Count > 0 && exists.All(s => s)); }
private string LoadPrinterConfiguration(TomlTable configTable) { if (configTable != null && configTable.ContainsKey("PrinterSettings")) { TomlTable settings = configTable.Get <TomlTable>("PrinterSettings"); if (settings.ContainsKey("Printer")) { return(settings.Get <TomlString>("Printer").Value); } } return("Microsoft XPS Document Writer"); }
// This method generate BaseParticle in system by side effect. internal void GenerateIntegratorManagers( GameObject scene_builder, List <GameObject> base_particles, float kb_scaled, float timescale) { if (SimulatorTable.ContainsKey("integrator")) { TomlTable integrator = SimulatorTable.Get <TomlTable>("integrator"); if (integrator.ContainsKey("type")) { string integrator_type = integrator.Get <string>("type"); if (integrator_type == "UnderdampedLangevin") { if (integrator.ContainsKey("gammas")) { int base_particles_num = base_particles.Count; List <TomlTable> gammas_tables = integrator.Get <List <TomlTable> >("gammas"); float[] gammas = new float[base_particles.Count]; foreach (TomlTable gamma_table in gammas_tables) { // TODO: check dupulicate and lacking of declaration. gammas[gamma_table.Get <int>("index")] = gamma_table.Get <float>("gamma"); } var temperature = SystemTable.Get <TomlTable>("attributes").Get <float>("temperature"); UnderdampedLangevinManager ul_manager = scene_builder.AddComponent <UnderdampedLangevinManager>() as UnderdampedLangevinManager; ul_manager.Init(kb_scaled, temperature, base_particles, gammas, timescale); Debug.Log("UnderdampedLangevinManager initialization finished."); } else { throw new System.Exception( "When you use UnderdampedLangevin integrator, you must specify gammas for integrator."); } } } } }
public static T ToModel <T>(this DocumentSyntax documentSyntax) where T : new() { T instance = new T(); TomlTable model = documentSyntax.ToModel(); foreach (PropertyInfo property in instance.GetType().GetProperties()) { TomlPropertyAttribute?attribute = property.GetCustomAttribute <TomlPropertyAttribute>(); if (attribute is null) { continue; } if (attribute.Header is null) { if (attribute.Required && !model.ContainsKey(property.Name)) { throw new Exception($"Toml file does not have required property '{property.Name}'."); } property.SetValue(instance, Convert.ChangeType(model[property.Name], property.PropertyType)); } else { if ((attribute.Required && !model.ContainsKey(attribute.Header)) || !((TomlTable)model[attribute.Header]).ContainsKey(property.Name)) { throw new Exception($"Toml file does not have required property '{property.Name}'."); } property.SetValue(instance, Convert.ChangeType(((TomlTable)model[attribute.Header])[property.Name], property.PropertyType)); } } return(instance); }
private AppConfiguration LoadAppConfiguration(TomlTable configTable) { AppConfiguration appConfiguration = new AppConfiguration(); if (configTable != null && configTable.ContainsKey("Application")) { TomlTable settings = configTable.Get <TomlTable>("Application"); if (settings.ContainsKey("ListenPort")) { appConfiguration.ListenPort = (int)settings.Get <TomlInt>("ListenPort").Value; } } return(appConfiguration); }
private void LoadConfig() { if (ConfigTable.ContainsKey("Application")) { TomlTable appSettings = ConfigTable.Get <TomlTable>("Application"); if (appSettings.ContainsKey("ListenPort")) { ServerPort = (int)appSettings.Get <TomlInt>("ListenPort").Value; Messenger.Default.ServerPort = ServerPort; } } foreach (var item in Items) { (item as IConfigViewModel).LoadConfigs(ConfigTable); } }
public void Parse(RenderSettings renderSettings, TomlTable toml) { if (toml == null) { return; } bool hasEaSetting = toml.ContainsKey(ENTERPRISE_ARCHITECT); if (!hasEaSetting) { return; } var ea = toml[ENTERPRISE_ARCHITECT] as TomlTable; if (!ea.ContainsKey(FILE)) { return; } var file = ea[FILE] as string; File = new File(renderSettings.SourceFolder, file); }
public void ReplaceOrAdd(string dottedKey, string value) { string[] segments = dottedKey.Split("."); TomlTable table = this.document; for (int i = 0; i < segments.Length - 1; i++) { string tableKey = segments[i]; try { table = (TomlTable)table[tableKey]; } catch (KeyNotFoundException) { // Nett does not provide a function to easily add table subkeys. // A hack workaround is to serialize the table, append the new table as a string, then deserialize. // This only needs to be done once to create the new subtable. // After that, Nett functions can be used to modify the subtable. string tableName = string.Join(".", segments.Take(segments.Length - 1)); this.AddTable(tableName, segments[segments.Length - 1], value); return; } } string key = segments[segments.Length - 1]; if (table.ContainsKey(key)) { table.Update(key, value); } else { table.Add(key, value); } }
static Config() { FilePath = Path.Combine(Core.BasePath, "Config.cfg"); if (!File.Exists(FilePath)) { Save(); return; } string filestr = File.ReadAllText(FilePath); if (string.IsNullOrEmpty(filestr)) { return; } DocumentSyntax docsyn = Toml.Parse(filestr); if (docsyn == null) { return; } TomlTable model = docsyn.ToModel(); if (model.Count <= 0) { return; } TomlTable tbl = (TomlTable)model["AssemblyGenerator"]; if (tbl == null) { return; } if (tbl.ContainsKey("UnityVersion")) { UnityVersion = (string)tbl["UnityVersion"]; } if (tbl.ContainsKey("Cpp2IL")) { Cpp2ILVersion = (string)tbl["Cpp2IL"]; } if (tbl.ContainsKey("Il2CppAssemblyUnhollower")) { Il2CppAssemblyUnhollowerVersion = (string)tbl["Il2CppAssemblyUnhollower"]; } if (tbl.ContainsKey("GameAssemblyHash")) { GameAssemblyHash = (string)tbl["GameAssemblyHash"]; } if (!tbl.ContainsKey("OldFiles")) { return; } TomlArray oldfilesarr = (TomlArray)tbl["OldFiles"]; if (oldfilesarr.Count <= 0) { return; } for (int i = 0; i < oldfilesarr.Count; i++) { string file = (string)oldfilesarr[i]; if (!string.IsNullOrEmpty(file)) { OldFiles.Add(file); } } }
public static bool Has <T>(this TomlTable table, string key) { return(table.ContainsKey(key) && table[key] is T); }
internal static IRunControlTask Create(TomlTable taskSpec, IAppState appState, IAppService appService) { RequireTrue( taskSpec.ContainsKey("n_samples"), "Distribution sampling task spec has missing n_samples setting" ); RequireTrue( taskSpec.ContainsKey("distributions"), "Distribution sampling task spec has missing distributions" ); RequireTrue( taskSpec.ContainsKey("outputs"), "Distribution sampling task spec has missing outputs" ); var name = taskSpec["name"].Get <string>(); RequireNotNullEmptyWhiteSpace(name, "Invalid task name"); var nSamples = taskSpec["n_samples"].Get <int>(); RequireTrue(nSamples > 0, "Invalid n_samples"); var distributionSpecs = taskSpec["distributions"] as TomlArray; RequireNotNull( distributionSpecs, "Distribution sampling task spec has missing or misspecified distributions" ); RequireTrue( distributionSpecs.Length > 0, "Distribution sampling task spec has empty distributions" ); var distributions = distributionSpecs.Items .Select(tv => Distribution.ParseRelation(tv.Get <string>())) .ToArr(); LatinHypercubeDesign latinHypercubeDesign = LatinHypercubeDesign.Default; if (taskSpec.ContainsKey("latin_hypercube")) { var latinHypercubeSpec = taskSpec["latin_hypercube"] as TomlTable; RequireNotNull(latinHypercubeSpec, "Expecting Latin hypercube specified as table array"); RequireTrue(latinHypercubeSpec.ContainsKey("type"), "Latin hypercube missing type"); var type = latinHypercubeSpec["type"].Get <LatinHypercubeDesignType>(); var t0 = latinHypercubeSpec.ContainsKey("t0") ? latinHypercubeSpec["t0"].Get <double>() : NaN; var c = latinHypercubeSpec.ContainsKey("c") ? latinHypercubeSpec["c"].Get <double>() : NaN; var iterations = latinHypercubeSpec.ContainsKey("iter") ? latinHypercubeSpec["iter"].Get <int>() : default; var p = latinHypercubeSpec.ContainsKey("p") ? latinHypercubeSpec["p"].Get <double>() : NaN; var profile = latinHypercubeSpec.ContainsKey("profile") ? latinHypercubeSpec["profile"].Get <TemperatureDownProfile>() : default; var imax = latinHypercubeSpec.ContainsKey("imax") ? latinHypercubeSpec["imax"].Get <int>() : default; var haveDesignType = type != LatinHypercubeDesignType.None; var hasValidSA = IsNaN(t0) || (!IsNaN(c) && iterations > 0 && !IsNaN(p)); RequireTrue( !haveDesignType || hasValidSA, "Invalid Latin hypercube configuration" ); latinHypercubeDesign = new LatinHypercubeDesign(type, t0, c, iterations, p, profile, imax); } Arr <(string Parameter, Arr <double> Correlations)> correlation = default; if (taskSpec.ContainsKey("correlation")) { var correlationSpec = taskSpec["correlation"] as TomlTableArray; RequireNotNull(correlationSpec, "Expecting correlation specified as table array"); correlation = correlationSpec.Items .Cast <TomlTable>() .Select(tt => ( Parameter: tt["name"].Get <string>(), Correlations: tt["values"].Get <double[]>().ToArr())) .ToArr(); var correlationComplete = distributions.ForAll( d => correlation.Exists(c => c.Parameter == d.Variable) ); RequireTrue(correlationComplete, "Incomplete correlation matrix"); RequireTrue(correlation.Count == distributions.Count, "Unexpected data in correlation matrix"); } var outputSpecs = taskSpec["outputs"] as TomlArray; RequireNotNull( outputSpecs, "Distribution sampling task spec has missing or misspecified outputs" ); RequireTrue( outputSpecs.Length > 0, "Distribution sampling task spec has empty outputs" ); var outputNames = outputSpecs.To <string>().ToArr(); return(new DistributionSamplingTask( name, nSamples, distributions, latinHypercubeDesign, correlation, outputNames, appState, appService )); }
// Start is called before the first frame update void Start() { // read input file string input_file_path = Application.dataPath + "/../input/input.toml"; Debug.Log($"input file path is {input_file_path}."); InputToml input = new InputToml(input_file_path); // generate initial particle position, velocity and system temperature TomlTable system = input.SystemTable; temperature = system.Get <TomlTable>("attributes").Get <float>("temperature"); // read particles information List <GameObject> base_particles = input.GenerateBaseParticles(m_BaseParticle, kb_scaled); // read simulator information input.GenerateIntegratorManagers(gameObject, base_particles, kb_scaled, timescale); // read boundary_shape information input.GenerateBoundaryManager(gameObject, base_particles); // read forcefields information TomlTable ff = input.ForceFieldTable; if (ff.ContainsKey("local")) { input.GenerateLocalInteractionManagers(gameObject, base_particles, timescale); } if (ff.ContainsKey("global")) { input.GenerateGlobalInteractionManagers(base_particles, timescale); } Debug.Log("ForceField initialization finished."); // Initialize SystemObserver m_SystemObserver = GetComponent <SystemObserver>(); m_SystemObserver.Init(base_particles, timescale); Debug.Log("SystemObserver initialization finished."); // set particle colors int particle_num = base_particles.Count; float color_step = 2.0f / (particle_num - 1); List <Color> color_list = new List <Color>(); float color_val = 0.0f; color_list.Add(new Color(1.0f, 0.0f, 0.0f)); foreach (GameObject base_particle in base_particles) { color_val += color_step; Material particle_material = base_particle.GetComponent <Renderer>().material; if (color_val < 1.0f) { particle_material.SetColor("_Color", new Color(1.0f, color_val, color_val)); } else { particle_material.SetColor("_Color", new Color(2.0f - color_val, 2.0f - color_val, 1.0f)); } } // Set Player position GameObject player = GameObject.Find("OVRPlayerController"); float max_radius = 0.0f; if (gameObject.GetComponent <ReflectingBoundaryManager>() != null) { foreach (GameObject base_particle in base_particles) { float radius = base_particle.transform.localScale.x; if (max_radius < radius) { max_radius = radius; } } var rb_manager = gameObject.GetComponent <ReflectingBoundaryManager>(); Vector3 upper_boundary = rb_manager.UpperBoundary; Vector3 lower_boundary = rb_manager.LowerBoundary; Vector3 box_length_half = upper_boundary - lower_boundary; Vector3 box_center = box_length_half + lower_boundary; player.transform.position = new Vector3(box_center.x, box_center.y, lower_boundary.z - box_length_half.z); } else { Vector3 upper_edge = detect_upper_edge(base_particles); Vector3 lower_edge = detect_lower_edge(base_particles); Vector3 pseudo_box_center = (upper_edge + lower_edge) * 0.5f; Vector3 pseudo_box_length_half = (upper_edge - lower_edge) * 0.5f; Vector3 upper_boundary = upper_edge + pseudo_box_length_half; Vector3 lower_boundary = lower_edge - pseudo_box_length_half; player.transform.position = new Vector3(pseudo_box_center.x, upper_boundary.y, lower_boundary.z - pseudo_box_length_half.z); player.transform.localScale = new Vector3(upper_boundary.y, upper_boundary.y, upper_boundary.y); } }
public static bool Has(this TomlTable table, string key) { return(table.ContainsKey(key)); }