PolymorphicType.cs

Go to the documentation of this file.

/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
using System;
using System.Collections;
using System.Reflection;
using System.Globalization;
 
namespace uno {
 
 
 
public class PolymorphicType: Type
{
    private Type m_base;
    private string m_type_name;
    
    private static Hashtable m_ht_types = Hashtable.Synchronized(new Hashtable(256));
 
    public static PolymorphicType GetType(Type type, string name)
    {
        if (name == null || type == null)
            throw new ArgumentNullException(
                "cli-uno: uno.PolymorphicType.GetType was called with a null argument");
        //check if the type is either an array of structs or a polymorphic struct.
        if (type.IsArray)
        {
            Type elementType = type;
            while ((elementType = elementType.GetElementType()).IsArray);
            //unfortunately we cannot check if it is a real polymorphic struct here.
            if ( ! elementType.IsClass)
                return null;
                   
            
        }
        else if (Attribute.GetCustomAttribute(type, typeof(uno.TypeParametersAttribute))
            == null)
        {
            return null;
        }
 
        lock (m_ht_types.SyncRoot)
        {
            PolymorphicType t = (PolymorphicType) m_ht_types[name];
            if (t == null)
            {
                t = new PolymorphicType(type, name);
                m_ht_types.Add(name, t);
            }
            return t;
        }
    }
 
    private PolymorphicType(Type type, string name)
    {
        m_type_name = name;
        m_base = type;
    }
 
    public string PolymorphicName
    {
        get
        {
            return m_type_name;
        }
    }
 
    public Type OriginalType
    {
        get
        {
            return m_base;
        }
    }
            
    
    //implementations of abstract methods and properties from base class
    public override string Name
    {
        get
        {
            return m_base.Name;
        }
    }
    
    public override Assembly Assembly
    {
        get
        {
            return m_base.Assembly;
        }
    }
 
    public override string AssemblyQualifiedName
    {
        get
        {
            return m_base.AssemblyQualifiedName;
        }
    }
 
    public override Type BaseType
    {
        get
        {
            return m_base.BaseType;
        }
    }
    
    public override string FullName
    {
        get
        {
            return m_base.FullName;
        }
    }
 
    public override Guid GUID
    {
        get
        {
            return m_base.GUID;
        }
    }
 
    public override Module Module
    {
        get
        {
            return m_base.Module;
        }
    }
 
    public override string Namespace
    {
        get
        {
            return m_base.Namespace;
        }
    }
 
    public override RuntimeTypeHandle TypeHandle
    {
        get
        {
            return m_base.TypeHandle;
        }
    }
 
    public override Type UnderlyingSystemType
    {
        get
        {
            return m_base.UnderlyingSystemType;
        }
    }
 
    public override Type DeclaringType
    {
        get
        {
            return m_base.DeclaringType;
        }
    }
 
    public override  object[] GetCustomAttributes(
        bool inherit)
    {
        return m_base.GetCustomAttributes(inherit);
    }
 
    public override object[] GetCustomAttributes(
        Type attributeType,
        bool inherit)
    {
        return m_base.GetCustomAttributes(attributeType, inherit);        
    }
 
    public override bool IsDefined(
        Type attributeType,
        bool inherit)
    {
        return IsDefined(attributeType, inherit);
    }
 
    protected override TypeAttributes GetAttributeFlagsImpl()
    {
        return m_base.Attributes;
    }
 
    protected override ConstructorInfo GetConstructorImpl(
        BindingFlags bindingAttr,
        Binder binder,
        CallingConventions callConvention,
        Type[] types,
        ParameterModifier[] modifiers)
    {
        return m_base.GetConstructor(
            bindingAttr, binder, callConvention, types, modifiers);
    }
 
    public override ConstructorInfo[] GetConstructors(
        BindingFlags bindingAttr)
    {
        return m_base.GetConstructors(bindingAttr);
    }
 
    public override Type GetElementType()
    {
        return m_base.GetElementType();
    }
 
    public override EventInfo GetEvent(
        string name,
        BindingFlags bindingAttr)
    {
        return m_base.GetEvent(name, bindingAttr);
    }
 
    public override EventInfo[] GetEvents(
        BindingFlags bindingAttr)
    {
        return m_base.GetEvents(bindingAttr);
    }
 
    public override FieldInfo GetField(
        string name,
        BindingFlags bindingAttr)
    {
        return m_base.GetField(name, bindingAttr);
    }
 
    public override FieldInfo[] GetFields(
        BindingFlags bindingAttr)
    {
        return m_base.GetFields(bindingAttr);
    }
 
    public override Type GetInterface(
        string name, bool ignoreCase)
    {
        return m_base.GetInterface(name, ignoreCase);
    }
 
    public override Type[] GetInterfaces()
    {
        return m_base.GetInterfaces();
    }
 
    public override MemberInfo[] GetMembers(
        BindingFlags bindingAttr)
    {
        return m_base.GetMembers(bindingAttr);
    }
 
    protected override MethodInfo GetMethodImpl(
        string name,
        BindingFlags bindingAttr,
        Binder binder,
        CallingConventions callConvention,
        Type[] types,
        ParameterModifier[] modifiers)
    {
        return m_base.GetMethod(
            name, bindingAttr, binder, callConvention, types, modifiers);
    }
 
    public override MethodInfo[] GetMethods(
        BindingFlags bindingAttr)
    {
        return m_base.GetMethods(bindingAttr);
    }
 
    public override Type GetNestedType(
        string name, BindingFlags bindingAttr)
    {
        return m_base.GetNestedType(name, bindingAttr);
    }
 
    public override Type[] GetNestedTypes(
        BindingFlags bindingAttr)
    {
        return m_base.GetNestedTypes(bindingAttr);
    }
 
    public override PropertyInfo[] GetProperties(
        BindingFlags bindingAttr)
    {
        return m_base.GetProperties(bindingAttr);
    }
 
    protected override PropertyInfo GetPropertyImpl(
        string name,
        BindingFlags bindingAttr,
        Binder binder,
        Type returnType,
        Type[] types,
        ParameterModifier[] modifiers)
    {
        return m_base.GetProperty(
            name, bindingAttr, binder, returnType, types, modifiers);
    }
 
    protected override  bool HasElementTypeImpl()
    {
        return m_base.HasElementType;
    }
 
    public override object InvokeMember(
        string name,
        BindingFlags invokeAttr,
        Binder binder,
        object target,
        object[] args,
        ParameterModifier[] modifiers,
        CultureInfo culture,
        string[] namedParameters)
    {
        return m_base.InvokeMember(
            name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
    }
 
    protected override bool IsArrayImpl()
    {
        return m_base.IsArray;
    }
 
    protected override bool IsByRefImpl()
    {
        return m_base.IsByRef;
    }
 
    protected override bool IsCOMObjectImpl()
    {
        return m_base.IsCOMObject;
    }
 
    protected override bool IsPointerImpl()
    {
        return m_base.IsPointer;
    }
 
    protected override bool IsPrimitiveImpl()
    {
        return m_base.IsPrimitive;
    }
}
}