← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ExtensionMethods.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ExtensionMethods.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections;
 
6
using System.Collections.Generic;
 
7
using System.Linq;
 
8
 
 
9
namespace ICSharpCode.SharpDevelop.Dom
 
10
{
 
11
        static class ExtensionMethods
 
12
        {
 
13
                public static void AddRange(this ArrayList arrayList, IEnumerable elements)
 
14
                {
 
15
                        foreach (object o in elements)
 
16
                                arrayList.Add(o);
 
17
                }
 
18
                
 
19
                public static void AddRange<T>(this ICollection<T> list, IEnumerable<T> elements)
 
20
                {
 
21
                        foreach (T o in elements)
 
22
                                list.Add(o);
 
23
                }
 
24
                
 
25
                /// <summary>
 
26
                /// Converts a recursive data structure into a flat list.
 
27
                /// </summary>
 
28
                /// <param name="input">The root elements of the recursive data structure.</param>
 
29
                /// <param name="recursive">The function that gets the children of an element.</param>
 
30
                /// <returns>Iterator that enumerates the tree structure in preorder.</returns>
 
31
                public static IEnumerable<T> Flatten<T>(this IEnumerable<T> input, Func<T, IEnumerable<T>> recursion)
 
32
                {
 
33
                        Stack<IEnumerator<T>> stack = new Stack<IEnumerator<T>>();
 
34
                        try {
 
35
                                stack.Push(input.GetEnumerator());
 
36
                                while (stack.Count > 0) {
 
37
                                        while (stack.Peek().MoveNext()) {
 
38
                                                T element = stack.Peek().Current;
 
39
                                                yield return element;
 
40
                                                IEnumerable<T> children = recursion(element);
 
41
                                                if (children != null) {
 
42
                                                        stack.Push(children.GetEnumerator());
 
43
                                                }
 
44
                                        }
 
45
                                        stack.Pop().Dispose();
 
46
                                }
 
47
                        } finally {
 
48
                                while (stack.Count > 0) {
 
49
                                        stack.Pop().Dispose();
 
50
                                }
 
51
                        }
 
52
                }
 
53
                
 
54
                public static IEnumerable<IUsing> GetAllUsings(this ICompilationUnit cu)
 
55
                {
 
56
                        return (new[]{cu.UsingScope}).Flatten(s=>s.ChildScopes).SelectMany(s=>s.Usings);
 
57
                }
 
58
        }
 
59
        
 
60
        /// <summary>
 
61
        /// Publicly visible helper methods.
 
62
        /// </summary>
 
63
        public static class ExtensionMethodsPublic
 
64
        {
 
65
                // the difference between IClass and IReturnType is that IClass only contains the members
 
66
                // that are declared in this very class,
 
67
                // and IReturnType contains also members from base classes (including System.Object) and default (undeclared) constructors
 
68
                
 
69
                static SignatureComparer memberSignatureComparer = new SignatureComparer();
 
70
                
 
71
                public static bool HasMember(this IClass containingClass, IMember member)
 
72
                {
 
73
                        return containingClass.AllMembers.Any(m => memberSignatureComparer.Equals(member, m));
 
74
                }
 
75
                
 
76
                public static bool HasMember(this IReturnType containingClass, IMember member)
 
77
                {
 
78
                        return containingClass.GetMembers().Any(m => memberSignatureComparer.Equals(member, m));
 
79
                }
 
80
                
 
81
                public static bool ImplementsInterface(this IClass targetClass, IClass requiredInterface)
 
82
                {
 
83
                        var targetClassType = targetClass.GetCompoundClass().DefaultReturnType;
 
84
                        var requiredInterfaceType = requiredInterface.GetCompoundClass().DefaultReturnType;
 
85
                        // class.DefaultReturnType.GetMethods() returns also methods from base classes, default ctor, ToString() etc. etc.
 
86
                        return !requiredInterfaceType.GetMembers().Any(missingMember => !targetClassType.HasMember(missingMember));
 
87
                }
 
88
                
 
89
                public static bool ImplementsAbstractClass(this IClass targetClass, IClass abstractClass)
 
90
                {
 
91
                        var requiredAbstractMembers = MemberLookupHelper.GetAccessibleMembers(abstractClass.DefaultReturnType, targetClass, LanguageProperties.CSharp, true).Where(m => m.IsAbstract);
 
92
                        return !requiredAbstractMembers.Any(missingMember => !targetClass.HasMember(missingMember));
 
93
                }
 
94
                
 
95
                public static IEnumerable<IMember> GetMembers(this IReturnType typeReference)
 
96
                {
 
97
                        var properties = typeReference.GetProperties().Cast<IMember>();
 
98
                        var methods = typeReference.GetMethods().Cast<IMember>();
 
99
                        var fields = typeReference.GetFields().Cast<IMember>();
 
100
                        var events = typeReference.GetEvents().Cast<IMember>();
 
101
                        return properties.Concat(methods).Concat(fields).Concat(events);
 
102
                }
 
103
        }
 
104
}