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.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 System.Threading;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
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.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
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("0.0.1.0")]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyProduct("ConfigurePlants")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("ConfigurePlants")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
namespace ConfigurePlants
{
[BepInPlugin("FixItFelix.ConfigurePlants", "ConfigurePlants", "1.1.3")]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class ConfigurePlantsPlugin : BaseUnityPlugin
{
private const string PluginAuthor = "FixItFelix";
private const string PluginName = "ConfigurePlants";
private const string PluginVersion = "1.1.3";
public const string PluginGuid = "FixItFelix.ConfigurePlants";
private static readonly ConfigSync ConfigSync = new ConfigSync("FixItFelix.ConfigurePlants")
{
CurrentVersion = "1.1.3"
};
private static readonly CustomSyncedValue<Dictionary<string, string>> PlantConfigFilesContent = new CustomSyncedValue<Dictionary<string, string>>(ConfigSync, "PlantConfigFilesContent", new Dictionary<string, string>());
private void Awake()
{
PlantConfigFilesContent.Value = PlantConfigFileAccess.ReadAllFiles();
PrefabManager.OnPrefabsRegistered += ReplacePlants;
CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new PlantsPrintController());
}
private static void ReplacePlants()
{
PlantsManager.RegisterPlantsFromCustomConfig(PlantConfigFilesContent.Value);
}
}
public class PlantsPrintController : ConsoleCommand
{
public override string Name => "configure_plants_print_defaults";
public override string Help => "Write all prefabs loaded in-game into a YAML translations template file inside the BepInEx config.";
public override void Run(string[] args)
{
PlantConfigFileAccess.WriteFile(PlantConfigFileAccess.DefaultFile, new SerializerBuilder().DisableAliases().WithNamingConvention(CamelCaseNamingConvention.Instance).Build()
.Serialize(Cache.GetPrefabs(typeof(Plant)).ToDictionary((KeyValuePair<string, Object> pair) => pair.Key, (KeyValuePair<string, Object> pair) => PlantModel.FromPlant((Plant)pair.Value))));
}
}
public static class PlantConfigFileAccess
{
private static readonly string DefaultConfigRootPath = Paths.ConfigPath;
private static readonly string DefaultOutputFileName = "FixItFelix.ConfigurePlants.defaults.yaml";
private static readonly string ConfigNamePatterns = "FixItFelix.ConfigurePlants.custom.*.yaml";
public static readonly string DefaultFile = Path.Combine(DefaultConfigRootPath, DefaultOutputFileName);
private static string ReadFile(string fileNameAndPath)
{
Logger.LogInfo((object)("reading from file '" + fileNameAndPath + "'"));
return File.ReadAllText(fileNameAndPath);
}
public static void WriteFile(string fileNameAndPath, string fileContent)
{
File.WriteAllText(fileNameAndPath, fileContent);
Logger.LogInfo((object)("file '" + fileNameAndPath + "' successfully written"));
}
private static List<string> SearchConfigFiles()
{
return Directory.GetFiles(Paths.ConfigPath, ConfigNamePatterns, SearchOption.AllDirectories).ToList();
}
public static Dictionary<string, string> ReadAllFiles()
{
return SearchConfigFiles().ToDictionary((string fileName) => fileName, ReadFile);
}
}
public class PlantModel
{
[UsedImplicitly]
public string Name;
[UsedImplicitly]
public float GrowTime;
[UsedImplicitly]
public float GrowRadius;
[UsedImplicitly]
public float MinScale;
[UsedImplicitly]
public float MaxScale;
[UsedImplicitly]
public bool NeedCultivatedGround;
[UsedImplicitly]
public bool DestroyIfCantGrow;
public static PlantModel FromPlant(Plant fromPlant)
{
return new PlantModel
{
Name = fromPlant.m_name,
GrowTime = fromPlant.m_growTime,
GrowRadius = fromPlant.m_growRadius,
MinScale = fromPlant.m_minScale,
MaxScale = fromPlant.m_maxScale,
NeedCultivatedGround = fromPlant.m_needCultivatedGround,
DestroyIfCantGrow = fromPlant.m_destroyIfCantGrow
};
}
public void ReconfigurePlant(Plant plant)
{
plant.m_name = Name;
plant.m_growRadius = GrowRadius;
plant.m_growTime = GrowTime;
plant.m_minScale = MinScale;
plant.m_maxScale = MaxScale;
plant.m_needCultivatedGround = NeedCultivatedGround;
plant.m_destroyIfCantGrow = DestroyIfCantGrow;
}
}
public static class PlantsManager
{
private static readonly IDeserializer Deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
public static void RegisterPlantsFromCustomConfig(Dictionary<string, string> fileContents)
{
Plant plant = default(Plant);
foreach (KeyValuePair<string, PlantModel> item in fileContents.Select(delegate(KeyValuePair<string, string> pair)
{
try
{
return Deserializer.Deserialize<Dictionary<string, PlantModel>>(pair.Value);
}
catch (Exception ex)
{
Logger.LogWarning((object)("Unable to parse config file '" + pair.Key + "' due to '" + ex.Message + "' because of '" + ex.GetBaseException().Message + "', \n" + ex.StackTrace));
}
return new Dictionary<string, PlantModel>();
}).SelectMany((Dictionary<string, PlantModel> i) => i).ToDictionary((KeyValuePair<string, PlantModel> pair) => pair.Key, (KeyValuePair<string, PlantModel> pair) => pair.Value))
{
if (!PrefabManager.Instance.GetPrefab(item.Key).TryGetComponent<Plant>(ref plant))
{
Logger.LogError((object)("chosen original prefab '" + item.Key + "' doesn't have a 'Plant' component, cannot reconfigure it"));
break;
}
item.Value.ReconfigurePlant(plant);
Logger.LogInfo((object)("reconfigured " + item.Key + " successfully"));
}
}
}
}
namespace Microsoft.CodeAnalysis
{
[<e5961f38-30fd-4f0e-8249-70174341a5c1>Embedded]
[CompilerGenerated]
internal sealed class <e5961f38-30fd-4f0e-8249-70174341a5c1>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[<e5961f38-30fd-4f0e-8249-70174341a5c1>Embedded]
[CompilerGenerated]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class <42f593cf-4ce8-4379-a7e7-8125068d2052>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <42f593cf-4ce8-4379-a7e7-8125068d2052>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <42f593cf-4ce8-4379-a7e7-8125068d2052>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[<e5961f38-30fd-4f0e-8249-70174341a5c1>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class <31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[<e5961f38-30fd-4f0e-8249-70174341a5c1>Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ServerSync
{
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
[PublicAPI]
internal abstract class OwnConfigEntryBase
{
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public object LocalBaseValue;
public bool SynchronizedConfig = true;
public abstract ConfigEntryBase BaseConfig { get; }
}
[PublicAPI]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
internal class SyncedConfigEntry<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] T> : OwnConfigEntryBase
{
public readonly ConfigEntry<T> SourceConfig;
public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;
public T Value
{
get
{
return SourceConfig.Value;
}
set
{
SourceConfig.Value = value;
}
}
public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
{
SourceConfig = sourceConfig;
}
public void AssignLocalValue(T value)
{
if (LocalBaseValue == null)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(2)]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
internal abstract class CustomSyncedValueBase
{
public object LocalBaseValue;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(1)]
public readonly string Identifier;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(1)]
public readonly Type Type;
private object boxedValue;
protected bool localIsOwner;
public readonly int Priority;
public object BoxedValue
{
get
{
return boxedValue;
}
set
{
boxedValue = value;
this.ValueChanged?.Invoke();
}
}
public event Action ValueChanged;
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
{
Priority = priority;
Identifier = identifier;
Type = type;
configSync.AddCustomValue(this);
localIsOwner = configSync.IsSourceOfTruth;
configSync.SourceOfTruthChanged += delegate(bool truth)
{
localIsOwner = truth;
};
}
}
[PublicAPI]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
internal sealed class CustomSyncedValue<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] T> : CustomSyncedValueBase
{
public T Value
{
get
{
return (T)base.BoxedValue;
}
set
{
base.BoxedValue = value;
}
}
public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
: base(configSync, identifier, typeof(T), priority)
{
Value = value;
}
public void AssignLocalValue(T value)
{
if (localIsOwner)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
internal class ConfigurationManagerAttributes
{
[UsedImplicitly]
public bool? ReadOnly = false;
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
[PublicAPI]
internal class ConfigSync
{
[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
private static class SnatchCurrentlyHandlingRPC
{
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public static ZRpc currentRpc;
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[HarmonyPrefix]
private static void Prefix(ZRpc __instance)
{
currentRpc = __instance;
}
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
[HarmonyPatch(typeof(ZNet), "Awake")]
internal static class RegisterRPCPatch
{
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[HarmonyPostfix]
private static void Postfix(ZNet __instance)
{
isServer = __instance.IsServer();
foreach (ConfigSync configSync2 in configSyncs)
{
ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
if (isServer)
{
configSync2.InitialSyncDone = true;
Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
}
}
if (isServer)
{
((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
{
ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
{
new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = isAdmin
}
});
ConfigSync configSync = configSyncs.First();
if (configSync != null)
{
((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
}
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
static IEnumerator WatchAdminListChanges()
{
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
List<string> CurrentList = new List<string>(adminList.GetList());
while (true)
{
yield return (object)new WaitForSeconds(30f);
if (!adminList.GetList().SequenceEqual(CurrentList))
{
CurrentList = new List<string>(adminList.GetList());
List<ZNetPeer> adminPeer = (from p in ZNet.instance.GetPeers()
where adminList.Contains(p.m_rpc.GetSocket().GetHostName())
select p).ToList();
List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
SendAdmin(nonAdminPeer, isAdmin: false);
SendAdmin(adminPeer, isAdmin: true);
}
}
}
}
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static class RegisterClientRPCPatch
{
[HarmonyPostfix]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
if (__instance.IsServer())
{
return;
}
foreach (ConfigSync configSync in configSyncs)
{
peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
}
}
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
private class ParsedConfigs
{
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 1, 1, 2 })]
public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 1, 1, 2 })]
public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
}
[HarmonyPatch(typeof(ZNet), "Shutdown")]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
private class ResetConfigsOnShutdown
{
[HarmonyPostfix]
private static void Postfix()
{
ProcessingServerUpdate = true;
foreach (ConfigSync configSync in configSyncs)
{
configSync.resetConfigsFromServer();
configSync.IsSourceOfTruth = true;
configSync.InitialSyncDone = false;
}
ProcessingServerUpdate = false;
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
private class SendConfigsAfterLogin
{
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
private class BufferingSocket : ISocket
{
public volatile bool finished = false;
public volatile int versionMatchQueued = -1;
public readonly List<ZPackage> Package = new List<ZPackage>();
public readonly ISocket Original;
public BufferingSocket(ISocket original)
{
Original = original;
}
public bool IsConnected()
{
return Original.IsConnected();
}
public ZPackage Recv()
{
return Original.Recv();
}
public int GetSendQueueSize()
{
return Original.GetSendQueueSize();
}
public int GetCurrentSendRate()
{
return Original.GetCurrentSendRate();
}
public bool IsHost()
{
return Original.IsHost();
}
public void Dispose()
{
Original.Dispose();
}
public bool GotNewData()
{
return Original.GotNewData();
}
public void Close()
{
Original.Close();
}
public string GetEndPointString()
{
return Original.GetEndPointString();
}
public void GetAndResetStats(out int totalSent, out int totalRecv)
{
Original.GetAndResetStats(ref totalSent, ref totalRecv);
}
public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
{
Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
}
public ISocket Accept()
{
return Original.Accept();
}
public int GetHostPort()
{
return Original.GetHostPort();
}
public bool Flush()
{
return Original.Flush();
}
public string GetHostName()
{
return Original.GetHostName();
}
public void VersionMatch()
{
if (finished)
{
Original.VersionMatch();
}
else
{
versionMatchQueued = Package.Count;
}
}
public void Send(ZPackage pkg)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
int pos = pkg.GetPos();
pkg.SetPos(0);
int num = pkg.ReadInt();
if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
{
ZPackage val = new ZPackage(pkg.GetArray());
val.SetPos(pos);
Package.Add(val);
}
else
{
pkg.SetPos(pos);
Original.Send(pkg);
}
}
}
[HarmonyPrefix]
[HarmonyPriority(800)]
private static void Prefix([<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Invalid comparison between Unknown and I4
if (__instance.IsServer())
{
BufferingSocket value = new BufferingSocket(rpc.GetSocket());
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (val != null && (int)ZNet.m_onlineBackend > 0)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
}
if (__state == null)
{
__state = new Dictionary<Assembly, BufferingSocket>();
}
__state[Assembly.GetExecutingAssembly()] = value;
}
}
[HarmonyPostfix]
private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
{
ZNetPeer peer;
if (__instance.IsServer())
{
object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (peer == null)
{
SendBufferedData();
}
else
{
((MonoBehaviour)__instance).StartCoroutine(sendAsync());
}
}
void SendBufferedData()
{
if (rpc.GetSocket() is BufferingSocket bufferingSocket)
{
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
if (val != null)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
}
}
BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
bufferingSocket2.finished = true;
for (int i = 0; i < bufferingSocket2.Package.Count; i++)
{
if (i == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
}
if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
}
IEnumerator sendAsync()
{
foreach (ConfigSync configSync in configSyncs)
{
List<PackageEntry> entries = new List<PackageEntry>();
if (configSync.CurrentVersion != null)
{
entries.Add(new PackageEntry
{
section = "Internal",
key = "serverversion",
type = typeof(string),
value = configSync.CurrentVersion
});
}
MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
entries.Add(new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
{
adminList,
rpc.GetSocket().GetHostName()
}))
});
ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
}
SendBufferedData();
}
}
}
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
private class PackageEntry
{
public string section = null;
public string key = null;
public Type type = null;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public object value;
}
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
private static class PreventSavingServerInfo
{
[HarmonyPrefix]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
private static bool Prefix(ConfigEntryBase __instance, ref string __result)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
{
return true;
}
__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
return false;
}
}
[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)]
private static class PreventConfigRereadChangingValues
{
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[HarmonyPrefix]
private static bool Prefix(ConfigEntryBase __instance, string value)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
{
return true;
}
try
{
ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
}
catch (Exception ex)
{
Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
}
return false;
}
}
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
private class InvalidDeserializationTypeException : Exception
{
public string expected = null;
public string received = null;
public string field = "";
}
public static bool ProcessingServerUpdate;
public readonly string Name;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public string DisplayName;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public string CurrentVersion;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public string MinimumRequiredVersion;
public bool ModRequired = false;
private bool? forceConfigLocking;
private bool isSourceOfTruth = true;
private static readonly HashSet<ConfigSync> configSyncs;
private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();
private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();
private static bool isServer;
private static bool lockExempt;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private OwnConfigEntryBase lockedConfig = null;
private const byte PARTIAL_CONFIGS = 1;
private const byte FRAGMENTED_CONFIG = 2;
private const byte COMPRESSED_CONFIG = 4;
private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 1, 0, 1 })]
private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();
private static long packageCounter;
public bool IsLocked
{
get
{
bool? flag = forceConfigLocking;
bool num;
if (!flag.HasValue)
{
if (lockedConfig == null)
{
goto IL_0052;
}
num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
}
else
{
num = flag.GetValueOrDefault();
}
if (!num)
{
goto IL_0052;
}
int result = ((!lockExempt) ? 1 : 0);
goto IL_0053;
IL_0053:
return (byte)result != 0;
IL_0052:
result = 0;
goto IL_0053;
}
set
{
forceConfigLocking = value;
}
}
public bool IsAdmin => lockExempt || isSourceOfTruth;
public bool IsSourceOfTruth
{
get
{
return isSourceOfTruth;
}
private set
{
if (value != isSourceOfTruth)
{
isSourceOfTruth = value;
this.SourceOfTruthChanged?.Invoke(value);
}
}
}
public bool InitialSyncDone { get; private set; } = false;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
[method: <31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(2)]
[field: <42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
public event Action<bool> SourceOfTruthChanged;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
[method: <31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(2)]
[field: <42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private event Action lockedConfigChanged;
static ConfigSync()
{
ProcessingServerUpdate = false;
configSyncs = new HashSet<ConfigSync>();
lockExempt = false;
packageCounter = 0L;
RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
}
public ConfigSync(string name)
{
Name = name;
configSyncs.Add(this);
new VersionCheck(this);
}
public SyncedConfigEntry<T> AddConfigEntry<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] T>(ConfigEntry<T> configEntry)
{
OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
if (syncedEntry == null)
{
syncedEntry = new SyncedConfigEntry<T>(configEntry);
AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
{
new ConfigurationManagerAttributes()
}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
configEntry.SettingChanged += [<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (object _, EventArgs _) =>
{
if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
{
Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
}
};
allConfigs.Add(syncedEntry);
}
return syncedEntry;
}
public SyncedConfigEntry<T> AddLockingConfigEntry<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
{
if (lockedConfig != null)
{
throw new Exception("Cannot initialize locking ConfigEntry twice");
}
lockedConfig = AddConfigEntry<T>(lockingConfig);
lockingConfig.SettingChanged += [<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (object _, EventArgs _) =>
{
this.lockedConfigChanged?.Invoke();
};
return (SyncedConfigEntry<T>)lockedConfig;
}
internal void AddCustomValue(CustomSyncedValueBase customValue)
{
if (allCustomValues.Select([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
{
throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
}
allCustomValues.Add(customValue);
allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
customValue.ValueChanged += delegate
{
if (!ProcessingServerUpdate)
{
Broadcast(ZRoutedRpc.Everybody, customValue);
}
};
}
private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
{
lockedConfigChanged += serverLockedSettingChanged;
IsSourceOfTruth = false;
if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
{
InitialSyncDone = true;
}
}
private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
{
HandleConfigSyncRPC(sender, package, clientUpdate: true);
}
private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Expected O, but got Unknown
//IL_024e: Unknown result type (might be due to invalid IL or missing references)
//IL_0255: Expected O, but got Unknown
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ef: Expected O, but got Unknown
try
{
if (isServer && IsLocked)
{
ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
object obj;
if (currentRpc == null)
{
obj = null;
}
else
{
ISocket socket = currentRpc.GetSocket();
obj = ((socket != null) ? socket.GetHostName() : null);
}
string text = (string)obj;
if (text != null)
{
MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
{
return false;
}
}
}
cacheExpirations.RemoveAll(([<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
{
if (kv.Key < DateTimeOffset.Now.Ticks)
{
configValueCache.Remove(kv.Value);
return true;
}
return false;
});
byte b = package.ReadByte();
if ((b & 2u) != 0)
{
long num = package.ReadLong();
string text2 = sender.ToString() + num;
if (!configValueCache.TryGetValue(text2, out var value))
{
value = new SortedDictionary<int, byte[]>();
configValueCache[text2] = value;
cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
}
int key = package.ReadInt();
int num2 = package.ReadInt();
value.Add(key, package.ReadByteArray());
if (value.Count < num2)
{
return false;
}
configValueCache.Remove(text2);
package = new ZPackage(value.Values.SelectMany([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (byte[] a) => a).ToArray());
b = package.ReadByte();
}
ProcessingServerUpdate = true;
if ((b & 4u) != 0)
{
byte[] buffer = package.ReadByteArray();
MemoryStream stream = new MemoryStream(buffer);
MemoryStream memoryStream = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
{
deflateStream.CopyTo(memoryStream);
}
package = new ZPackage(memoryStream.ToArray());
b = package.ReadByte();
}
if ((b & 1) == 0)
{
resetConfigsFromServer();
}
ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
{
if (!isServer && configValue.Key.LocalBaseValue == null)
{
configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
}
configValue.Key.BaseConfig.BoxedValue = configValue.Value;
}
foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
{
if (!isServer)
{
CustomSyncedValueBase key2 = customValue.Key;
if (key2.LocalBaseValue == null)
{
key2.LocalBaseValue = customValue.Key.BoxedValue;
}
}
customValue.Key.BoxedValue = customValue.Value;
}
Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
if (!isServer)
{
serverLockedSettingChanged();
}
return true;
}
finally
{
ProcessingServerUpdate = false;
}
}
private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
{
ParsedConfigs parsedConfigs = new ParsedConfigs();
Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (OwnConfigEntryBase c) => c);
Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (CustomSyncedValueBase c) => c);
int num = package.ReadInt();
for (int i = 0; i < num; i++)
{
string text = package.ReadString();
string text2 = package.ReadString();
string text3 = package.ReadString();
Type type = Type.GetType(text3);
if (text3 == "" || type != null)
{
object obj;
try
{
obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
}
catch (InvalidDeserializationTypeException ex)
{
Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
continue;
}
OwnConfigEntryBase value2;
if (text == "Internal")
{
CustomSyncedValueBase value;
if (text2 == "serverversion")
{
if (obj?.ToString() != CurrentVersion)
{
Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
}
}
else if (text2 == "lockexempt")
{
if (obj is bool flag)
{
lockExempt = flag;
}
}
else if (dictionary2.TryGetValue(text2, out value))
{
if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
{
parsedConfigs.customValues[value] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
}
}
else if (dictionary.TryGetValue(text + "_" + text2, out value2))
{
Type type2 = configType(value2.BaseConfig);
if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
{
parsedConfigs.configValues[value2] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
}
else
{
Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
}
continue;
}
Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
return new ParsedConfigs();
}
return parsedConfigs;
}
private static bool isWritableConfig(OwnConfigEntryBase config)
{
ConfigSync configSync = configSyncs.FirstOrDefault([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
if (configSync == null)
{
return true;
}
return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
}
private void serverLockedSettingChanged()
{
foreach (OwnConfigEntryBase allConfig in allConfigs)
{
configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
}
}
private void resetConfigsFromServer()
{
foreach (OwnConfigEntryBase item in allConfigs.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
{
item.BaseConfig.BoxedValue = item.LocalBaseValue;
item.LocalBaseValue = null;
}
foreach (CustomSyncedValueBase item2 in allCustomValues.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
{
item2.BoxedValue = item2.LocalBaseValue;
item2.LocalBaseValue = null;
}
lockedConfigChanged -= serverLockedSettingChanged;
serverLockedSettingChanged();
}
private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
{
ZRoutedRpc rpc = ZRoutedRpc.instance;
if (rpc == null)
{
yield break;
}
byte[] data = package.GetArray();
if (data != null && data.LongLength > 250000)
{
int fragments = (int)(1 + (data.LongLength - 1) / 250000);
long packageIdentifier = ++packageCounter;
int fragment = 0;
while (fragment < fragments)
{
foreach (bool item in waitForQueue())
{
yield return item;
}
if (peer.m_socket.IsConnected())
{
ZPackage fragmentedPackage = new ZPackage();
fragmentedPackage.Write((byte)2);
fragmentedPackage.Write(packageIdentifier);
fragmentedPackage.Write(fragment);
fragmentedPackage.Write(fragments);
fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
SendPackage(fragmentedPackage);
if (fragment != fragments - 1)
{
yield return true;
}
int num = fragment + 1;
fragment = num;
continue;
}
break;
}
yield break;
}
foreach (bool item2 in waitForQueue())
{
yield return item2;
}
SendPackage(package);
void SendPackage(ZPackage pkg)
{
string text = Name + " ConfigSync";
if (isServer)
{
peer.m_rpc.Invoke(text, new object[1] { pkg });
}
else
{
rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
}
}
IEnumerable<bool> waitForQueue()
{
float timeout = Time.time + 30f;
while (peer.m_socket.GetSendQueueSize() > 20000)
{
if (Time.time > timeout)
{
Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
ZNet.instance.Disconnect(peer);
break;
}
yield return false;
}
}
}
private IEnumerator sendZPackage(long target, ZPackage package)
{
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
return Enumerable.Empty<object>().GetEnumerator();
}
List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
if (target != ZRoutedRpc.Everybody)
{
list = list.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
}
return sendZPackage(list, package);
}
private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
{
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
yield break;
}
byte[] rawData = package.GetArray();
if (rawData != null && rawData.LongLength > 10000)
{
ZPackage compressedPackage = new ZPackage();
compressedPackage.Write((byte)4);
MemoryStream output = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
{
deflateStream.Write(rawData, 0, rawData.Length);
}
compressedPackage.Write(output.ToArray());
package = compressedPackage;
}
List<IEnumerator<bool>> writers = (from peer in peers
where peer.IsReady()
select peer into p
select distributeConfigToPeers(p, package)).ToList();
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
while (writers.Count > 0)
{
yield return null;
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
}
}
private void Broadcast(long target, params ConfigEntryBase[] configs)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(configs);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(null, customValues);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
[return: <42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private static OwnConfigEntryBase configData(ConfigEntryBase config)
{
return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
}
[return: <42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1 })]
public static SyncedConfigEntry<T> ConfigData<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] T>(ConfigEntry<T> config)
{
return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
}
private static T configAttribute<[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] T>(ConfigEntryBase config)
{
return config.Description.Tags.OfType<T>().First();
}
private static Type configType(ConfigEntryBase config)
{
return configType(config.SettingType);
}
private static Type configType(Type type)
{
return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
}
private static ZPackage ConfigsToPackage([<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
List<ConfigEntryBase> list = configs?.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
ZPackage val = new ZPackage();
val.Write((byte)(partial ? 1 : 0));
val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
{
AddEntryToPackage(val, item);
}
foreach (CustomSyncedValueBase item2 in list2)
{
AddEntryToPackage(val, new PackageEntry
{
section = "Internal",
key = item2.Identifier,
type = item2.Type,
value = item2.BoxedValue
});
}
foreach (ConfigEntryBase item3 in list)
{
AddEntryToPackage(val, new PackageEntry
{
section = item3.Definition.Section,
key = item3.Definition.Key,
type = configType(item3),
value = item3.BoxedValue
});
}
return val;
}
private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
{
package.Write(entry.section);
package.Write(entry.key);
package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
AddValueToZPackage(package, entry.value);
}
private static string GetZPackageTypeString(Type type)
{
return type.AssemblyQualifiedName;
}
private static void AddValueToZPackage(ZPackage package, [<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] object value)
{
Type type = value?.GetType();
if (value is Enum)
{
value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
}
else
{
if (value is ICollection collection)
{
package.Write(collection.Count);
{
foreach (object item in collection)
{
AddValueToZPackage(package, item);
}
return;
}
}
if ((object)type != null && type.IsValueType && !type.IsPrimitive)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
package.Write(fields.Length);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
package.Write(GetZPackageTypeString(fieldInfo.FieldType));
AddValueToZPackage(package, fieldInfo.GetValue(value));
}
return;
}
}
ZRpc.Serialize(new object[1] { value }, ref package);
}
private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
{
if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num = package.ReadInt();
if (num != fields.Length)
{
throw new InvalidDeserializationTypeException
{
received = $"(field count: {num})",
expected = $"(field count: {fields.Length})"
};
}
object uninitializedObject = FormatterServices.GetUninitializedObject(type);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = package.ReadString();
if (text != GetZPackageTypeString(fieldInfo.FieldType))
{
throw new InvalidDeserializationTypeException
{
received = text,
expected = GetZPackageTypeString(fieldInfo.FieldType),
field = fieldInfo.Name
};
}
fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
}
return uninitializedObject;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
{
int num2 = package.ReadInt();
IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
for (int j = 0; j < num2; j++)
{
object obj = ReadValueWithTypeFromZPackage(package, type2);
dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
}
return dictionary;
}
if (type != typeof(List<string>) && type.IsGenericType)
{
Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
if ((object)type3 != null && type3.IsAssignableFrom(type))
{
int num3 = package.ReadInt();
object obj2 = Activator.CreateInstance(type);
MethodInfo method = type3.GetMethod("Add");
for (int k = 0; k < num3; k++)
{
method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
}
return obj2;
}
}
ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
List<object> source = new List<object>();
ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
return source.First();
}
}
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(0)]
[PublicAPI]
[<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(1)]
[HarmonyPatch]
internal class VersionCheck
{
private static readonly HashSet<VersionCheck> versionChecks;
private static readonly Dictionary<string, string> notProcessedNames;
public string Name;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private string displayName;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private string currentVersion;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private string minimumRequiredVersion;
public bool ModRequired = true;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private string ReceivedCurrentVersion;
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private string ReceivedMinimumRequiredVersion;
private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();
[<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)]
private ConfigSync ConfigSync;
public string DisplayName
{
get
{
return displayName ?? Name;
}
set
{
displayName = value;
}
}
public string CurrentVersion
{
get
{
return currentVersion ?? "0.0.0";
}
set
{
currentVersion = value;
}
}
public string MinimumRequiredVersion
{
get
{
return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
}
set
{
minimumRequiredVersion = value;
}
}
private static void PatchServerSync()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
if (patchInfo != null && patchInfo.Postfixes.Count([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
{
return;
}
Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
where t.IsClass
select t)
{
val.PatchAll(item);
}
}
static VersionCheck()
{
versionChecks = new HashSet<VersionCheck>();
notProcessedNames = new Dictionary<string, string>();
typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
{
new Action(PatchServerSync)
});
}
public VersionCheck(string name)
{
Name = name;
ModRequired = true;
versionChecks.Add(this);
}
public VersionCheck(ConfigSync configSync)
{
ConfigSync = configSync;
Name = ConfigSync.Name;
versionChecks.Add(this);
}
public void Initialize()
{
ReceivedCurrentVersion = null;
ReceivedMinimumRequiredVersion = null;
if (ConfigSync != null)
{
Name = ConfigSync.Name;
DisplayName = ConfigSync.DisplayName;
CurrentVersion = ConfigSync.CurrentVersion;
MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
ModRequired = ConfigSync.ModRequired;
}
}
private bool IsVersionOk()
{
if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
{
return !ModRequired;
}
bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
return flag && flag2;
}
private string ErrorClient()
{
if (ReceivedMinimumRequiredVersion == null)
{
return "Mod " + DisplayName + " must not be installed.";
}
return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? ("Mod " + DisplayName + " requires maximum " + ReceivedCurrentVersion + ". Installed is version " + CurrentVersion + ".") : ("Mod " + DisplayName + " requires minimum " + ReceivedMinimumRequiredVersion + ". Installed is version " + CurrentVersion + ".");
}
private string ErrorServer(ZRpc rpc)
{
return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
}
private string Error([<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(2)] ZRpc rpc = null)
{
return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
}
private static VersionCheck[] GetFailedClient()
{
return versionChecks.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
}
private static VersionCheck[] GetFailedServer(ZRpc rpc)
{
return versionChecks.Where([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
}
private static void Logout()
{
Game.instance.Logout(true, true);
AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
}
private static void DisconnectClient(ZRpc rpc)
{
rpc.Invoke("Error", new object[1] { 3 });
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg)
{
CheckVersion(rpc, pkg, null);
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg, [<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(new byte[] { 2, 1, 1 })] Action<ZRpc, ZPackage> original)
{
string text = pkg.ReadString();
string text2 = pkg.ReadString();
string text3 = pkg.ReadString();
bool flag = false;
foreach (VersionCheck versionCheck in versionChecks)
{
if (!(text != versionCheck.Name))
{
Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
versionCheck.ReceivedMinimumRequiredVersion = text2;
versionCheck.ReceivedCurrentVersion = text3;
if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
{
versionCheck.ValidatedClients.Add(rpc);
}
flag = true;
}
}
if (flag)
{
return;
}
pkg.SetPos(0);
if (original != null)
{
original(rpc, pkg);
if (pkg.GetPos() == 0)
{
notProcessedNames.Add(text, text3);
}
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
[HarmonyPrefix]
private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
{
VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
if (array.Length == 0)
{
return true;
}
VersionCheck[] array2 = array;
foreach (VersionCheck versionCheck in array2)
{
Debug.LogWarning((object)versionCheck.Error(rpc));
}
if (__instance.IsServer())
{
DisconnectClient(rpc);
}
else
{
Logout();
}
return false;
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
[HarmonyPrefix]
private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
{
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Expected O, but got Unknown
notProcessedNames.Clear();
IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
{
object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (ZRpc rpc, [<42f593cf-4ce8-4379-a7e7-8125068d2052>Nullable(1)] ZPackage pkg) =>
{
CheckVersion(rpc, pkg, action);
}));
}
else
{
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.Initialize();
if (versionCheck.ModRequired || __instance.IsServer())
{
Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
ZPackage val = new ZPackage();
val.Write(versionCheck.Name);
val.Write(versionCheck.MinimumRequiredVersion);
val.Write(versionCheck.CurrentVersion);
peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
}
}
}
[HarmonyPatch(typeof(ZNet), "Disconnect")]
[HarmonyPrefix]
private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
{
if (!__instance.IsServer())
{
return;
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.ValidatedClients.Remove(peer.m_rpc);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
private static void ShowConnectionError(FejdStartup __instance)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Invalid comparison between Unknown and I4
if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
{
return;
}
VersionCheck[] failedClient = GetFailedClient();
if (failedClient.Length != 0)
{
string text = string.Join("\n", failedClient.Select([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (VersionCheck check) => check.Error()));
TMP_Text connectionFailedError = __instance.m_connectionFailedError;
connectionFailedError.text = connectionFailedError.text + "\n" + text;
}
foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([<31576b23-6bb8-4d8b-85b9-f4f6b6936661>NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
{
if (!__instance.m_connectionFailedError.text.Contains(item.Key))
{
TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
connectionFailedError2.text = connectionFailedError2.text + "\n" + item.Key + " (Version: " + item.Value + ")";
}
}
}
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
internal sealed class IsReadOnlyAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace YamlDotNet
{
internal sealed class CultureInfoAdapter : CultureInfo
{
private readonly IFormatProvider provider;
public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
: base(baseCulture.LCID)
{
this.provider = provider;
}
public override object? GetFormat(Type? formatType)
{
return provider.GetFormat(formatType);
}
}
internal static class ReflectionExtensions
{
private static readonly FieldInfo? RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);
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, bool allowPrivateConstructors)
{
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (allowPrivateConstructors)
{
bindingFlags |= BindingFlags.NonPublic;
}
if (!type.IsValueType)
{
return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
}
return true;
}
public static TypeCode GetTypeCode(this Type type)
{
return Type.GetTypeCode(type);
}
public static PropertyInfo? GetPublicProperty(this Type type, string name)
{
return type.GetProperty(name);
}
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((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 + "'.");
}
public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
{
return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
}
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<TAttribute>(this PropertyInfo property)
{
return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
}
}
internal static class PropertyInfoExtensions
{
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
{
internal abstract class BuilderSkeleton<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;
internal bool ignoreFields;
internal bool includeNonPublicProperties;
internal Settings settings;
internal YamlFormatter yamlFormatter = YamlFormatter.Default;
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");
settings = new Settings();
}
public TBuilder IgnoreFields()
{
ignoreFields = true;
return Self;
}
public TBuilder IncludeNonPublicProperties()
{
includeNonPublicProperties = true;
return Self;
}
public TBuilder EnablePrivateConstructors()
{
settings.AllowPrivateConstructors = 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<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)
{
IYamlTypeConverter typeConverter2 = typeConverter;
if (typeConverter2 == null)
{
throw new ArgumentNullException("typeConverter");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
return Self;
}
public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
{
WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
if (typeConverterFactory2 == null)
{
throw new ArgumentNullException("typeConverterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
return Self;
}
public TBuilder WithoutTypeConverter<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<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
{
return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
{
w.OnTop();
});
}
public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
return Self;
}
public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
return Self;
}
public TBuilder WithoutTypeInspector<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;
}
public TBuilder WithYamlFormatter(YamlFormatter formatter)
{
yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
return Self;
}
protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
{
return typeConverterFactories.BuildComponentList();
}
}
internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
[Flags]
internal enum DefaultValuesHandling
{
Preserve = 0,
OmitNull = 1,
OmitDefaults = 2,
OmitEmptyCollections = 4
}
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<T>(string input)
{
using StringReader input2 = new StringReader(input);
return Deserialize<T>(input2);
}
public T Deserialize<T>(TextReader input)
{
return Deserialize<T>(new Parser(input));
}
public T Deserialize<T>(IParser parser)
{
return (T)Deserialize(parser, typeof(T));
}
public object? Deserialize(string input)
{
return Deserialize(input, typeof(object));
}
public object? Deserialize(TextReader input)
{
return Deserialize(input, typeof(object));
}
public object? Deserialize(IParser parser)
{
return Deserialize(parser, typeof(object));
}
public object? Deserialize(string input, Type type)
{
using StringReader input2 = new StringReader(input);
return Deserialize(input2, type);
}
public object? Deserialize(TextReader input, Type type)
{
return Deserialize(new Parser(input), type);
}
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;
}
}
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 readonly ITypeConverter typeConverter;
private bool ignoreUnmatched;
private bool duplicateKeyChecking;
private bool attemptUnknownTypeDeserialization;
protected override DeserializerBuilder Self => this;
public DeserializerBuilder()
: base((ITypeResolver)new StaticTypeResolver())
{
typeMappings = new Dictionary<Type, Type>();
objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), 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(attemptUnknownTypeDeserialization, typeConverter, yamlFormatter)
},
{
typeof(ArrayNodeDeserializer),
(Nothing _) => new ArrayNodeDeserializer()
},
{
typeof(DictionaryNodeDeserializer),
(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
},
{
typeof(CollectionNodeDeserializer),
(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
},
{
typeof(EnumerableNodeDeserializer),
(Nothing _) => new EnumerableNodeDeserializer()
},
{
typeof(ObjectNodeDeserializer),
(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
}
};
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()
}
};
typeConverter = new ReflectionTypeConverter();
}
internal ITypeInspector BuildTypeInspector()
{
ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
if (!ignoreFields)
{
typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
}
return typeInspectorFactories.BuildComponentChain(typeInspector);
}
public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
{
attemptUnknownTypeDeserialization = true;
return this;
}
public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
{
IObjectFactory objectFactory2 = objectFactory;
if (objectFactory2 == null)
{
throw new ArgumentNullException("objectFactory");
}
this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, 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)
{
INodeDeserializer nodeDeserializer2 = nodeDeserializer;
if (nodeDeserializer2 == null)
{
throw new ArgumentNullException("nodeDeserializer");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
return this;
}
public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
{
WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
if (nodeDeserializerFactory2 == null)
{
throw new ArgumentNullException("nodeDeserializerFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeDeserializer<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 WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
{
TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
{
s.Before<DictionaryNodeDeserializer>();
});
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
{
return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
{
w.OnTop();
});
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
{
INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
if (nodeTypeResolver2 == null)
{
throw new ArgumentNullException("nodeTypeResolver");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
return this;
}
public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
{
WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
if (nodeTypeResolverFactory2 == null)
{
throw new ArgumentNullException("nodeTypeResolverFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeTypeResolver<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 Type 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<TInterface, 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 DeserializerBuilder WithDuplicateKeyChecking()
{
duplicateKeyChecking = true;
return this;
}
public IDeserializer Build()
{
return Deserializer.FromValueDeserializer(BuildValueDeserializer());
}
public IValueDeserializer BuildValueDeserializer()
{
return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
}
}
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<T>() where T : IObjectGraphVisitor<Nothing>
{
return preProcessingPhaseVisitors.OfType<T>().Single();
}
}
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; }
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; }
protected ObjectEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
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; }
public MappingStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class MappingEndEventInfo : EventInfo
{
public MappingEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class SequenceStartEventInfo : ObjectEventInfo
{
public bool IsImplicit { get; set; }
public SequenceStyle Style { get; set; }
public SequenceStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal sealed class SequenceEndEventInfo : EventInfo
{
public SequenceEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
internal interface IAliasProvider
{
AnchorName GetAlias(object target);
}
internal interface IDeserializer
{
T Deserialize<T>(string input);
T Deserialize<T>(TextReader input);
T Deserialize<T>(IParser parser);
object? Deserialize(string input);
object? Deserialize(TextReader input);
object? Deserialize(IParser parser);
object? Deserialize(string input, Type type);
object? Deserialize(TextReader input, Type type);
object? Deserialize(IParser parser, Type type);
}
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);
}
internal interface INamingConvention
{
string Apply(string value);
}
internal interface INodeDeserializer
{
bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value);
}
internal interface INodeTypeResolver
{
bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
}
internal interface IObjectAccessor
{
void Set(string name, object target, object value);
object? Read(string name, object target);
}
internal interface IObjectDescriptor
{
object? Value { get; }
Type Type { get; }
Type StaticType { get; }
ScalarStyle ScalarStyle { get; }
}
internal static class ObjectDescriptorExtensions
{
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.");
}
}
internal interface IObjectFactory
{
object Create(Type type);
object? CreatePrimitive(Type type);
bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);
Type GetValueType(Type type);
void ExecuteOnDeserializing(object value);
void ExecuteOnDeserialized(object value);
void ExecuteOnSerializing(object value);
void ExecuteOnSerialized(object value);
}
internal interface IObjectGraphTraversalStrategy
{
void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
}
internal interface IObjectGraphVisitor<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);
}
internal interface IPropertyDescriptor
{
string Name { get; }
bool CanWrite { get; }
Type Type { get; }
Type? TypeOverride { get; set; }
int Order { get; set; }
ScalarStyle ScalarStyle { get; set; }
T? GetCustomAttribute<T>() where T : Attribute;
IObjectDescriptor Read(object target);
void Write(object target, object? value);
}
internal interface IRegistrationLocationSelectionSyntax<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<TBaseRegistrationType>
{
void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
}
internal interface ISerializer
{
string Serialize(object? graph);
string Serialize(object? graph, Type type);
void Serialize(TextWriter writer, object? graph);
void Serialize(TextWriter writer, object? graph, Type type);
void Serialize(IEmitter emitter, object? graph);
void Serialize(IEmitter emitter, object? graph, Type type);
}
internal interface ITypeInspector
{
IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);
IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
}
internal interface ITypeResolver
{
Type Resolve(Type staticType, object? actualValue);
}
internal interface IValueDeserializer
{
object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
}
internal interface IValuePromise
{
event Action<object?> ValueAvailable;
}
internal interface IValueSerializer
{
void SerializeValue(IEmitter emitter, object? value, Type? type);
}
internal interface IYamlConvertible
{
void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);
void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
}
internal delegate object? ObjectDeserializer(Type type);
internal delegate void ObjectSerializer(object? value, Type? type = null);
[Obsolete("Please use IYamlConvertible instead")]
internal interface IYamlSerializable
{
void ReadYaml(IParser parser);
void WriteYaml(IEmitter emitter);
}
internal interface IYamlTypeConverter
{
bool Accepts(Type type);
object? ReadYaml(IParser parser, Type type);
void WriteYaml(IEmitter emitter, object? value, Type type);
}
internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
{
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;
}
}
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;
}
}
private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
{
private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;
private readonly LazyComponentRegistration newRegistration;
public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, 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 IRegistrationLocationSelectionSusing System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ServerSync")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ServerSync")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("E16C3332-50B4-4DA6-9E8A-A590C4E5CD49")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName = ".NET Framework 4.6.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace ServerSync
{
[PublicAPI]
public abstract class OwnConfigEntryBase
{
public object? LocalBaseValue;
public bool SynchronizedConfig = true;
public abstract ConfigEntryBase BaseConfig { get; }
}
[PublicAPI]
public class SyncedConfigEntry<T> : OwnConfigEntryBase
{
public readonly ConfigEntry<T> SourceConfig;
public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;
public T Value
{
get
{
return SourceConfig.Value;
}
set
{
SourceConfig.Value = value;
}
}
public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
{
SourceConfig = sourceConfig;
}
public void AssignLocalValue(T value)
{
if (LocalBaseValue == null)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
public abstract class CustomSyncedValueBase
{
public object? LocalBaseValue;
public readonly string Identifier;
public readonly Type Type;
private object? boxedValue;
protected bool localIsOwner;
public object? BoxedValue
{
get
{
return boxedValue;
}
set
{
boxedValue = value;
this.ValueChanged?.Invoke();
}
}
public event Action? ValueChanged;
protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type)
{
Identifier = identifier;
Type = type;
configSync.AddCustomValue(this);
localIsOwner = configSync.IsSourceOfTruth;
configSync.SourceOfTruthChanged += delegate(bool truth)
{
localIsOwner = truth;
};
}
}
[PublicAPI]
public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
{
public T Value
{
get
{
return (T)base.BoxedValue;
}
set
{
base.BoxedValue = value;
}
}
public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T))
: base(configSync, identifier, typeof(T))
{
Value = value;
}
public void AssignLocalValue(T value)
{
if (localIsOwner)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
internal class ConfigurationManagerAttributes
{
[UsedImplicitly]
public bool? ReadOnly = false;
}
[PublicAPI]
public class ConfigSync
{
[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
private static class SnatchCurrentlyHandlingRPC
{
public static ZRpc? currentRpc;
[HarmonyPrefix]
private static void Prefix(ZRpc __instance)
{
currentRpc = __instance;
}
}
[HarmonyPatch(typeof(ZNet), "Awake")]
internal static class RegisterRPCPatch
{
[HarmonyPostfix]
private static void Postfix(ZNet __instance)
{
isServer = __instance.IsServer();
foreach (ConfigSync configSync2 in configSyncs)
{
configSync2.IsSourceOfTruth = __instance.IsDedicated() || __instance.IsServer();
ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_ConfigSync);
if (isServer)
{
Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
}
}
if (isServer)
{
((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
}
static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
{
ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
{
new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = isAdmin
}
});
ConfigSync configSync = configSyncs.First();
if (configSync != null)
{
((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
}
}
static IEnumerator WatchAdminListChanges()
{
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
List<string> CurrentList = new List<string>(adminList.GetList());
while (true)
{
yield return (object)new WaitForSeconds(30f);
if (!adminList.GetList().SequenceEqual(CurrentList))
{
CurrentList = new List<string>(adminList.GetList());
List<ZNetPeer> adminPeer = (from p in ZNet.instance.GetPeers()
where adminList.Contains(p.m_rpc.GetSocket().GetHostName())
select p).ToList();
List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
SendAdmin(nonAdminPeer, isAdmin: false);
SendAdmin(adminPeer, isAdmin: true);
}
}
}
}
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static class RegisterClientRPCPatch
{
[HarmonyPostfix]
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
if (__instance.IsServer())
{
return;
}
foreach (ConfigSync configSync in configSyncs)
{
peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_InitialConfigSync);
}
}
}
private class ParsedConfigs
{
public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();
public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
}
[HarmonyPatch(typeof(ZNet), "Shutdown")]
private class ResetConfigsOnShutdown
{
[HarmonyPostfix]
private static void Postfix()
{
ProcessingServerUpdate = true;
foreach (ConfigSync configSync in configSyncs)
{
configSync.resetConfigsFromServer();
}
ProcessingServerUpdate = false;
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
private class SendConfigsAfterLogin
{
private class BufferingSocket : ISocket
{
public volatile bool finished = false;
public volatile int versionMatchQueued = -1;
public readonly List<ZPackage> Package = new List<ZPackage>();
public readonly ISocket Original;
public BufferingSocket(ISocket original)
{
Original = original;
}
public bool IsConnected()
{
return Original.IsConnected();
}
public ZPackage Recv()
{
return Original.Recv();
}
public int GetSendQueueSize()
{
return Original.GetSendQueueSize();
}
public int GetCurrentSendRate()
{
return Original.GetCurrentSendRate();
}
public bool IsHost()
{
return Original.IsHost();
}
public void Dispose()
{
Original.Dispose();
}
public bool GotNewData()
{
return Original.GotNewData();
}
public void Close()
{
Original.Close();
}
public string GetEndPointString()
{
return Original.GetEndPointString();
}
public void GetAndResetStats(out int totalSent, out int totalRecv)
{
Original.GetAndResetStats(ref totalSent, ref totalRecv);
}
public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
{
Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
}
public ISocket Accept()
{
return Original.Accept();
}
public int GetHostPort()
{
return Original.GetHostPort();
}
public bool Flush()
{
return Original.Flush();
}
public string GetHostName()
{
return Original.GetHostName();
}
public void VersionMatch()
{
if (finished)
{
Original.VersionMatch();
}
else
{
versionMatchQueued = Package.Count;
}
}
public void Send(ZPackage pkg)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
int pos = pkg.GetPos();
pkg.SetPos(0);
int num = pkg.ReadInt();
if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
{
ZPackage val = new ZPackage(pkg.GetArray());
val.SetPos(pos);
Package.Add(val);
}
else
{
pkg.SetPos(pos);
Original.Send(pkg);
}
}
}
[HarmonyPriority(800)]
[HarmonyPrefix]
private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Invalid comparison between Unknown and I4
if (__instance.IsServer())
{
BufferingSocket value = new BufferingSocket(rpc.GetSocket());
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (val != null && (int)ZNet.m_onlineBackend > 0)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
}
if (__state == null)
{
__state = new Dictionary<Assembly, BufferingSocket>();
}
__state[Assembly.GetExecutingAssembly()] = value;
}
}
[HarmonyPostfix]
private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
{
ZRpc rpc2 = rpc;
ZNet __instance2 = __instance;
Dictionary<Assembly, BufferingSocket> __state2 = __state;
ZNetPeer peer;
if (__instance2.IsServer())
{
object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (peer == null)
{
SendBufferedData();
}
else
{
((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
}
}
void SendBufferedData()
{
if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
{
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
if (val != null)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
}
}
BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
bufferingSocket2.finished = true;
for (int i = 0; i < bufferingSocket2.Package.Count; i++)
{
if (i == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
}
if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
}
IEnumerator sendAsync()
{
foreach (ConfigSync configSync in configSyncs)
{
List<PackageEntry> entries = new List<PackageEntry>();
if (configSync.CurrentVersion != null)
{
entries.Add(new PackageEntry
{
section = "Internal",
key = "serverversion",
type = typeof(string),
value = configSync.CurrentVersion
});
}
MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
entries.Add(new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
{
adminList,
rpc2.GetSocket().GetHostName()
}))
});
ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
}
SendBufferedData();
}
}
}
private class PackageEntry
{
public string section = null;
public string key = null;
public Type type = null;
public object? value;
}
[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
private static class PreventSavingServerInfo
{
[HarmonyPrefix]
private static bool Prefix(ConfigEntryBase __instance, ref string __result)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
{
return true;
}
__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
return false;
}
}
[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
private static class PreventConfigRereadChangingValues
{
[HarmonyPrefix]
private static bool Prefix(ConfigEntryBase __instance, string value)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
{
return true;
}
try
{
ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
}
catch (Exception ex)
{
Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
}
return false;
}
}
private class InvalidDeserializationTypeException : Exception
{
public string expected = null;
public string received = null;
public string field = "";
}
public static bool ProcessingServerUpdate;
public readonly string Name;
public string? DisplayName;
public string? CurrentVersion;
public string? MinimumRequiredVersion;
public bool ModRequired = false;
private bool? forceConfigLocking;
private bool isSourceOfTruth = true;
private static readonly HashSet<ConfigSync> configSyncs;
private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();
private readonly HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();
private static bool isServer;
private static bool lockExempt;
private OwnConfigEntryBase? lockedConfig = null;
private const byte PARTIAL_CONFIGS = 1;
private const byte FRAGMENTED_CONFIG = 2;
private const byte COMPRESSED_CONFIG = 4;
private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();
private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();
private static long packageCounter;
public bool IsLocked
{
get
{
bool? flag = forceConfigLocking;
bool num;
if (!flag.HasValue)
{
if (lockedConfig == null)
{
goto IL_0052;
}
num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
}
else
{
num = flag.GetValueOrDefault();
}
if (!num)
{
goto IL_0052;
}
int result = ((!lockExempt) ? 1 : 0);
goto IL_0053;
IL_0053:
return (byte)result != 0;
IL_0052:
result = 0;
goto IL_0053;
}
set
{
forceConfigLocking = value;
}
}
public bool IsAdmin => lockExempt;
public bool IsSourceOfTruth
{
get
{
return isSourceOfTruth;
}
private set
{
if (value != isSourceOfTruth)
{
isSourceOfTruth = value;
this.SourceOfTruthChanged?.Invoke(value);
}
}
}
public event Action<bool>? SourceOfTruthChanged;
private event Action? lockedConfigChanged;
static ConfigSync()
{
ProcessingServerUpdate = false;
configSyncs = new HashSet<ConfigSync>();
lockExempt = false;
packageCounter = 0L;
RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
}
public ConfigSync(string name)
{
Name = name;
configSyncs.Add(this);
new VersionCheck(this);
}
public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
{
ConfigEntry<T> configEntry2 = configEntry;
OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
if (syncedEntry == null)
{
syncedEntry = new SyncedConfigEntry<T>(configEntry2);
AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
{
new ConfigurationManagerAttributes()
}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
configEntry2.SettingChanged += delegate
{
if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
{
Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
}
};
allConfigs.Add(syncedEntry);
}
return syncedEntry;
}
public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
{
if (lockedConfig != null)
{
throw new Exception("Cannot initialize locking ConfigEntry twice");
}
lockedConfig = AddConfigEntry<T>(lockingConfig);
lockingConfig.SettingChanged += delegate
{
this.lockedConfigChanged?.Invoke();
};
return (SyncedConfigEntry<T>)lockedConfig;
}
internal void AddCustomValue(CustomSyncedValueBase customValue)
{
CustomSyncedValueBase customValue2 = customValue;
if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
{
throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
}
allCustomValues.Add(customValue2);
customValue2.ValueChanged += delegate
{
if (!ProcessingServerUpdate)
{
Broadcast(ZRoutedRpc.Everybody, customValue2);
}
};
}
private void RPC_InitialConfigSync(ZRpc rpc, ZPackage package)
{
RPC_ConfigSync(0L, package);
}
private void RPC_ConfigSync(long sender, ZPackage package)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0226: Unknown result type (might be due to invalid IL or missing references)
//IL_022d: Expected O, but got Unknown
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Expected O, but got Unknown
try
{
if (isServer && IsLocked)
{
SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
bool? obj;
if ((int)val == 0)
{
obj = null;
}
else
{
ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
object obj2;
if (currentRpc == null)
{
obj2 = null;
}
else
{
ISocket socket = currentRpc.GetSocket();
obj2 = ((socket != null) ? socket.GetHostName() : null);
}
obj = val.Contains((string)obj2);
}
if (obj == false)
{
return;
}
}
cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
{
if (kv.Key < DateTimeOffset.Now.Ticks)
{
configValueCache.Remove(kv.Value);
return true;
}
return false;
});
byte b = package.ReadByte();
if ((b & 2u) != 0)
{
long num = package.ReadLong();
string text = sender.ToString() + num;
if (!configValueCache.TryGetValue(text, out SortedDictionary<int, byte[]> value))
{
value = new SortedDictionary<int, byte[]>();
configValueCache[text] = value;
cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text));
}
int key = package.ReadInt();
int num2 = package.ReadInt();
value.Add(key, package.ReadByteArray());
if (value.Count < num2)
{
return;
}
configValueCache.Remove(text);
package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
b = package.ReadByte();
}
ProcessingServerUpdate = true;
if ((b & 4u) != 0)
{
byte[] buffer = package.ReadByteArray();
MemoryStream stream = new MemoryStream(buffer);
MemoryStream memoryStream = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
{
deflateStream.CopyTo(memoryStream);
}
package = new ZPackage(memoryStream.ToArray());
b = package.ReadByte();
}
if ((b & 1) == 0)
{
resetConfigsFromServer();
}
if (!isServer)
{
if (IsSourceOfTruth)
{
lockedConfigChanged += serverLockedSettingChanged;
}
IsSourceOfTruth = false;
}
ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
{
if (!isServer && configValue.Key.LocalBaseValue == null)
{
configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
}
configValue.Key.BaseConfig.BoxedValue = configValue.Value;
}
foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
{
if (!isServer)
{
CustomSyncedValueBase key2 = customValue.Key;
if (key2.LocalBaseValue == null)
{
key2.LocalBaseValue = customValue.Key.BoxedValue;
}
}
customValue.Key.BoxedValue = customValue.Value;
}
if (!isServer)
{
Debug.Log((object)$"Received {parsedConfigs.configValues.Count} configs and {parsedConfigs.customValues.Count} custom values from the server for mod {DisplayName ?? Name}");
serverLockedSettingChanged();
}
}
finally
{
ProcessingServerUpdate = false;
}
}
private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
{
ParsedConfigs parsedConfigs = new ParsedConfigs();
Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
int num = package.ReadInt();
for (int i = 0; i < num; i++)
{
string text = package.ReadString();
string text2 = package.ReadString();
string text3 = package.ReadString();
Type type = Type.GetType(text3);
if (text3 == "" || type != null)
{
object obj;
try
{
obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
}
catch (InvalidDeserializationTypeException ex)
{
Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
continue;
}
OwnConfigEntryBase value2;
if (text == "Internal")
{
CustomSyncedValueBase value;
if (text2 == "serverversion")
{
if (obj?.ToString() != CurrentVersion)
{
Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
}
}
else if (text2 == "lockexempt")
{
if (obj is bool flag)
{
lockExempt = flag;
}
}
else if (dictionary2.TryGetValue(text2, out value))
{
if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
{
parsedConfigs.customValues[value] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
}
}
else if (dictionary.TryGetValue(text + "_" + text2, out value2))
{
Type type2 = configType(value2.BaseConfig);
if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
{
parsedConfigs.configValues[value2] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
}
else
{
Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
}
continue;
}
Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
return new ParsedConfigs();
}
return parsedConfigs;
}
private static bool isWritableConfig(OwnConfigEntryBase config)
{
OwnConfigEntryBase config2 = config;
ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
if (configSync == null)
{
return true;
}
return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
}
private void serverLockedSettingChanged()
{
foreach (OwnConfigEntryBase allConfig in allConfigs)
{
configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
}
}
private void resetConfigsFromServer()
{
foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
{
item.BaseConfig.BoxedValue = item.LocalBaseValue;
item.LocalBaseValue = null;
}
foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
{
item2.BoxedValue = item2.LocalBaseValue;
item2.LocalBaseValue = null;
}
lockedConfigChanged -= serverLockedSettingChanged;
IsSourceOfTruth = true;
serverLockedSettingChanged();
}
private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
{
ZNetPeer peer2 = peer;
ZRoutedRpc rpc = ZRoutedRpc.instance;
if (rpc == null)
{
yield break;
}
byte[] data = package.GetArray();
if (data != null && data.LongLength > 250000)
{
int fragments = (int)(1 + (data.LongLength - 1) / 250000);
long packageIdentifier = ++packageCounter;
int fragment = 0;
while (fragment < fragments)
{
foreach (bool item in waitForQueue())
{
yield return item;
}
if (peer2.m_socket.IsConnected())
{
ZPackage fragmentedPackage = new ZPackage();
fragmentedPackage.Write((byte)2);
fragmentedPackage.Write(packageIdentifier);
fragmentedPackage.Write(fragment);
fragmentedPackage.Write(fragments);
fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
SendPackage(fragmentedPackage);
if (fragment != fragments - 1)
{
yield return true;
}
int num = fragment + 1;
fragment = num;
continue;
}
break;
}
yield break;
}
foreach (bool item2 in waitForQueue())
{
yield return item2;
}
SendPackage(package);
void SendPackage(ZPackage pkg)
{
string text = Name + " ConfigSync";
if (isServer)
{
peer2.m_rpc.Invoke(text, new object[1] { pkg });
}
else
{
rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
}
}
IEnumerable<bool> waitForQueue()
{
float timeout = Time.time + 30f;
while (peer2.m_socket.GetSendQueueSize() > 20000)
{
if (Time.time > timeout)
{
Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
ZNet.instance.Disconnect(peer2);
break;
}
yield return false;
}
}
}
private IEnumerator sendZPackage(long target, ZPackage package)
{
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
return Enumerable.Empty<object>().GetEnumerator();
}
List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
if (target != ZRoutedRpc.Everybody)
{
list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
}
return sendZPackage(list, package);
}
private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
{
ZPackage package2 = package;
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
yield break;
}
byte[] rawData = package2.GetArray();
if (rawData != null && rawData.LongLength > 10000)
{
ZPackage compressedPackage = new ZPackage();
compressedPackage.Write((byte)4);
MemoryStream output = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
{
deflateStream.Write(rawData, 0, rawData.Length);
}
compressedPackage.Write(output.ToArray());
package2 = compressedPackage;
}
List<IEnumerator<bool>> writers = (from peer in peers
where peer.IsReady()
select peer into p
select distributeConfigToPeers(p, package2)).ToList();
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
while (writers.Count > 0)
{
yield return null;
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
}
}
private void Broadcast(long target, params ConfigEntryBase[] configs)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(configs);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(null, customValues);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
private static OwnConfigEntryBase? configData(ConfigEntryBase config)
{
return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
}
public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
{
return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
}
private static T configAttribute<T>(ConfigEntryBase config)
{
return config.Description.Tags.OfType<T>().First();
}
private static Type configType(ConfigEntryBase config)
{
return configType(config.SettingType);
}
private static Type configType(Type type)
{
return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
}
private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
ZPackage val = new ZPackage();
val.Write((byte)(partial ? 1 : 0));
val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
{
AddEntryToPackage(val, item);
}
foreach (CustomSyncedValueBase item2 in list2)
{
AddEntryToPackage(val, new PackageEntry
{
section = "Internal",
key = item2.Identifier,
type = item2.Type,
value = item2.BoxedValue
});
}
foreach (ConfigEntryBase item3 in list)
{
AddEntryToPackage(val, new PackageEntry
{
section = item3.Definition.Section,
key = item3.Definition.Key,
type = configType(item3),
value = item3.BoxedValue
});
}
return val;
}
private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
{
package.Write(entry.section);
package.Write(entry.key);
package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
AddValueToZPackage(package, entry.value);
}
private static string GetZPackageTypeString(Type type)
{
return type.AssemblyQualifiedName;
}
private static void AddValueToZPackage(ZPackage package, object? value)
{
Type type = value?.GetType();
if (value is Enum)
{
value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
}
else
{
if (value is ICollection collection)
{
package.Write(collection.Count);
{
foreach (object item in collection)
{
AddValueToZPackage(package, item);
}
return;
}
}
if ((object)type != null && type.IsValueType && !type.IsPrimitive)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
package.Write(fields.Length);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
package.Write(GetZPackageTypeString(fieldInfo.FieldType));
AddValueToZPackage(package, fieldInfo.GetValue(value));
}
return;
}
}
ZRpc.Serialize(new object[1] { value }, ref package);
}
private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
{
if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num = package.ReadInt();
if (num != fields.Length)
{
throw new InvalidDeserializationTypeException
{
received = $"(field count: {num})",
expected = $"(field count: {fields.Length})"
};
}
object uninitializedObject = FormatterServices.GetUninitializedObject(type);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = package.ReadString();
if (text != GetZPackageTypeString(fieldInfo.FieldType))
{
throw new InvalidDeserializationTypeException
{
received = text,
expected = GetZPackageTypeString(fieldInfo.FieldType),
field = fieldInfo.Name
};
}
fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
}
return uninitializedObject;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
{
int num2 = package.ReadInt();
IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
for (int j = 0; j < num2; j++)
{
object obj = ReadValueWithTypeFromZPackage(package, type2);
dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
}
return dictionary;
}
if (type != typeof(List<string>) && type.IsGenericType)
{
Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
if ((object)type3 != null && type3.IsAssignableFrom(type.GetGenericTypeDefinition()))
{
int num3 = package.ReadInt();
object obj2 = Activator.CreateInstance(type);
MethodInfo method = type3.GetMethod("Add");
for (int k = 0; k < num3; k++)
{
method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
}
return obj2;
}
}
ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
List<object> source = new List<object>();
ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
return source.First();
}
}
[PublicAPI]
[HarmonyPatch]
public class VersionCheck
{
private static readonly HashSet<VersionCheck> versionChecks;
private static readonly Dictionary<string, string> notProcessedNames;
public string Name;
private string? displayName;
private string? currentVersion;
private string? minimumRequiredVersion;
public bool ModRequired = true;
private string? ReceivedCurrentVersion;
private string? ReceivedMinimumRequiredVersion;
private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();
private ConfigSync? ConfigSync;
public string DisplayName
{
get
{
return displayName ?? Name;
}
set
{
displayName = value;
}
}
public string CurrentVersion
{
get
{
return currentVersion ?? "0.0.0";
}
set
{
currentVersion = value;
}
}
public string MinimumRequiredVersion
{
get
{
return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
}
set
{
minimumRequiredVersion = value;
}
}
private static void PatchServerSync()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
{
return;
}
Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
where t.IsClass
select t)
{
val.PatchAll(item);
}
}
static VersionCheck()
{
versionChecks = new HashSet<VersionCheck>();
notProcessedNames = new Dictionary<string, string>();
typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
{
new Action(PatchServerSync)
});
}
public VersionCheck(string name)
{
Name = name;
ModRequired = true;
versionChecks.Add(this);
}
public VersionCheck(ConfigSync configSync)
{
ConfigSync = configSync;
Name = ConfigSync.Name;
versionChecks.Add(this);
}
public void Initialize()
{
ReceivedCurrentVersion = null;
ReceivedMinimumRequiredVersion = null;
if (ConfigSync != null)
{
Name = ConfigSync.Name;
DisplayName = ConfigSync.DisplayName;
CurrentVersion = ConfigSync.CurrentVersion;
MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
ModRequired = ConfigSync.ModRequired;
}
}
private bool IsVersionOk()
{
if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
{
return !ModRequired;
}
bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
return flag && flag2;
}
private string ErrorClient()
{
if (ReceivedMinimumRequiredVersion == null)
{
return "Mod " + DisplayName + " must not be installed.";
}
return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? ("Mod " + DisplayName + " requires maximum " + ReceivedCurrentVersion + ". Installed is version " + CurrentVersion + ".") : ("Mod " + DisplayName + " requires minimum " + ReceivedMinimumRequiredVersion + ". Installed is version " + CurrentVersion + ".");
}
private string ErrorServer(ZRpc rpc)
{
return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
}
private string Error(ZRpc? rpc = null)
{
return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
}
private static VersionCheck[] GetFailedClient()
{
return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
}
private static VersionCheck[] GetFailedServer(ZRpc rpc)
{
ZRpc rpc2 = rpc;
return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
}
private static void Logout()
{
Game.instance.Logout();
AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
}
private static void DisconnectClient(ZRpc rpc)
{
rpc.Invoke("Error", new object[1] { 3 });
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg)
{
CheckVersion(rpc, pkg, null);
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
{
string text = pkg.ReadString();
string text2 = pkg.ReadString();
string text3 = pkg.ReadString();
bool flag = false;
foreach (VersionCheck versionCheck in versionChecks)
{
if (!(text != versionCheck.Name))
{
Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
versionCheck.ReceivedMinimumRequiredVersion = text2;
versionCheck.ReceivedCurrentVersion = text3;
if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
{
versionCheck.ValidatedClients.Add(rpc);
}
flag = true;
}
}
if (flag)
{
return;
}
pkg.SetPos(0);
if (original != null)
{
original(rpc, pkg);
if (pkg.GetPos() == 0)
{
notProcessedNames.Add(text, text3);
}
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
[HarmonyPrefix]
private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
{
VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
if (array.Length == 0)
{
return true;
}
VersionCheck[] array2 = array;
foreach (VersionCheck versionCheck in array2)
{
Debug.LogWarning((object)versionCheck.Error(rpc));
}
if (__instance.IsServer())
{
DisconnectClient(rpc);
}
else
{
Logout();
}
return false;
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
[HarmonyPrefix]
private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
{
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Expected O, but got Unknown
notProcessedNames.Clear();
IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
{
object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
{
CheckVersion(rpc, pkg, action);
});
}
else
{
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.Initialize();
if (versionCheck.ModRequired || __instance.IsServer())
{
Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
ZPackage val = new ZPackage();
val.Write(versionCheck.Name);
val.Write(versionCheck.MinimumRequiredVersion);
val.Write(versionCheck.CurrentVersion);
peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
}
}
}
[HarmonyPatch(typeof(ZNet), "Disconnect")]
[HarmonyPrefix]
private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
{
if (!__instance.IsServer())
{
return;
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.ValidatedClients.Remove(peer.m_rpc);
}
}
[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
[HarmonyPostfix]
private static void ShowConnectionError(FejdStartup __instance)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Invalid comparison between Unknown and I4
if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
{
return;
}
VersionCheck[] failedClient = GetFailedClient();
if (failedClient.Length != 0)
{
string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
Text connectionFailedError = __instance.m_connectionFailedError;
connectionFailedError.text = connectionFailedError.text + "\n" + text;
}
foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
{
if (!__instance.m_connectionFailedError.text.Contains(item.Key))
{
Text connectionFailedError2 = __instance.m_connectionFailedError;
connectionFailedError2.text = connectionFailedError2.text + "\n" + item.Key + " (Version: " + item.Value + ")";
}
}
}
}
}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.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Microsoft.CodeAnalysis;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
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: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: AssemblyFileVersion("13.1.0.0")]
[assembly: AssemblyInformationalVersion("13.1.0")]
[assembly: AssemblyTitle("YamlDotNet")]
[assembly: AssemblyDescription("The YamlDotNet library.")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("YamlDotNet")]
[assembly: AssemblyCopyright("Copyright (c) Antoine Aubry and contributors 2008 - 2019")]
[assembly: AssemblyTrademark("")]
[assembly: CLSCompliant(true)]
[assembly: InternalsVisibleTo("YamlDotNet.Test, PublicKey=002400000480000094000000060200000024000052534131000400000100010065e52a453dde5c5b4be5bbe2205755727fce80244b79b894faf8793d80f7db9a96d360b51c220782db32aacee4cb5b8a91bee33aeec700e1f21895c4baadef501eeeac609220d1651603b378173811ee5bb6a002df973d38821bd2fef820c00c174a69faec326a1983b570f07ec66147026b9c8753465de3a8d0c44b613b02af")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyVersion("13.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class IsReadOnlyAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace YamlDotNet
{
internal sealed class CultureInfoAdapter : CultureInfo
{
private readonly IFormatProvider provider;
public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
: base(baseCulture.LCID)
{
this.provider = provider;
}
public override object? GetFormat(Type? formatType)
{
return provider.GetFormat(formatType);
}
}
internal static class ReflectionExtensions
{
private static readonly FieldInfo? RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);
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, bool allowPrivateConstructors)
{
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (allowPrivateConstructors)
{
bindingFlags |= BindingFlags.NonPublic;
}
if (!type.IsValueType)
{
return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
}
return true;
}
public static TypeCode GetTypeCode(this Type type)
{
return Type.GetTypeCode(type);
}
public static PropertyInfo? GetPublicProperty(this Type type, string name)
{
return type.GetProperty(name);
}
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((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 + "'.");
}
public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
{
return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
}
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<TAttribute>(this PropertyInfo property)
{
return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
}
}
internal static class PropertyInfoExtensions
{
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
{
public abstract class BuilderSkeleton<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;
internal bool ignoreFields;
internal bool includeNonPublicProperties;
internal Settings settings;
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");
settings = new Settings();
}
public TBuilder IgnoreFields()
{
ignoreFields = true;
return Self;
}
public TBuilder IncludeNonPublicProperties()
{
includeNonPublicProperties = true;
return Self;
}
public TBuilder EnablePrivateConstructors()
{
settings.AllowPrivateConstructors = 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<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)
{
IYamlTypeConverter typeConverter2 = typeConverter;
if (typeConverter2 == null)
{
throw new ArgumentNullException("typeConverter");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
return Self;
}
public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
{
WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
if (typeConverterFactory2 == null)
{
throw new ArgumentNullException("typeConverterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
return Self;
}
public TBuilder WithoutTypeConverter<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<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
{
return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
{
w.OnTop();
});
}
public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
return Self;
}
public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
return Self;
}
public TBuilder WithoutTypeInspector<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();
}
}
public delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
public delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
[Flags]
public enum DefaultValuesHandling
{
Preserve = 0,
OmitNull = 1,
OmitDefaults = 2,
OmitEmptyCollections = 4
}
public 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<T>(string input)
{
using StringReader input2 = new StringReader(input);
return Deserialize<T>(input2);
}
public T Deserialize<T>(TextReader input)
{
return Deserialize<T>(new Parser(input));
}
public object? Deserialize(TextReader input)
{
return Deserialize(input, typeof(object));
}
public object? Deserialize(string input, Type type)
{
using StringReader input2 = new StringReader(input);
return Deserialize(input2, type);
}
public object? Deserialize(TextReader input, Type type)
{
return Deserialize(new Parser(input), type);
}
public T Deserialize<T>(IParser parser)
{
return (T)Deserialize(parser, typeof(T));
}
public object? Deserialize(IParser parser)
{
return Deserialize(parser, typeof(object));
}
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;
}
}
public 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 readonly ITypeConverter typeConverter;
private bool ignoreUnmatched;
private bool duplicateKeyChecking;
private bool attemptUnknownTypeDeserialization;
protected override DeserializerBuilder Self => this;
public DeserializerBuilder()
: base((ITypeResolver)new StaticTypeResolver())
{
typeMappings = new Dictionary<Type, Type>();
objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), 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(attemptUnknownTypeDeserialization, typeConverter)
},
{
typeof(ArrayNodeDeserializer),
(Nothing _) => new ArrayNodeDeserializer()
},
{
typeof(DictionaryNodeDeserializer),
(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
},
{
typeof(CollectionNodeDeserializer),
(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
},
{
typeof(EnumerableNodeDeserializer),
(Nothing _) => new EnumerableNodeDeserializer()
},
{
typeof(ObjectNodeDeserializer),
(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
}
};
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()
}
};
typeConverter = new ReflectionTypeConverter();
}
internal ITypeInspector BuildTypeInspector()
{
ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
if (!ignoreFields)
{
typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
}
return typeInspectorFactories.BuildComponentChain(typeInspector);
}
public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
{
attemptUnknownTypeDeserialization = true;
return this;
}
public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
{
IObjectFactory objectFactory2 = objectFactory;
if (objectFactory2 == null)
{
throw new ArgumentNullException("objectFactory");
}
this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, 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)
{
INodeDeserializer nodeDeserializer2 = nodeDeserializer;
if (nodeDeserializer2 == null)
{
throw new ArgumentNullException("nodeDeserializer");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
return this;
}
public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
{
WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
if (nodeDeserializerFactory2 == null)
{
throw new ArgumentNullException("nodeDeserializerFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeDeserializer<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 WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
{
TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
{
s.Before<DictionaryNodeDeserializer>();
});
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
{
return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
{
w.OnTop();
});
}
public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
{
INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
if (nodeTypeResolver2 == null)
{
throw new ArgumentNullException("nodeTypeResolver");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
return this;
}
public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
{
WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
if (nodeTypeResolverFactory2 == null)
{
throw new ArgumentNullException("nodeTypeResolverFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
return this;
}
public DeserializerBuilder WithoutNodeTypeResolver<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 Type 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<TInterface, 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 DeserializerBuilder WithDuplicateKeyChecking()
{
duplicateKeyChecking = true;
return this;
}
public IDeserializer Build()
{
return Deserializer.FromValueDeserializer(BuildValueDeserializer());
}
public IValueDeserializer BuildValueDeserializer()
{
return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
}
}
public 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<T>() where T : IObjectGraphVisitor<Nothing>
{
return preProcessingPhaseVisitors.OfType<T>().Single();
}
}
public abstract class EventInfo
{
public IObjectDescriptor Source { get; }
protected EventInfo(IObjectDescriptor source)
{
Source = source ?? throw new ArgumentNullException("source");
}
}
public class AliasEventInfo : EventInfo
{
public AnchorName Alias { get; }
public bool NeedsExpansion { get; set; }
public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
: base(source)
{
if (alias.IsEmpty)
{
throw new ArgumentNullException("alias");
}
Alias = alias;
}
}
public class ObjectEventInfo : EventInfo
{
public AnchorName Anchor { get; set; }
public TagName Tag { get; set; }
protected ObjectEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
public 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;
}
}
public sealed class MappingStartEventInfo : ObjectEventInfo
{
public bool IsImplicit { get; set; }
public MappingStyle Style { get; set; }
public MappingStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
public sealed class MappingEndEventInfo : EventInfo
{
public MappingEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
public sealed class SequenceStartEventInfo : ObjectEventInfo
{
public bool IsImplicit { get; set; }
public SequenceStyle Style { get; set; }
public SequenceStartEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
public sealed class SequenceEndEventInfo : EventInfo
{
public SequenceEndEventInfo(IObjectDescriptor source)
: base(source)
{
}
}
public interface IAliasProvider
{
AnchorName GetAlias(object target);
}
public interface IDeserializer
{
T Deserialize<T>(string input);
T Deserialize<T>(TextReader input);
object? Deserialize(TextReader input);
object? Deserialize(string input, Type type);
object? Deserialize(TextReader input, Type type);
T Deserialize<T>(IParser parser);
object? Deserialize(IParser parser);
object? Deserialize(IParser parser, Type type);
}
public 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);
}
public interface INamingConvention
{
string Apply(string value);
}
public interface INodeDeserializer
{
bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value);
}
public interface INodeTypeResolver
{
bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
}
public interface IObjectAccessor
{
void Set(string name, object target, object value);
object? Read(string name, object target);
}
public interface IObjectDescriptor
{
object? Value { get; }
Type Type { get; }
Type StaticType { get; }
ScalarStyle ScalarStyle { get; }
}
public static class ObjectDescriptorExtensions
{
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.");
}
}
public interface IObjectFactory
{
object Create(Type type);
object? CreatePrimitive(Type type);
bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);
Type GetValueType(Type type);
}
public interface IObjectGraphTraversalStrategy
{
void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
}
public interface IObjectGraphVisitor<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);
}
public interface IPropertyDescriptor
{
string Name { get; }
bool CanWrite { get; }
Type Type { get; }
Type? TypeOverride { get; set; }
int Order { get; set; }
ScalarStyle ScalarStyle { get; set; }
T? GetCustomAttribute<T>() where T : Attribute;
IObjectDescriptor Read(object target);
void Write(object target, object? value);
}
public interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
{
void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
void OnTop();
void OnBottom();
}
public interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
{
void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
}
public 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);
}
public interface ITypeInspector
{
IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);
IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
}
public interface ITypeResolver
{
Type Resolve(Type staticType, object? actualValue);
}
public interface IValueDeserializer
{
object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
}
public interface IValuePromise
{
event Action<object?> ValueAvailable;
}
public interface IValueSerializer
{
void SerializeValue(IEmitter emitter, object? value, Type? type);
}
public interface IYamlConvertible
{
void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);
void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
}
public delegate object? ObjectDeserializer(Type type);
public delegate void ObjectSerializer(object? value, Type? type = null);
[Obsolete("Please use IYamlConvertible instead")]
public interface IYamlSerializable
{
void ReadYaml(IParser parser);
void WriteYaml(IEmitter emitter);
}
public interface IYamlTypeConverter
{
bool Accepts(Type type);
object? ReadYaml(IParser parser, Type type);
void WriteYaml(IEmitter emitter, object? value, Type type);
}
internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
{
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;
}
}
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;
}
}
private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
{
private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;
private readonly LazyComponentRegistration newRegistration;
public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, 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);
}
}
private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
{
private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;
private readonly TrackingLazyComponentRegistration newRegistration;
public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, 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, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
}
}
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 Clear()
{
entries.Clear();
}
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((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.");
}
}
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;
}
}
internal static class LazyComponentRegistrationListExtensions
{
public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
{
return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
}
public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
{
Func<TComponent, TArgument> argumentBuilder2 = argumentBuilder;
return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder2(inner)));
}
public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
{
return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
}
public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
{
TArgument argument2 = argument;
return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
}
}
[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct Nothing
{
}
public sealed class ObjectDescriptor : IObjectDescriptor
{
public object? Value { get; private set; }
public Type Type { get; private set; }
public Type StaticType { get; private set; }
public ScalarStyle ScalarStyle { get; private set; }
public ObjectDescriptor(object? value, Type type, Type staticType)
: this(value, type, staticType, ScalarStyle.Any)
{
}
public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
{
Value = value;
Type = type ?? throw new ArgumentNullException("type");
StaticType = staticType ?? throw new ArgumentNullException("staticType");
ScalarStyle = scalarStyle;
}
}
public delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
public sealed class PropertyDescriptor : IPropertyDescriptor
{
private readonly IPropertyDescriptor baseDescriptor;
public string Name { get; set; }
public Type Type => baseDescriptor.Type;
public Type? TypeOverride
{
get
{
return baseDescriptor.TypeOverride;
}
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, object? value)
{
baseDescriptor.Write(target, value);
}
public T? GetCustomAttribute<T>() where T : Attribute
{
return baseDescriptor.GetCustomAttribute<T>();
}
public IObjectDescriptor Read(object target)
{
return baseDescriptor.Read(target);
}
}
public 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, 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());
}
}
public sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
{
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;
}
public void SerializeValue(IEmitter emitter, object? value, Type? type)
{
IEmitter emitter2 = emitter;
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<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
traversalStrategy.Traverse(graph, visitor, emitter2);
void NestedObjectSerializer(object? v, Type? t)
{
SerializeValue(emitter2, 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 readonly IObjectFactory objectFactory;
private int maximumRecursion = 50;
private EmitterSettings emitterSettings = EmitterSettings.Default;
private DefaultValuesHandling defaultValuesHandlingConfiguration;
private bool quoteNecessaryStrings;
private bool quoteYaml1_1Strings;
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, new DefaultObjectFactory())
},
{
typeof(CommentsObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
}
};
eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> {
{
typeof(TypeAssigningEventEmitter),
(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings)
} };
objectFactory = new DefaultObjectFactory();
objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
}
public SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
{
quoteNecessaryStrings = true;
this.quoteYaml1_1Strings = quoteYaml1_1Strings;
return this;
}
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<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
{
return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
{
w.OnTop();
});
}
public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
if (eventEmitterFactory2 == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner)));
return Self;
}
public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
if (eventEmitterFactory2 == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
return Self;
}
public SerializerBuilder WithoutEventEmitter<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, settings, objectFactory);
WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
return WithTypeInspector((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>();
}).WithTypeConverter(new YamlDotNet.Serialization.Converters.DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
}
public SerializerBuilder WithNewLine(string newLine)
{
emitterSettings = emitterSettings.WithNewLine(newLine);
return this;
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
{
w.OnTop();
});
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
if (objectGraphVisitor2 == null)
{
throw new ArgumentNullException("objectGraphVisitor");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
return this;
}
public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
if (objectGraphVisitorFactory2 == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
return this;
}
public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<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<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
{
w.OnTop();
});
}
public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
if (objectGraphVisitorFactory2 == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
return this;
}
public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
if (objectGraphVisitorFactory2 == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
return this;
}
public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<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());
}
internal ITypeInspector BuildTypeInspector()
{
ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
if (!ignoreFields)
{
typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
}
return typeInspectorFactories.BuildComponentChain(typeInspector);
}
}
public class Settings
{
public bool AllowPrivateConstructors { get; set; }
}
public abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
{
internal INamingConvention namingConvention = NullNamingConvention.Instance;
internal ITypeResolver typeResolver;
internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;
internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;
internal bool includeNonPublicProperties;
internal Settings settings;
protected abstract TBuilder Self { get; }
internal StaticBuilderSkeleton(ITypeResolver typeResolver)
{
typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter> {
{
typeof(YamlDotNet.Serialization.Converters.GuidConverter),
(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
} };
typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
settings = new Settings();
}
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 WithTypeConverter(IYamlTypeConverter typeConverter)
{
return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
{
w.OnTop();
});
}
public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
{
IYamlTypeConverter typeConverter2 = typeConverter;
if (typeConverter2 == null)
{
throw new ArgumentNullException("typeConverter");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
return Self;
}
public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
{
WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
if (typeConverterFactory2 == null)
{
throw new ArgumentNullException("typeConverterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
return Self;
}
public TBuilder WithoutTypeConverter<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<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
{
return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
{
w.OnTop();
});
}
public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
return Self;
}
public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
{
WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
if (typeInspectorFactory2 == null)
{
throw new ArgumentNullException("typeInspectorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
return Self;
}
public TBuilder WithoutTypeInspector<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();
}
}
public abstract class StaticContext
{
public virtual StaticObjectFactory GetFactory()
{
throw new NotImplementedException();
}
public virtual ITypeInspector GetTypeInspector()
{
throw new NotImplementedException();
}
}
public sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
{
private readonly StaticContext context;
private readonly StaticObjectFactory factory;
private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;
private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;
private readonly Dictionary<TagName, Type> tagMappings;
private readonly ITypeConverter typeConverter;
private readonly Dictionary<Type, Type> typeMappings;
private bool ignoreUnmatched;
private bool duplicateKeyChecking;
private bool attemptUnknownTypeDeserialization;
protected override StaticDeserializerBuilder Self => this;
public StaticDeserializerBuilder(StaticContext context)
: base((ITypeResolver)new StaticTypeResolver())
{
this.context = context;
factory = context.GetFactory();
typeMappings = new Dictionary<Type, Type>();
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));
nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
{
{
typeof(YamlConvertibleNodeDeserializer),
(Nothing _) => new YamlConvertibleNodeDeserializer(factory)
},
{
typeof(YamlSerializableNodeDeserializer),
(Nothing _) => new YamlSerializableNodeDeserializer(factory)
},
{
typeof(TypeConverterNodeDeserializer),
(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
},
{
typeof(NullNodeDeserializer),
(Nothing _) => new NullNodeDeserializer()
},
{
typeof(ScalarNodeDeserializer),
(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter)
},
{
typeof(StaticArrayNodeDeserializer),
(Nothing _) => new StaticArrayNodeDeserializer(factory)
},
{
typeof(StaticDictionaryNodeDeserializer),
(Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
},
{
typeof(StaticCollectionNodeDeserializer),
(Nothing _) => new StaticCollectionNodeDeserializer(factory)
},
{
typeof(ObjectNodeDeserializer),
(Nothing _) => new ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
}
};
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()
}
};
typeConverter = new NullTypeConverter();
}
internal ITypeInspector BuildTypeInspector()
{
ITypeInspector typeInspector = context.GetTypeInspector();
return typeInspectorFactories.BuildComponentChain(typeInspector);
}
public StaticDeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
{
attemptUnknownTypeDeserialization = true;
return this;
}
public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
{
return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
{
w.OnTop();
});
}
public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
{
INodeDeserializer nodeDeserializer2 = nodeDeserializer;
if (nodeDeserializer2 == null)
{
throw new ArgumentNullException("nodeDeserializer");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
return this;
}
public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
{
WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
if (nodeDeserializerFactory2 == null)
{
throw new ArgumentNullException("nodeDeserializerFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
return this;
}
public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
{
return WithoutNodeDeserializer(typeof(TNodeDeserializer));
}
public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
{
if (nodeDeserializerType == null)
{
throw new ArgumentNullException("nodeDeserializerType");
}
nodeDeserializerFactories.Remove(nodeDeserializerType);
return this;
}
public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
{
TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
{
s.Before<DictionaryNodeDeserializer>();
});
}
public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
{
return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
{
w.OnTop();
});
}
public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
{
INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
if (nodeTypeResolver2 == null)
{
throw new ArgumentNullException("nodeTypeResolver");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
return this;
}
public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
{
WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
if (nodeTypeResolverFactory2 == null)
{
throw new ArgumentNullException("nodeTypeResolverFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
return this;
}
public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
{
return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
}
public StaticDeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
{
if (nodeTypeResolverType == null)
{
throw new ArgumentNullException("nodeTypeResolverType");
}
nodeTypeResolverFactories.Remove(nodeTypeResolverType);
return this;
}
public override StaticDeserializerBuilder 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 Type value))
{
throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
}
tagMappings.Add(tag, type);
return this;
}
public StaticDeserializerBuilder WithTypeMapping<TInterface, 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 StaticDeserializerBuilder 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 StaticDeserializerBuilder IgnoreUnmatchedProperties()
{
ignoreUnmatched = true;
return this;
}
public StaticDeserializerBuilder WithDuplicateKeyChecking()
{
duplicateKeyChecking = true;
return this;
}
public IDeserializer Build()
{
return Deserializer.FromValueDeserializer(BuildValueDeserializer());
}
public IValueDeserializer BuildValueDeserializer()
{
return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
}
}
public sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
{
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;
}
public void SerializeValue(IEmitter emitter, object? value, Type? type)
{
IEmitter emitter2 = emitter;
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<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
traversalStrategy.Traverse(graph, visitor, emitter2);
void NestedObjectSerializer(object? v, Type? t)
{
SerializeValue(emitter2, v, t);
}
}
}
private readonly StaticContext context;
private readonly StaticObjectFactory factory;
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;
private bool quoteNecessaryStrings;
protected override StaticSerializerBuilder Self => this;
public StaticSerializerBuilder(StaticContext context)
: base((ITypeResolver)new DynamicTypeResolver())
{
this.context = context;
factory = context.GetFactory();
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));
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, factory)
},
{
typeof(CommentsObjectGraphVisitor),
(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
}
};
eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> {
{
typeof(TypeAssigningEventEmitter),
(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings)
} };
objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
}
public StaticSerializerBuilder WithQuotingNecessaryStrings()
{
quoteNecessaryStrings = true;
return this;
}
public StaticSerializerBuilder 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 StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
{
return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
{
w.OnTop();
});
}
public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
if (eventEmitterFactory2 == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner)));
return Self;
}
public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
{
WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
if (eventEmitterFactory2 == null)
{
throw new ArgumentNullException("eventEmitterFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
return Self;
}
public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
{
return WithoutEventEmitter(typeof(TEventEmitter));
}
public StaticSerializerBuilder WithoutEventEmitter(Type eventEmitterType)
{
if (eventEmitterType == null)
{
throw new ArgumentNullException("eventEmitterType");
}
eventEmitterFactories.Remove(eventEmitterType);
return this;
}
public override StaticSerializerBuilder 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 StaticSerializerBuilder 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 StaticSerializerBuilder EnsureRoundtrip()
{
objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
{
loc.OnBottom();
});
}
public StaticSerializerBuilder 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 StaticSerializerBuilder EmitDefaults()
{
return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
}
public StaticSerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
{
defaultValuesHandlingConfiguration = configuration;
return this;
}
public StaticSerializerBuilder 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((IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
{
loc.InsteadOf<TypeAssigningEventEmitter>();
});
}
public StaticSerializerBuilder WithNewLine(string newLine)
{
emitterSettings = emitterSettings.WithNewLine(newLine);
return this;
}
public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
{
w.OnTop();
});
}
public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
if (objectGraphVisitor2 == null)
{
throw new ArgumentNullException("objectGraphVisitor");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
return this;
}
public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
if (objectGraphVisitorFactory2 == null)
{
throw new ArgumentNullException("objectGraphVisitorFactory");
}
if (where == null)
{
throw new ArgumentNullException("where");
}
where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
return this;
}
public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
{
return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
}
public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
{
if (objectGraphVisitorType == null)
{
throw new ArgumentNullException("objectGraphVisitorType")