garden_client/Assets/Script/Extension/ExtList.cs

using UnityEngine;
using UnityEngine.Events;

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public static class ExtList
{
    public static T Roll<T>(this List<T> list)
    {
        T t = list[0];
        list.RemoveAt(0);
        list.Add(t);
        return list[0];
    }

    public static void Switch<T>(this List<T> list, int index0, int index1)
    {
        T t0 = list[index0];
        list[index0] = list[index1];
        list[index1] = t0;
    }


    public static T Prev<T>(this List<T> list, int index)
    {
        return list[(index + list.Count - 1) % list.Count];
    }

    public static T Next<T>(this List<T> list, int index)
    {
        return list[(index + 1) % list.Count];
    }


    public static T Back<T>(this List<T> list, int index, bool remove = false)
    {
        T t = list[list.Count - 1 - index];

        if (remove)
        {
            list.RemoveAt(list.Count - 1 - index);
        }

        return t;
    }

    public static T Forward<T>(this List<T> list, int index, bool remove = false)
    {
        T t = list[index];

        if (remove)
        {
            list.RemoveAt(index);
        }

        return t;
    }

    public static List<T> Random<T>(this List<T> list, int amt = 1, bool allDifferent = true, bool remove = false, Func<T,bool> func = null)
    {
        if (amt > list.Count && allDifferent)
        {
            throw new Exception();
        }


        int antiCrush = 0;

        List<T> resultList = new List<T>();

        while (resultList.Count < amt)
        {
            if (antiCrush++ > 10000)
            {
                throw new Exception();
            }

            int index = UnityEngine.Random.Range(0, list.Count);
            
            T result = list[index];

            if (func != null)
            {
                if (!func(result))
                {
                    continue;
                }
            }

            if (allDifferent)
            {
                if (resultList.Contains(result))
                {
                    continue;
                }
            }

            if (remove)
            {
                list.RemoveAt(index);

                resultList.Add(result);
            }
            else
            {
                resultList.Add(result);
            }
        }

        return resultList;
    }

    public static List<T> Disturb<T>(this List<T> list)
    {
        List<T> resultList = new List<T>();

        resultList.AddRange(list.Random(list.Count));

        return resultList;
    }

    public static List<T2> ToSingleList<T1,T2>(this List<T1> twoLevelList) where T1 : List<T2>
    {
        //for (int i = 0; i < highLevelList.Count; i++)
        //{
        //    highLevelList[i][i].GetType()
        //}

        return null;
    }


    public static bool Valid<T>(this List<T> list)
    {
        if (list == null || list.Count == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    public static bool UniqueAdd<T>(this List<T> list, T obj)
    {
        if (list.Contains(obj) == false)
        {
            list.Add(obj);

            return true;
        }
        else
        {
            return false;
        }
    }


    public static bool AddUnique<T>(this List<T> list, T t, Func<T, T, bool> comparer)
    {
        if (!list.HasIdentical(t, comparer))
        {
            list.Add(t);
            return true;
        }
        else
        {
            return false;
        }
    }

    public static bool HasIdentical<T>(this List<T> list, T t, Func<T, T, bool> comparer)
    {
        for (int i = 0; i < list.Count; i++)
        {
            if (comparer.Invoke(list[i], t))
            {
                return true;
            }
        }
        return false;
    }



    public static void ForEach<T>(this List<T> list, Action<T> action, bool remove = false)
    {
        for (int i = 0; i < list.Count; i++)
        {
            action(list[i]);

            if (remove)
            {
                list.RemoveAt(i--);
            }
        }
    }

    public static void BackRemoveAt<T>(this List<T> list, int index)
    {
        list.RemoveAt(list.Count - 1 - index);
    }


    public static void MySort<T>(this List<T> list, Func<T, T, bool> func)
    {
        bool finish = false;

        for (int i = 0; i < list.Count; i++)
        {
            finish = true;

            for (int j = 0; j < list.Count - i - 1; j++)
            {
                if (func(list[j], list[j + 1]))
                {
                    finish = false;

                    T t = list[j];

                    list[j] = list[j + 1];
                    list[j + 1] = t;
                }
            }

            if (finish)
            {
                break;
            }
        }
    }

    public static float MyMin<T>(this List<T> list, Func<T, float> func)
    {
        float result = func(list[0]);

        for (int i = 1; i < list.Count; i++)
        {
            if (result > func(list[i]))
            {
                result = func(list[i]);
            }
        }

        return result;
    }

    public static float MyMax<T>(this List<T> list, Func<T, float> func)
    {
        float result = func(list[0]);

        for (int i = 1; i < list.Count; i++)
        {
            if (result < func(list[i]))
            {
                result = func(list[i]);
            }
        }

        return result;
    }

    public static float MySum<T>(this List<T> list, Func<T,float> func, int count = -1)
    {
        if (count == -1)
        {
            count = list.Count;
        }

        float result = 0;
        
        for (int i = 0; i < count; i++)
        {
            result += func(list[i]);
        }

        return result;
    }

    public static bool MyContains<T>(this List<T> list, Func<T, bool> func)
    {
        for (int i = 0; i < list.Count; i++)
        {
            if (func.Invoke(list[i]))
            {
                return true;
            }
        }
        return false;
    }

    public static int MyMinIndex<T>(this List<T> list, Func<T, float> func)
    {
        int index = 0;
        float result = func(list[index]);
        for (int i = 1; i < list.Count; i++)
        {
            if (result > func(list[i]))
            {
                result = func(list[i]);
                index = i;
            }
        }
        return index;
    }

    public static int MyMaxIndex<T>(this List<T> list, Func<T, float> func)
    {
        int index = 0;
        float result = func(list[index]);
        for (int i = 1; i < list.Count; i++)
        {
            if (result < func(list[i]))
            {
                result = func(list[i]);
                index = i;
            }
        }
        return index;
    }


    public static int GetMatchAmount<T>(this List<T> list, Func<T, bool> func)
    {
        int matchAmount = 0;
        for (int i = 0; i < list.Count; i++)
        {
            if (func.Invoke(list[i])) matchAmount++;
        }
        return matchAmount;
    }
}