public static bool ShouldDefine(this ISingleApi api, string[] array)
 {
     foreach (var name in array)
     {
         if (api.TryGetEnabled(name, out var apiEnabled) && apiEnabled)
         {
             return(true);
         }
     }
     return(false);
 }
示例#2
0
 public AnyRefFunc(ISingleApi api)
 {
     Api = api;
 }
 public DistinctFunc(ISingleApi api)
 {
     Api = api;
 }
 public SelectFunc(ISingleApi api)
 {
     Api = api;
 }
示例#5
0
 public OrderByNoneNumber(ISingleApi api)
 {
     Api             = api;
     elementTypeName = api.Description.Substring(4);
 }
 public TryGetFirstNone(ISingleApi api)
 {
     Api = api;
 }
 public TryGetMinMaxFunc(ISingleApi api)
 {
     Api         = api;
     isMax       = Api.Name == "TryGetMax";
     processType = Api.Description.Split(new[] { " --- " }, StringSplitOptions.RemoveEmptyEntries)[1];
 }
 public AllFunc(ISingleApi api)
 {
     Api = api;
 }
示例#9
0
 public Repeat(ISingleApi api)
 {
     Api = api;
 }
 public MinMaxByRefFunc(ISingleApi api)
 {
     Api = api;
     isMax = api.Name[1] == 'a';
     keyName = api.Name.Substring(5);
 }
示例#11
0
 public ForEachAction(ISingleApi api)
 {
     Api = api;
 }
 public TryGetFirstIndexOfRefFunc(ISingleApi api)
 {
     Api = api;
 }
 public ForEachOperator(ISingleApi api)
 {
     Api = api;
 }
示例#14
0
 public WhereSkipWhileTakeWhileFunc(ISingleApi api)
 {
     Api = api;
 }
 public OrderByOperator(ISingleApi api)
 {
     Api = api;
 }
 public OrderByNone(ISingleApi api)
 {
     Api = api;
 }
 public ContainsOperator(ISingleApi api)
 {
     Api = api;
 }
 public AggregateRefValue1Operator(ISingleApi api)
 {
     Api = api;
 }
 public DistinctOperator(ISingleApi api)
 {
     Api = api;
 }
 public TryGetLastRefFunc(ISingleApi api)
 {
     Api = api;
 }
 public SelectRefAction(ISingleApi api)
 {
     Api = api;
 }
示例#22
0
 public SumInt32(ISingleApi api)
 {
     Api = api;
 }
示例#23
0
 public TryGetFirstFunc(ISingleApi api)
 {
     Api = api;
 }
 public SelectIndexRefFunc(ISingleApi api)
 {
     Api = api;
 }
 public TryGetAverageNone(ISingleApi api)
 {
     Api            = api;
     returnTypeName = api.Description;
 }
 public AggregateValue2Functions(ISingleApi api)
 {
     Api = api;
 }
示例#27
0
 public AllOperator(ISingleApi api)
 {
     Api = api;
 }
        private static void RegisterEachSingleApi(ISingleApi api, List <IApiExtensionMethodGenerator> list)
        {
            switch (api.Name)
            {
            case "Create":
                list.Add(new Create(api));
                break;

            case "Cast":
                list.Add(new Cast(api));
                break;

            case "AsRefEnumerableUnsafe":
                list.Add(new AsRefEnumerableUnsafe(api));
                break;

            case "GroupBy":
                switch (api.Description)
                {
                case "Func1":
                    list.Add(new GroupByFunc1DefaultEqualityComparer(api));
                    break;

                case "Func2":
                    list.Add(new GroupByFunc2DefaultEqualityComparer(api));
                    break;

                case "Func3":
                    list.Add(new GroupByFunc3(api));
                    break;

                case "RefAction1":
                    list.Add(new GroupByRefAction1DefaultEqualityComparer(api));
                    break;

                case "RefAction2":
                    list.Add(new GroupByRefAction2DefaultEqualityComparer(api));
                    break;

                case "RefAction2_RefFunc1":
                    list.Add(new GroupByRefAction3(api));
                    break;
                }
                break;

            case "RangeRepeat":
                switch (api.Description)
                {
                case "Repeat":
                    list.Add(new Repeat(api));
                    break;

                case "Range":
                    list.Add(new Range(api));
                    break;
                }
                break;

            case "ForEach":
                switch (api.Description)
                {
                case "Action":
                    list.Add(new ForEachAction(api));
                    break;

                case "RefAction":
                    list.Add(new ForEachRefAction(api));
                    break;

                case "Operator":
                    list.Add(new ForEachOperator(api));
                    break;
                }
                break;

            case "OrderBy":
                switch (api.Description)
                {
                case "NoneDouble":
                case "NoneSingle":
                case "NoneInt32":
                case "NoneUInt32":
                case "NoneInt64":
                case "NoneUInt64":
                    list.Add(new OrderByNoneNumber(api));
                    break;

                case "None":
                    list.Add(new OrderByNone(api));
                    break;

                case "IComparer":
                    list.Add(new OrderByIComparer(api));
                    break;

                case "Func":
                    list.Add(new OrderByFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new OrderByRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new OrderByOperator(api));
                    break;
                }
                break;

            case "SelectIndex":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new SelectIndexFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new SelectIndexRefFunc(api));
                    break;

                case "WithIndex":
                    list.Add(new SelectIndexWithIndex(api));
                    break;
                }
                break;

            case "WhereIndex":
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new WhereIndexOperator(api));
                    break;

                case "Func":
                    list.Add(new WhereIndexFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new WhereIndexRefFunc(api));
                    break;
                }
                break;

            case "Reverse":
                list.Add(new Reverse(api));
                break;

            case "Distinct":
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new DistinctOperator(api));
                    break;

                case "Func":
                    list.Add(new DistinctFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new DistinctRefFunc(api));
                    break;

                case "None":
                    list.Add(new DistinctNone(api));
                    break;
                }
                break;

            case "Append":
            case "Prepend":
                list.Add(new AppendPrependDefaultIfEmpty(api));
                break;

            case "DefaultIfEmpty":
                switch (api.Description)
                {
                case "None":
                    list.Add(new DefaultIfEmptyNone(api));
                    break;

                default:
                    list.Add(new AppendPrependDefaultIfEmpty(api));
                    break;
                }
                break;

            case "Skip":
            case "SkipLast":
            case "Take":
            case "TakeLast":
            case "Repeat":
                list.Add(new SkipSkipLastTakeTakeLastRepeat(api));
                break;

            case "Select":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new SelectFunc(api));
                    break;

                case "RefAction":
                    list.Add(new SelectRefAction(api));
                    break;
                }
                break;

            case "Where":
            case "SkipWhile":
            case "TakeWhile":
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new WhereSkipWhileTakeWhileOperator(api));
                    break;

                case "Func":
                    list.Add(new WhereSkipWhileTakeWhileFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new WhereSkipWhileTakeWhileRefFunc(api));
                    break;
                }
                break;

            case "MaxByDouble":
            case "MaxBySingle":
            case "MaxByInt32":
            case "MaxByInt64":
            case "MaxByUInt32":
            case "MaxByUInt64":
            case "MinByDouble":
            case "MinBySingle":
            case "MinByInt32":
            case "MinByInt64":
            case "MinByUInt32":
            case "MinByUInt64":
            {
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new MinMaxByOperator(api));
                    break;

                case "Func":
                    list.Add(new MinMaxByFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new MinMaxByRefFunc(api));
                    break;
                }
            }
            break;

            case "Contains":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new ContainsFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new ContainsRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new ContainsOperator(api));
                    break;

                case "None":
                    list.Add(new ContainsNone(api));
                    break;
                }
                break;

            case "TryGetFirstIndexOf":
                switch (api.Description)
                {
                case "None":
                    list.Add(new TryGetFirstIndexOfNone(api));
                    break;

                case "Func":
                    list.Add(new TryGetFirstIndexOfFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new TryGetFirstIndexOfRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new TryGetFirstIndexOfOperator(api));
                    break;
                }
                break;

            case "TryGetFirst":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new TryGetFirstFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new TryGetFirstRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new TryGetFirstOperator(api));
                    break;

                case "None":
                    list.Add(new TryGetFirstNone(api));
                    break;
                }
                break;

            case "TryGetLast":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new TryGetLastFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new TryGetLastRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new TryGetLastOperator(api));
                    break;

                case "None":
                    list.Add(new TryGetLastNone(api));
                    break;
                }
                break;

            case "TryGetElementAt":
                list.Add(new TryGetElementAt(api));
                break;

            case "TryGetSingle":
                switch (api.Description)
                {
                case "Func":
                    list.Add(new TryGetSingleFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new TryGetSingleRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new TryGetSingleOperator(api));
                    break;

                case "None":
                    list.Add(new TryGetSingleNone(api));
                    break;
                }
                break;

            case "TryGetAverage":
                list.Add(new TryGetAverageNone(api));
                break;

            case "Aggregate":
                switch (api.Description)
                {
                case "void Aggregate(ref TAccumulate seed, RefAction<T, TAccumulate> func)":
                    list.Add(new AggregateRefValue1Ref(api));
                    break;

                case "TAccumulate Aggregate(TAccumulate seed, RefAction<T, TAccumulate> func)":
                    list.Add(new AggregateValue1Ref(api));
                    break;

                case "TResult Aggregate(TAccumulate seed, RefAction<TAccumulate, T, TAccumulate> func, RefFunc<TAccumulate, TResult> resultFunc)":
                    list.Add(new AggregateValue2Refs(api));
                    break;

                case "TResult Aggregate(ref TAccumulate seed, in TFunc func, in TResultFunc resultFunc)":
                    list.Add(new AggregateRefValue2Operators(api));
                    break;

                case "TResult Aggregate(ref TAccumulate seed, RefAction<T, TAccumulate> func, RefFunc<TAccumulate, TResult> resultFunc)":
                    list.Add(new AggregateRefValue2Refs(api));
                    break;

                case "TResult Aggregate(TAccumulate seed, Func<TAccumulate, T, TAccumulate> func, Func<TAccumulate, TResult> resultFunc)":
                    list.Add(new AggregateValue2Functions(api));
                    break;

                case "void Aggregate(ref TAccumulate seed, in TFunc func)":
                    list.Add(new AggregateRefValue1Operator(api));
                    break;

                case "TAccumulate Aggregate(TAccumulate seed, in TFunc func)":
                    list.Add(new AggregateValue1Operator(api));
                    break;

                case "TAccumulate Aggregate(TAccumulate seed, Func<TAccumulate, T, TAccumulate> func)":
                    list.Add(new AggregateValue1Function(api));
                    break;
                }
                break;

            case "TryGetMax":
            case "TryGetMin":
            {
                var result = api.Description.Split(new[] { " --- " }, StringSplitOptions.RemoveEmptyEntries);
                if (result.Length != 2)
                {
                    Debug.LogWarning(api.Name + "\n" + api.Description);
                    return;
                }
                switch (result[0])
                {
                case "Func":
                    list.Add(new TryGetMinMaxFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new TryGetMinMaxRefFunc(api));
                    break;

                case "Operator":
                    list.Add(new TryGetMinMaxOperator(api));
                    break;

                case "None":
                    list.Add(new TryGetMinMaxNone(api));
                    break;
                }
            }
            break;

            case "All":
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new AllOperator(api));
                    break;

                case "Func":
                    list.Add(new AllFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new AllRefFunc(api));
                    break;
                }
                break;

            case "Any":
                switch (api.Description)
                {
                case "Operator":
                    list.Add(new AnyOperator(api));
                    break;

                case "Func":
                    list.Add(new AnyFunc(api));
                    break;

                case "RefFunc":
                    list.Add(new AnyRefFunc(api));
                    break;
                }
                break;

            case "Sum":
                switch (api.Description)
                {
                case "Double":
                    list.Add(new SumDouble(api));
                    break;

                case "Single":
                    list.Add(new SumSingle(api));
                    break;

                case "Int32":
                    list.Add(new SumInt32(api));
                    break;

                case "UInt32":
                    list.Add(new SumUInt32(api));
                    break;

                case "Int64":
                    list.Add(new SumInt64(api));
                    break;

                case "UInt64":
                    list.Add(new SumUInt64(api));
                    break;
                }
                break;
            }
        }
 public SelectIndexWithIndex(ISingleApi api)
 {
     Api = api;
 }
 public WhereSkipWhileTakeWhileOperator(ISingleApi api)
 {
     Api = api;
 }