BepInEx/BepInEx.Core/Configuration/ConfigDefinition.cs

using System;
using System.Linq;

namespace BepInEx.Configuration;

/// <summary>
///     Section and key of a setting. Used as a unique key for identification within a
///     <see cref="T:BepInEx.Configuration.ConfigFile" />.
///     The same definition can be used in multiple config files, it will point to different settings then.
/// </summary>
/// <inheritdoc />
public class ConfigDefinition : IEquatable<ConfigDefinition>
{
    private static readonly char[] _invalidConfigChars = { '=', '\n', '\t', '\\', '"', '\'', '[', ']' };

    /// <summary>
    ///     Create a new definition. Definitions with same section and key are equal.
    /// </summary>
    /// <param name="section">Group of the setting, case sensitive.</param>
    /// <param name="key">Name of the setting, case sensitive.</param>
    public ConfigDefinition(string section, string key)
    {
        CheckInvalidConfigChars(section, nameof(section));
        CheckInvalidConfigChars(key, nameof(key));
        Key = key;
        Section = section;
    }

    /// <inheritdoc />
    [Obsolete("description argument is no longer used, put it in a ConfigDescription instead")]
    public ConfigDefinition(string section, string key, string description)
    {
        Key = key ?? "";
        Section = section ?? "";
    }

    /// <summary>
    ///     Group of the setting. All settings within a config file are grouped by this.
    /// </summary>
    public string Section { get; }

    /// <summary>
    ///     Name of the setting.
    /// </summary>
    public string Key { get; }

    /// <summary>
    ///     Check if the definitions are the same.
    /// </summary>
    /// <inheritdoc />
    public bool Equals(ConfigDefinition other)
    {
        if (other == null) return false;
        return string.Equals(Key, other.Key)
            && string.Equals(Section, other.Section);
    }

    private static void CheckInvalidConfigChars(string val, string name)
    {
        if (val == null) throw new ArgumentNullException(name);
        if (val != val.Trim())
            throw new ArgumentException("Cannot use whitespace characters at start or end of section and key names",
                                        name);
        if (val.Any(c => _invalidConfigChars.Contains(c)))
            throw new
                ArgumentException(@"Cannot use any of the following characters in section and key names: = \n \t \ "" ' [ ]",
                                  name);
    }

    /// <summary>
    ///     Check if the definitions are the same.
    /// </summary>
    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj))
            return false;
        if (ReferenceEquals(this, obj))
            return true;

        return Equals(obj as ConfigDefinition);
    }

    /// <inheritdoc />
    public override int GetHashCode()
    {
        unchecked
        {
            var hashCode = Key != null ? Key.GetHashCode() : 0;
            hashCode = (hashCode * 397) ^ (Section != null ? Section.GetHashCode() : 0);
            return hashCode;
        }
    }

    /// <summary>
    ///     Check if the definitions are the same.
    /// </summary>
    public static bool operator ==(ConfigDefinition left, ConfigDefinition right) => Equals(left, right);

    /// <summary>
    ///     Check if the definitions are the same.
    /// </summary>
    public static bool operator !=(ConfigDefinition left, ConfigDefinition right) => !Equals(left, right);

    /// <inheritdoc />
    public override string ToString() => Section + "." + Key;
}