Beispiel #1
0
        public MethodName(MethodInfo method, TypeNameFlag flags)
        {
            Method     = method;
            ReturnType = TypeNameFactory.Create(method.ReturnType, flags);

            if (!method.Name.Contains("."))
            {
                Name = method.Name;
                ExplicitInterface = null;
            }
            else
            {
                var iSplit        = method.Name.LastIndexOf('.');
                var interfacePart = method.Name.Substring(0, iSplit);
                Name = method.Name.Substring(iSplit + 1);
                var interfaceType = method.DeclaringType.GetInterface(interfacePart);
                ExplicitInterface = TypeNameFactory.Create(interfaceType, flags);
            }

            Generics = new GenericList();
            if (method.IsGenericMethod)
            {
                foreach (var generic in method.GetGenericArguments())
                {
                    Generics.Add(TypeNameFactory.Create(generic, flags));
                }
            }

            Parameters = new ParameterList();
            foreach (var parameter in method.GetParameters())
            {
                Parameters.Add(new ParameterName(parameter, flags));
            }
        }
Beispiel #2
0
        internal ParameterName(ParameterInfo parameter, TypeNameFlag flags)
        {
            Parameter = parameter;
            TypeName  = TypeNameFactory.Create(parameter.ParameterType, flags);
            Name      = parameter.Name;

            if (parameter.IsOut)
            {
                Modifier = "out";
            }
            else if (parameter.ParameterType.IsByRef)
            {
                if (!flags.Has(TypeNameFlag.ExplicitRef))
                {
                    Modifier = "ref";
                }
            }
            else if (parameter.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0)
            {
                Modifier = "params";
            }
            else
            {
                Modifier = null;
            }
        }
Beispiel #3
0
 internal static TypeName Create(Type type, TypeNameFlag flags)
 {
     if (SimpleTypeName.IsSimpleType(type))
     {
         return(new SimpleTypeName(type, flags));
     }
     if (type.IsArray)
     {
         return(new ArrayTypeName(type, flags));
     }
     if (type.IsGenericParameter)
     {
         return(new GenericParameterTypeName(type, flags));
     }
     if (type.IsPointer)
     {
         return(new PointerTypeName(type, flags));
     }
     if (type.IsByRef)
     {
         return(new RefTypeName(type, flags));
     }
     if (type.IsGenericType)
     {
         if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
         {
             return(new NullableTypeName(type, flags));
         }
         return(new GenericTypeName(type, flags));
     }
     return(new DirectTypeName(type));
 }
Beispiel #4
0
        internal TypeNameView(Type type, GenericVisitor visitor, TypeNameFlag flags)
        {
            Type     = type;
            Generics = new GenericList();

            var genericName = type.Name;
            var iQuota      = genericName.LastIndexOf('`');

            int lenGeneric;

            if (iQuota > 0)
            {
                Name       = genericName.Substring(0, iQuota);
                lenGeneric = int.Parse(genericName.Substring(iQuota + 1));
            }
            else
            {
                Name       = genericName;
                lenGeneric = 0;
            }

            for (int i = 0; i < lenGeneric; i++)
            {
                Generics.Add(TypeNameFactory.Create(visitor.Next(), flags));
            }
        }
        public static IMethodName GetDefinitionName(this MethodInfo method, TypeNameFlag flags = TypeNameFlag.Default)
        {
            var name   = new MethodName(method, flags);
            var filter = new NamespaceFilter();

            name.FilterNamespace(filter);
            filter.ClearNamespace();
            return(name);
        }
Beispiel #6
0
        public static ITypeName GetTypeName(this Type type, TypeNameFlag flags = TypeNameFlag.Default)
        {
            var name   = TypeNameFactory.Create(type, flags);
            var filter = new NamespaceFilter();

            name.FilterNamespace(filter);
            filter.ClearNamespace();
            return(name);
        }
 internal ArrayTypeName(Type type, TypeNameFlag flags) : base(type)
 {
     ArrayRanks = new ArrayRankList();
     while (type.IsArray)
     {
         ArrayRanks.Add(type.GetArrayRank());
         type = type.GetElementType();
     }
     ComponentType = TypeNameFactory.Create(type, flags);
 }
Beispiel #8
0
 internal GenericParameterTypeName(Type type, TypeNameFlag flags) : base(type)
 {
     if (flags.Has(TypeNameFlag.OmitGenericParameter))
     {
         Name = "";
     }
     else
     {
         Name = type.Name;
     }
 }
Beispiel #9
0
 internal RefTypeName(Type type, TypeNameFlag flags) : base(type)
 {
     ComponentType = TypeNameFactory.Create(type.GetElementType(), flags);
     if (flags.Has(TypeNameFlag.ExplicitRef))
     {
         Sign = SignConstant.Ref;
     }
     else
     {
         Sign = null;
     }
 }
 internal SimpleTypeName(Type type, TypeNameFlag flags) : base(type)
 {
     if (flags.Has(TypeNameFlag.FullPrimitive))
     {
         Namespace = new Namespace(type.Namespace);
         Name      = type.Name;
     }
     else
     {
         Namespace = Namespace.Empty;
         Name      = SimpleNames[type];
     }
 }
        public GenericTypeName(Type type, TypeNameFlag flags) : base(type)
        {
            Namespace      = new Namespace(type.Namespace);
            EnclosingNames = new EnclosingNameList();
            Generics       = new GenericList();

            var visitor = new GenericVisitor(type);

            {
                var super = type.DeclaringType;
                while (super != null)
                {
                    if (super.IsGenericType)
                    {
                        EnclosingNames.AddBefore(new TypeNameView(super, visitor, flags));
                    }
                    else
                    {
                        EnclosingNames.AddBefore(new TypeNameView(super));
                    }
                    super = super.DeclaringType;
                }
            }

            var genericName = type.Name;
            var iQuota      = genericName.LastIndexOf('`');

            int lenGeneric;

            if (iQuota > 0)
            {
                Name       = iQuota < 0 ? genericName : genericName.Substring(0, iQuota);
                lenGeneric = int.Parse(genericName.Substring(iQuota + 1));
            }
            else
            {
                Name       = genericName;
                lenGeneric = 0;
            }

            for (var i = 0; i < lenGeneric; i++)
            {
                Generics.Add(TypeNameFactory.Create(visitor.Next(), flags));
            }
        }
Beispiel #12
0
        public MethodName(MethodInfo method, TypeNameFlag flags)
        {
            Method            = method;
            ReturnType        = TypeNameFactory.Create(method.ReturnType, flags);
            Name              = method.Name;
            ExplicitInterface = null;

            Generics = new GenericList();
            if (method.IsGenericMethod)
            {
                foreach (var generic in method.GetGenericArguments())
                {
                    Generics.Add(TypeNameFactory.Create(generic, flags));
                }
            }

            Parameters = new ParameterList();
            foreach (var parameter in method.GetParameters())
            {
                Parameters.Add(new ParameterName(parameter, flags));
            }
        }
Beispiel #13
0
        internal NullableTypeName(Type type, TypeNameFlag flags) : base(type)
        {
            var component     = type.GetGenericArguments()[0];
            var componentType = TypeNameFactory.Create(component, flags);

            if (flags.Has(TypeNameFlag.FullNullable))
            {
                Namespace = new Namespace(type.Namespace);
                BaseNames = BaseNameList.Empty;
                Name      = nameof(Sign);
                Generics  = new GenericList {
                    componentType
                };
                Sign = null;
            }
            else
            {
                Namespace = componentType.Namespace;
                BaseNames = componentType.BaseNames;
                Name      = componentType.Name;
                Generics  = GenericList.Empty;
                Sign      = SignConstant.Nullable;
            }
        }
 internal PointerTypeName(Type type, TypeNameFlag flags) : base(type)
 {
     ComponentType = TypeNameFactory.Create(type.GetElementType(), flags);
 }
Beispiel #15
0
 public static ITypeName GetTypeFullName(this Type type, TypeNameFlag flags = TypeNameFlag.Default)
 {
     return(TypeNameFactory.Create(type, flags));
 }
Beispiel #16
0
 public static string GetTypeFullNameString(this Type type, TypeNameFlag flags = TypeNameFlag.Default)
 {
     return(GetTypeFullName(type, flags).ToString());
 }
Beispiel #17
0
 public static bool Has(this TypeNameFlag flags, TypeNameFlag flag)
 {
     return((flags & flag) != 0);
 }
 public static string GetDefinitionNameString(this MethodInfo method, TypeNameFlag flags = TypeNameFlag.Default)
 {
     return(GetDefinitionName(method, flags).ToString());
 }
 public static IMethodName GetDefinitionFullName(this MethodInfo method, TypeNameFlag flags = TypeNameFlag.Default)
 {
     return(new MethodName(method, flags));
 }