File: UI\PropertyMapper.cs
Project: ndp\fx\src\xsp\system\Web\System.Web.csproj (System.Web)
//------------------------------------------------------------------------------
// <copyright file="PropertyMapper.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
 
/*
 * PropertyMapper.cs
 *
 * Copyright (c) 1999 Microsoft Corporation
 */
 
namespace System.Web.UI {
    using System;
    using System.Collections;
    using System.Reflection;
    using System.Web.Util;
    using System.ComponentModel;
 
    internal sealed class PropertyMapper {
        private const char PERSIST_CHAR = '-';
        private const char OM_CHAR = '.';
        private const string STR_OM_CHAR = ".";
 
 
        /*
         * Maps persisted attribute names to the object model equivalents.
         * This class should not be instantiated by itself.
         */
        private PropertyMapper() {
        }
 
        /*
         * Returns the PropertyInfo or FieldInfo corresponding to the
         * specified property name.
         */
        internal static MemberInfo GetMemberInfo(Type ctrlType, string name, out string nameForCodeGen) {
 
            Type currentType = ctrlType;
            PropertyInfo propInfo = null;
            FieldInfo fieldInfo = null;
 
            string mappedName = MapNameToPropertyName(name);
            nameForCodeGen = null;
 
            int startIndex = 0;
            while (startIndex < mappedName.Length) {   // parse thru dots of object model to locate PropertyInfo
                string propName;
                int index = mappedName.IndexOf(OM_CHAR, startIndex);
 
                if (index < 0) {
                    propName = mappedName.Substring(startIndex);
                    startIndex = mappedName.Length;
                }
                else {
                    propName = mappedName.Substring(startIndex, index - startIndex);
                    startIndex = index + 1;
                }
 
                BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase;
 
                // 
 
 
 
                try {
                    propInfo = TargetFrameworkUtil.GetProperty(currentType, propName, flags);
                }
                catch (AmbiguousMatchException) {
                    flags |= BindingFlags.DeclaredOnly;
                    propInfo = TargetFrameworkUtil.GetProperty(currentType, propName, flags);
                }
 
                if (propInfo == null) {   // could not find a public property, look for a public field
                    fieldInfo = TargetFrameworkUtil.GetField(currentType, propName, flags);
                    if (fieldInfo == null) {
                        nameForCodeGen = null;
                        break;
                    }
                }
 
                propName = null;
                if (propInfo != null) {   // found a public property
                    currentType = propInfo.PropertyType;
                    propName = propInfo.Name;
                }
                else {   // found a public field
                    currentType = fieldInfo.FieldType;
                    propName = fieldInfo.Name;
                }
 
                // Throw if the type of not CLS-compliant (ASURT 83438)
                if (!IsTypeCLSCompliant(currentType)) {
                    throw new HttpException(SR.GetString(SR.Property_Not_ClsCompliant, name, ctrlType.FullName, currentType.FullName));
                }
 
                if (propName != null) {
                    if (nameForCodeGen == null)
                        nameForCodeGen = propName;
                    else
                        nameForCodeGen += STR_OM_CHAR + propName;
                }
            }
 
            if (propInfo != null)
                return propInfo;
            else
                return fieldInfo;
        }
 
        private static bool IsTypeCLSCompliant(Type type) {
 
            // We used to check this by looking up the CLSCompliantAttribute, but that was
            // way too inefficent.  So instead, we just juck for a few specific types
            if ((type == typeof(SByte)) ||
                (type == typeof(TypedReference)) ||
                (type == typeof(UInt16)) ||
                (type == typeof(UInt32)) ||
                (type == typeof(UInt64)) ||
                (type == typeof(UIntPtr))) {
                return false;
            }
 
            return true;
        }
 
        /*
         * Maps the specified persisted name to its object model equivalent.
         * The convention is to map all dashes to dots.
         * For example :  Font-Size maps to Font.Size
         *                HeaderStyle-Font-Name maps to HeaderStyle.Font.Name
         */
        internal static string MapNameToPropertyName(string attrName) {
            return attrName.Replace(PERSIST_CHAR,OM_CHAR);
        }
 
        internal static object LocatePropertyObject(object obj, string mappedName, out string propertyName, bool inDesigner) {
            object currentObject = obj;
            Type currentType = obj.GetType();
            propertyName = null;
            int index;
            int startIndex = 0;
 
            // step through the dots of the object model to extract the PropertyInfo
            // and object on which the property will be set
            while (startIndex < mappedName.Length) {
                index = mappedName.IndexOf(OM_CHAR, startIndex);
 
                // If we didn't find a separator, we're on the last piece
                if (index < 0)
                    break;
 
                // There is a sub property, so get its info and iterate
 
                propertyName = mappedName.Substring(startIndex, index - startIndex);
                startIndex = index + 1;
 
                currentObject = FastPropertyAccessor.GetProperty(currentObject, propertyName, inDesigner);
 
                if (currentObject == null)
                    return null;
            }
 
            // Avoid a useless call to Substring if possible
            if (startIndex > 0)
                propertyName = mappedName.Substring(startIndex);
            else
                propertyName = mappedName;
 
            return currentObject;
        }
 
        /*
         * Walks the object model using the mapped property name to get the
         * value of an instance's property.
         */
        internal static PropertyDescriptor GetMappedPropertyDescriptor(object obj, string mappedName, out object childObject, out string propertyName, bool inDesigner)
        {
            childObject = LocatePropertyObject(obj, mappedName, out propertyName, inDesigner);
            if (childObject == null) return null;
            PropertyDescriptorCollection properties = TargetFrameworkUtil.GetProperties(childObject);
            return properties[propertyName];
        }
 
 
        /*
         * Walks the object model using the mapped property name to set the
         * value of an instance's property.
         */
        internal static void SetMappedPropertyValue(object obj, string mappedName, object value, bool inDesigner) {
            string propertyName;
            object childObj = LocatePropertyObject(obj, mappedName, out propertyName, inDesigner);
            if (childObj == null) return;
            FastPropertyAccessor.SetProperty(childObj, propertyName, value, inDesigner);
        }
 
    }
}