//
// (C) Ximian, Inc. http://www.ximian.com
//
-// TODO: Mucho left to implement.
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+using System.Diagnostics;
using System.Reflection;
+using System.Reflection.Emit;
using System.Collections;
+using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Globalization;
namespace System {
- //
- // FIXME: Implement the various IReflect dependencies
- //
-
- [MonoTODO]
[Serializable]
- public abstract class Type : MemberInfo, IReflect {
+ [ClassInterface (ClassInterfaceType.None)]
+#if NET_2_0
+ [ComVisible (true)]
+ [ComDefaultInterface (typeof (_Type))]
+#endif
+ public abstract class Type : MemberInfo, IReflect, _Type, _MemberInfo {
internal RuntimeTypeHandle _impl;
public static readonly MemberFilter FilterNameIgnoreCase = new MemberFilter (FilterNameIgnoreCase_impl);
public static readonly object Missing;
+ internal const BindingFlags DefaultBindingFlags =
+ BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
+
/* implementation of the delegates for MemberFilter */
- static bool FilterName_impl (MemberInfo m, object filterCriteria) {
+ static bool FilterName_impl (MemberInfo m, object filterCriteria)
+ {
string name = (string) filterCriteria;
- return name.Equals (m.Name);
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, false, CultureInfo.InvariantCulture) == 0;
+
+ return name.Equals (m.Name);
}
-
- static bool FilterNameIgnoreCase_impl (MemberInfo m, object filterCriteria) {
+
+ static bool FilterNameIgnoreCase_impl (MemberInfo m, object filterCriteria)
+ {
string name = (string) filterCriteria;
- return String.Compare (name, m.Name, true) == 0;
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, true, CultureInfo.InvariantCulture) == 0;
+
+ return String.Compare (name, m.Name, true, CultureInfo.InvariantCulture) == 0;
}
-
- [MonoTODO]
- static bool FilterAttribute_impl (MemberInfo m, object filterCriteria) {
- throw new NotImplementedException ("FilterAttribute_impl");
+
+ static bool FilterAttribute_impl (MemberInfo m, object filterCriteria)
+ {
+ int flags = ((IConvertible)filterCriteria).ToInt32 (null);
+ if (m is MethodInfo)
+ return ((int)((MethodInfo)m).Attributes & flags) != 0;
+ if (m is FieldInfo)
+ return ((int)((FieldInfo)m).Attributes & flags) != 0;
+ if (m is PropertyInfo)
+ return ((int)((PropertyInfo)m).Attributes & flags) != 0;
+ if (m is EventInfo)
+ return ((int)((EventInfo)m).Attributes & flags) != 0;
+ return false;
}
- protected Type () {
+ protected Type ()
+ {
}
/// <summary>
return GetAttributeFlagsImpl ();
}
}
-
+
/// <summary>
/// Returns the basetype for this type
/// </summary>
public abstract Type BaseType {
get;
}
-
+
/// <summary>
/// Returns the class that declares the member.
/// </summary>
- [MonoTODO]
public override Type DeclaringType {
get {
- throw new NotImplementedException ();
+ return null;
}
}
/// <summary>
///
/// </summary>
- [MonoTODO]
public static Binder DefaultBinder {
get {
- throw new NotImplementedException ();
+ return Binder.DefaultBinder;
}
}
-
+
/// <summary>
/// The full name of the type including its namespace
/// </summary>
get;
}
- [MonoTODO]
public bool HasElementType {
- get {return false;} // FIXME
+ get {
+ return HasElementTypeImpl ();
+ }
}
public bool IsAbstract {
public bool IsAnsiClass {
get {
- return (Attributes & TypeAttributes.StringFormatMask) == TypeAttributes.AnsiClass;
+ return (Attributes & TypeAttributes.StringFormatMask)
+ == TypeAttributes.AnsiClass;
}
}
public bool IsClass {
get {
- if (this == typeof (System.Enum) || this == typeof (System.ValueType))
+ //
+ // This code used to probe for "this == typeof (System.Enum)", but in
+ // The .NET Framework 1.0, the above test return false
+ //
+ if (this == typeof (System.ValueType))
return true;
if (IsInterface)
return false;
- return !type_is_subtype_of (this, typeof (System.ValueType), false);
+ return !is_subtype_of (this, typeof (System.ValueType), false);
}
}
public bool IsEnum {
get {
- return type_is_subtype_of (this, typeof (System.Enum), false) &&
+ // This hack is needed because EnumBuilder's UnderlyingSystemType returns the enum's basetype
+ if (this is EnumBuilder)
+ return true;
+
+ return is_subtype_of (this, typeof (System.Enum), false) &&
this != typeof (System.Enum);
}
}
public bool IsNotPublic {
get {
- return !IsPublic;
+ return (Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic;
}
}
}
}
- [MonoTODO]
public bool IsPublic {
get {
- // FIXME: handle nestedpublic, too?
return (Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public;
}
}
public bool IsSerializable {
get {
- return (Attributes & TypeAttributes.Serializable) != 0;
+ // Enums and delegates are always serializable
+ return (Attributes & TypeAttributes.Serializable) != 0 || IsEnum ||
+ is_subtype_of (this, typeof (System.Delegate), false);
}
}
}
}
- [MonoTODO]
public override MemberTypes MemberType {
- get {return MemberTypes.TypeInfo;} // FIXME
+ get {return MemberTypes.TypeInfo;}
}
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ override
+#endif
public abstract Module Module {get;}
public abstract string Namespace {get;}
- [MonoTODO]
public override Type ReflectedType {
get {
- throw new NotImplementedException ();
+ return null;
}
}
public abstract RuntimeTypeHandle TypeHandle {get;}
- [MonoTODO]
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo TypeInitializer {
get {
- throw new NotImplementedException ();
+ return GetConstructorImpl (
+ BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
+ null,
+ CallingConventions.Any,
+ EmptyTypes,
+ null);
}
}
public abstract Type UnderlyingSystemType {get;}
- public override bool Equals (object o) {
+ public override bool Equals (object o)
+ {
if (o == null)
return false;
+
+ // TODO: return UnderlyingSystemType == o.UnderlyingSystemType;
Type cmp = o as Type;
if (cmp == null)
return false;
return Equals (cmp);
}
-
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern bool Equals (Type type);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Type internal_from_handle (RuntimeTypeHandle handle);
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Type internal_from_name (string name);
+ private static extern Type internal_from_handle (IntPtr handle);
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private static extern Type internal_from_name (string name, bool throwOnError, bool ignoreCase);
+
public static Type GetType(string typeName)
{
- return internal_from_name (typeName);
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ return internal_from_name (typeName, false, false);
}
public static Type GetType(string typeName, bool throwOnError)
{
- // LAMESPEC: what kinds of errors cause exception to be thrown?
- return internal_from_name (typeName);
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ Type type = internal_from_name (typeName, throwOnError, false);
+ if (throwOnError && type == null)
+ throw new TypeLoadException ("Error loading '" + typeName + "'");
+
+ return type;
}
- [MonoTODO]
public static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
{
- throw new NotImplementedException ();
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ Type t = internal_from_name (typeName, throwOnError, ignoreCase);
+ if (throwOnError && t == null)
+ throw new TypeLoadException ("Error loading '" + typeName + "'");
+
+ return t;
}
public static Type[] GetTypeArray (object[] args) {
- Type[] ret;
+ if (args == null)
+ throw new ArgumentNullException ("args");
+ Type[] ret;
ret = new Type [args.Length];
for (int i = 0; i < args.Length; ++i)
ret [i] = args[i].GetType ();
return ret;
}
- [MonoTODO]
- public static TypeCode GetTypeCode( Type type)
- {
- // FIXME
- return TypeCode.Empty;
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal extern static TypeCode GetTypeCodeInternal (Type type);
+
+ public static TypeCode GetTypeCode (Type type) {
+ type = type.UnderlyingSystemType;
+
+ if (!type.IsSystemType)
+ return Type.GetTypeCode (typeof (object));
+ else
+ return GetTypeCodeInternal (type);
}
[MonoTODO]
- public static Type GetTypeFromCLSID (Guid clsid) {
+ public static Type GetTypeFromCLSID (Guid clsid)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromCLSID (Guid clsid, bool throwOnError) {
+ public static Type GetTypeFromCLSID (Guid clsid, bool throwOnError)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromCLSID (Guid clsid, string server) {
+ public static Type GetTypeFromCLSID (Guid clsid, string server)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromCLSID (Guid clsid, string server, bool throwOnError) {
+ public static Type GetTypeFromCLSID (Guid clsid, string server, bool throwOnError)
+ {
throw new NotImplementedException ();
}
public static Type GetTypeFromHandle (RuntimeTypeHandle handle)
{
- return internal_from_handle (handle);
+ return internal_from_handle (handle.Value);
}
[MonoTODO]
- public static Type GetTypeFromProgID (string progID) {
+ public static Type GetTypeFromProgID (string progID)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromProgID (string progID, bool throwOnError) {
+ public static Type GetTypeFromProgID (string progID, bool throwOnError)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromProgID (string progID, string server) {
+ public static Type GetTypeFromProgID (string progID, string server)
+ {
throw new NotImplementedException ();
}
[MonoTODO]
- public static Type GetTypeFromProgID (string progID, string server, bool throwOnError) {
+ public static Type GetTypeFromProgID (string progID, string server, bool throwOnError)
+ {
throw new NotImplementedException ();
}
- public static RuntimeTypeHandle GetTypeHandle (object o) {
+ public static RuntimeTypeHandle GetTypeHandle (object o)
+ {
return o.GetType().TypeHandle;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool type_is_subtype_of (Type a, Type b, bool check_interfaces);
-
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern bool type_is_assignable_from (Type a, Type b);
+
+ internal static bool is_subtype_of (Type a, Type b, bool check_interfaces)
+ {
+ a = a.UnderlyingSystemType;
+ b = b.UnderlyingSystemType;
+
+ if (!a.IsSystemType || !b.IsSystemType)
+ return false;
+ else
+ return type_is_subtype_of (a, b, check_interfaces);
+ }
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual bool IsSubclassOf (Type c)
{
- return type_is_subtype_of (this, c, false);
+ if (c == null)
+ return false;
+
+ return (this != c) && is_subtype_of (this, c, false);
}
- [MonoTODO]
public virtual Type[] FindInterfaces (TypeFilter filter, object filterCriteria)
{
- // FIXME
- throw new NotImplementedException ();
+ if (filter == null)
+ throw new ArgumentNullException ("filter");
+
+ ArrayList ifaces = new ArrayList ();
+ foreach (Type iface in GetInterfaces ()) {
+ if (filter (iface, filterCriteria))
+ ifaces.Add (iface);
+ }
+
+ return (Type []) ifaces.ToArray (typeof (Type));
}
public Type GetInterface (string name) {
public abstract Type GetInterface (string name, bool ignoreCase);
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern void GetInterfaceMapData (Type t, Type iface, out MethodInfo[] targets, out MethodInfo[] methods);
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual InterfaceMapping GetInterfaceMap (Type interfaceType) {
- throw new NotImplementedException ();
+ InterfaceMapping res;
+ if (interfaceType == null)
+ throw new ArgumentNullException ("interfaceType");
+ if (!interfaceType.IsInterface)
+ throw new ArgumentException (Locale.GetText ("Argument must be an interface."), "interfaceType");
+ res.TargetType = this;
+ res.InterfaceType = interfaceType;
+ GetInterfaceMapData (this, interfaceType, out res.TargetMethods, out res.InterfaceMethods);
+ if (res.TargetMethods == null)
+ throw new ArgumentException (Locale.GetText ("Interface not found"), "interfaceType");
+
+ return res;
}
public abstract Type[] GetInterfaces ();
- [MonoTODO]
public virtual bool IsAssignableFrom (Type c)
{
- // FIXME
- return type_is_subtype_of (c, this, true);
- }
+ if (c == null)
+ return false;
+
+ if (Equals (c))
+ return true;
+
+ if (c is TypeBuilder)
+ return ((TypeBuilder)c).IsAssignableTo (this);
- public virtual bool IsInstanceOfType (object o) {
- if (o != null) {
- return o.GetType().IsSubclassOf (this);
+ /* Handle user defined type classes */
+ if (!IsSystemType) {
+ Type systemType = UnderlyingSystemType;
+ if (!systemType.IsSystemType)
+ return false;
+ return systemType.IsAssignableFrom (c);
}
- return false;
+
+ if (!c.IsSystemType) {
+ Type underlyingType = c.UnderlyingSystemType;
+ if (!underlyingType.IsSystemType)
+ return false;
+ return IsAssignableFrom (underlyingType);
+ }
+
+ return type_is_assignable_from (this, c);
}
- [MonoTODO]
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual bool IsInstanceOfType (object o);
+
public virtual int GetArrayRank ()
{
- // FIXME
- throw new NotImplementedException ();
+ throw new NotSupportedException (); // according to MSDN
}
public abstract Type GetElementType ();
- [MonoTODO]
- public EventInfo GetEvent (string name) {
- throw new NotImplementedException ();
+ public EventInfo GetEvent (string name)
+ {
+ return GetEvent (name, DefaultBindingFlags);
}
public abstract EventInfo GetEvent (string name, BindingFlags bindingAttr);
- public virtual EventInfo[] GetEvents () {
- return GetEvents (BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance);
+ public virtual EventInfo[] GetEvents ()
+ {
+ return GetEvents (DefaultBindingFlags);
}
public abstract EventInfo[] GetEvents (BindingFlags bindingAttr);
- public FieldInfo GetField( string name) {
- return GetField (name, BindingFlags.Public);
+ public FieldInfo GetField( string name)
+ {
+ return GetField (name, DefaultBindingFlags);
}
public abstract FieldInfo GetField( string name, BindingFlags bindingAttr);
public FieldInfo[] GetFields ()
{
- return GetFields (BindingFlags.Public|BindingFlags.Instance|BindingFlags.Static);
+ return GetFields (DefaultBindingFlags);
}
public abstract FieldInfo[] GetFields (BindingFlags bindingAttr);
- public override int GetHashCode() {
+ public override int GetHashCode()
+ {
return (int)_impl.Value;
}
- public MemberInfo[] GetMember( string name) {
- return GetMember (name, BindingFlags.Public);
+ public MemberInfo[] GetMember (string name)
+ {
+ return GetMember (name, DefaultBindingFlags);
}
- [MonoTODO]
- public virtual MemberInfo[] GetMember( string name, BindingFlags bindingAttr) {
- // FIXME
- throw new NotImplementedException ();
+ public virtual MemberInfo[] GetMember (string name, BindingFlags bindingAttr)
+ {
+ return GetMember (name, MemberTypes.All, bindingAttr);
}
- [MonoTODO]
- public virtual MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr) {
- // FIXME
- throw new NotImplementedException ();
+ public virtual MemberInfo[] GetMember (string name, MemberTypes type, BindingFlags bindingAttr)
+ {
+ if ((bindingAttr & BindingFlags.IgnoreCase) != 0)
+ return FindMembers (type, bindingAttr, FilterNameIgnoreCase, name);
+ else
+ return FindMembers (type, bindingAttr, FilterName, name);
}
- public MemberInfo[] GetMembers() {
- return GetMembers (BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance);
+ public MemberInfo[] GetMembers ()
+ {
+ return GetMembers (DefaultBindingFlags);
}
- public abstract MemberInfo[] GetMembers( BindingFlags bindingAttr);
-
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern MethodInfo get_method (Type type, string name, Type[] types);
+ public abstract MemberInfo[] GetMembers (BindingFlags bindingAttr);
- public MethodInfo GetMethod( string name) {
- return GetMethod (name, BindingFlags.Public);
+ public MethodInfo GetMethod (string name)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ return GetMethodImpl (name, DefaultBindingFlags, null, CallingConventions.Any, null, null);
}
- [MonoTODO]
- public MethodInfo GetMethod( string name, BindingFlags bindingAttr) {
- // FIXME
- throw new NotImplementedException ();
+ public MethodInfo GetMethod (string name, BindingFlags bindingAttr)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+
+ return GetMethodImpl (name, bindingAttr, null, CallingConventions.Any, null, null);
}
public MethodInfo GetMethod (string name, Type[] types)
{
- return get_method (this, name, types);
+ return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
- [MonoTODO]
- public MethodInfo GetMethod( string name, Type[] types, ParameterModifier[] modifiers) {
- // FIXME
- throw new NotImplementedException ();
+ public MethodInfo GetMethod (string name, Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, modifiers);
}
- [MonoTODO]
- public MethodInfo GetMethod( string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers) {
- // FIXME
- throw new NotImplementedException ();
+ public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
+ Type[] types, ParameterModifier[] modifiers)
+ {
+
+ return GetMethod (name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
- [MonoTODO]
- public MethodInfo GetMethod( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
- // FIXME
- throw new NotImplementedException ();
+ public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (types == null)
+ throw new ArgumentNullException ("types");
+
+ for (int i = 0; i < types.Length; i++)
+ if (types[i] == null)
+ throw new ArgumentNullException ("types");
+
+ return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
+ }
+
+ protected abstract MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers);
+
+ internal MethodInfo GetMethodImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers)
+ {
+ return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
}
- protected abstract MethodInfo GetMethodImpl( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+ internal virtual MethodInfo GetMethod (MethodInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual FieldInfo GetField (FieldInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
public MethodInfo[] GetMethods ()
{
- return GetMethods (BindingFlags.Public|BindingFlags.Instance|BindingFlags.Static);
+ return GetMethods (DefaultBindingFlags);
}
public abstract MethodInfo[] GetMethods (BindingFlags bindingAttr);
- public Type GetNestedType( string name) {
- return GetNestedType (name, BindingFlags.Public);
+ public Type GetNestedType (string name)
+ {
+ return GetNestedType (name, DefaultBindingFlags);
}
- public abstract Type GetNestedType( string name, BindingFlags bindingAttr);
+ public abstract Type GetNestedType (string name, BindingFlags bindingAttr);
- public Type[] GetNestedTypes () {
- return GetNestedTypes (BindingFlags.Public);
+ public Type[] GetNestedTypes ()
+ {
+ return GetNestedTypes (DefaultBindingFlags);
}
public abstract Type[] GetNestedTypes (BindingFlags bindingAttr);
+
public PropertyInfo[] GetProperties ()
{
- return GetProperties (BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance);
+ return GetProperties (DefaultBindingFlags);
}
- public abstract PropertyInfo[] GetProperties( BindingFlags bindingAttr);
+ public abstract PropertyInfo[] GetProperties (BindingFlags bindingAttr);
+
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern PropertyInfo get_property (Type type, string name, Type[] types);
-
public PropertyInfo GetProperty (string name)
{
- return GetProperty (name, BindingFlags.Public);
+ if (name == null)
+ throw new ArgumentNullException ("name");
+
+ return GetPropertyImpl (name, DefaultBindingFlags, null, null, null, null);
}
- [MonoTODO]
- public PropertyInfo GetProperty( string name, BindingFlags bindingAttr) {
- // FIXME
- throw new NotImplementedException ();
+ public PropertyInfo GetProperty (string name, BindingFlags bindingAttr)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ return GetPropertyImpl (name, bindingAttr, null, null, null, null);
}
- [MonoTODO]
- public PropertyInfo GetProperty( string name, Type returnType) {
- // FIXME
- throw new NotImplementedException ();
+ public PropertyInfo GetProperty (string name, Type returnType)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ return GetPropertyImpl (name, DefaultBindingFlags, null, returnType, null, null);
}
public PropertyInfo GetProperty (string name, Type[] types)
{
- return get_property (this, name, types);
+ return GetProperty (name, DefaultBindingFlags, null, null, types, null);
}
- [MonoTODO]
public PropertyInfo GetProperty (string name, Type returnType, Type[] types)
{
- // FIXME
- throw new NotImplementedException ();
+ return GetProperty (name, DefaultBindingFlags, null, returnType, types, null);
}
- [MonoTODO]
- public PropertyInfo GetProperty( string name, Type returnType, Type[] types, ParameterModifier[] modifiers) {
- // FIXME
- throw new NotImplementedException ();
+ public PropertyInfo GetProperty( string name, Type returnType, Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetProperty (name, DefaultBindingFlags, null, returnType, types, modifiers);
}
- [MonoTODO]
- public PropertyInfo GetProperty( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
- // FIXME
- throw new NotImplementedException ();
+ public PropertyInfo GetProperty (string name, BindingFlags bindingAttr, Binder binder, Type returnType,
+ Type[] types, ParameterModifier[] modifiers)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (types == null)
+ throw new ArgumentNullException ("types");
+
+ return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
}
- protected abstract PropertyInfo GetPropertyImpl( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers);
+ protected abstract PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers);
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern ConstructorInfo get_constructor (Type type, Type[] types);
+ internal PropertyInfo GetPropertyImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
+ }
- protected abstract ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+ protected abstract ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr,
+ Binder binder,
+ CallingConventions callConvention,
+ Type[] types,
+ ParameterModifier[] modifiers);
protected abstract TypeAttributes GetAttributeFlagsImpl ();
protected abstract bool HasElementTypeImpl ();
protected abstract bool IsArrayImpl ();
protected abstract bool IsByRefImpl ();
protected abstract bool IsCOMObjectImpl ();
- protected virtual bool IsContextfulImpl () {
- return typeof (ContextBoundObject).IsAssignableFrom (this);
- }
- [MonoTODO]
- protected virtual bool IsMarshalByRefImpl () {
- // FIXME
- return false;
- }
protected abstract bool IsPointerImpl ();
protected abstract bool IsPrimitiveImpl ();
- protected abstract bool IsValueTypeImpl ();
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern bool IsArrayImpl (Type type);
+
+ protected virtual bool IsValueTypeImpl ()
+ {
+ if (this == typeof (Enum) || this == typeof (ValueType))
+ return false;
+
+ return IsSubclassOf (typeof (ValueType));
+ }
+
+ protected virtual bool IsContextfulImpl ()
+ {
+ return typeof (ContextBoundObject).IsAssignableFrom (this);
+ }
+
+ protected virtual bool IsMarshalByRefImpl ()
+ {
+ return typeof (MarshalByRefObject).IsAssignableFrom (this);
+ }
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (Type[] types)
{
- return get_constructor (this, types);
+ return GetConstructorImpl (
+ DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
- [MonoTODO]
- public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers) {
- throw new NotImplementedException ();
+#if NET_2_0
+ [ComVisible (true)]
+#endif
+ public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
+ Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetConstructorImpl (
+ bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
- [MonoTODO]
- public ConstructorInfo GetConstructor( BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
- throw new NotImplementedException ();
+#if NET_2_0
+ [ComVisible (true)]
+#endif
+ public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention,
+ Type[] types, ParameterModifier[] modifiers)
+ {
+ if (types == null)
+ throw new ArgumentNullException ("types");
+
+ return GetConstructorImpl (bindingAttr, binder, callConvention, types, modifiers);
}
- public ConstructorInfo[] GetConstructors () {
- return GetConstructors (BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance);
+#if NET_2_0
+ [ComVisible (true)]
+#endif
+ public ConstructorInfo[] GetConstructors ()
+ {
+ return GetConstructors (BindingFlags.Public | BindingFlags.Instance);
}
-
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public abstract ConstructorInfo[] GetConstructors (BindingFlags bindingAttr);
- [MonoTODO]
- public virtual MemberInfo[] GetDefaultMembers () {
- throw new NotImplementedException ();
+ public virtual MemberInfo[] GetDefaultMembers ()
+ {
+ object [] att = GetCustomAttributes (typeof (DefaultMemberAttribute), true);
+ if (att.Length == 0)
+ return new MemberInfo [0];
+
+ MemberInfo [] member = GetMember (((DefaultMemberAttribute) att [0]).MemberName);
+ return (member != null) ? member : new MemberInfo [0];
}
- public virtual MemberInfo[] FindMembers( MemberTypes memberType, BindingFlags bindingAttr,
- MemberFilter filter, object filterCriteria) {
+ public virtual MemberInfo[] FindMembers (MemberTypes memberType, BindingFlags bindingAttr,
+ MemberFilter filter, object filterCriteria)
+ {
MemberInfo[] result;
ArrayList l = new ArrayList ();
- //Console.WriteLine ("FindMembers for {0} (Type: {1}): {2}", this.FullName, this.GetType().FullName, this.obj_address());
+ // Console.WriteLine ("FindMembers for {0} (Type: {1}): {2}",
+ // this.FullName, this.GetType().FullName, this.obj_address());
if ((memberType & MemberTypes.Constructor) != 0) {
ConstructorInfo[] c = GetConstructors (bindingAttr);
l.AddRange (c);
}
}
+ if ((memberType & MemberTypes.NestedType) != 0) {
+ Type[] c = GetNestedTypes (bindingAttr);
+ if (filter != null) {
+ foreach (MemberInfo m in c) {
+ if (filter (m, filterCriteria)) {
+ l.Add (m);
+ }
+ }
+ } else {
+ l.AddRange (c);
+ }
+ }
result = new MemberInfo [l.Count];
l.CopyTo (result);
return result;
}
- [MonoTODO]
- public object InvokeMember( string name, BindingFlags invokeAttr, Binder binder, object target, object[] args) {
- // FIXME
- return null;
+ [DebuggerHidden]
+ [DebuggerStepThrough]
+ public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args)
+ {
+ return InvokeMember (name, invokeAttr, binder, target, args, null, null, null);
}
- [MonoTODO]
- public object InvokeMember( string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, CultureInfo culture) {
- // FIXME
- return null;
+ [DebuggerHidden]
+ [DebuggerStepThrough]
+ public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder,
+ object target, object[] args, CultureInfo culture)
+ {
+ return InvokeMember (name, invokeAttr, binder, target, args, null, culture, null);
}
- public abstract object InvokeMember( string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters);
+ public abstract object InvokeMember (string name, BindingFlags invokeAttr,
+ Binder binder, object target, object[] args,
+ ParameterModifier[] modifiers,
+ CultureInfo culture, string[] namedParameters);
public override string ToString()
{
- string res = FullName;
- if (IsArray)
- res = res + "[]";
- if (IsByRef)
- res = res + "&";
- if (IsPointer)
- res = res + "*";
+ return FullName;
+ }
+
+ internal bool IsSystemType {
+ get {
+ return _impl.Value != IntPtr.Zero;
+ }
+ }
+
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ public abstract Type[] GetGenericArguments ();
+
+ public abstract bool HasGenericArguments {
+ get;
+ }
+
+ public abstract bool ContainsGenericParameters {
+ get;
+ }
+
+ public extern bool IsGenericTypeDefinition {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type GetGenericTypeDefinition_impl ();
+
+ public virtual Type GetGenericTypeDefinition ()
+ {
+ Type res = GetGenericTypeDefinition_impl ();
+ if (res == null)
+ throw new InvalidOperationException ();
+
return res;
}
+
+ public extern bool IsGenericInstance {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ static extern Type BindGenericParameters (Type gt, Type [] types);
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
+ public Type BindGenericParameters (Type [] types)
+ {
+ if (types == null)
+ throw new ArgumentNullException ("types");
+ foreach (Type t in types) {
+ if (t == null)
+ throw new ArgumentNullException ("types");
+ }
+ Type res = BindGenericParameters (this, types);
+ if (res == null)
+ throw new TypeLoadException ();
+ return res;
+ }
+
+ public Type MakeGenericType (Type[] types)
+ {
+ return BindGenericParameters (types);
+ }
+
+ public abstract bool IsGenericParameter {
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern int GetGenericParameterPosition ();
+
+ public virtual int GenericParameterPosition {
+ get {
+ int res = GetGenericParameterPosition ();
+ if (res < 0)
+ throw new InvalidOperationException ();
+ return res;
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern GenericParameterAttributes GetGenericParameterAttributes ();
+
+ public virtual GenericParameterAttributes GenericParameterAttributes {
+ get {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterAttributes ();
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type[] GetGenericParameterConstraints_impl ();
+
+ public virtual Type[] GetGenericParameterConstraints ()
+ {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterConstraints_impl ();
+ }
+
+ public abstract MethodInfo DeclaringMethod {
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_array_type (int rank);
+
+ public virtual Type MakeArrayType ()
+ {
+ return MakeArrayType (1);
+ }
+
+ public virtual Type MakeArrayType (int rank)
+ {
+ if (rank < 1)
+ throw new IndexOutOfRangeException ();
+ return make_array_type (rank);
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_byref_type ();
+
+ public virtual Type MakeByRefType ()
+ {
+ return make_byref_type ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual Type MakePointerType ();
+
+ [MonoTODO]
+ public static Type ReflectionOnlyGetType (string typeName,
+ bool throwIfNotFound,
+ bool ignoreCase)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern void GetPacking (out int packing, out int size);
+
+ public virtual StructLayoutAttribute StructLayoutAttribute {
+ get {
+ LayoutKind kind;
+
+ if (IsLayoutSequential)
+ kind = LayoutKind.Sequential;
+ else if (IsExplicitLayout)
+ kind = LayoutKind.Explicit;
+ else
+ kind = LayoutKind.Auto;
+
+ StructLayoutAttribute attr = new StructLayoutAttribute (kind);
+
+ if (IsUnicodeClass)
+ attr.CharSet = CharSet.Unicode;
+ else if (IsAnsiClass)
+ attr.CharSet = CharSet.Ansi;
+ else
+ attr.CharSet = CharSet.Auto;
+
+ if (kind != LayoutKind.Auto)
+ GetPacking (out attr.Pack, out attr.Size);
+
+ return attr;
+ }
+ }
+
+ internal object[] GetPseudoCustomAttributes () {
+ int count = 0;
+
+ if (IsSerializable)
+ count ++;
+
+ if (count == 0)
+ return null;
+ object[] attrs = new object [count];
+ count = 0;
+
+ if (IsSerializable)
+ attrs [count ++] = new SerializableAttribute ();
+
+ return attrs;
+ }
+
+#endif
}
}
projects / mono.git / blobdiff