using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("D181CDA7-EF07-4BBC-B975-2B80FC6BBFAE")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyProduct("CrystalArrows")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("CrystalArrows")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace CrystalArrows
{
[BepInPlugin("org.bepinex.plugins.crystalarrows", "CrystalArrows", "1.0.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class CrystalArrows : BaseUnityPlugin
{
private enum Toggle
{
On = 1,
Off = 0
}
private const string ModName = "CrystalArrows";
private const string ModVersion = "1.0.2";
private const string ModGUID = "org.bepinex.plugins.crystalarrows";
private static readonly ConfigSync configSync = new ConfigSync("CrystalArrows")
{
DisplayName = "CrystalArrows",
CurrentVersion = "1.0.2",
MinimumRequiredVersion = "1.0.2"
};
private static ConfigEntry<Toggle> serverConfigLocked = null;
private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
{
ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
return val;
}
private ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
}
public void Awake()
{
//IL_092f: Unknown result type (might be due to invalid IL or missing references)
//IL_0936: Expected O, but got Unknown
Localizer.Load();
Item item = new Item("jewelarrows", "JC_Crystal_Arrow_Black");
item.Configurable = Configurability.Full;
item["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item["Shard Recipe"].RequiredItems.Add("Shattered_Black_Crystal", 10);
item["Shard Recipe"].RequiredItems.Add("Wood", 5);
item["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item["Shard Recipe"].CraftAmount = 20;
item["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item["Crystal Recipe"].RequiredItems.Add("Simple_Black_Socket", 1);
item["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Black");
Item item2 = new Item("jewelarrows", "JC_Crystal_Arrow_Blue");
item2.Configurable = Configurability.Full;
item2["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item2["Shard Recipe"].RequiredItems.Add("Shattered_Blue_Crystal", 10);
item2["Shard Recipe"].RequiredItems.Add("Wood", 5);
item2["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item2["Shard Recipe"].CraftAmount = 20;
item2["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item2["Crystal Recipe"].RequiredItems.Add("Simple_Blue_Socket", 1);
item2["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item2["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item2["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Blue");
Item item3 = new Item("jewelarrows", "JC_Crystal_Arrow_Green");
item3.Configurable = Configurability.Full;
item3["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item3["Shard Recipe"].RequiredItems.Add("Shattered_Green_Crystal", 10);
item3["Shard Recipe"].RequiredItems.Add("Wood", 5);
item3["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item3["Shard Recipe"].CraftAmount = 20;
item3["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item3["Crystal Recipe"].RequiredItems.Add("Simple_Green_Socket", 1);
item3["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item3["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item3["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Green");
Item item4 = new Item("jewelarrows", "JC_Crystal_Arrow_Orange");
item4.Configurable = Configurability.Full;
item4["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item4["Shard Recipe"].RequiredItems.Add("Shattered_Orange_Crystal", 10);
item4["Shard Recipe"].RequiredItems.Add("Wood", 5);
item4["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item4["Shard Recipe"].CraftAmount = 20;
item4["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item4["Crystal Recipe"].RequiredItems.Add("Simple_Orange_Socket", 1);
item4["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item4["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item4["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Orange");
Item item5 = new Item("jewelarrows", "JC_Crystal_Arrow_Purple");
item5.Configurable = Configurability.Full;
item5["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item5["Shard Recipe"].RequiredItems.Add("Shattered_Purple_Crystal", 10);
item5["Shard Recipe"].RequiredItems.Add("Wood", 5);
item5["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item5["Shard Recipe"].CraftAmount = 20;
item5["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item5["Crystal Recipe"].RequiredItems.Add("Simple_Purple_Socket", 1);
item5["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item5["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item5["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Purple");
Item item6 = new Item("jewelarrows", "JC_Crystal_Arrow_Red");
item6.Configurable = Configurability.Full;
item6["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item6["Shard Recipe"].RequiredItems.Add("Shattered_Red_Crystal", 10);
item6["Shard Recipe"].RequiredItems.Add("Wood", 5);
item6["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item6["Shard Recipe"].CraftAmount = 20;
item6["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item6["Crystal Recipe"].RequiredItems.Add("Simple_Red_Socket", 1);
item6["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item6["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item6["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Red");
Item item7 = new Item("jewelarrows", "JC_Crystal_Arrow_Yellow");
item7.Configurable = Configurability.Full;
item7["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
item7["Shard Recipe"].RequiredItems.Add("Shattered_Yellow_Crystal", 10);
item7["Shard Recipe"].RequiredItems.Add("Wood", 5);
item7["Shard Recipe"].RequiredItems.Add("Feathers", 2);
item7["Shard Recipe"].CraftAmount = 20;
item7["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
item7["Crystal Recipe"].RequiredItems.Add("Simple_Yellow_Socket", 1);
item7["Crystal Recipe"].RequiredItems.Add("Wood", 5);
item7["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
item7["Crystal Recipe"].CraftAmount = 20;
PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Yellow");
PrefabManager.RegisterPrefab("jewelarrows", "sfx_jc_arrow_hit");
PrefabManager.RegisterPrefab("jewelarrows", "VFX_JC_Arrow_Hit");
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Harmony val = new Harmony("org.bepinex.plugins.crystalarrows");
val.PatchAll(executingAssembly);
}
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
internal sealed class <b89b921d-8954-4084-bd4d-1feb826a594e>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
internal sealed class <bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace LocalizationManager
{
[<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(1)]
[PublicAPI]
[<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(0)]
internal class Localizer
{
private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;
private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;
private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;
private static readonly List<WeakReference<Localization>> localizationObjects;
[<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(2)]
private static BaseUnityPlugin _plugin;
private static readonly List<string> fileExtensions;
private static BaseUnityPlugin plugin
{
get
{
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Expected O, but got Unknown
if (_plugin == null)
{
IEnumerable<TypeInfo> source;
try
{
source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
}
catch (ReflectionTypeLoadException ex)
{
source = from t in ex.Types
where t != null
select t.GetTypeInfo();
}
_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
}
return _plugin;
}
}
private static void UpdatePlaceholderText(Localization localization, string key)
{
localizationLanguage.TryGetValue(localization, out var value);
string text = loadedTexts[value][key];
if (PlaceholderProcessors.TryGetValue(key, out var value2))
{
text = value2.Aggregate(text, [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
}
localization.AddWord(key, text);
}
public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
{
if (convertConfigValue == null)
{
convertConfigValue = [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] [return: <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(1)] (T val) => val.ToString();
}
if (!PlaceholderProcessors.ContainsKey(key))
{
PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
}
config.SettingChanged += [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (object _, EventArgs _) =>
{
UpdatePlaceholder();
};
if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
{
UpdatePlaceholder();
}
void UpdatePlaceholder()
{
PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
UpdatePlaceholderText(Localization.instance, key);
}
}
public static void AddText(string key, string text)
{
List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
foreach (WeakReference<Localization> localizationObject in localizationObjects)
{
if (localizationObject.TryGetTarget(out var target))
{
Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
if (!target.m_translations.ContainsKey(key))
{
dictionary[key] = text;
target.AddWord(key, text);
}
}
else
{
list.Add(localizationObject);
}
}
foreach (WeakReference<Localization> item in list)
{
localizationObjects.Remove(item);
}
}
public static void Load()
{
LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
}
private static void LoadLocalization(Localization __instance, string language)
{
if (!localizationLanguage.Remove(__instance))
{
localizationObjects.Add(new WeakReference<Localization>(__instance));
}
localizationLanguage.Add(__instance, language);
Dictionary<string, string> dictionary = new Dictionary<string, string>();
foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
select f)
{
string text = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
if (dictionary.ContainsKey(text))
{
Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
}
else
{
dictionary[text] = item;
}
}
byte[] array = LoadTranslationFromAssembly("English");
if (array == null)
{
throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
}
Dictionary<string, string> dictionary2 = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
if (dictionary2 == null)
{
throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
}
string text2 = null;
if (language != "English")
{
if (dictionary.ContainsKey(language))
{
text2 = File.ReadAllText(dictionary[language]);
}
else
{
byte[] array2 = LoadTranslationFromAssembly(language);
if (array2 != null)
{
text2 = Encoding.UTF8.GetString(array2);
}
}
}
if (text2 == null && dictionary.ContainsKey("English"))
{
text2 = File.ReadAllText(dictionary["English"]);
}
if (text2 != null)
{
foreach (KeyValuePair<string, string> item2 in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
{
dictionary2[item2.Key] = item2.Value;
}
}
loadedTexts[language] = dictionary2;
foreach (KeyValuePair<string, string> item3 in dictionary2)
{
UpdatePlaceholderText(__instance, item3.Key);
}
}
static Localizer()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
loadedTexts = new Dictionary<string, Dictionary<string, string>>();
localizationLanguage = new ConditionalWeakTable<Localization, string>();
localizationObjects = new List<WeakReference<Localization>>();
fileExtensions = new List<string> { ".json", ".yml" };
new Harmony("org.bepinex.helpers.LocalizationManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
[return: <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(2)]
private static byte[] LoadTranslationFromAssembly(string language)
{
foreach (string fileExtension in fileExtensions)
{
byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
if (array != null)
{
return array;
}
}
return null;
}
[<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(2)]
public static byte[] ReadEmbeddedFileBytes([<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
{
using MemoryStream memoryStream = new MemoryStream();
if ((object)containingAssembly == null)
{
containingAssembly = Assembly.GetCallingAssembly();
}
string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
if (text != null)
{
containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
}
return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
}
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<9769ba02-5026-4d94-8c8e-b51fb74b9bab>Embedded]
internal sealed class <9769ba02-5026-4d94-8c8e-b51fb74b9bab>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[<9769ba02-5026-4d94-8c8e-b51fb74b9bab>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class <1a5dc612-6501-416d-b792-3ff5b270eef3>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <1a5dc612-6501-416d-b792-3ff5b270eef3>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <1a5dc612-6501-416d-b792-3ff5b270eef3>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[<9769ba02-5026-4d94-8c8e-b51fb74b9bab>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class <2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
internal sealed class AllowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
internal sealed class DisallowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
internal sealed class DoesNotReturnAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal sealed class DoesNotReturnIfAttribute : Attribute
{
public bool ParameterValue { get; }
public DoesNotReturnIfAttribute(bool parameterValue)
{
ParameterValue = parameterValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
internal sealed class MaybeNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal sealed class MaybeNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public MaybeNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
internal sealed class NotNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class NotNullIfNotNullAttribute : Attribute
{
public string ParameterName { get; }
public NotNullIfNotNullAttribute(string parameterName)
{
ParameterName = parameterName;
}
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal sealed class NotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public NotNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
}
namespace System.Collections.Generic
{
internal static class DeconstructionExtensions
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public static void Deconstruct<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TKey, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TValue>([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
{
key = pair.Key;
value = pair.Value;
}
}
}
namespace YamlDotNet
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class CultureInfoAdapter : CultureInfo
{
private readonly IFormatProvider provider;
public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
: base(baseCulture.LCID)
{
this.provider = provider;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
public override object GetFormat(Type formatType)
{
return provider.GetFormat(formatType);
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal static class ReflectionExtensions
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static Type BaseType(this Type type)
{
return type.BaseType;
}
public static bool IsValueType(this Type type)
{
return type.IsValueType;
}
public static bool IsGenericType(this Type type)
{
return type.IsGenericType;
}
public static bool IsGenericTypeDefinition(this Type type)
{
return type.IsGenericTypeDefinition;
}
public static bool IsInterface(this Type type)
{
return type.IsInterface;
}
public static bool IsEnum(this Type type)
{
return type.IsEnum;
}
public static bool IsDbNull(this object value)
{
return value is DBNull;
}
public static bool HasDefaultConstructor(this Type type)
{
if (!type.IsValueType)
{
return type.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null) != null;
}
return true;
}
public static TypeCode GetTypeCode(this Type type)
{
return Type.GetTypeCode(type);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static PropertyInfo GetPublicProperty(this Type type, string name)
{
return type.GetProperty(name);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static FieldInfo GetPublicStaticField(this Type type, string name)
{
return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
}
public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
{
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (includeNonPublic)
{
bindingFlags |= BindingFlags.NonPublic;
}
if (!type.IsInterface)
{
return type.GetProperties(bindingFlags);
}
return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (Type i) => i.GetProperties(bindingFlags));
}
public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
{
return type.GetProperties(includeNonPublic: false);
}
public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
{
return type.GetFields(BindingFlags.Instance | BindingFlags.Public);
}
public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
{
return type.GetMethods(BindingFlags.Static | BindingFlags.Public);
}
public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
{
return type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
{
return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
{
return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
}
public static Exception Unwrap(this TargetInvocationException ex)
{
Exception innerException = ex.InnerException;
if (innerException == null)
{
return ex;
}
if (RemoteStackTraceField != null)
{
RemoteStackTraceField.SetValue(innerException, innerException.StackTrace + "\r\n");
}
return innerException;
}
public static bool IsInstanceOf(this Type type, object o)
{
return type.IsInstanceOfType(o);
}
public static Attribute[] GetAllCustomAttributes<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TAttribute>(this PropertyInfo property)
{
return Attribute.GetCustomAttributes(property, typeof(TAttribute));
}
}
internal static class PropertyInfoExtensions
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public static object ReadValue(this PropertyInfo property, object target)
{
return property.GetValue(target, null);
}
}
internal static class StandardRegexOptions
{
public const RegexOptions Compiled = RegexOptions.Compiled;
}
}
namespace YamlDotNet.Serialization
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal abstract class BuilderSkeleton<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
{
internal INamingConvention namingConvention = NullNamingConvention.Instance;
internal ITypeResolver typeResolver;
internal readonly YamlAttributeOverrides overrides;
internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;
internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;
private bool ignoreFields;
private bool includeNonPublicProperties;
protected abstract TBuilder Self { get; }
internal BuilderSkeleton(ITypeResolver typeResolver)
{
overrides = new YamlAttributeOverrides();
typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
{
{
typeof(YamlDotNet.Serialization.Converters.GuidConverter),
(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
},
{
typeof(SystemTypeConverter),
(Nothing _) => new SystemTypeConverter()
}
};
typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
}
internal ITypeInspector BuildTypeInspector()
{
ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
if (!ignoreFields)
{
typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
}
return typeInspectorFactories.BuildComponentChain(typeInspector);
}
public TBuilder IgnoreFields()
{
ignoreFields = true;
return Self;
}
public TBuilder IncludeNonPublicProperties()
{
includeNonPublicProperties = true;
return Self;
}
public TBuilder WithNamingConvention(INamingConvention namingConvention)
{
this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
return Self;
}
public TBuilder WithTypeResolver(ITypeResolver typeResolver)
{
this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
return Self;
}
public abstract TBuilder WithTagMapping(TagName tag, Type type);
public TBuilder WithAttributeOverride<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
{
overrides.Add(propertyAccessor, attribute);
return Self;
}
public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
{
overrides.Add(type, member, attribute);
return Self;
}
public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
{
return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
{
w.OnTop();
});
}
public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
{
if (typeConverter == null)
{
throw new ArgumentNullException("typeConverter");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
return Self;
}
public TBuilder WithTypeConverter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
{
if (typeConverterFactory == null)
{
throw new ArgumentNullException("typeConverterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
return Self;
}
public TBuilder WithoutTypeConverter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
{
return WithoutTypeConverter(typeof(TYamlTypeConverter));
}
public TBuilder WithoutTypeConverter(Type converterType)
{
if (converterType == null)
{
throw new ArgumentNullException("converterType");
}
typeConverterFactories.Remove(converterType);
return Self;
}
public TBuilder WithTypeInspector<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
{
return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
{
w.OnTop();
});
}
public TBuilder WithTypeInspector<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
if (typeInspectorFactory == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
return Self;
}
public TBuilder WithTypeInspector<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
if (typeInspectorFactory == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
return Self;
}
public TBuilder WithoutTypeInspector<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TTypeInspector>() where TTypeInspector : ITypeInspector
{
return WithoutTypeInspector(typeof(TTypeInspector));
}
public TBuilder WithoutTypeInspector(Type inspectorType)
{
if (inspectorType == null)
{
throw new ArgumentNullException("inspectorType");
}
typeInspectorFactories.Remove(inspectorType);
return Self;
}
protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
{
return typeConverterFactories.BuildComponentList();
}
}
internal delegate TComponent WrapperFactory<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
internal delegate TComponent WrapperFactory<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TArgument, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
[Flags]
internal enum DefaultValuesHandling
{
Preserve = 0,
OmitNull = 1,
OmitDefaults = 2,
OmitEmptyCollections = 4
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class Deserializer : IDeserializer
{
private readonly IValueDeserializer valueDeserializer;
public Deserializer()
: this(new DeserializerBuilder().BuildValueDeserializer())
{
}
private Deserializer(IValueDeserializer valueDeserializer)
{
this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
}
public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
{
return new Deserializer(valueDeserializer);
}
public T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(string input)
{
using StringReader input2 = new StringReader(input);
return Deserialize<T>(input2);
}
public T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(TextReader input)
{
return Deserialize<T>(new Parser(input));
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Deserialize(TextReader input)
{
return Deserialize(input, typeof(object));
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Deserialize(string input, Type type)
{
using StringReader input2 = new StringReader(input);
return Deserialize(input2, type);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Deserialize(TextReader input, Type type)
{
return Deserialize(new Parser(input), type);
}
public T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(IParser parser)
{
return (T)Deserialize(parser, typeof(T));
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Deserialize(IParser parser)
{
return Deserialize(parser, typeof(object));
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Deserialize(IParser parser, Type type)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
YamlDotNet.Core.Events.StreamStart @event;
bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
YamlDotNet.Core.Events.DocumentStart event2;
bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
object result = null;
if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
{
using SerializerState serializerState = new SerializerState();
result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
serializerState.OnDeserialization();
}
if (flag2)
{
parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
}
if (flag)
{
parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
}
return result;
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 0, 1 })]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
{
private Lazy<IObjectFactory> objectFactory;
private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;
private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;
private readonly Dictionary<TagName, Type> tagMappings;
private readonly Dictionary<Type, Type> typeMappings;
private bool ignoreUnmatched;
protected override DeserializerBuilder Self => this;
public DeserializerBuilder()
: base((ITypeResolver)new StaticTypeResolver())
{
typeMappings = new Dictionary<Type, Type>();
objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings), isThreadSafe: true);
tagMappings = new Dictionary<TagName, Type>
{
{
FailsafeSchema.Tags.Map,
typeof(Dictionary<object, object>)
},
{
FailsafeSchema.Tags.Str,
typeof(string)
},
{
JsonSchema.Tags.Bool,
typeof(bool)
},
{
JsonSchema.Tags.Float,
typeof(double)
},
{
JsonSchema.Tags.Int,
typeof(int)
},
{
DefaultSchema.Tags.Timestamp,
typeof(DateTime)
}
};
typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
typeInspectorFactories.Add(typeof(ReadableAndWritablePropertiesTypeInspector), (ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner));
nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
{
{
typeof(YamlConvertibleNodeDeserializer),
(Nothing _) => new YamlConvertibleNodeDeserializer(objectFactory.Value)
},
{
typeof(YamlSerializableNodeDeserializer),
(Nothing _) => new YamlSerializableNodeDeserializer(objectFactory.Value)
},
{
typeof(TypeConverterNodeDeserializer),
(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
},
{
typeof(NullNodeDeserializer),
(Nothing _) => new NullNodeDeserializer()
},
{
typeof(ScalarNodeDeserializer),
(Nothing _) => new ScalarNodeDeserializer()
},
{
typeof(ArrayNodeDeserializer),
(Nothing _) => new ArrayNodeDeserializer()
},
{
typeof(DictionaryNodeDeserializer),
(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value)
},
{
typeof(CollectionNodeDeserializer),
(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
},
{
typeof(EnumerableNodeDeserializer),
(Nothing _) => new EnumerableNodeDeserializer()
},
{
typeof(ObjectNodeDeserializer),
(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched)
}
};
nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
{
{
typeof(MappingNodeTypeResolver),
(Nothing _) => new MappingNodeTypeResolver(typeMappings)
},
{
typeof(YamlConvertibleTypeResolver),
(Nothing _) => new YamlConvertibleTypeResolver()
},
{
typeof(YamlSerializableTypeResolver),
(Nothing _) => new YamlSerializableTypeResolver()
},
{
typeof(TagNodeTypeResolver),
(Nothing _) => new TagNodeTypeResolver(tagMappings)
},
{
typeof(PreventUnknownTagsNodeTypeResolver),
(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
},
{
typeof(DefaultContainersNodeTypeResolver),
(Nothing _) => new DefaultContainersNodeTypeResolver()
}
};
}
public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
{
if (objectFactory == null)
{
throw new ArgumentNullException("objectFactory");
}
this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, isThreadSafe: true);
return this;
}
public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
{
if (objectFactory == null)
{
throw new ArgumentNullException("objectFactory");
}
return WithObjectFactory(new LambdaObjectFactory(objectFactory));
}
public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
{
return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
{
w.OnTop();
});
}
public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
{
if (nodeDeserializer == null)
{
throw new ArgumentNullException("nodeDeserializer");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
return this;
}
public DeserializerBuilder WithNodeDeserializer<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
{
if (nodeDeserializerFactory == null)
{
throw new ArgumentNullException("nodeDeserializerFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeDeserializer<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
{
return WithoutNodeDeserializer(typeof(TNodeDeserializer));
}
public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
{
if (nodeDeserializerType == null)
{
throw new ArgumentNullException("nodeDeserializerType");
}
nodeDeserializerFactories.Remove(nodeDeserializerType);
return this;
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
{
return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
{
w.OnTop();
});
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
{
if (nodeTypeResolver == null)
{
throw new ArgumentNullException("nodeTypeResolver");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
return this;
}
public DeserializerBuilder WithNodeTypeResolver<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
{
if (nodeTypeResolverFactory == null)
{
throw new ArgumentNullException("nodeTypeResolverFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeTypeResolver<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
{
return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
}
public DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
{
if (nodeTypeResolverType == null)
{
throw new ArgumentNullException("nodeTypeResolverType");
}
nodeTypeResolverFactories.Remove(nodeTypeResolverType);
return this;
}
public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
{
if (tag.IsEmpty)
{
throw new ArgumentException("Non-specific tags cannot be maped");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (tagMappings.TryGetValue(tag, out var value))
{
throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
}
tagMappings.Add(tag, type);
return this;
}
public DeserializerBuilder WithTypeMapping<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TInterface, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TConcrete>() where TConcrete : TInterface
{
Type typeFromHandle = typeof(TInterface);
Type typeFromHandle2 = typeof(TConcrete);
if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
{
throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
}
if (typeMappings.ContainsKey(typeFromHandle))
{
typeMappings[typeFromHandle] = typeFromHandle2;
}
else
{
typeMappings.Add(typeFromHandle, typeFromHandle2);
}
return this;
}
public DeserializerBuilder WithoutTagMapping(TagName tag)
{
if (tag.IsEmpty)
{
throw new ArgumentException("Non-specific tags cannot be maped");
}
if (!tagMappings.Remove(tag))
{
throw new KeyNotFoundException($"Tag '{tag}' is not registered");
}
return this;
}
public DeserializerBuilder IgnoreUnmatchedProperties()
{
ignoreUnmatched = true;
return this;
}
public IDeserializer Build()
{
return Deserializer.FromValueDeserializer(BuildValueDeserializer());
}
public IValueDeserializer BuildValueDeserializer()
{
return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList()));
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class EmissionPhaseObjectGraphVisitorArgs
{
private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;
public IObjectGraphVisitor<IEmitter> InnerVisitor { get; private set; }
public IEventEmitter EventEmitter { get; private set; }
public ObjectSerializer NestedObjectSerializer { get; private set; }
public IEnumerable<IYamlTypeConverter> TypeConverters { get; private set; }
public EmissionPhaseObjectGraphVisitorArgs(IObjectGraphVisitor<IEmitter> innerVisitor, IEventEmitter eventEmitter, IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
{
InnerVisitor = innerVisitor ?? throw new ArgumentNullException("innerVisitor");
EventEmitter = eventEmitter ?? throw new ArgumentNullException("eventEmitter");
this.preProcessingPhaseVisitors = preProcessingPhaseVisitors ?? throw new ArgumentNullException("preProcessingPhaseVisitors");
TypeConverters = typeConverters ?? throw new ArgumentNullException("typeConverters");
NestedObjectSerializer = nestedObjectSerializer ?? throw new ArgumentNullException("nestedObjectSerializer");
}
public T GetPreProcessingPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] T>() where T : IObjectGraphVisitor<Nothing>
{
return preProcessingPhaseVisitors.OfType<T>().Single();
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal abstract class EventInfo
{
public IObjectDescriptor Source { get; }
protected EventInfo(IObjectDescriptor source)
{
Source = source ?? throw new ArgumentNullException("source");
}
}
internal class AliasEventInfo : EventInfo
{
public AnchorName Alias { get; }
public bool NeedsExpansion { get; set; }
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
: base(source)
{
if (alias.IsEmpty)
{
throw new ArgumentNullException("alias");
}
Alias = alias;
}
}
internal class ObjectEventInfo : EventInfo
{
public AnchorName Anchor { get; set; }
public TagName Tag { get; set; }
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
protected ObjectEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class ScalarEventInfo : ObjectEventInfo
{
public string RenderedValue { get; set; }
public ScalarStyle Style { get; set; }
public bool IsPlainImplicit { get; set; }
public bool IsQuotedImplicit { get; set; }
public ScalarEventInfo(IObjectDescriptor source)
: base(source)
{
Style = source.ScalarStyle;
RenderedValue = string.Empty;
}
}
internal sealed class MappingStartEventInfo : ObjectEventInfo
{
public bool IsImplicit { get; set; }
public MappingStyle Style { get; set; }
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public MappingStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class MappingEndEventInfo : EventInfo
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public MappingEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class SequenceStartEventInfo : ObjectEventInfo
{
public bool IsImplicit { get; set; }
public SequenceStyle Style { get; set; }
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public SequenceStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class SequenceEndEventInfo : EventInfo
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public SequenceEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IAliasProvider
{
AnchorName GetAlias(object target);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IDeserializer
{
T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(string input);
T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(TextReader input);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Deserialize(TextReader input);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Deserialize(string input, Type type);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Deserialize(TextReader input, Type type);
T Deserialize<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] T>(IParser parser);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Deserialize(IParser parser);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Deserialize(IParser parser, Type type);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IEventEmitter
{
void Emit(AliasEventInfo eventInfo, IEmitter emitter);
void Emit(ScalarEventInfo eventInfo, IEmitter emitter);
void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);
void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);
void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);
void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface INamingConvention
{
string Apply(string value);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface INodeDeserializer
{
bool Deserialize(IParser reader, Type expectedType, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] out object value);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface INodeTypeResolver
{
bool Resolve([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] NodeEvent nodeEvent, ref Type currentType);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IObjectDescriptor
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object Value
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
get;
}
Type Type { get; }
Type StaticType { get; }
ScalarStyle ScalarStyle { get; }
}
internal static class ObjectDescriptorExtensions
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public static object NonNullValue(this IObjectDescriptor objectDescriptor)
{
return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IObjectFactory
{
object Create(Type type);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IObjectGraphTraversalStrategy
{
void Traverse<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TContext>
{
bool Enter(IObjectDescriptor value, TContext context);
bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context);
bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context);
void VisitScalar(IObjectDescriptor scalar, TContext context);
void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);
void VisitMappingEnd(IObjectDescriptor mapping, TContext context);
void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context);
void VisitSequenceEnd(IObjectDescriptor sequence, TContext context);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IPropertyDescriptor
{
string Name { get; }
bool CanWrite { get; }
Type Type { get; }
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
Type TypeOverride
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
get;
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
set;
}
int Order { get; set; }
ScalarStyle ScalarStyle { get; set; }
T GetCustomAttribute<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] T>() where T : Attribute;
IObjectDescriptor Read(object target);
void Write(object target, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object value);
}
internal interface IRegistrationLocationSelectionSyntax<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TBaseRegistrationType>
{
void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void OnTop();
void OnBottom();
}
internal interface ITrackingRegistrationLocationSelectionSyntax<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TBaseRegistrationType>
{
void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface ISerializer
{
void Serialize(TextWriter writer, object graph);
string Serialize(object graph);
void Serialize(TextWriter writer, object graph, Type type);
void Serialize(IEmitter emitter, object graph);
void Serialize(IEmitter emitter, object graph, Type type);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface ITypeInspector
{
IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object container);
IPropertyDescriptor GetProperty(Type type, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface ITypeResolver
{
Type Resolve(Type staticType, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object actualValue);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IValueDeserializer
{
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
}
internal interface IValuePromise
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 2 })]
event Action<object> ValueAvailable;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
internal interface IValueSerializer
{
void SerializeValue([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)] IEmitter emitter, object value, Type type);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IYamlConvertible
{
void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);
void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
internal delegate object ObjectDeserializer(Type type);
internal delegate void ObjectSerializer(object value, Type type = null);
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[Obsolete("Please use IYamlConvertible instead")]
internal interface IYamlSerializable
{
void ReadYaml(IParser parser);
void WriteYaml(IEmitter emitter);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal interface IYamlTypeConverter
{
bool Accepts(Type type);
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
object ReadYaml(IParser parser, Type type);
void WriteYaml(IEmitter emitter, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object value, Type type);
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class LazyComponentRegistrationList<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TArgument, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
public sealed class LazyComponentRegistration
{
public readonly Type ComponentType;
public readonly Func<TArgument, TComponent> Factory;
public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
{
ComponentType = componentType;
Factory = factory;
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
public sealed class TrackingLazyComponentRegistration
{
public readonly Type ComponentType;
public readonly Func<TComponent, TArgument, TComponent> Factory;
public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
{
ComponentType = componentType;
Factory = factory;
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)]
private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)]
private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 0, 0 })]
private readonly LazyComponentRegistration newRegistration;
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
{
this.registrations = registrations;
this.newRegistration = newRegistration;
}
void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
{
if (newRegistration.ComponentType != typeof(TRegistrationType))
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
}
int index = registrations.EnsureRegistrationExists<TRegistrationType>();
registrations.entries[index] = newRegistration;
}
void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
int num = registrations.EnsureRegistrationExists<TRegistrationType>();
registrations.entries.Insert(num + 1, newRegistration);
}
void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
int index = registrations.EnsureRegistrationExists<TRegistrationType>();
registrations.entries.Insert(index, newRegistration);
}
void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
registrations.entries.Add(newRegistration);
}
void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
registrations.entries.Insert(0, newRegistration);
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)]
private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)]
private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 0, 0 })]
private readonly TrackingLazyComponentRegistration newRegistration;
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
{
this.registrations = registrations;
this.newRegistration = newRegistration;
}
void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
{
if (newRegistration.ComponentType != typeof(TRegistrationType))
{
registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
}
int index = registrations.EnsureRegistrationExists<TRegistrationType>();
Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, [<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 1, 1, 0, 0 })]
private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();
public int Count => entries.Count;
public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
{
get
{
int i = entries.Count - 1;
while (i >= 0)
{
yield return entries[i].Factory;
int num = i - 1;
i = num;
}
}
}
public LazyComponentRegistrationList<TArgument, TComponent> Clone()
{
LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
foreach (LazyComponentRegistration entry in entries)
{
lazyComponentRegistrationList.entries.Add(entry);
}
return lazyComponentRegistrationList;
}
public void Add(Type componentType, Func<TArgument, TComponent> factory)
{
entries.Add(new LazyComponentRegistration(componentType, factory));
}
public void Remove(Type componentType)
{
for (int i = 0; i < entries.Count; i++)
{
if (entries[i].ComponentType == componentType)
{
entries.RemoveAt(i);
return;
}
}
throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
}
public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
{
return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
}
public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
{
return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
}
public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
{
return entries.Select([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (LazyComponentRegistration e) => e.Factory).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
private int IndexOfRegistration(Type registrationType)
{
for (int i = 0; i < entries.Count; i++)
{
if (registrationType == entries[i].ComponentType)
{
return i;
}
}
return -1;
}
private void EnsureNoDuplicateRegistrationType(Type componentType)
{
if (IndexOfRegistration(componentType) != -1)
{
throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
private int EnsureRegistrationExists<TRegistrationType>()
{
int num = IndexOfRegistration(typeof(TRegistrationType));
if (num == -1)
{
throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
}
return num;
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal static class LazyComponentRegistrationListExtensions
{
public static TComponent BuildComponentChain<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
{
return registrations.InReverseOrder.Aggregate(innerComponent, [<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
}
public static TComponent BuildComponentChain<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TArgument, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
{
return registrations.InReverseOrder.Aggregate(innerComponent, [<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
}
public static List<TComponent> BuildComponentList<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
{
return registrations.Select([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
}
public static List<TComponent> BuildComponentList<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TArgument, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
{
return registrations.Select([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
}
}
[StructLayout(LayoutKind.Sequential, Size = 1)]
internal struct Nothing
{
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class ObjectDescriptor : IObjectDescriptor
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
[field: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public object Value
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
get;
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
private set;
}
public Type Type { get; private set; }
public Type StaticType { get; private set; }
public ScalarStyle ScalarStyle { get; private set; }
public ObjectDescriptor([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object value, Type type, Type staticType)
: this(value, type, staticType, ScalarStyle.Any)
{
}
public ObjectDescriptor([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object value, Type type, Type staticType, ScalarStyle scalarStyle)
{
Value = value;
Type = type ?? throw new ArgumentNullException("type");
StaticType = staticType ?? throw new ArgumentNullException("staticType");
ScalarStyle = scalarStyle;
}
}
internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class PropertyDescriptor : IPropertyDescriptor
{
private readonly IPropertyDescriptor baseDescriptor;
public string Name { get; set; }
public Type Type => baseDescriptor.Type;
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public Type TypeOverride
{
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
get
{
return baseDescriptor.TypeOverride;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
set
{
baseDescriptor.TypeOverride = value;
}
}
public int Order { get; set; }
public ScalarStyle ScalarStyle
{
get
{
return baseDescriptor.ScalarStyle;
}
set
{
baseDescriptor.ScalarStyle = value;
}
}
public bool CanWrite => baseDescriptor.CanWrite;
public PropertyDescriptor(IPropertyDescriptor baseDescriptor)
{
this.baseDescriptor = baseDescriptor;
Name = baseDescriptor.Name;
}
public void Write(object target, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] object value)
{
baseDescriptor.Write(target, value);
}
public T GetCustomAttribute<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] T>() where T : Attribute
{
return baseDescriptor.GetCustomAttribute<T>();
}
public IObjectDescriptor Read(object target)
{
return baseDescriptor.Read(target);
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class Serializer : ISerializer
{
private readonly IValueSerializer valueSerializer;
private readonly EmitterSettings emitterSettings;
public Serializer()
: this(new SerializerBuilder().BuildValueSerializer(), EmitterSettings.Default)
{
}
private Serializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
{
this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
}
public static Serializer FromValueSerializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
{
return new Serializer(valueSerializer, emitterSettings);
}
public void Serialize(TextWriter writer, object graph)
{
Serialize(new Emitter(writer, emitterSettings), graph);
}
public string Serialize(object graph)
{
using StringWriter stringWriter = new StringWriter();
Serialize(stringWriter, graph);
return stringWriter.ToString();
}
public void Serialize(TextWriter writer, object graph, Type type)
{
Serialize(new Emitter(writer, emitterSettings), graph, type);
}
public void Serialize(IEmitter emitter, object graph)
{
if (emitter == null)
{
throw new ArgumentNullException("emitter");
}
EmitDocument(emitter, graph, null);
}
public void Serialize(IEmitter emitter, object graph, Type type)
{
if (emitter == null)
{
throw new ArgumentNullException("emitter");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
EmitDocument(emitter, graph, type);
}
private void EmitDocument(IEmitter emitter, object graph, [<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] Type type)
{
emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
valueSerializer.SerializeValue(emitter, graph, type);
emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(new byte[] { 0, 1 })]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
private class ValueSerializer : IValueSerializer
{
private readonly IObjectGraphTraversalStrategy traversalStrategy;
private readonly IEventEmitter eventEmitter;
private readonly IEnumerable<IYamlTypeConverter> typeConverters;
private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;
private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;
public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
{
this.traversalStrategy = traversalStrategy;
this.eventEmitter = eventEmitter;
this.typeConverters = typeConverters;
this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
public void SerializeValue([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)] IEmitter emitter, object value, Type type)
{
Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
Type staticType = type ?? typeof(object);
ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
{
traversalStrategy.Traverse(graph, item, default(Nothing));
}
IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new EmittingObjectGraphVisitor(eventEmitter), [<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
traversalStrategy.Traverse(graph, visitor, emitter);
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
void NestedObjectSerializer(object v, Type t)
{
SerializeValue(emitter, v, t);
}
}
}
private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;
private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;
private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;
private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;
private readonly IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();
private int maximumRecursion = 50;
private EmitterSettings emitterSettings = EmitterSettings.Default;
private DefaultValuesHandling defaultValuesHandlingConfiguration;
protected override SerializerBuilder Self => this;
public SerializerBuilder()
: base((ITypeResolver)new DynamicTypeResolver())
{
typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> {
{
typeof(AnchorAssigner),
(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
} };
emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
{
{
typeof(CustomSerializationObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
},
{
typeof(AnchorAssigningObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
},
{
typeof(DefaultValuesObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor)
},
{
typeof(CommentsObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
}
};
eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> {
{
typeof(TypeAssigningEventEmitter),
(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings)
} };
objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention);
}
public SerializerBuilder WithMaximumRecursion(int maximumRecursion)
{
if (maximumRecursion <= 0)
{
throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
}
this.maximumRecursion = maximumRecursion;
return this;
}
public SerializerBuilder WithEventEmitter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
{
return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
{
w.OnTop();
});
}
public SerializerBuilder WithEventEmitter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
if (eventEmitterFactory == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
return Self;
}
public SerializerBuilder WithEventEmitter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
if (eventEmitterFactory == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
return Self;
}
public SerializerBuilder WithoutEventEmitter<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TEventEmitter>() where TEventEmitter : IEventEmitter
{
return WithoutEventEmitter(typeof(TEventEmitter));
}
public SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
{
if (eventEmitterType == null)
{
throw new ArgumentNullException("eventEmitterType");
}
eventEmitterFactories.Remove(eventEmitterType);
return this;
}
public override SerializerBuilder WithTagMapping(TagName tag, Type type)
{
if (tag.IsEmpty)
{
throw new ArgumentException("Non-specific tags cannot be maped");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (tagMappings.TryGetValue(type, out var value))
{
throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
}
tagMappings.Add(type, tag);
return this;
}
public SerializerBuilder WithoutTagMapping(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!tagMappings.Remove(type))
{
throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
}
return this;
}
public SerializerBuilder EnsureRoundtrip()
{
objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention);
WithEventEmitter([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] ([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
return WithTypeInspector([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] ([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)] ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
{
loc.OnBottom();
});
}
public SerializerBuilder DisableAliases()
{
preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
return this;
}
[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
public SerializerBuilder EmitDefaults()
{
return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
}
public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
{
defaultValuesHandlingConfiguration = configuration;
return this;
}
public SerializerBuilder JsonCompatible()
{
emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
{
w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
}).WithEventEmitter([<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(0)] ([<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(1)] IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
{
w.OnTop();
});
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
if (objectGraphVisitor == null)
{
throw new ArgumentNullException("objectGraphVisitor");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
return this;
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
if (objectGraphVisitorFactory == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
return this;
}
public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
}
public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
{
if (objectGraphVisitorType == null)
{
throw new ArgumentNullException("objectGraphVisitorType");
}
preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
return this;
}
public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
{
this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
return this;
}
public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
{
w.OnTop();
});
}
public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
if (objectGraphVisitorFactory == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
return this;
}
public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
if (objectGraphVisitorFactory == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
return this;
}
public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
}
public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
{
if (objectGraphVisitorType == null)
{
throw new ArgumentNullException("objectGraphVisitorType");
}
emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
return this;
}
public SerializerBuilder WithIndentedSequences()
{
emitterSettings = emitterSettings.WithIndentedSequences();
return this;
}
public ISerializer Build()
{
return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
}
public IValueSerializer BuildValueSerializer()
{
IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
ITypeInspector typeInspector = BuildTypeInspector();
IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class StreamFragment : IYamlConvertible
{
private readonly List<ParsingEvent> events = new List<ParsingEvent>();
public IList<ParsingEvent> Events => events;
void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
{
events.Clear();
int num = 0;
do
{
if (!parser.MoveNext())
{
throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
}
ParsingEvent current = parser.Current;
events.Add(current);
num += current.NestingIncrease;
}
while (num > 0);
}
void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
{
foreach (ParsingEvent @event in events)
{
emitter.Emit(@event);
}
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class TagMappings
{
private readonly IDictionary<string, Type> mappings;
public TagMappings()
{
mappings = new Dictionary<string, Type>();
}
public TagMappings(IDictionary<string, Type> mappings)
{
this.mappings = new Dictionary<string, Type>(mappings);
}
public void Add(string tag, Type mapping)
{
mappings.Add(tag, mapping);
}
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
internal Type GetMapping(string tag)
{
if (!mappings.TryGetValue(tag, out var value))
{
return null;
}
return value;
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
internal sealed class YamlAttributeOverrides
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
private struct AttributeKey
{
public readonly Type AttributeType;
public readonly string PropertyName;
public AttributeKey(Type attributeType, string propertyName)
{
AttributeType = attributeType;
PropertyName = propertyName;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
public override bool Equals(object obj)
{
if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
{
return PropertyName.Equals(attributeKey.PropertyName);
}
return false;
}
public override int GetHashCode()
{
return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
}
}
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
private sealed class AttributeMapping
{
public readonly Type RegisteredType;
public readonly Attribute Attribute;
public AttributeMapping(Type registeredType, Attribute attribute)
{
RegisteredType = registeredType;
Attribute = attribute;
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(2)]
public override bool Equals(object obj)
{
if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
{
return Attribute.Equals(attributeMapping.Attribute);
}
return false;
}
public override int GetHashCode()
{
return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
}
public int Matches(Type matchType)
{
int num = 0;
Type type = matchType;
while (type != null)
{
num++;
if (type == RegisteredType)
{
return num;
}
type = type.BaseType();
}
if (matchType.GetInterfaces().Contains(RegisteredType))
{
return num;
}
return 0;
}
}
private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();
[return: <1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)]
public T GetAttribute<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)] T>(Type type, string member) where T : Attribute
{
if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out var value))
{
int num = 0;
AttributeMapping attributeMapping = null;
foreach (AttributeMapping item in value)
{
int num2 = item.Matches(type);
if (num2 > num)
{
num = num2;
attributeMapping = item;
}
}
if (num > 0)
{
return (T)attributeMapping.Attribute;
}
}
return null;
}
public void Add(Type type, string member, Attribute attribute)
{
AttributeMapping item = new AttributeMapping(type, attribute);
AttributeKey key = new AttributeKey(attribute.GetType(), member);
if (!overrides.TryGetValue(key, out var value))
{
value = new List<AttributeMapping>();
overrides.Add(key, value);
}
else if (value.Contains(item))
{
throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
}
value.Add(item);
}
public YamlAttributeOverrides Clone()
{
YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
{
foreach (AttributeMapping item in @override.Value)
{
yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
}
}
return yamlAttributeOverrides;
}
public void Add<[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
{
PropertyInfo propertyInfo = propertyAccessor.AsProperty();
Add(typeof(TClass), propertyInfo.Name, attribute);
}
}
[<2baa39ee-9455-4c30-9bc6-708a5f3e9b22>NullableContext(1)]
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
{
[<1a5dc612-6501-416d-b792-3ff5b270eef3>Nullable(0)]
public sealed class OverridePropertyDescriptor : IPropertyD
