public static UniversityPortalConfig GetInstance (int portalId) { var lazyPortalConfig = portalConfigs.GetOrAdd (portalId, newKey => new Lazy<UniversityPortalConfig> (() => { var portalSettings = new PortalSettings (portalId); var portalConfigFile = Path.Combine (portalSettings.HomeDirectoryMapPath, "R7.University.yml"); // ensure portal config file exists if (!File.Exists (portalConfigFile)) { File.Copy (Path.Combine ( Globals.ApplicationMapPath, "DesktopModules\\R7.University\\R7.University\\R7.University.yml"), portalConfigFile); } using (var configReader = new StringReader (File.ReadAllText (portalConfigFile))) { var deserializer = new Deserializer (namingConvention: new HyphenatedNamingConvention ()); return deserializer.Deserialize<UniversityPortalConfig> (configReader); } } )); return lazyPortalConfig.Value; }
// Use this for initialization void Start () { var input = new StringReader(Document); var deserializer = new Deserializer(); var reader = new EventReader(new Parser(input)); // Consume the stream start event "manually" reader.Expect<StreamStart>(); var output = new StringBuilder(); while(reader.Accept<DocumentStart>()) { // Deserialize the document var doc = deserializer.Deserialize<List<string>>(reader); output.AppendLine("## Document"); foreach(var item in doc) { output.AppendLine(item); } } Debug.Log(output); }
/// <summary> /// Loads an article from a .yml file. /// </summary> static Article FromYaml(string path) { // Get the file path from the given URL path var filename = "articles/" + path + ".yml"; if (!File.Exists(filename)) throw new FileNotFoundException(filename); // Load the article with a YamlDotNet deserializer var articleFile = File.OpenRead(filename); var deserializer = new Deserializer(); var article = deserializer.Deserialize<Article>(new StreamReader(articleFile)); // Set some default values if they are not specified in the file if (article.Slug == null) article.Slug = path; if (article.Summary == null) { var firstLine = article.Content.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries)[0]; article.Summary = firstLine; } // Convert the Markdown content to HTML var markdownConverter = new Markdown(); article.Content = markdownConverter.Transform(article.Content); article.Summary = Utils.StripHtmlTags(markdownConverter.Transform(article.Summary)); return article; }
public static void Notify(StringReader reader) { var deserializer = new Deserializer(null, new NullNamingConvention(), ignoreUnmatched: true); var legacyConfig = deserializer.Deserialize<LegacyConfig>(reader); if (legacyConfig == null) return; var issues = new List<string>(); var oldConfigs = legacyConfig.Branches.Keys.Where(k => OldConfigKnownRegexes.Keys.Contains(k) && k != OldConfigKnownRegexes[k]).ToList(); if (oldConfigs.Any()) { var max = oldConfigs.Max(c => c.Length); var oldBranchConfigs = oldConfigs.Select(c => string.Format("{0} -> {1}", c.PadRight(max), OldConfigKnownRegexes[c])); var branchErrors = string.Join("\r\n ", oldBranchConfigs); issues.Add(string.Format( @"GitVersion branch configs no longer are keyed by regexes, update: {0}", branchErrors)); } if (legacyConfig.assemblyVersioningScheme != null) issues.Add("assemblyVersioningScheme has been replaced by assembly-versioning-scheme"); if (legacyConfig.DevelopBranchTag != null) issues.Add("develop-branch-tag has been replaced by branch specific configuration. See http://gitversion.readthedocs.org/en/latest/configuration/#branch-configuration"); if (legacyConfig.ReleaseBranchTag != null) issues.Add("release-branch-tag has been replaced by branch specific configuration. See http://gitversion.readthedocs.org/en/latest/configuration/#branch-configuration"); if (legacyConfig.Branches != null && legacyConfig.Branches.Any(branches => branches.Value.IsDevelop != null)) issues.Add("'is-develop' is deprecated, use 'tracks-release-branches' instead. See http://gitversion.readthedocs.org/en/latest/configuration/#branch-configuration"); if (issues.Any()) throw new OldConfigurationException("GitVersion configuration file contains old configuration, please fix the following errors:\r\n" + string.Join("\r\n", issues)); }
public static void Load(string filename) { var buffer = File.ReadAllText(filename); var deserializer = new Deserializer(); var config = deserializer.Deserialize<Config>(new StringReader(buffer)); }
public static void LoadFiles(AddFunc addFunc) { TextAsset dirTxt = Resources.Load<TextAsset>(HFT_WEB_DIR); if (dirTxt == null) { Debug.LogError("could not load: " + HFT_WEB_DIR); return; } Deserializer deserializer = new Deserializer(); string[] files = deserializer.Deserialize<string[] >(dirTxt.text); foreach (string file in files) { string path = HFT_WEB_PATH + file; TextAsset asset = Resources.Load(path) as TextAsset; if (asset == null) { Debug.LogError("Could not load: " + path); } else { addFunc(file, asset.bytes); } } }
static void Main(string[] args) { var sourceList = new Item[10000]; for (int i = 0; i < sourceList.Length; i++) { sourceList[i] = new Item { IntValue = i, StringValue = i.ToString() }; } var mySerializer = new YamlSerializer(); var myDeserializer = new YamlDeserializer(); var defaultSerializer = new Serializer(); var defaultDeserializer = new Deserializer(); var watch = new Stopwatch(); while (true) { var sw = new StringWriter(); watch.Restart(); mySerializer.Serialize(sw, sourceList); var stime = watch.ElapsedMilliseconds; watch.Restart(); var list = myDeserializer.Deserialize<List<Item>>(new StringReader(sw.ToString())); var dtime = watch.ElapsedMilliseconds; Console.WriteLine("My - Serialize time: {0}ms, Deserialize time: {1}ms", stime, dtime); sw = new StringWriter(); watch.Restart(); defaultSerializer.Serialize(sw, sourceList); stime = watch.ElapsedMilliseconds; watch.Restart(); list = defaultDeserializer.Deserialize<List<Item>>(new StringReader(sw.ToString())); dtime = watch.ElapsedMilliseconds; Console.WriteLine("Default - Serialize time: {0}ms, Deserialize time: {1}ms", stime, dtime); } }
//private static Configuration ConfigOnDisk; public static LoadResult Load(string fileName) { if (!File.Exists(fileName)) { Logger.Log(null, "Config file not found. Creating a new one...", LogLevel.Info); try { var exampleConfigStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("BaggyBot.src.EmbeddedData.Configuration.example-config.yaml"); exampleConfigStream.CopyTo(File.Create(fileName)); } catch (Exception e) when (e is FileNotFoundException || e is FileLoadException || e is IOException) { Logger.Log(null, "Unable to load the default config file.", LogLevel.Error); Logger.Log(null, "Default config file not created. You might have to create one yourself.", LogLevel.Warning); return LoadResult.Failure; } return LoadResult.NewFileCreated; } var deserialiser = new Deserializer(namingConvention: new HyphenatedNamingConvention(), ignoreUnmatched: false); using (var reader = File.OpenText(fileName)) { Config = deserialiser.Deserialize<Configuration>(reader); } /*using (var reader = File.OpenText(fileName)) { ConfigOnDisk = deserialiser.Deserialize<Configuration>(reader); }*/ return LoadResult.Success; }
private void Initialize() { if (!JustInitialized) return; _serializer = new Serializer<SimpleJsonWriter>(_primaryType); _deserializer = new Deserializer<SimpleJsonReader>(_primaryType); JustInitialized = false; }
public void Generate_All() { Clean(); EnsurePathsExist(); var files = GetAllYamlFiles(); var deser = new Deserializer(); foreach( var file in files ) { //if( !file.Contains("random", StringComparison.OrdinalIgnoreCase) ) // continue;//just deal with random for now. Console.WriteLine("READING: " + file); var sr = new StringReader(File.ReadAllText(file)); var yamlTest = deser.Deserialize<YamlTest>(sr); var mutator = new CSharpTestMutator(yamlTest); mutator.MutateTests(); var outputFile = Path.Combine(OutputDir, Path.GetFileName( Path.ChangeExtension(file, ".cs"))); Console.WriteLine("OUTPUT: " + outputFile); var template = new TestTemplate() {YamlTest = yamlTest}; File.WriteAllText(outputFile, template.TransformText()); } }
public static AgentConfig LoadFromFile(string file) { AgentConfig ac; using (StreamReader sr = File.OpenText(file)) { Deserializer ds = new Deserializer(namingConvention: new CamelCaseNamingConvention()); ac = ds.Deserialize<AgentConfig>(sr); } CheckAgentConfigForNull(ac); ac = InitializeAgentConfigLists(ac); ac = SetDefaultTaskValues(ac); if (ac._checks != null) ac = LoadSerializedCheck(ac); if (ac._info != null) ac = LoadSerializedInfo(ac); if (ac._actions != null) ac = LoadSerializedActions(ac); return ac; }
public static NemesisConfig LoadFromFile(string file) { using (var sr = File.OpenText(file)) { var ds = new Deserializer(namingConvention: new CamelCaseNamingConvention()); return ds.Deserialize<NemesisConfig>(sr); } }
public void TestInit() { _fixture = new Fixture(); _jsonSerializer = new Mock<IJsonSerializer>(MockBehavior.Strict); _jsonDeserializer = new Mock<IJsonSerializer>(MockBehavior.Strict); _deserializer = new Deserializer<SampleSource>(_jsonSerializer.Object, _jsonDeserializer.Object); }
// Use this for initialization void Awake() { //Read in archetype file Reader = new StringReader(Resources.Load<TextAsset>("creatures").text); NPCReader = new StringReader(Resources.Load<TextAsset>("npcDefinitions").text); CamelCaseDeserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention()); DialogNPCs = new List<NpcData>(); }
static Config() { using (var reader = new StreamReader(File.OpenRead("config.yml"))) { var deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention()); Instance = deserializer.Deserialize<Config>(reader); } }
public NavMeshConfigurationFile(StreamReader input) { var deserializer = new Deserializer(namingConvention: new HyphenatedNamingConvention()); var data = deserializer.Deserialize<YamlData>(input); GenerationSettings = data.Config; ExportPath = data.Export; InputMeshes = data.Meshes; }
public override void Deserialize(Deserializer deserializer) { base.Deserialize(deserializer); var touched = new Capo<bool>(fingerprint, tag.Offset); if (touched[0]) { deserializer.Read(out message_); } }
public static void Load(string filename) { var buffer = File.ReadAllText("data//" + filename); var deserializer = new Deserializer(ignoreUnmatched: true); var config = deserializer.Deserialize<Config>(new StringReader(buffer)); Users = config.Users; }
public static SimpleDataView[] ReadControls(string cfgPath) { SimpleDataView[] views = null; var d = new Deserializer(); using(var reader = new StreamReader(cfgPath)) { views = d.Deserialize<SimpleDataView[]>(reader); } return views; }
public void PortalConfigDeserializationTest () { var defaultConfigFile = Path.Combine ("..", "..", "..", "R7.Epsilon", "Skins", "R7.Epsilon.yml"); using (var configReader = new StringReader (File.ReadAllText (defaultConfigFile))) { var deserializer = new Deserializer (namingConvention: new HyphenatedNamingConvention ()); Assert.NotNull (deserializer.Deserialize<EpsilonPortalConfig> (configReader)); } }
private void Initialize() { if (!JustInitialized) return; _serializer = new Serializer<FastBinaryWriter<OutputBuffer>>(_primaryType); _deserializer = new Deserializer<FastBinaryReader<InputBuffer>>(_primaryType); _serializerStream = new Serializer<FastBinaryWriter<OutputStream>>(_primaryType); _deserializerStream = new Deserializer<FastBinaryReader<InputStream>>(_primaryType); JustInitialized = false; }
public void InvalidXml_ThrowsXmlDeserializationFailureException() { var deserializer = new Deserializer(); var xml = XDocument.Parse("<?xml version=\"1.0\" encoding=\"UTF-16\"?><root></root>"); var exception = Assert.Throws<XmlDeserializationFailureException>(() => deserializer.Deserialize<schemeType>(xml)); Assert.NotNull(exception.InnerException); }
public void PortalConfigDeserializationTest (int portalNumber) { var configFile = Path.Combine ("..", "..", "..", "R7.Epsilon", "Customizations", "volgau.com", "Portals", portalNumber.ToString (), "R7.Epsilon.yml"); using (var configReader = new StringReader (File.ReadAllText (configFile))) { var deserializer = new Deserializer (namingConvention: new HyphenatedNamingConvention ()); Assert.NotNull (deserializer.Deserialize<EpsilonPortalConfig> (configReader)); } }
public static void Load(string filename) { var buffer = File.ReadAllText(filename); var deserializer = new Deserializer(ignoreUnmatched: true); var config = deserializer.Deserialize<Config>(new StringReader(buffer)); DatabaseConfiguration = config.DatabaseConfiguration; DebugLog = config.DebugLog; }
public void ReadString_ReadsCompactEmptyString() { var data = new byte[] { 0x00 }; var stream = new MemoryStream(data); var ds = new Deserializer(stream); var str = ds.ReadString(); Assert.AreEqual(string.Empty, str); }
private void LoadPlugins() { string text = File.ReadAllText(_pluginsYmlFile); Deserializer deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention()); PluginsConf pluginsConf = deserializer.Deserialize<PluginsConf>(new StringReader(text)); OnPluginsLoaded(new PluginsConfLoadedEventArgs(pluginsConf)); }
private List<CardDescriptor> LoadCards () { var deserializer = new Deserializer (namingConvention: new CamelCaseNamingConvention ()); var cardsString = new StringReader (cardAsset.text); List<CardDescriptor> cards = deserializer.Deserialize<List<CardDescriptor>> (cardsString); //PrintDebug(cards); return cards; }
public static Config Read(TextReader reader) { var deserializer = new Deserializer(null, new CamelCaseNamingConvention()); var deserialize = deserializer.Deserialize<Config>(reader); if (deserialize == null) { return new Config(); } return deserialize; }
public GameServer(Options options, GameObject gameObject) { m_options = options; m_gameObject = gameObject; m_players = new Dictionary<int, NetPlayer>(); m_sendQueue = new List<String>(); m_deserializer = new Deserializer(); m_eventProcessor = m_gameObject.AddComponent<EventProcessor>(); }
public void Run(string[] args) { // Setup the input var input = new StringReader(_document); var deserializer = new Deserializer(); var order = (Order)deserializer.Deserialize(input, typeof(Order)); Console.WriteLine("Receipt: {0}", order.Receipt); Console.WriteLine("Customer: {0} {1}", order.Customer.Given, order.Customer.Family); }
static JsonExtensions() { _javaScriptSerializer = new JavaScriptSerializer(); _serializer = _javaScriptSerializer.Serialize; _deserializer = _javaScriptSerializer.Deserialize; }
private void LoadData() { var deserializer = new Deserializer(); var fishYamlObject = deserializer.Deserialize(new StringReader(Resources.Fish)); var fishJToken = JToken.FromObject(fishYamlObject); Data.FishList = ((JObject)fishJToken["content"]).Properties().Select(pro => new { Id = int.Parse(pro.Name), Value = pro.Value.Value <string>().Split('/') }).Where(item => item.Value[1] != "trap") .Select(item => new Fish { Id = item.Id, Name = item.Value[0], MoveType = (MoveType)Enum.Parse(typeof(MoveType), item.Value[2].FirstLetterToUpper()), TimeRangeStart = int.Parse(item.Value[5].Split(' ')[0]) / 100, TimeRangeFinish = int.Parse(item.Value[5].Split(' ')[1]) / 100, Season = EnumIntialTool.GetSeason(item.Value[6].Split(' ')), Weather = (Weather)Enum.Parse(typeof(Weather), item.Value[7].FirstLetterToUpper()) }).ToList(); var locationObject = deserializer.Deserialize(new StringReader(Resources.Locations)); var locationJToken = JToken.FromObject(locationObject); Data.LocationList = ((JObject)locationJToken["content"]).Properties().Select(pro => new { Location = pro.Name, Value = pro.Value.Value <string>().Split('/') }).Select(item => new Location { Name = item.Location, Range = new Dictionary <Season, List <IdAndRate> > { { Season.Spring, IdAndRate.FromStrings(item.Value[0].Split(' ')) }, { Season.Summer, IdAndRate.FromStrings(item.Value[1].Split(' ')) }, { Season.Fall, IdAndRate.FromStrings(item.Value[2].Split(' ')) }, { Season.Winter, IdAndRate.FromStrings(item.Value[3].Split(' ')) }, }, Fish = new Dictionary <Season, List <IdAndState> > { { Season.Spring, IdAndState.FromStrings(item.Value[4].Split(' ')) }, { Season.Summer, IdAndState.FromStrings(item.Value[5].Split(' ')) }, { Season.Fall, IdAndState.FromStrings(item.Value[6].Split(' ')) }, { Season.Winter, IdAndState.FromStrings(item.Value[7].Split(' ')) }, }, Unkonw = IdAndRate.FromStrings(item.Value[8].Split(' ')) }).ToList(); List <string> fishNameCbItem = new List <string> { "Any" }; fishNameCbItem.AddRange(Data.FishList.Select(fish => fish.Name)); cbFishName.DataSource = fishNameCbItem; cbFishName.SelectedIndex = 0; cbSeason.DataSource = new List <string> { "Any", "Spring", "Summer", "Fall", "Winter" }; cbSeason.SelectedIndex = 0; List <string> locationCbItem = new List <string> { "Any" }; locationCbItem.AddRange(Data.LocationList.Select(loc => loc.Name)); cbLocation.DataSource = locationCbItem; cbLocation.SelectedIndex = 0; cbWeather.DataSource = new List <string> { "Any", "Both", "Sunny", "Rainy" }; cbWeather.SelectedIndex = 0; _loaded = true; ShowData(); }
private T ParseData <T>(Deserializer reader) where T : BaseMsg, new() { return(reader.Parse <T>()); }
internal void Import() { CreateFileStream(); _deserializer = new Deserializer(_xr); // If total count has been requested, return a dummy object with zero confidence if (_cmdlet.PagingParameters.IncludeTotalCount) { PSObject totalCount = _cmdlet.PagingParameters.NewTotalCount(0, 0); _cmdlet.WriteObject(totalCount); } ulong skip = _cmdlet.PagingParameters.Skip; ulong first = _cmdlet.PagingParameters.First; // if paging is not specified then keep the old V2 behavior if (skip == 0 && first == ulong.MaxValue) { while (!_deserializer.Done()) { object result = _deserializer.Deserialize(); _cmdlet.WriteObject(result); } } // else try to flatten the output if possible else { ulong skipped = 0; ulong count = 0; while (!_deserializer.Done() && count < first) { object result = _deserializer.Deserialize(); PSObject psObject = result as PSObject; if (psObject != null) { ICollection c = psObject.BaseObject as ICollection; if (c != null) { foreach (object o in c) { if (count >= first) { break; } if (skipped++ >= skip) { count++; _cmdlet.WriteObject(o); } } } else { if (skipped++ >= skip) { count++; _cmdlet.WriteObject(result); } } } else if (skipped++ >= skip) { count++; _cmdlet.WriteObject(result); continue; } } } }
public void Rate() { ConsoleLogger.Log("Starting rate."); ConsoleLogger.Log("Loading policy."); // load policy - open file policy.json string policyJson = PolicyReader.GetPolicyContent(); var policy = Deserializer.DeserializePolicy(policyJson); switch (policy.Type) { case PolicyType.Auto: ConsoleLogger.Log("Rating AUTO policy..."); ConsoleLogger.Log("Validating policy."); if (String.IsNullOrEmpty(policy.Make)) { ConsoleLogger.Log("Auto policy must specify Make"); return; } if (policy.Make == "BMW") { if (policy.Deductible < 500) { Rating = 1000m; } Rating = 900m; } break; case PolicyType.Land: ConsoleLogger.Log("Rating LAND policy..."); ConsoleLogger.Log("Validating policy."); if (policy.BondAmount == 0 || policy.Valuation == 0) { ConsoleLogger.Log("Land policy must specify Bond Amount and Valuation."); return; } if (policy.BondAmount < 0.8m * policy.Valuation) { ConsoleLogger.Log("Insufficient bond amount."); return; } Rating = policy.BondAmount * 0.05m; break; case PolicyType.Life: ConsoleLogger.Log("Rating LIFE policy..."); ConsoleLogger.Log("Validating policy."); if (policy.DateOfBirth == DateTime.MinValue) { ConsoleLogger.Log("Life policy must include Date of Birth."); return; } if (policy.DateOfBirth < DateTime.Today.AddYears(-100)) { ConsoleLogger.Log("Centenarians are not eligible for coverage."); return; } if (policy.Amount == 0) { ConsoleLogger.Log("Life policy must include an Amount."); return; } int age = DateTime.Today.Year - policy.DateOfBirth.Year; if (policy.DateOfBirth.Month == DateTime.Today.Month && DateTime.Today.Day < policy.DateOfBirth.Day || DateTime.Today.Month < policy.DateOfBirth.Month) { age--; } decimal baseRate = policy.Amount * age / 200; if (policy.IsSmoker) { Rating = baseRate * 2; break; } Rating = baseRate; break; default: ConsoleLogger.Log("Unknown policy type"); break; } ConsoleLogger.Log("Rating completed."); }
/// <summary> /// Deserializes the specified json string as either a Dictionary[string, object] or as a List[object] /// depending on the syntax of the JSON string. /// </summary> /// <param name="json">The json.</param> /// <returns>Type of the current deserializes.</returns> /// <example> /// The following code shows how to deserialize a JSON string into a Dictionary. /// <code> /// using Unosquare.Swan.Formatters; /// /// class Example /// { /// static void Main() /// { /// // json to deserialize /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}"; /// /// // deserializes the specified json into a Dictionary<string, object>. /// var data = Json.Deserialize(basicJson); /// } /// } /// </code> /// </example> public static object Deserialize(string json) => Deserializer.DeserializeInternal(json);
public override void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadInt16(); }
/// <summary> /// Deserializes the property value /// </summary> /// <param name="Input">Binary representation.</param> /// <param name="ExpectedType">Expected Type</param> /// <returns>Deserialized value.</returns> public abstract object Deserialize(Deserializer Input, Type ExpectedType);
public override void DeserializeRequest(ArraySegment <byte> val) { Request = Deserializer.Deserialize <TRequest>(val); }
internal EncodedConnection(Options opts) : base(opts) { onSerialize = defaultSerializer; onDeserialize = defaultDeserializer; }
/// <summary> /// Loads and fills a <see cref="ConfigurationStore"/> using UTF-8 encoding. /// </summary> /// <param name="entryFilePath">Path of the entry file.</param> /// <param name="deserializer">The deserializer to deserialize files. It must support <see cref="DeserializerBuilder.IgnoreUnmatchedProperties"/>.</param> /// <returns></returns> public static ConfigurationStore Load([NotNull] string entryFilePath, [NotNull] Deserializer deserializer) { return(Load(entryFilePath, deserializer, Encoding.UTF8)); }
public override void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadVarint(); }
public override void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadVarint(); this.Unknown1 = deserializer.ReadWorldPosition(); this.Unknown2 = deserializer.ReadSingle(); }
public static GameObject FromJson(Deserializer deserializer) { var(coords, halfsize, origin) = PositionJson.FromJson(deserializer.getData()); return(new Ladder(coords, halfsize)); }
/// <summary> /// Adds serialization delegates for <paramref name="type"/>. /// </summary> /// <param name="serializerFeature">The serializer feature.</param> /// <param name="type">The type.</param> /// <param name="copier">The copy delegate.</param> /// <param name="serializer">The serializer delegate.</param> /// <param name="deserializer">The deserializer delegate.</param> /// <param name="overrideExisting">Whether or not to override existing registrations.</param> public static void AddSerializerDelegates(this SerializerFeature serializerFeature, Type type, DeepCopier copier, Serializer serializer, Deserializer deserializer, bool overrideExisting) { serializerFeature.SerializerDelegates.Add(new SerializerDelegateMetadata(type, copier, serializer, deserializer, overrideExisting)); }
public void Deserialize(Deserializer deserializer) { }
/// <summary> /// Deserializes the specified json string and converts it to the specified object type. /// </summary> /// <param name="json">The json.</param> /// <param name="resultType">Type of the result.</param> /// <param name="includeNonPublic">if set to true, it also uses the non-public constructors and property setters.</param> /// <returns>Type of the current conversion from json result.</returns> public static object Deserialize(string json, Type resultType, bool includeNonPublic = false) => Converter.FromJsonResult(Deserializer.DeserializeInternal(json), resultType, includeNonPublic);
public void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadUtf16String(); }
public static T Deserialize <T>(IReader reader) { return(Deserializer <T> .DeserializeFunc(reader)); }
public override void Deserialize(Deserializer reader) { AnnotationStr = reader.ReadString(); }
public override void Deserialize(Deserializer deserializer) { }
public MarkdownConverterService(ILogger <MarkdownConverterService> logger) { this.logger = logger; yamlDeserializer = new Deserializer(); jsonSerializer = new JsonSerializer(); }
public override void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadVarint(); this.Unknown1 = deserializer.ReadUtf16String(); }
public override void Deserialize(Deserializer reader) { tick = reader.GetInt32(); inputDatas = reader.GetBytes(); AfterDeserialize(); }
public void TestVariableLengthInt64() { //using (var stream = new MemoryStream()) { var stream = new x2net.Buffer(); Serializer serializer = new Serializer(stream); Deserializer deserializer = new Deserializer(stream); // Boundary value tests serializer.Write(0L); serializer.Write(-1L); serializer.Write(Int64.MaxValue); serializer.Write(Int64.MinValue); stream.Rewind(); //stream.Seek(0, SeekOrigin.Begin); long l; long bytes = deserializer.Read(out l); Assert.Equal(1, bytes); Assert.Equal(0L, l); bytes = deserializer.Read(out l); Assert.Equal(1, bytes); Assert.Equal(-1L, l); bytes = deserializer.Read(out l); Assert.Equal(10, bytes); Assert.Equal(Int64.MaxValue, l); bytes = deserializer.Read(out l); Assert.Equal(10, bytes); Assert.Equal(Int64.MinValue, l); stream.Trim(); //stream.SetLength(0); // Intermediate value tests serializer.Write(0x00003f80L >> 1); // 2 serializer.Write(0x001fc000L >> 1); // 3 serializer.Write(0x0fe00000L >> 1); // 4 serializer.Write(0x00000007f0000000L >> 1); // 5 serializer.Write(0x000003f800000000L >> 1); // 6 serializer.Write(0x0001fc0000000000L >> 1); // 7 serializer.Write(0x00fe000000000000L >> 1); // 8 serializer.Write(0x7f00000000000000L >> 1); // 9 stream.Rewind(); //stream.Seek(0, SeekOrigin.Begin); bytes = deserializer.Read(out l); Assert.Equal(2, bytes); Assert.Equal(0x00003f80L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(3, bytes); Assert.Equal(0x001fc000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(4, bytes); Assert.Equal(0x0fe00000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(5, bytes); Assert.Equal(0x00000007f0000000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(6, bytes); Assert.Equal(0x000003f800000000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(7, bytes); Assert.Equal(0x0001fc0000000000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(8, bytes); Assert.Equal(0x00fe000000000000L >> 1, l); bytes = deserializer.Read(out l); Assert.Equal(9, bytes); Assert.Equal(0x7f00000000000000L >> 1, l); } }
public override void Deserialize(Deserializer reader) { type = reader.GetByte(); size = reader.GetByte(); name = reader.GetString(); }
public static List <Weather> GetClimate() { var deserializer = new Deserializer(); return(deserializer.Deserialize <List <Weather> >(ForestClimate)); }
public void Deserialize(Deserializer reader) { throw new NotImplementedException(); }
private static ViewDefinition GetView(PSPropertyExpressionFactory expressionFactory, TypeInfoDataBase db, System.Type mainControlType, Collection <string> typeNames, string viewName) { TypeMatch match = new TypeMatch(expressionFactory, db, typeNames); foreach (ViewDefinition vd in db.viewDefinitionsSection.viewDefinitionList) { if (vd == null || mainControlType != vd.mainControl.GetType()) { ActiveTracer.WriteLine( "NOT MATCH {0} NAME: {1}", ControlBase.GetControlShapeName(vd.mainControl), (vd != null ? vd.name : string.Empty)); continue; } if (IsOutOfBandView(vd)) { ActiveTracer.WriteLine( "NOT MATCH OutOfBand {0} NAME: {1}", ControlBase.GetControlShapeName(vd.mainControl), vd.name); continue; } if (vd.appliesTo == null) { ActiveTracer.WriteLine( "NOT MATCH {0} NAME: {1} No applicable types", ControlBase.GetControlShapeName(vd.mainControl), vd.name); continue; } // first make sure we match on name: // if not, we do not try a match at all if (viewName != null && !string.Equals(vd.name, viewName, StringComparison.OrdinalIgnoreCase)) { ActiveTracer.WriteLine( "NOT MATCH {0} NAME: {1}", ControlBase.GetControlShapeName(vd.mainControl), vd.name); continue; } // check if we have a perfect match // if so, we are done try { TypeMatch.SetTracer(ActiveTracer); if (match.PerfectMatch(new TypeMatchItem(vd, vd.appliesTo))) { TraceHelper(vd, true); return(vd); } } finally { TypeMatch.ResetTracer(); } TraceHelper(vd, false); } // this is the best match we had ViewDefinition result = GetBestMatch(match); // we were unable to find a best match so far..try // to get rid of Deserialization prefix and see if a // match can be found. if (result == null) { Collection <string> typesWithoutPrefix = Deserializer.MaskDeserializationPrefix(typeNames); if (typesWithoutPrefix != null) { result = GetView(expressionFactory, db, mainControlType, typesWithoutPrefix, viewName); } } return(result); }
public void Deserialize(Deserializer deserializer) { this.Unknown0 = deserializer.ReadVarint(); this.Unknown1 = deserializer.ReadVarint(); }