Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Services/System/Web/Services/Protocols/PatternMatcher.cs

@@ -0,0 +1,204 @@
+namespace System.Web.Services.Protocols {
+    using System;
+    using System.Reflection;
+    using System.Collections;
+    using System.Text.RegularExpressions;
+    using System.Security.Permissions;
+
+    /// <include file='doc\PatternMatcher.uex' path='docs/doc[@for="PatternMatcher"]/*' />
+    /// <devdoc>
+    ///    <para>[To be supplied.]</para>
+    /// </devdoc>
+    [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
+    public sealed class PatternMatcher {
+        MatchType matchType;
+
+        /// <include file='doc\PatternMatcher.uex' path='docs/doc[@for="PatternMatcher.PatternMatcher"]/*' />
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public PatternMatcher(Type type) {
+            matchType = MatchType.Reflect(type);
+        }
+
+        /// <include file='doc\PatternMatcher.uex' path='docs/doc[@for="PatternMatcher.Match"]/*' />
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public object Match(string text) {
+            return matchType.Match(text);
+        }
+    }
+
+    internal class MatchType {
+        Type type;
+        MatchMember[] fields;
+
+        internal Type Type {
+            get { return type; }
+        }
+
+        internal static MatchType Reflect(Type type) {
+            MatchType matchType = new MatchType();
+            matchType.type = type;
+
+            MemberInfo[] memberInfos = type.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
+            ArrayList list = new ArrayList();
+            for (int i = 0; i < memberInfos.Length; i++) {
+                MatchMember member = MatchMember.Reflect(memberInfos[i]);
+                if (member != null) list.Add(member);
+            }
+            matchType.fields = (MatchMember[])list.ToArray(typeof(MatchMember));
+            return matchType;
+        }
+
+        internal object Match(string text) {
+            object target = Activator.CreateInstance(type);
+            for (int i = 0; i < fields.Length; i++)
+                fields[i].Match(target, text);
+            return target;
+        }
+    }
+
+    internal class MatchMember {
+        MemberInfo memberInfo;
+        Regex regex;
+        int group;
+        int capture;
+        int maxRepeats;
+        MatchType matchType;
+
+        internal void Match(object target, string text) {
+            if (memberInfo is FieldInfo)
+                ((FieldInfo)memberInfo).SetValue(target, matchType == null ? MatchString(text) : MatchClass(text));
+            else if (memberInfo is PropertyInfo) {
+                ((PropertyInfo)memberInfo).SetValue(target, matchType == null ? MatchString(text) : MatchClass(text), new object[0]);
+            }
+        }
+
+        object MatchString(string text) {
+            Match m = regex.Match(text);
+            Type fieldType = memberInfo is FieldInfo ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType;
+            if (fieldType.IsArray) {
+                ArrayList matches = new ArrayList();
+                int matchCount = 0;
+                while (m.Success && matchCount < maxRepeats) {
+                    if (m.Groups.Count <= group) 
+                        throw BadGroupIndexException(group, memberInfo.Name, m.Groups.Count - 1);
+                    Group g = m.Groups[group];
+                    foreach (Capture c in g.Captures) {
+                        matches.Add(text.Substring(c.Index, c.Length));
+                    }
+                    m = m.NextMatch();
+                    matchCount++;
+                }
+                return matches.ToArray(typeof(string));
+            }
+            else {
+                if (m.Success) {
+                    if (m.Groups.Count <= group) 
+                        throw BadGroupIndexException(group, memberInfo.Name, m.Groups.Count - 1);
+                    Group g = m.Groups[group];
+                    if (g.Captures.Count > 0) {
+                        if (g.Captures.Count <= capture) 
+                            throw BadCaptureIndexException(capture, memberInfo.Name, g.Captures.Count - 1);
+                        Capture c = g.Captures[capture];
+                        return text.Substring(c.Index, c.Length);
+                    }
+                }
+                return null;
+            }
+        }
+
+        object MatchClass(string text) {
+            Match m = regex.Match(text);
+            Type fieldType = memberInfo is FieldInfo ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType;
+            if (fieldType.IsArray) {
+                ArrayList matches = new ArrayList();
+                int matchCount = 0;
+                while (m.Success && matchCount < maxRepeats) {
+                    if (m.Groups.Count <= group) 
+                        throw BadGroupIndexException(group, memberInfo.Name, m.Groups.Count - 1);
+                    Group g = m.Groups[group];
+                    foreach (Capture c in g.Captures) {
+                        matches.Add(matchType.Match(text.Substring(c.Index, c.Length)));
+                    }
+                    m = m.NextMatch();
+                    matchCount++;
+                }
+                return matches.ToArray(matchType.Type);
+            }
+            else {
+                if (m.Success) {
+                    if (m.Groups.Count <= group) 
+                        throw BadGroupIndexException(group, memberInfo.Name, m.Groups.Count - 1);
+                    Group g = m.Groups[group];
+                    if (g.Captures.Count > 0) {
+                        if (g.Captures.Count <= capture) 
+                            throw BadCaptureIndexException(capture, memberInfo.Name, g.Captures.Count - 1);
+                        Capture c = g.Captures[capture];
+                        return matchType.Match(text.Substring(c.Index, c.Length));
+                    }
+                }
+                return null;
+            }
+        }
+
+        static Exception BadCaptureIndexException(int index, string matchName, int highestIndex) {
+            return new Exception(Res.GetString(Res.WebTextMatchBadCaptureIndex, index, matchName, highestIndex));
+        }
+
+        static Exception BadGroupIndexException(int index, string matchName, int highestIndex) {
+            return new Exception(Res.GetString(Res.WebTextMatchBadGroupIndex, index, matchName, highestIndex));
+        }
+
+        internal static MatchMember Reflect(MemberInfo memberInfo) {
+            Type memberType = null;
+            if (memberInfo is PropertyInfo) {
+                PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
+                if (!propertyInfo.CanRead)
+                    return null;
+                // 
+                if (!propertyInfo.CanWrite)
+                    return null;
+                
+                MethodInfo getMethod = propertyInfo.GetGetMethod();
+                if (getMethod.IsStatic) 
+                    return null;
+                ParameterInfo[] parameters = getMethod.GetParameters();
+                if (parameters.Length > 0) 
+                    return null;
+                memberType = propertyInfo.PropertyType;
+            }
+            if (memberInfo is FieldInfo) {
+                FieldInfo fieldInfo = (FieldInfo)memberInfo;
+                if (!fieldInfo.IsPublic) 
+                    return null;
+                if (fieldInfo.IsStatic)
+                    return null;
+                if (fieldInfo.IsSpecialName) 
+                    return null;
+                memberType = fieldInfo.FieldType;
+            }
+            object[] attrs = memberInfo.GetCustomAttributes(typeof(MatchAttribute), false);
+            if (attrs.Length == 0) return null;
+            MatchAttribute attr = (MatchAttribute)attrs[0];
+            MatchMember member = new MatchMember();
+            member.regex = new Regex(attr.Pattern, RegexOptions.Singleline | (attr.IgnoreCase ? RegexOptions.IgnoreCase | RegexOptions.CultureInvariant : 0));
+            member.group = attr.Group;
+            member.capture = attr.Capture;
+            member.maxRepeats = attr.MaxRepeats;
+            member.memberInfo = memberInfo;
+            
+            if (member.maxRepeats < 0) // unspecified
+                member.maxRepeats = memberType.IsArray ? int.MaxValue : 1;
+            if (memberType.IsArray) {
+                memberType = memberType.GetElementType();
+            }
+            if (memberType != typeof(string)) {
+                member.matchType = MatchType.Reflect(memberType);
+            }
+            return member;
+        }
+    }
+}