using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Fournit des méthodes pour faciliter la création de collections génériques avec des types anonymes,
    /// grâce à l'inférence de type générique.
    /// </summary>
    public static class CollectionFactory
    {
        /// <summary>
        /// Crée une pile (<see cref="Stack{T}"/>) en utilisant le paramètre pour déterminer le type des éléments
        /// </summary>
        /// <typeparam name="T">Type des éléments (déterminé implicitement par inférence)</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des éléments</param>
        /// <returns>Une pile (<see cref="Stack{T}"/>) vide</returns>
        public static Stack<T> Stack<T>(T dummy)
        {
            return new Stack<T>();
        }

        /// <summary>
        /// Crée une file (<see cref="Queue{T}"/>) en utilisant le paramètre pour déterminer le type des éléments
        /// </summary>
        /// <typeparam name="T">Type des éléments (déterminé implicitement par inférence)</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des éléments</param>
        /// <returns>Une file (<see cref="Queue{T}"/>) vide</returns>
        public static Queue<T> Queue<T>(T dummy)
        {
            return new Queue<T>();
        }

        /// <summary>
        /// Crée une liste (<see cref="List{T}"/>) en utilisant le paramètre pour déterminer le type des éléments
        /// </summary>
        /// <typeparam name="T">Type des éléments (déterminé implicitement par inférence)</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des éléments</param>
        /// <returns>Une liste (<see cref="List{T}"/>) vide</returns>
        public static List<T> List<T>(T dummy)
        {
            return new List<T>();
        }

        /// <summary>
        /// Crée un ensemble (<see cref="HashSet{T}"/>) en utilisant le paramètre pour déterminer le type des éléments
        /// </summary>
        /// <typeparam name="T">Type des éléments (déterminé implicitement par inférence)</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des éléments</param>
        /// <returns>Un ensemble (<see cref="HashSet{T}"/>) vide</returns>
        public static HashSet<T> HashSet<T>(T dummy)
        {
            return new HashSet<T>();
        }

        /// <summary>
        /// Crée un dictionnaire (<see cref="Dictionary{TKey,TValue}"/>) en utilisant les paramètres pour déterminer le type de clé et le type de valeur
        /// </summary>
        /// <typeparam name="TKey">Type de clé (déterminé implicitement par inférence)</typeparam>
        /// <typeparam name="TValue">Type de valeur (déterminé implicitement par inférence)</typeparam>
        /// <param name="dummyKey">Objet modèle pour déterminer le type de clé</param>
        /// <param name="dummyValue">Objet modèle pour déterminer le type de valeur</param>
        /// <returns>Un dictionnaire (<see cref="Dictionary{TKey,TValue}"/>) vide</returns>
        public static Dictionary<TKey, TValue> Dictionary<TKey, TValue>(TKey dummyKey, TValue dummyValue)
        {
            return new Dictionary<TKey, TValue>();
        }
    }
}