public virtual Type[] FindInterfaces(TypeFilter filter, object filterCriteria)
 {
     if (filter == null)
     {
         throw new ArgumentNullException("filter");
     }
     Type[] interfaces = this.GetInterfaces();
     int num = 0;
     for (int i = 0; i < interfaces.Length; i++)
     {
         if (!filter(interfaces[i], filterCriteria))
         {
             interfaces[i] = null;
         }
         else
         {
             num++;
         }
     }
     if (num == interfaces.Length)
     {
         return interfaces;
     }
     Type[] typeArray2 = new Type[num];
     num = 0;
     for (int j = 0; j < interfaces.Length; j++)
     {
         if (interfaces[j] != null)
         {
             typeArray2[num++] = interfaces[j];
         }
     }
     return typeArray2;
 }

        public static string ContactPageIdentifier(this HtmlHelper helper)
        {
            var filter = new TypeFilter(typeof(ContactFormPage));
            var page = Find.StartPage.GetChildren(filter).FirstOrDefault();

            return page != null ? page.Name : string.Empty;
        }

		public void CanFilterTwoItemsWithFilterInstance()
		{
			ItemFilter filter = new TypeFilter(typeof(FirstItem));
			ItemList list = CreateList();
			filter.Filter(list);
			Assert.AreEqual(1, list.Count);
		}

 static Module()
 {
     __Filters _fltObj;
     _fltObj = new __Filters();
     FilterTypeName = new TypeFilter(_fltObj.FilterTypeName);
     FilterTypeNameIgnoreCase = new TypeFilter(_fltObj.FilterTypeNameIgnoreCase);
 }        

 public virtual Type[] FindTypes(TypeFilter filter, object filterCriteria)
 {
     Type[] types = this.GetTypes();
     int num = 0;
     for (int i = 0; i < types.Length; i++)
     {
         if ((filter != null) && !filter(types[i], filterCriteria))
         {
             types[i] = null;
         }
         else
         {
             num++;
         }
     }
     if (num == types.Length)
     {
         return types;
     }
     Type[] typeArray2 = new Type[num];
     num = 0;
     for (int j = 0; j < types.Length; j++)
     {
         if (types[j] != null)
         {
             typeArray2[num++] = types[j];
         }
     }
     return typeArray2;
 }

        public static void Run()
        {
            //FirstMember
            TypeFilter filt = new TypeFilter(DbElementTypeInstance.NOZZLE);
            DbElement nozz1 = filt.FirstMember(Example.Instance.mEqui);
            DbElementType type = nozz1.GetElementType();

            //NextMember
            DbElement nozz2 = filt.Next(nozz1);

            //NextMember
            DbElement[] members = filt.Members(Example.Instance.mEqui);

            //parent
            TypeFilter filt2 = new TypeFilter(DbElementTypeInstance.SITE);
            DbElement site = filt2.Parent(nozz1);
            type = site.GetElementType();

            //Valid
            AndFilter andFilt4 = new AndFilter();
            andFilt4.Add(new TypeFilter(DbElementTypeInstance.EQUIPMENT));
            andFilt4.Add(new TrueFilter());
            bool valid = andFilt4.Valid(Example.Instance.mEqui);

            // attribute true
            AttributeTrueFilter filt1 = new AttributeTrueFilter(DbAttributeInstance.ISNAME);
            //should be true for named element
            bool named = filt1.Valid(Example.Instance.mEqui);
            //for first member it is also true
            named = filt1.Valid(Example.Instance.mEqui.FirstMember());

            //Element type at or below
            BelowOrAtType filt3 = new BelowOrAtType(DbElementTypeInstance.EQUIPMENT);
            bool below = filt3.ScanBelow(Example.Instance.mEqui);
        }

        public static void Run()
        {
            // Set up a navigator which looks at sites/pipes/Nozzles/Tee only
            TypeFilter filt = new TypeFilter();
            filt.Add(DbElementTypeInstance.SITE);
            filt.Add(DbElementTypeInstance.PIPE);
            filt.Add(DbElementTypeInstance.NOZZLE);
            filt.Add(DbElementTypeInstance.TEE);
            CompoundFilter filt2 = new CompoundFilter();
            filt2.AddShow(filt);
            ElementTreeNavigator navi = new ElementTreeNavigator(DbElement.GetElement("/*"), filt2);

            // Test FirstMember
            DbElement site = navi.FirstMemberInScan(Example.Instance.mWorld);
            DbElement nozz = navi.FirstMemberInScan(Example.Instance.mZone);
            nozz = navi.FirstMemberInScan(Example.Instance.mEqui);
            DbElement ele = navi.FirstMemberInScan(nozz);

            // Next
            DbElement zone = site.FirstMember();
            DbElement next = navi.NextInScan(zone);

            // parent
            DbElement parent = navi.Parent(Example.Instance.mEqui);
            parent = navi.Parent(nozz);
            parent = navi.Parent(parent);

            //All Members
            DbElement[] tees = navi.MembersInScan(Example.Instance.mPipe);
        }

        public static Type[] FindInterfaces(this Type type, TypeFilter filter, object filterCriteria)
        {
            if (filter == null)
            {
                throw new ArgumentNullException("filter");
            }

            var interfaces = type.GetInterfaces();
            var count = 0;
            for (var i = 0; i < interfaces.Length; i++)
            {
                if (!filter(interfaces[i], filterCriteria))
                {
                    interfaces[i] = null;
                }
                else
                {
                    count++;
                }
            }

            if (count == interfaces.Length)
            {
                return interfaces;
            }

            var array = new Type[count];
            count = 0;
            foreach (var t in interfaces.Where(t => t != null))
            {
                array[count++] = t;
            }

            return array;
        }

        public void PASS_Serialize()
        {
            TypeFilter filter = new TypeFilter("type");
            string json = JsonConvert.SerializeObject(filter);
            Assert.IsNotNull(json);

            string expectedJson = "{\"type\":{\"value\":\"type\"}}";
            Assert.AreEqual(expectedJson, json);
        }

 public RoleSet(Type _Class)
 {
     TypeFilter filter = new TypeFilter(RoleFilter);
     Type[] Roles = _Class.FindInterfaces(filter, (object)__RoleTypes);
     _Set = new HashSet<Type>();
     foreach (Type r in Roles) {
         _Set.Add(r);
     }
 }

        public override object ReadJson(JsonReader reader, System.Type objectType, object existingValue, JsonSerializer serializer)
        {
            Dictionary<string, object> fieldDict = serializer.Deserialize<Dictionary<string, object>>(reader);
            if (fieldDict.ContainsKey(FilterTypeEnum.Type.ToString()))
                fieldDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldDict.First().Value.ToString());

            TypeFilter filter = new TypeFilter(fieldDict.GetString(_TYPE));
            filter.FilterName = fieldDict.GetStringOrDefault(FilterSerializer._FILTER_NAME);

            return filter;
        }

 public void FAIL_CreateFilter()
 {
     try
     {
         TypeFilter filter = new TypeFilter(null);
         Assert.Fail();
     }
     catch (ArgumentNullException ex)
     {
         Assert.AreEqual("documentType", ex.ParamName);
     }
 }

        public static string RenderMainMenu(this HtmlHelper helper)
        {
            var builder = new StringBuilder();
            var formatString = "<li> <a href=\"#{0}\" class=\"jump {1}\">{2}</a>";

            var filter = new TypeFilter(typeof(AbstractPage));

            foreach (var child in Find.StartPage.GetChildren(filter))
            {
                builder.Append(string.Format(formatString, child.Name, child is ContactFormPage ? "contact-page" : string.Empty, child.Title));
            }
            return builder.ToString();
        }

        public static Type[] FindInterfaces(this Type myType, TypeFilter TypeFilter, Object FilterCriteria)
        {
            if (TypeFilter == null)
                throw new ArgumentNullException("filter");

            var Interfaces = new List<Type>();
            foreach (var Interface in myType.GetInterfaces())
            {
                if (TypeFilter(Interface, FilterCriteria))
                    Interfaces.Add(Interface);
            }

            return Interfaces.ToArray();
        }

		public static Type[] FindInterfaces(this Type type, TypeFilter filter, object filterCriteria)
		{
			if (filter == null)
				throw new ArgumentNullException("filter");

			List<Type> ifaces = new List<Type>();
			foreach (Type iface in type.GetInterfaces())
			{
				if (filter(iface, filterCriteria))
					ifaces.Add(iface);
			}

			return ifaces.ToArray();
		}

        public static string RenderPagesHtml(this HtmlHelper helper)
        {
            var builder = new StringBuilder();
            var formatString = "<div class=\"sub\" id=\"{0}\"><h1>{1}</h1>{2}</div>";

            var filter = new TypeFilter(typeof(ContentPage));
            foreach (ContentPage child in Find.StartPage.GetChildren(filter).OrderBy(x => x.SortOrder))
            {
                builder.Append(string.Format(formatString, child.Name, child.Title, child.Text));
            }

            filter = new TypeFilter(typeof(ContactFormPage));
            foreach (ContactFormPage child in Find.StartPage.GetChildren(filter))
            {
                builder.Append(string.Format(formatString, child.Name, child.Title, child.Text));
            }
            return builder.ToString();
        }

        internal static void InitLibs()
        {
            // load dumplib for reflection
            Assembly dumplib3 = Assembly.ReflectionOnlyLoadFrom("DumpLib.dll");

            Assembly dumplibasm  = Assembly.LoadFile(Path.Combine(Program.WorkDir, "DumpLib.dll"));
            // get a list of all the external assemblies and load them
            AssemblyName[] dumplib_refs = dumplibasm.GetReferencedAssemblies();
            for (int h = 0; h < dumplib_refs.Length; h++)
                Assembly.ReflectionOnlyLoad(dumplib_refs[h].FullName);

            var filter = new TypeFilter(InterfaceFilter);

            var j = dumplibasm.GetTypes();
            Type[] ifaces = null;
            foreach (var type in j)
            {
                ifaces = type.FindInterfaces(filter, "dumplib.Gfx.IColorConverter");
                if (ifaces.Length > 0)
                {
                    dumplib.Gfx.IColorConverter newinstance = (dumplib.Gfx.IColorConverter)Activator.CreateInstance(type);
                    Program.ColorConverters.Add(newinstance.ID, newinstance);
                }

                ifaces = type.FindInterfaces(filter, "dumplib.Gfx.ITileConverter");
                if (ifaces.Length > 0)
                {
                    dumplib.Gfx.ITileConverter newinstance = (dumplib.Gfx.ITileConverter)Activator.CreateInstance(type);
                    Program.TileConverters.Add(newinstance.ID, newinstance);
                }

                ifaces = type.FindInterfaces(filter, "dumplib.Gfx.IPaletteConverter");
                if (ifaces.Length > 0)
                {
                    dumplib.Gfx.IPaletteConverter newinstance = (dumplib.Gfx.IPaletteConverter)Activator.CreateInstance(type);
                    Program.PaletteConverters.Add(newinstance.ID, newinstance);
                }

                //if (type.BaseType != null && type.BaseType.FullName == "dumplib.Image.MediaImage") Program.MediaImages.Add((dumplib.Image.MediaImage)Activator.CreateInstance(type));
            }
            Console.WriteLine(ifaces.ToString());

            // load teh same from other DLLs
        }

        //Create and iterate through collections
        public static void Run()
        {
            //Scan Nozzles below equi
            TypeFilter filt = new TypeFilter(DbElementTypeInstance.NOZZLE);
            DBElementCollection collection = new DBElementCollection(Example.Instance.mEqui, filt);
            DbAttribute att = DbAttributeInstance.FLNN;
            foreach (DbElement ele in collection)
            {
                Console.WriteLine(ele.GetAsString(att));
            }

            //Scan branches below site
            DBElementCollection coll = new DBElementCollection(Example.Instance.mSite);
            coll.IncludeRoot = true;
            coll.Filter = new TypeFilter(DbElementTypeInstance.BRANCH);
            DBElementEnumerator iter = (DBElementEnumerator)coll.GetEnumerator();
            while (iter.MoveNext())
            {
                Console.WriteLine(iter.Current.ToString());
            }
        }

        public virtual Type[] FindTypes(TypeFilter filter, object filterCriteria)
        {
            Type[] c = GetTypes();
            int cnt = 0;
            for (int i = 0; i < c.Length; i++)
            {
                if (filter != null && !filter(c[i], filterCriteria))
                    c[i] = null;
                else
                    cnt++;
            }
            if (cnt == c.Length)
                return c;

            Type[] ret = new Type[cnt];
            cnt = 0;
            for (int i = 0; i < c.Length; i++)
            {
                if (c[i] != null)
                    ret[cnt++] = c[i];
            }
            return ret;
        }

		public Type[] FindInterfaces(TypeFilter filter, object filterCriteria)
		{
			List<Type> list = new List<Type>();
			foreach (Type type in GetInterfaces())
			{
				if (filter(type, filterCriteria))
				{
					list.Add(type);
				}
			}
			return list.ToArray();
		}