Example #1
0
 //: base(types, filter)
 /// <summary>
 /// Initializes all the components of the explorer.
 /// </summary>
 /// <param name="userParams"></param>
 public RandomExplorer(Collection<Type> types, IReflectionFilter filter, bool exceptionLearning,
     int randomSeed, int arrayMaxSize, StatsManager stats, ActionSet actions)
 {
     this.actions = actions;
     this.filter = filter;
     this.arrayMaxSize = arrayMaxSize;
     this.stats = stats;
 }
Example #2
0
 /// <summary>
 /// Initializes all the components of the explorer.
 /// </summary>
 /// <param name="userParams"></param>
 public RandomExplorer(Collection <Type> types, IReflectionFilter filter, bool exceptionLearning,
                       int randomSeed, int arrayMaxSize, StatsManager stats, ActionSet actions)
 //: base(types, filter)
 {
     this.actions      = actions;
     this.filter       = filter;
     this.arrayMaxSize = arrayMaxSize;
     this.stats        = stats;
 }
Example #3
0
 public void Add(IReflectionFilter f)
 {
     filters.Add(f);
 }
Example #4
0
        public void Add(IReflectionFilter f)
        {
            filters.Add(f);

        }
Example #5
0
        /// <summary>
        /// Populates fields based on input types and filters
        /// Performs dependency analysis on types
        /// </summary>
        /// <param name="allTypes"></param>
        /// <param name="filter"></param>
        public ActionSet(Collection <Type> allTypes, IReflectionFilter filter)
        {
            types.AddRange(allTypes);

            //print # of classes
            Console.Write("{0} classes.", allTypes.Count);
            foreach (Type t in allTypes)
            {
                //Logger.Debug("Processing type {0}", t.ToString());

                List <FieldInfo> fieldInfoDictList;
                fields.TryGetValue(t, out fieldInfoDictList);
                if (fieldInfoDictList == null)
                {
                    fields[t] = fieldInfoDictList = new List <FieldInfo>();
                }

                List <ConstructorInfo> constructorDictList;
                constructors.TryGetValue(t, out constructorDictList);
                if (constructorDictList == null)
                {
                    constructors[t] = constructorDictList = new List <ConstructorInfo>();
                }

                List <MethodInfo> methodDictList;
                methods.TryGetValue(t, out methodDictList);
                if (methodDictList == null)
                {
                    methods[t] = methodDictList = new List <MethodInfo>();
                }

                {
                    string message;
                    if (!filter.OkToUse(t, out message))
                    {
                        //Logger.Debug(message);
                        continue;
                    }
                    //Logger.Debug(message);
                }

                foreach (FieldInfo fi in t.GetFields())
                {
                    string message;
                    if (!filter.OkToUse(fi.DeclaringType, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(fi, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    //Logger.Debug(message);

                    FieldInfo info = fi;

                    fieldInfoDictList.Add(info);
                    fieldList.Add(info);
                }

                foreach (ConstructorInfo ci in t.GetConstructors())
                {
                    string message;
                    if (!filter.OkToUse(ci.DeclaringType, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(ci, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    //Logger.Debug(message);

                    ConstructorInfo info = ci;

                    constructorDictList.Add(info);

                    constructorsList.Add(info);
                }


                foreach (MethodInfo mi in t.GetMethods())
                {
                    MethodInfo info = mi;

                    string message;
                    if (!filter.OkToUse(mi.DeclaringType, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(mi, out message))
                    {
                        //Logger.Debug("\t" + message);
                        continue;
                    }

                    //Logger.Debug(message);

                    methodDictList.Add(info);

                    methodsList.Add(info);
                }
            }

            Collection <MemberInfo> methodsAndConstructorsAsList = new Collection <MemberInfo>();

            foreach (Type t in types)
            {
                foreach (MethodInfo m in this.methods[t])
                {
                    methodsAndConstructorsAsList.Add(m);
                }
                foreach (ConstructorInfo c in this.constructors[t])
                {
                    methodsAndConstructorsAsList.Add(c);
                }
            }
            methodsAndConstructorsArray = new MemberInfo[methodsAndConstructorsAsList.Count];
            for (int i = 0; i < methodsAndConstructorsAsList.Count; i++)
            {
                methodsAndConstructorsArray[i] = methodsAndConstructorsAsList[i];
            }

            foreach (MethodInfo m in methodsList)
            {
                roundRobinList.Add(m);
            }
            foreach (ConstructorInfo c in constructorsList)
            {
                roundRobinList.Add(c);
            }

            if (methodsAndConstructorsArray.Length == 0)
            {
                throw new EmpytActionSetException();
            }

            Console.Write(" {0} members.", methodsAndConstructorsArray.Length);
        }
Example #6
0
        /// <summary>
        /// Populates fields based on input types and filters
        /// Performs dependency analysis on types
        /// </summary>
        /// <param name="allTypes"></param>
        /// <param name="filter"></param>
        public ActionSet(Collection<Type> allTypes, IReflectionFilter filter)
        {        
            types.AddRange(allTypes);            

            //print # of classes
            Console.Write("{0} classes.", allTypes.Count);
            foreach (Type t in allTypes)
            {
                //Console.WriteLine("Processing type {0}", t.ToString());

                List<FieldInfo> fieldInfoDictList;
                fields.TryGetValue(t, out fieldInfoDictList);
                if (fieldInfoDictList == null)
                    fields[t] = fieldInfoDictList = new List<FieldInfo>();

                List<ConstructorInfo> constructorDictList;
                constructors.TryGetValue(t, out constructorDictList);
                if (constructorDictList == null)
                    constructors[t] = constructorDictList = new List<ConstructorInfo>();

                List<MethodInfo> methodDictList;
                methods.TryGetValue(t, out methodDictList);
                if (methodDictList == null)
                    methods[t] = methodDictList = new List<MethodInfo>();

                {
                    string message;
                    if (!filter.OkToUse(t, out message))
                    {
                        //Console.WriteLine(message);
                        continue;
                    }
                    //Console.WriteLine(message);
                }

                foreach (FieldInfo fi in t.GetFields())
                {
                    string message;
                    if (!filter.OkToUse(fi.DeclaringType, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(fi, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    //Console.WriteLine(message);

                    FieldInfo info = fi;

                    fieldInfoDictList.Add(info);
                    fieldList.Add(info);


                }

                foreach (ConstructorInfo ci in t.GetConstructors())
                {
                    string message;
                    if (!filter.OkToUse(ci.DeclaringType, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(ci, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    //Console.WriteLine(message);

                    ConstructorInfo info = ci;

                    constructorDictList.Add(info);

                    constructorsList.Add(info);
                }

                                             
                foreach (MethodInfo mi in t.GetMethods())
                {
                    MethodInfo info = mi;                                    

                    string message;
                    if (!filter.OkToUse(mi.DeclaringType, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    if (!filter.OkToUse(mi, out message))
                    {
                        //Console.WriteLine("\t" + message);
                        continue;
                    }

                    //Console.WriteLine(message);

                    methodDictList.Add(info);

                    methodsList.Add(info);

                    
                }
            }

            Collection<MemberInfo> methodsAndConstructorsAsList = new Collection<MemberInfo>();
            foreach (Type t in types)
            {
                foreach (MethodInfo m in this.methods[t])
                    methodsAndConstructorsAsList.Add(m);
                foreach (ConstructorInfo c in this.constructors[t])
                    methodsAndConstructorsAsList.Add(c);
            }
            methodsAndConstructorsArray = new MemberInfo[methodsAndConstructorsAsList.Count];
            for (int i = 0; i < methodsAndConstructorsAsList.Count; i++)
                methodsAndConstructorsArray[i] = methodsAndConstructorsAsList[i];

            foreach (MethodInfo m in methodsList)
                roundRobinList.Add(m);
            foreach (ConstructorInfo c in constructorsList)
                roundRobinList.Add(c);

            if (methodsAndConstructorsArray.Length == 0)
            {
                throw new EmpytActionSetException();
            }

            Console.Write(" {0} members.", methodsAndConstructorsArray.Length);
        }