using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName = ".NET Framework 4.6.1")]
[assembly: AssemblyCompany("SharpConfig")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2013-2020 Cemalettin Dervis")]
[assembly: AssemblyDescription("An easy to use CFG/INI configuration library for .NET.")]
[assembly: AssemblyFileVersion("3.2.9.1")]
[assembly: AssemblyInformationalVersion("3.2.9.1")]
[assembly: AssemblyProduct("SharpConfig")]
[assembly: AssemblyTitle("SharpConfig")]
[assembly: AssemblyVersion("3.2.9.1")]
namespace SharpConfig;

public class Configuration : IEnumerable<Section>, IEnumerable
{
	private static CultureInfo mCultureInfo;

	private static char mPreferredCommentChar;

	private static char mArrayElementSeparator;

	private static Dictionary<Type, ITypeStringConverter> mTypeStringConverters;

	internal readonly List<Section> mSections;

	public string StringRepresentation
	{
		get
		{
			StringBuilder sb = new StringBuilder();
			bool isFirstSection = true;
			Section defaultSection = DefaultSection;
			if (defaultSection.SettingCount > 0)
			{
				WriteSection(DefaultSection);
			}
			foreach (Section mSection in mSections)
			{
				if (mSection != defaultSection)
				{
					WriteSection(mSection);
				}
			}
			return sb.ToString();
			void WriteSection(Section section)
			{
				if (!isFirstSection)
				{
					sb.AppendLine();
				}
				if (!isFirstSection && section.PreComment != null)
				{
					sb.AppendLine();
				}
				if (section.Name != "$SharpConfigDefaultSection")
				{
					sb.AppendLine(section.ToString());
				}
				foreach (Setting item in section)
				{
					sb.AppendLine(item.ToString());
				}
				if (section.Name != "$SharpConfigDefaultSection" || section.SettingCount > 0)
				{
					isFirstSection = false;
				}
			}
		}
	}

	internal static ITypeStringConverter FallbackConverter { get; private set; }

	public static CultureInfo CultureInfo
	{
		get
		{
			return mCultureInfo;
		}
		set
		{
			mCultureInfo = value ?? throw new ArgumentNullException("value");
		}
	}

	public static char[] ValidCommentChars { get; private set; }

	public static char PreferredCommentChar
	{
		get
		{
			return mPreferredCommentChar;
		}
		set
		{
			if (!Array.Exists(ValidCommentChars, (char c) => c == value))
			{
				throw new ArgumentException("The specified char '" + value + "' is not allowed as a comment char.");
			}
			mPreferredCommentChar = value;
		}
	}

	public static char ArrayElementSeparator
	{
		get
		{
			return mArrayElementSeparator;
		}
		set
		{
			if (value == '\0')
			{
				throw new ArgumentException("Zero-character is not allowed.");
			}
			mArrayElementSeparator = value;
		}
	}

	public static bool OutputRawStringValues { get; set; }

	public static bool IgnoreInlineComments { get; set; }

	public static bool IgnorePreComments { get; set; }

	public static bool SpaceBetweenEquals { get; set; }

	public int SectionCount => mSections.Count;

	public Section this[int index]
	{
		get
		{
			if (index < 0 || index >= mSections.Count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			return mSections[index];
		}
	}

	public Section this[string name]
	{
		get
		{
			Section section = FindSection(name);
			if (section == null)
			{
				section = new Section(name);
				Add(section);
			}
			return section;
		}
	}

	public Section DefaultSection => this["$SharpConfigDefaultSection"];

	static Configuration()
	{
		mCultureInfo = (CultureInfo)CultureInfo.InvariantCulture.Clone();
		ValidCommentChars = new char[2] { '#', ';' };
		mPreferredCommentChar = '#';
		mArrayElementSeparator = ',';
		FallbackConverter = new FallbackStringConverter();
		mTypeStringConverters = new Dictionary<Type, ITypeStringConverter>
		{
			{
				typeof(bool),
				new BoolStringConverter()
			},
			{
				typeof(byte),
				new ByteStringConverter()
			},
			{
				typeof(char),
				new CharStringConverter()
			},
			{
				typeof(DateTime),
				new DateTimeStringConverter()
			},
			{
				typeof(decimal),
				new DecimalStringConverter()
			},
			{
				typeof(double),
				new DoubleStringConverter()
			},
			{
				typeof(Enum),
				new EnumStringConverter()
			},
			{
				typeof(short),
				new Int16StringConverter()
			},
			{
				typeof(int),
				new Int32StringConverter()
			},
			{
				typeof(long),
				new Int64StringConverter()
			},
			{
				typeof(sbyte),
				new SByteStringConverter()
			},
			{
				typeof(float),
				new SingleStringConverter()
			},
			{
				typeof(string),
				new StringStringConverter()
			},
			{
				typeof(ushort),
				new UInt16StringConverter()
			},
			{
				typeof(uint),
				new UInt32StringConverter()
			},
			{
				typeof(ulong),
				new UInt64StringConverter()
			}
		};
		IgnoreInlineComments = false;
		IgnorePreComments = false;
		SpaceBetweenEquals = false;
		OutputRawStringValues = false;
	}

	public Configuration()
	{
		mSections = new List<Section>();
	}

	public IEnumerator<Section> GetEnumerator()
	{
		return mSections.GetEnumerator();
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return GetEnumerator();
	}

	public void Add(Section section)
	{
		if (section == null)
		{
			throw new ArgumentNullException("section");
		}
		if (Contains(section))
		{
			throw new ArgumentException("The specified section already exists in the configuration.");
		}
		mSections.Add(section);
	}

	public Section Add(string sectionName)
	{
		Section section = new Section(sectionName);
		Add(section);
		return section;
	}

	public bool Remove(string sectionName)
	{
		if (string.IsNullOrEmpty(sectionName))
		{
			throw new ArgumentNullException("sectionName");
		}
		return Remove(FindSection(sectionName));
	}

	public bool Remove(Section section)
	{
		return mSections.Remove(section);
	}

	public void RemoveAllNamed(string sectionName)
	{
		if (string.IsNullOrEmpty(sectionName))
		{
			throw new ArgumentNullException("sectionName");
		}
		while (Remove(sectionName))
		{
		}
	}

	public void Clear()
	{
		mSections.Clear();
	}

	public bool Contains(Section section)
	{
		return mSections.Contains(section);
	}

	public bool Contains(string sectionName)
	{
		if (string.IsNullOrEmpty(sectionName))
		{
			throw new ArgumentNullException("sectionName");
		}
		return FindSection(sectionName) != null;
	}

	public bool Contains(string sectionName, string settingName)
	{
		if (string.IsNullOrEmpty(sectionName))
		{
			throw new ArgumentNullException("sectionName");
		}
		if (string.IsNullOrEmpty(settingName))
		{
			throw new ArgumentNullException("settingName");
		}
		return FindSection(sectionName)?.Contains(settingName) ?? false;
	}

	public static void RegisterTypeStringConverter(ITypeStringConverter converter)
	{
		if (converter == null)
		{
			throw new ArgumentNullException("converter");
		}
		Type convertibleType = converter.ConvertibleType;
		if (mTypeStringConverters.ContainsKey(convertibleType))
		{
			throw new InvalidOperationException("A converter for type '" + convertibleType.FullName + "' is already registered.");
		}
		mTypeStringConverters.Add(convertibleType, converter);
	}

	public static void DeregisterTypeStringConverter(Type type)
	{
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		if (!mTypeStringConverters.ContainsKey(type))
		{
			throw new InvalidOperationException("No converter is registered for type '" + type.FullName + "'.");
		}
		mTypeStringConverters.Remove(type);
	}

	internal static ITypeStringConverter FindTypeStringConverter(Type type)
	{
		if (type.IsEnum)
		{
			type = typeof(Enum);
		}
		if (!mTypeStringConverters.TryGetValue(type, out var value))
		{
			return FallbackConverter;
		}
		return value;
	}

	public static Configuration LoadFromFile(string filename)
	{
		return LoadFromFile(filename, null);
	}

	public static Configuration LoadFromFile(string filename, Encoding encoding)
	{
		if (string.IsNullOrEmpty(filename))
		{
			throw new ArgumentNullException("filename");
		}
		if (!File.Exists(filename))
		{
			throw new FileNotFoundException("Configuration file not found.", filename);
		}
		if (encoding != null)
		{
			return LoadFromString(File.ReadAllText(filename, encoding));
		}
		return LoadFromString(File.ReadAllText(filename));
	}

	public static Configuration LoadFromStream(Stream stream)
	{
		return LoadFromStream(stream, null);
	}

	public static Configuration LoadFromStream(Stream stream, Encoding encoding)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		string source = null;
		StreamReader streamReader = ((encoding == null) ? new StreamReader(stream) : new StreamReader(stream, encoding));
		using (streamReader)
		{
			source = streamReader.ReadToEnd();
		}
		return LoadFromString(source);
	}

	public static Configuration LoadFromString(string source)
	{
		if (source == null)
		{
			throw new ArgumentNullException("source");
		}
		return ConfigurationReader.ReadFromString(source);
	}

	public static Configuration LoadFromBinaryFile(string filename)
	{
		return LoadFromBinaryFile(filename, null);
	}

	public static Configuration LoadFromBinaryFile(string filename, BinaryReader reader)
	{
		if (string.IsNullOrEmpty(filename))
		{
			throw new ArgumentNullException("filename");
		}
		using FileStream stream = File.OpenRead(filename);
		return LoadFromBinaryStream(stream, reader);
	}

	public static Configuration LoadFromBinaryStream(Stream stream)
	{
		return LoadFromBinaryStream(stream, null);
	}

	public static Configuration LoadFromBinaryStream(Stream stream, BinaryReader reader)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		return ConfigurationReader.ReadFromBinaryStream(stream, reader);
	}

	public void SaveToFile(string filename)
	{
		SaveToFile(filename, null);
	}

	public void SaveToFile(string filename, Encoding encoding)
	{
		if (string.IsNullOrEmpty(filename))
		{
			throw new ArgumentNullException("filename");
		}
		using FileStream stream = new FileStream(filename, FileMode.Create, FileAccess.Write);
		SaveToStream(stream, encoding);
	}

	public void SaveToStream(Stream stream)
	{
		SaveToStream(stream, null);
	}

	public void SaveToStream(Stream stream, Encoding encoding)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		ConfigurationWriter.WriteToStreamTextual(this, stream, encoding);
	}

	public void SaveToBinaryFile(string filename)
	{
		SaveToBinaryFile(filename, null);
	}

	public void SaveToBinaryFile(string filename, BinaryWriter writer)
	{
		if (string.IsNullOrEmpty(filename))
		{
			throw new ArgumentNullException("filename");
		}
		using FileStream stream = new FileStream(filename, FileMode.Create, FileAccess.Write);
		SaveToBinaryStream(stream, writer);
	}

	public void SaveToBinaryStream(Stream stream)
	{
		SaveToBinaryStream(stream, null);
	}

	public void SaveToBinaryStream(Stream stream, BinaryWriter writer)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		ConfigurationWriter.WriteToStreamBinary(this, stream, writer);
	}

	public IEnumerable<Section> GetSectionsNamed(string name)
	{
		List<Section> list = new List<Section>();
		foreach (Section mSection in mSections)
		{
			if (string.Equals(mSection.Name, name, StringComparison.OrdinalIgnoreCase))
			{
				list.Add(mSection);
			}
		}
		return list;
	}

	private Section FindSection(string name)
	{
		foreach (Section mSection in mSections)
		{
			if (string.Equals(mSection.Name, name, StringComparison.OrdinalIgnoreCase))
			{
				return mSection;
			}
		}
		return null;
	}
}
public abstract class ConfigurationElement
{
	public string Name { get; }

	public string Comment { get; set; }

	public string PreComment { get; set; }

	internal ConfigurationElement(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			throw new ArgumentNullException("name");
		}
		Name = name;
	}

	public override string ToString()
	{
		string stringExpression = GetStringExpression();
		if (Comment != null && PreComment != null && !Configuration.IgnoreInlineComments && !Configuration.IgnorePreComments)
		{
			return GetFormattedPreComment() + Environment.NewLine + stringExpression + " " + GetFormattedComment();
		}
		if (Comment != null && !Configuration.IgnoreInlineComments)
		{
			return stringExpression + " " + GetFormattedComment();
		}
		if (PreComment != null && !Configuration.IgnorePreComments)
		{
			return GetFormattedPreComment() + Environment.NewLine + stringExpression;
		}
		return stringExpression;
	}

	private string GetFormattedComment()
	{
		string text = Comment;
		int num = Comment.IndexOfAny(Environment.NewLine.ToCharArray());
		if (num >= 0)
		{
			text = text.Substring(0, num);
		}
		return Configuration.PreferredCommentChar + " " + text;
	}

	private string GetFormattedPreComment()
	{
		string[] array = PreComment.Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.None);
		return string.Join(Environment.NewLine, Array.ConvertAll(array, (string s) => Configuration.PreferredCommentChar + " " + s));
	}

	protected abstract string GetStringExpression();
}
internal static class ConfigurationReader
{
	internal static Configuration ReadFromString(string source)
	{
		Configuration configuration = new Configuration();
		using StringReader reader = new StringReader(source);
		Parse(reader, configuration);
		return configuration;
	}

	private static void Parse(StringReader reader, Configuration config)
	{
		Section section = new Section("$SharpConfigDefaultSection");
		StringBuilder stringBuilder = new StringBuilder();
		int length = Environment.NewLine.Length;
		int num = 0;
		string text;
		while ((text = reader.ReadLine()) != null)
		{
			num++;
			text = text.Trim();
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			int commentIndex;
			string text2 = ParseComment(text, out commentIndex);
			if (commentIndex == 0)
			{
				if (!Configuration.IgnorePreComments)
				{
					stringBuilder.AppendLine(text2);
				}
				continue;
			}
			string text3 = text;
			if (commentIndex > 0)
			{
				text3 = text.Remove(commentIndex).Trim();
			}
			if (text3.StartsWith("["))
			{
				if (section != null && section.Name == "$SharpConfigDefaultSection")
				{
					config.mSections.Add(section);
				}
				section = ParseSection(text3, num);
				if (!Configuration.IgnoreInlineComments)
				{
					section.Comment = text2;
				}
				if (!Configuration.IgnorePreComments && stringBuilder.Length > 0)
				{
					stringBuilder.Remove(stringBuilder.Length - length, length);
					section.PreComment = stringBuilder.ToString();
					stringBuilder.Length = 0;
				}
				config.mSections.Add(section);
			}
			else
			{
				Setting setting = ParseSetting(Configuration.IgnoreInlineComments ? text : text3, num);
				if (!Configuration.IgnoreInlineComments)
				{
					setting.Comment = text2;
				}
				if (section == null)
				{
					throw new ParserException($"The setting '{setting.Name}' has to be in a section.", num);
				}
				if (!Configuration.IgnorePreComments && stringBuilder.Length > 0)
				{
					stringBuilder.Remove(stringBuilder.Length - length, length);
					setting.PreComment = stringBuilder.ToString();
					stringBuilder.Length = 0;
				}
				section.Add(setting);
			}
		}
	}

	private static bool IsInQuoteMarks(string line, int startIndex)
	{
		int num = startIndex;
		bool flag = false;
		while (--num >= 0)
		{
			if (line[num] == '"')
			{
				flag = true;
				break;
			}
		}
		bool flag2 = line.IndexOf('"', startIndex) > 0;
		return flag && flag2;
	}

	private static string ParseComment(string line, out int commentIndex)
	{
		string result = null;
		commentIndex = -1;
		do
		{
			commentIndex = line.IndexOfAny(Configuration.ValidCommentChars, commentIndex + 1);
			if (commentIndex < 0)
			{
				break;
			}
			if (commentIndex > 0 && line[commentIndex - 1] == '\\')
			{
				commentIndex = -1;
				return null;
			}
			if (!IsInQuoteMarks(line, commentIndex))
			{
				result = line.Substring(commentIndex + 1).Trim();
				break;
			}
		}
		while (commentIndex >= 0);
		return result;
	}

	private static Section ParseSection(string line, int lineNumber)
	{
		int num = line.LastIndexOf(']');
		if (num < 0)
		{
			throw new ParserException("closing bracket missing.", lineNumber);
		}
		if (line.Length - 1 > num && line.Substring(num + 1).Trim().IndexOfAny(Configuration.ValidCommentChars) != 0)
		{
			string arg = line.Substring(num + 1);
			throw new ParserException($"unexpected token '{arg}'", lineNumber);
		}
		return new Section(line.Substring(1, line.Length - 2).Trim());
	}

	private static Setting ParseSetting(string line, int lineNumber)
	{
		string text = null;
		bool flag = line.StartsWith("\"");
		int num2;
		if (flag)
		{
			int num = 0;
			do
			{
				num = line.IndexOf('"', num + 1);
			}
			while (num > 0 && line[num - 1] == '\\');
			if (num < 0)
			{
				throw new ParserException("closing quote mark expected.", lineNumber);
			}
			text = line.Substring(1, num - 1);
			num2 = line.IndexOf('=', num + 1);
		}
		else
		{
			num2 = line.IndexOf('=');
		}
		if (num2 < 0)
		{
			throw new ParserException("setting assignment expected.", lineNumber);
		}
		if (!flag)
		{
			text = line.Substring(0, num2).Trim();
		}
		string text2 = line.Substring(num2 + 1);
		text2 = text2.Trim();
		if (string.IsNullOrEmpty(text))
		{
			throw new ParserException("setting name expected.", lineNumber);
		}
		return new Setting(text, text2);
	}

	internal static Configuration ReadFromBinaryStream(Stream stream, BinaryReader reader)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		if (reader == null)
		{
			reader = new BinaryReader(stream);
		}
		Configuration configuration = new Configuration();
		int num = reader.ReadInt32();
		for (int i = 0; i < num; i++)
		{
			string name = reader.ReadString();
			int num2 = reader.ReadInt32();
			Section section = new Section(name);
			ReadCommentsBinary(reader, section);
			for (int j = 0; j < num2; j++)
			{
				Setting setting = new Setting(reader.ReadString())
				{
					RawValue = reader.ReadString()
				};
				ReadCommentsBinary(reader, setting);
				section.Add(setting);
			}
			configuration.Add(section);
		}
		return configuration;
	}

	private static void ReadCommentsBinary(BinaryReader reader, ConfigurationElement element)
	{
		if (reader.ReadBoolean())
		{
			reader.ReadChar();
			element.Comment = reader.ReadString();
		}
		if (reader.ReadBoolean())
		{
			reader.ReadChar();
			element.PreComment = reader.ReadString();
		}
	}
}
internal static class ConfigurationWriter
{
	private class NonClosingBinaryWriter : BinaryWriter
	{
		public NonClosingBinaryWriter(Stream stream)
			: base(stream)
		{
		}

		protected override void Dispose(bool disposing)
		{
		}
	}

	internal static void WriteToStreamTextual(Configuration cfg, Stream stream, Encoding encoding)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		if (encoding == null)
		{
			encoding = Encoding.UTF8;
		}
		string stringRepresentation = cfg.StringRepresentation;
		byte[] array = new byte[encoding.GetByteCount(stringRepresentation)];
		int bytes = encoding.GetBytes(stringRepresentation, 0, stringRepresentation.Length, array, 0);
		stream.Write(array, 0, bytes);
		stream.Flush();
	}

	internal static void WriteToStreamBinary(Configuration cfg, Stream stream, BinaryWriter writer)
	{
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		if (writer == null)
		{
			writer = new NonClosingBinaryWriter(stream);
		}
		writer.Write(cfg.SectionCount);
		foreach (Section item in cfg)
		{
			writer.Write(item.Name);
			writer.Write(item.SettingCount);
			WriteCommentsBinary(writer, item);
			foreach (Setting item2 in item)
			{
				writer.Write(item2.Name);
				writer.Write(item2.RawValue);
				WriteCommentsBinary(writer, item2);
			}
		}
		writer.Close();
	}

	private static void WriteCommentsBinary(BinaryWriter writer, ConfigurationElement element)
	{
		writer.Write(element.Comment != null);
		if (element.Comment != null)
		{
			writer.Write(' ');
			writer.Write(element.Comment);
		}
		writer.Write(element.PreComment != null);
		if (element.PreComment != null)
		{
			writer.Write(' ');
			writer.Write(element.PreComment);
		}
	}
}
public sealed class IgnoreAttribute : Attribute
{
}
public interface ITypeStringConverter
{
	Type ConvertibleType { get; }

	string ConvertToString(object value);

	object TryConvertFromString(string value, Type hint);
}
public abstract class TypeStringConverter<T> : ITypeStringConverter
{
	public Type ConvertibleType => typeof(T);

	public abstract string ConvertToString(object value);

	public abstract object TryConvertFromString(string value, Type hint);
}
[Serializable]
public sealed class ParserException : Exception
{
	public int Line { get; private set; }

	internal ParserException(string message, int line)
		: base($"Line {line}: {message}")
	{
		Line = line;
	}
}
public sealed class Section : ConfigurationElement, IEnumerable<Setting>, IEnumerable
{
	public const string DefaultSectionName = "$SharpConfigDefaultSection";

	private readonly List<Setting> mSettings;

	public int SettingCount => mSettings.Count;

	public Setting this[int index]
	{
		get
		{
			if (index < 0 || index >= mSettings.Count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			return mSettings[index];
		}
	}

	public Setting this[string name]
	{
		get
		{
			Setting setting = FindSetting(name);
			if (setting == null)
			{
				setting = new Setting(name);
				mSettings.Add(setting);
			}
			return setting;
		}
	}

	public Section(string name)
		: base(name)
	{
		mSettings = new List<Setting>();
	}

	public static Section FromObject(string name, object obj)
	{
		if (string.IsNullOrEmpty(name))
		{
			throw new ArgumentException("The section name must not be null or empty.", "name");
		}
		if (obj == null)
		{
			throw new ArgumentNullException("obj");
		}
		Section section = new Section(name);
		Type type = obj.GetType();
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.CanRead && !ShouldIgnoreMappingFor(propertyInfo))
			{
				Setting item = new Setting(propertyInfo.Name, propertyInfo.GetValue(obj, null));
				section.mSettings.Add(item);
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		foreach (FieldInfo fieldInfo in fields)
		{
			if (!ShouldIgnoreMappingFor(fieldInfo))
			{
				Setting item2 = new Setting(fieldInfo.Name, fieldInfo.GetValue(obj));
				section.mSettings.Add(item2);
			}
		}
		return section;
	}

	public T ToObject<T>() where T : new()
	{
		T val = new T();
		SetValuesTo(val);
		return val;
	}

	public object ToObject(Type type)
	{
		if (type == null)
		{
			throw new ArgumentNullException(type.Name);
		}
		object obj = Activator.CreateInstance(type);
		SetValuesTo(obj);
		return obj;
	}

	public void GetValuesFrom(object obj)
	{
		if (obj == null)
		{
			throw new ArgumentNullException("obj");
		}
		Type type = obj.GetType();
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.CanRead)
			{
				SetSettingValueFromMemberInfo(propertyInfo, obj);
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		foreach (FieldInfo info in fields)
		{
			SetSettingValueFromMemberInfo(info, obj);
		}
	}

	private void SetSettingValueFromMemberInfo(MemberInfo info, object instance)
	{
		if (ShouldIgnoreMappingFor(info))
		{
			return;
		}
		Setting setting = FindSetting(info.Name);
		if (setting != null)
		{
			object value = null;
			if (info is FieldInfo)
			{
				value = ((FieldInfo)info).GetValue(instance);
			}
			else if (info is PropertyInfo)
			{
				value = ((PropertyInfo)info).GetValue(instance, null);
			}
			setting.SetValue(value);
		}
	}

	public void SetValuesTo(object obj)
	{
		if (obj == null)
		{
			throw new ArgumentNullException("obj");
		}
		Type type = obj.GetType();
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (!propertyInfo.CanWrite || ShouldIgnoreMappingFor(propertyInfo))
			{
				continue;
			}
			Setting setting = FindSetting(propertyInfo.Name);
			if (setting == null)
			{
				continue;
			}
			object obj2 = (propertyInfo.PropertyType.IsArray ? setting.GetValueArray(propertyInfo.PropertyType.GetElementType()) : setting.GetValue(propertyInfo.PropertyType));
			if (propertyInfo.PropertyType.IsArray)
			{
				Array array = obj2 as Array;
				Array array2 = propertyInfo.GetValue(obj, null) as Array;
				if (array != null && (array2 == null || array2.Length != array.Length))
				{
					array2 = Array.CreateInstance(propertyInfo.PropertyType.GetElementType(), array.Length);
				}
				for (int j = 0; j < array.Length; j++)
				{
					array2?.SetValue(array.GetValue(j), j);
				}
				propertyInfo.SetValue(obj, array2, null);
			}
			else
			{
				propertyInfo.SetValue(obj, obj2, null);
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		foreach (FieldInfo fieldInfo in fields)
		{
			if (fieldInfo.IsInitOnly || ShouldIgnoreMappingFor(fieldInfo))
			{
				continue;
			}
			Setting setting2 = FindSetting(fieldInfo.Name);
			if (setting2 == null)
			{
				continue;
			}
			object obj3 = (fieldInfo.FieldType.IsArray ? setting2.GetValueArray(fieldInfo.FieldType.GetElementType()) : setting2.GetValue(fieldInfo.FieldType));
			if (fieldInfo.FieldType.IsArray)
			{
				Array array3 = obj3 as Array;
				Array array4 = fieldInfo.GetValue(obj) as Array;
				if (array3 != null && (array4 == null || array4.Length != array3.Length))
				{
					array4 = Array.CreateInstance(fieldInfo.FieldType.GetElementType(), array3.Length);
				}
				for (int k = 0; k < array3.Length; k++)
				{
					array4.SetValue(array3.GetValue(k), k);
				}
				fieldInfo.SetValue(obj, array4);
			}
			else
			{
				fieldInfo.SetValue(obj, obj3);
			}
		}
	}

	private static bool ShouldIgnoreMappingFor(MemberInfo member)
	{
		if (member.GetCustomAttributes(typeof(IgnoreAttribute), inherit: false).Length != 0)
		{
			return true;
		}
		if (member as PropertyInfo != null)
		{
			return (member as PropertyInfo).PropertyType.GetCustomAttributes(typeof(IgnoreAttribute), inherit: false).Length != 0;
		}
		if (member as FieldInfo != null)
		{
			return (member as FieldInfo).FieldType.GetCustomAttributes(typeof(IgnoreAttribute), inherit: false).Length != 0;
		}
		return false;
	}

	public IEnumerator<Setting> GetEnumerator()
	{
		return mSettings.GetEnumerator();
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return GetEnumerator();
	}

	public void Add(Setting setting)
	{
		if (setting == null)
		{
			throw new ArgumentNullException("setting");
		}
		if (Contains(setting))
		{
			throw new ArgumentException("The specified setting already exists in the section.");
		}
		mSettings.Add(setting);
	}

	public Setting Add(string settingName)
	{
		return Add(settingName, string.Empty);
	}

	public Setting Add(string settingName, object settingValue)
	{
		Setting setting = new Setting(settingName, settingValue);
		Add(setting);
		return setting;
	}

	public bool Remove(string settingName)
	{
		if (string.IsNullOrEmpty(settingName))
		{
			throw new ArgumentNullException("settingName");
		}
		return Remove(FindSetting(settingName));
	}

	public bool Remove(Setting setting)
	{
		return mSettings.Remove(setting);
	}

	public void RemoveAllNamed(string settingName)
	{
		if (string.IsNullOrEmpty(settingName))
		{
			throw new ArgumentNullException("settingName");
		}
		while (Remove(settingName))
		{
		}
	}

	public void Clear()
	{
		mSettings.Clear();
	}

	public bool Contains(Setting setting)
	{
		return mSettings.Contains(setting);
	}

	public bool Contains(string settingName)
	{
		if (string.IsNullOrEmpty(settingName))
		{
			throw new ArgumentNullException("settingName");
		}
		return FindSetting(settingName) != null;
	}

	public IEnumerable<Setting> GetSettingsNamed(string name)
	{
		List<Setting> list = new List<Setting>();
		foreach (Setting mSetting in mSettings)
		{
			if (string.Equals(mSetting.Name, name, StringComparison.OrdinalIgnoreCase))
			{
				list.Add(mSetting);
			}
		}
		return list;
	}

	private Setting FindSetting(string name)
	{
		foreach (Setting mSetting in mSettings)
		{
			if (string.Equals(mSetting.Name, name, StringComparison.OrdinalIgnoreCase))
			{
				return mSetting;
			}
		}
		return null;
	}

	protected override string GetStringExpression()
	{
		return "[" + base.Name + "]";
	}
}
public sealed class Setting : ConfigurationElement
{
	private int mCachedArraySize;

	private bool mShouldCalculateArraySize;

	private char mCachedArrayElementSeparator;

	public bool IsEmpty => string.IsNullOrEmpty(RawValue);

	[Obsolete("Use StringValue instead")]
	public string StringValueTrimmed
	{
		get
		{
			string text = StringValue;
			if (text[0] == '"')
			{
				text = text.Trim(new char[1] { '"' });
			}
			return text;
		}
	}

	public string RawValue { get; set; } = string.Empty;


	public string StringValue
	{
		get
		{
			return GetValue<string>().Trim(new char[1] { '"' });
		}
		set
		{
			SetValue(value.Trim(new char[1] { '"' }));
		}
	}

	public string[] StringValueArray
	{
		get
		{
			return GetValueArray<string>();
		}
		set
		{
			SetValue(value);
		}
	}

	public int IntValue
	{
		get
		{
			return GetValue<int>();
		}
		set
		{
			SetValue(value);
		}
	}

	public int[] IntValueArray
	{
		get
		{
			return GetValueArray<int>();
		}
		set
		{
			SetValue(value);
		}
	}

	public float FloatValue
	{
		get
		{
			return GetValue<float>();
		}
		set
		{
			SetValue(value);
		}
	}

	public float[] FloatValueArray
	{
		get
		{
			return GetValueArray<float>();
		}
		set
		{
			SetValue(value);
		}
	}

	public double DoubleValue
	{
		get
		{
			return GetValue<double>();
		}
		set
		{
			SetValue(value);
		}
	}

	public double[] DoubleValueArray
	{
		get
		{
			return GetValueArray<double>();
		}
		set
		{
			SetValue(value);
		}
	}

	public decimal DecimalValue
	{
		get
		{
			return GetValue<decimal>();
		}
		set
		{
			SetValue(value);
		}
	}

	public decimal[] DecimalValueArray
	{
		get
		{
			return GetValueArray<decimal>();
		}
		set
		{
			SetValue(value);
		}
	}

	public bool BoolValue
	{
		get
		{
			return GetValue<bool>();
		}
		set
		{
			SetValue(value);
		}
	}

	public bool[] BoolValueArray
	{
		get
		{
			return GetValueArray<bool>();
		}
		set
		{
			SetValue(value);
		}
	}

	public DateTime DateTimeValue
	{
		get
		{
			return GetValue<DateTime>();
		}
		set
		{
			SetValue(value);
		}
	}

	public DateTime[] DateTimeValueArray
	{
		get
		{
			return GetValueArray<DateTime>();
		}
		set
		{
			SetValue(value);
		}
	}

	public byte ByteValue
	{
		get
		{
			return GetValue<byte>();
		}
		set
		{
			SetValue(value);
		}
	}

	public byte[] ByteValueArray
	{
		get
		{
			return GetValueArray<byte>();
		}
		set
		{
			SetValue(value);
		}
	}

	public sbyte SByteValue
	{
		get
		{
			return GetValue<sbyte>();
		}
		set
		{
			SetValue(value);
		}
	}

	public sbyte[] SByteValueArray
	{
		get
		{
			return GetValueArray<sbyte>();
		}
		set
		{
			SetValue(value);
		}
	}

	public char CharValue
	{
		get
		{
			return GetValue<char>();
		}
		set
		{
			SetValue(value);
		}
	}

	public char[] CharValueArray
	{
		get
		{
			if (ByteValueArray != null)
			{
				return Encoding.UTF8.GetChars(ByteValueArray);
			}
			return null;
		}
		set
		{
			if (value != null)
			{
				ByteValueArray = Encoding.UTF8.GetBytes(value);
			}
			else
			{
				SetEmptyValue();
			}
		}
	}

	public bool IsArray => ArraySize >= 0;

	public int ArraySize
	{
		get
		{
			if (mCachedArrayElementSeparator != Configuration.ArrayElementSeparator)
			{
				mCachedArrayElementSeparator = Configuration.ArrayElementSeparator;
				mShouldCalculateArraySize = true;
			}
			if (mShouldCalculateArraySize)
			{
				mCachedArraySize = CalculateArraySize();
				mShouldCalculateArraySize = false;
			}
			return mCachedArraySize;
		}
	}

	public Setting(string name)
		: this(name, string.Empty)
	{
	}

	public Setting(string name, object value)
		: base(name)
	{
		SetValue(value);
		mCachedArrayElementSeparator = Configuration.ArrayElementSeparator;
	}

	private int CalculateArraySize()
	{
		int num = 0;
		SettingArrayEnumerator settingArrayEnumerator = new SettingArrayEnumerator(RawValue, shouldCalcElemString: false);
		while (settingArrayEnumerator.Next())
		{
			num++;
		}
		if (!settingArrayEnumerator.IsValid)
		{
			return -1;
		}
		return num;
	}

	public object GetValue(Type type)
	{
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		if (type.IsArray)
		{
			throw new InvalidOperationException("To obtain an array value, use GetValueArray() instead of GetValue().");
		}
		if (IsArray)
		{
			throw new InvalidOperationException("The setting represents an array. Use GetValueArray() to obtain its value.");
		}
		return CreateObjectFromString(RawValue, type);
	}

	public object[] GetValueArray(Type elementType)
	{
		if (elementType.IsArray)
		{
			throw CreateJaggedArraysNotSupportedEx(elementType);
		}
		int arraySize = ArraySize;
		if (ArraySize < 0)
		{
			return null;
		}
		object[] array = new object[arraySize];
		if (arraySize > 0)
		{
			SettingArrayEnumerator settingArrayEnumerator = new SettingArrayEnumerator(RawValue, shouldCalcElemString: true);
			int num = 0;
			while (settingArrayEnumerator.Next())
			{
				array[num] = CreateObjectFromString(settingArrayEnumerator.Current, elementType);
				num++;
			}
		}
		return array;
	}

	public T GetValue<T>()
	{
		Type typeFromHandle = typeof(T);
		if (typeFromHandle.IsArray)
		{
			throw new InvalidOperationException("To obtain an array value, use GetValueArray() instead of GetValue().");
		}
		if (IsArray)
		{
			throw new InvalidOperationException("The setting represents an array. Use GetValueArray() to obtain its value.");
		}
		return (T)CreateObjectFromString(RawValue, typeFromHandle);
	}

	public T[] GetValueArray<T>()
	{
		Type typeFromHandle = typeof(T);
		if (typeFromHandle.IsArray)
		{
			throw CreateJaggedArraysNotSupportedEx(typeFromHandle);
		}
		int arraySize = ArraySize;
		if (arraySize < 0)
		{
			return null;
		}
		T[] array = new T[arraySize];
		if (arraySize > 0)
		{
			SettingArrayEnumerator settingArrayEnumerator = new SettingArrayEnumerator(RawValue, shouldCalcElemString: true);
			int num = 0;
			while (settingArrayEnumerator.Next())
			{
				array[num] = (T)CreateObjectFromString(settingArrayEnumerator.Current, typeFromHandle);
				num++;
			}
		}
		return array;
	}

	public T GetValueOrDefault<T>(T defaultValue, bool setDefault = false)
	{
		Type typeFromHandle = typeof(T);
		if (typeFromHandle.IsArray)
		{
			throw new InvalidOperationException("GetValueOrDefault<T> cannot be used with arrays.");
		}
		if (IsArray)
		{
			throw new InvalidOperationException("The setting represents an array. Use GetValueArray() to obtain its value.");
		}
		object obj = CreateObjectFromString(RawValue, typeFromHandle, tryConvert: true);
		if (obj != null)
		{
			return (T)obj;
		}
		if (setDefault)
		{
			SetValue(defaultValue);
		}
		return defaultValue;
	}

	private static object CreateObjectFromString(string value, Type dstType, bool tryConvert = false)
	{
		Type underlyingType = Nullable.GetUnderlyingType(dstType);
		if (underlyingType != null)
		{
			if (string.IsNullOrEmpty(value))
			{
				return null;
			}
			dstType = underlyingType;
		}
		object obj = Configuration.FindTypeStringConverter(dstType).TryConvertFromString(value, dstType);
		if (obj == null && !tryConvert)
		{
			throw SettingValueCastException.Create(value, dstType, null);
		}
		return obj;
	}

	public void SetValue(object value)
	{
		if (value == null)
		{
			SetEmptyValue();
			return;
		}
		Type type = value.GetType();
		if (type.IsArray)
		{
			Type elementType = type.GetElementType();
			if (elementType != null && elementType.IsArray)
			{
				throw CreateJaggedArraysNotSupportedEx(type.GetElementType());
			}
			Array array = value as Array;
			if (array != null)
			{
				string[] array2 = new string[array.Length];
				for (int i = 0; i < array.Length; i++)
				{
					object value2 = array.GetValue(i);
					ITypeStringConverter typeStringConverter = Configuration.FindTypeStringConverter(value2.GetType());
					array2[i] = GetValueForOutput(typeStringConverter.ConvertToString(value2));
				}
				RawValue = "{" + string.Join(Configuration.ArrayElementSeparator.ToString(), array2) + "}";
			}
			if (array != null)
			{
				mCachedArraySize = array.Length;
			}
			mShouldCalculateArraySize = false;
		}
		else
		{
			ITypeStringConverter typeStringConverter2 = Configuration.FindTypeStringConverter(type);
			RawValue = typeStringConverter2.ConvertToString(value);
			mShouldCalculateArraySize = true;
		}
	}

	private void SetEmptyValue()
	{
		RawValue = string.Empty;
		mCachedArraySize = -1;
		mShouldCalculateArraySize = false;
	}

	private static string GetValueForOutput(string rawValue)
	{
		if (Configuration.OutputRawStringValues)
		{
			return rawValue;
		}
		if (rawValue.StartsWith("{") && rawValue.EndsWith("}"))
		{
			return rawValue;
		}
		if (rawValue.StartsWith("\"") && rawValue.EndsWith("\""))
		{
			return rawValue;
		}
		if (rawValue.IndexOf(" ", StringComparison.Ordinal) >= 0 || (rawValue.IndexOfAny(Configuration.ValidCommentChars) >= 0 && !Configuration.IgnoreInlineComments))
		{
			rawValue = "\"" + rawValue + "\"";
		}
		return rawValue;
	}

	protected override string GetStringExpression()
	{
		if (Configuration.SpaceBetweenEquals)
		{
			return base.Name + " = " + GetValueForOutput(RawValue);
		}
		return base.Name + "=" + GetValueForOutput(RawValue);
	}

	private static ArgumentException CreateJaggedArraysNotSupportedEx(Type type)
	{
		Type elementType = type.GetElementType();
		while (elementType != null && elementType.IsArray)
		{
			elementType = elementType.GetElementType();
		}
		throw new ArgumentException("Jagged arrays are not supported. The type you have specified is '" + type.Name + "', but '" + elementType?.Name + "' was expected.");
	}
}
internal sealed class SettingArrayEnumerator
{
	private readonly string mStringValue;

	private readonly bool mShouldCalcElemString;

	private int mIdxInString;

	private readonly int mLastRBraceIdx;

	private int mPrevElemIdxInString;

	private int mBraceBalance;

	private bool mIsInQuotes;

	private bool mIsDone;

	public string Current { get; private set; }

	public bool IsValid { get; private set; }

	public SettingArrayEnumerator(string value, bool shouldCalcElemString)
	{
		mStringValue = value;
		mIdxInString = -1;
		mLastRBraceIdx = -1;
		mShouldCalcElemString = shouldCalcElemString;
		IsValid = true;
		mIsDone = false;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (c != ' ' && c != '{')
			{
				break;
			}
			if (c == '{')
			{
				mIdxInString = i + 1;
				mBraceBalance = 1;
				mPrevElemIdxInString = i + 1;
				break;
			}
		}
		if (mIdxInString < 0)
		{
			IsValid = false;
			mIsDone = true;
			return;
		}
		for (int num = value.Length - 1; num >= 0; num--)
		{
			char c2 = value[num];
			if (c2 != ' ' && c2 != '}')
			{
				break;
			}
			if (c2 == '}')
			{
				mLastRBraceIdx = num;
				break;
			}
		}
		if (mLastRBraceIdx < 0)
		{
			IsValid = false;
			mIsDone = true;
		}
		else if (mIdxInString == mLastRBraceIdx || !IsNonEmptyValue(mStringValue, mIdxInString, mLastRBraceIdx))
		{
			IsValid = true;
			mIsDone = true;
		}
	}

	private void UpdateElementString(int idx)
	{
		Current = mStringValue.Substring(mPrevElemIdxInString, idx - mPrevElemIdxInString);
		Current = Current.Trim(new char[1] { ' ' });
		if (Current[Current.Length - 1] == '"')
		{
			Current = Current.Remove(Current.Length - 1, 1);
		}
		if (Current[0] == '"')
		{
			Current = Current.Remove(0, 1);
		}
	}

	public bool Next()
	{
		if (mIsDone)
		{
			return false;
		}
		int i;
		for (i = mIdxInString; i <= mLastRBraceIdx; i++)
		{
			char c = mStringValue[i];
			if (c == '{' && !mIsInQuotes)
			{
				mBraceBalance++;
			}
			else if (c == '}' && !mIsInQuotes)
			{
				mBraceBalance--;
				if (i == mLastRBraceIdx)
				{
					if (!IsNonEmptyValue(mStringValue, mPrevElemIdxInString, i))
					{
						IsValid = false;
					}
					else if (mShouldCalcElemString)
					{
						UpdateElementString(i);
					}
					mIsDone = true;
					break;
				}
			}
			else if (c == '"')
			{
				int num = mStringValue.IndexOf('"', i + 1);
				if (num > 0 && mStringValue[num - 1] != '\\')
				{
					i = num;
					mIsInQuotes = false;
				}
				else
				{
					mIsInQuotes = true;
				}
			}
			else if (c == Configuration.ArrayElementSeparator && mBraceBalance == 1 && !mIsInQuotes)
			{
				if (!IsNonEmptyValue(mStringValue, mPrevElemIdxInString, i))
				{
					IsValid = false;
				}
				else if (mShouldCalcElemString)
				{
					UpdateElementString(i);
				}
				mPrevElemIdxInString = i + 1;
				i++;
				break;
			}
		}
		mIdxInString = i;
		if (mIsInQuotes)
		{
			IsValid = false;
		}
		return IsValid;
	}

	private static bool IsNonEmptyValue(string s, int begin, int end)
	{
		while (begin < end)
		{
			if (s[begin] != ' ')
			{
				return true;
			}
			begin++;
		}
		return false;
	}
}
[Serializable]
public sealed class SettingValueCastException : Exception
{
	private SettingValueCastException(string message, Exception innerException)
		: base(message, innerException)
	{
	}

	internal static SettingValueCastException Create(string stringValue, Type dstType, Exception innerException)
	{
		return new SettingValueCastException("Failed to convert value '" + stringValue + "' to type " + dstType.FullName + ".", innerException);
	}
}
internal sealed class FallbackStringConverter : ITypeStringConverter
{
	public Type ConvertibleType => null;

	public string ConvertToString(object value)
	{
		try
		{
			return TypeDescriptor.GetConverter(value).ConvertToString(null, Configuration.CultureInfo, value);
		}
		catch (Exception innerException)
		{
			throw SettingValueCastException.Create(value.ToString(), value.GetType(), innerException);
		}
	}

	public object ConvertFromString(string value, Type hint)
	{
		try
		{
			return TypeDescriptor.GetConverter(hint).ConvertFrom(null, Configuration.CultureInfo, value);
		}
		catch (Exception innerException)
		{
			throw SettingValueCastException.Create(value, hint, innerException);
		}
	}

	public object TryConvertFromString(string value, Type hint)
	{
		return ConvertFromString(value, hint);
	}
}
internal sealed class BoolStringConverter : TypeStringConverter<bool>
{
	public override string ConvertToString(object value)
	{
		return value.ToString();
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		switch (value.ToLowerInvariant())
		{
		case "":
		case "false":
		case "off":
		case "no":
		case "n":
		case "0":
			return false;
		case "true":
		case "on":
		case "yes":
		case "y":
		case "1":
			return true;
		default:
			return null;
		}
	}
}
internal sealed class ByteStringConverter : TypeStringConverter<byte>
{
	public override string ConvertToString(object value)
	{
		return value.ToString();
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return (byte)0;
		}
		if (!byte.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class CharStringConverter : TypeStringConverter<char>
{
	public override string ConvertToString(object value)
	{
		return value.ToString();
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return '\0';
		}
		if (!char.TryParse(value, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class DateTimeStringConverter : TypeStringConverter<DateTime>
{
	public override string ConvertToString(object value)
	{
		return ((DateTime)value).ToString(Configuration.CultureInfo.DateTimeFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return default(DateTime);
		}
		if (!DateTime.TryParse(value, Configuration.CultureInfo.DateTimeFormat, DateTimeStyles.None, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class DecimalStringConverter : TypeStringConverter<decimal>
{
	public override string ConvertToString(object value)
	{
		return ((decimal)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0m;
		}
		if (!decimal.TryParse(value, NumberStyles.Number, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class DoubleStringConverter : TypeStringConverter<double>
{
	public override string ConvertToString(object value)
	{
		return ((double)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0.0;
		}
		if (!double.TryParse(value, NumberStyles.Float | NumberStyles.AllowThousands, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class EnumStringConverter : TypeStringConverter<Enum>
{
	public override string ConvertToString(object value)
	{
		return value.ToString();
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0.0;
		}
		value = RemoveTypeNames(value);
		if (!Enum.IsDefined(hint, value))
		{
			return null;
		}
		return Enum.Parse(hint, value);
	}

	private static string RemoveTypeNames(string value)
	{
		int num = value.LastIndexOf('.');
		if (num >= 0)
		{
			value = value.Substring(num + 1, value.Length - num - 1).Trim();
		}
		return value;
	}
}
internal sealed class Int16StringConverter : TypeStringConverter<short>
{
	public override string ConvertToString(object value)
	{
		return ((short)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return (short)0;
		}
		if (!short.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class Int32StringConverter : TypeStringConverter<int>
{
	public override string ConvertToString(object value)
	{
		return ((int)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0;
		}
		if (!int.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class Int64StringConverter : TypeStringConverter<long>
{
	public override string ConvertToString(object value)
	{
		return ((long)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0L;
		}
		if (!long.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class SByteStringConverter : TypeStringConverter<sbyte>
{
	public override string ConvertToString(object value)
	{
		return ((sbyte)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return (sbyte)0;
		}
		if (!sbyte.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class SingleStringConverter : TypeStringConverter<float>
{
	public override string ConvertToString(object value)
	{
		return ((float)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0f;
		}
		if (!float.TryParse(value, NumberStyles.Float | NumberStyles.AllowThousands, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class StringStringConverter : TypeStringConverter<string>
{
	public override string ConvertToString(object value)
	{
		return value.ToString().Trim(new char[1] { '"' });
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		return value.Trim(new char[1] { '"' });
	}
}
internal sealed class UInt16StringConverter : TypeStringConverter<ushort>
{
	public override string ConvertToString(object value)
	{
		return ((ushort)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return (ushort)0;
		}
		if (!ushort.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class UInt32StringConverter : TypeStringConverter<uint>
{
	public override string ConvertToString(object value)
	{
		return ((uint)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0u;
		}
		if (!uint.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}
internal sealed class UInt64StringConverter : TypeStringConverter<ulong>
{
	public override string ConvertToString(object value)
	{
		return ((ulong)value).ToString(Configuration.CultureInfo.NumberFormat);
	}

	public override object TryConvertFromString(string value, Type hint)
	{
		if (value == string.Empty)
		{
			return 0uL;
		}
		if (!ulong.TryParse(value, NumberStyles.Integer, Configuration.CultureInfo.NumberFormat, out var result))
		{
			return null;
		}
		return result;
	}
}