Exemplo n.º 1
0
        public string Type(string type, string[] genericArgs)
        {
            var useType = TypeFilter?.Invoke(type, genericArgs);

            if (useType != null)
            {
                return(useType);
            }

            if (genericArgs != null)
            {
                var parts = type.Split('`');
                if (parts.Length > 1)
                {
                    var args = StringBuilderCacheAlt.Allocate();
                    foreach (var arg in genericArgs)
                    {
                        if (args.Length > 0)
                        {
                            args.Append(", ");
                        }

                        args.Append(TypeAlias(arg));
                    }

                    var typeName = NameOnly(type);
                    return("{0}<{1}>".Fmt(typeName, StringBuilderCacheAlt.ReturnAndFree(args)));
                }
            }

            return(TypeAlias(type));
        }
Exemplo n.º 2
0
        public string Type(string type, string[] genericArgs)
        {
            var useType = TypeFilter?.Invoke(type, genericArgs);

            if (useType != null)
            {
                return(useType);
            }

            if (genericArgs != null)
            {
                string cooked = null;
                if (type == "Nullable`1")
                {
                    cooked = "{0}?".Fmt(GenericArg(genericArgs[0]));
                }
                else if (ArrayTypes.Contains(type))
                {
                    cooked = "{0}[]".Fmt(GenericArg(genericArgs[0])).StripNullable();
                }
                else if (DictionaryTypes.Contains(type))
                {
                    cooked = "{{ [index: {0}]: {1}; }}".Fmt(
                        GenericArg(genericArgs[0]),
                        GenericArg(genericArgs[1]));
                }
                else
                {
                    var parts = type.Split('`');
                    if (parts.Length > 1)
                    {
                        var args = StringBuilderCacheAlt.Allocate();
                        foreach (var arg in genericArgs)
                        {
                            if (args.Length > 0)
                            {
                                args.Append(", ");
                            }

                            args.Append(GenericArg(arg));
                        }

                        var typeName = TypeAlias(type);
                        cooked = "{0}<{1}>".Fmt(typeName, StringBuilderCacheAlt.ReturnAndFree(args));
                    }
                }

                if (cooked != null)
                {
                    return(CookedTypeFilter?.Invoke(cooked) ?? cooked);
                }
            }
            else
            {
                type = type.StripNullable();
            }

            return(TypeAlias(type));
        }
Exemplo n.º 3
0
        public string Type(string type, string[] genericArgs)
        {
            var useType = TypeFilter?.Invoke(type, genericArgs);

            if (useType != null)
            {
                return(useType);
            }

            if (genericArgs != null)
            {
                if (type == "Nullable`1")
                {
                    return /*@Nullable*/ ("{0}".Fmt(GenericArg(genericArgs[0])));
                }
                if (ArrayTypes.Contains(type))
                {
                    return("ArrayList<{0}>".Fmt(GenericArg(genericArgs[0])).StripNullable());
                }
                if (DictionaryTypes.Contains(type))
                {
                    return("HashMap<{0},{1}>".Fmt(
                               GenericArg(genericArgs[0]),
                               GenericArg(genericArgs[1])));
                }

                var parts = type.Split('`');
                if (parts.Length > 1)
                {
                    var args = StringBuilderCacheAlt.Allocate();
                    foreach (var arg in genericArgs)
                    {
                        if (args.Length > 0)
                        {
                            args.Append(", ");
                        }

                        args.Append(GenericArg(arg));
                    }

                    var typeName = TypeAlias(type);
                    return("{0}<{1}>".Fmt(typeName, StringBuilderCacheAlt.ReturnAndFree(args)));
                }
            }
            else
            {
                type = type.StripNullable();
            }

            return(TypeAlias(type));
        }
Exemplo n.º 4
0
        public string Type(string type, string[] genericArgs, bool includeNested = false)
        {
            var useType = TypeFilter?.Invoke(type, genericArgs);

            if (useType != null)
            {
                return(useType);
            }

            if (genericArgs != null)
            {
                if (type == "Nullable`1")
                {
                    return($"{TypeAlias(genericArgs[0], includeNested: includeNested)}?");
                }

                var parts = type.Split('`');
                if (parts.Length > 1)
                {
                    var args = StringBuilderCacheAlt.Allocate();
                    foreach (var arg in genericArgs)
                    {
                        if (args.Length > 0)
                        {
                            args.Append(", ");
                        }

                        args.Append(TypeAlias(arg.SanitizeType(), includeNested: includeNested));
                    }

                    var typeName = NameOnly(type, includeNested: includeNested).SanitizeType();
                    return($"{typeName}<{StringBuilderCacheAlt.ReturnAndFree(args)}>");
                }
            }

            return(TypeAlias(type, includeNested: includeNested));
        }