public int CompareTo(object obj) { EnumSort other = obj as EnumSort; int result = this.name.CompareTo(other.name); return(result); }
public IEnumerable <int?> ExecuteRecursiveSlow(IEnumerable <int?> list, EnumSort sort) { if (list.Count() <= 1) { return(list); } int?pivot = list.First(); IEnumerable <int?> less; IEnumerable <int?> greater; if (sort == EnumSort.Asc) { less = list.Skip(1).Where(i => i <= pivot); greater = list.Skip(1).Where(i => i > pivot); } else { less = list.Skip(1).Where(i => i > pivot); greater = list.Skip(1).Where(i => i <= pivot); } return(ExecuteRecursiveSlow(less, sort). Union(new List <int?> { pivot }). Union(ExecuteRecursiveSlow(greater, sort))); }
internal Model(Context context, Solver solver) { Context = context; Solver = solver; _enumType = context.MkEnumSort("types", "str", "int"); }
// GET: backend/Admin public ActionResult Index(int?page, string q, string column = "Date", EnumSort order = EnumSort.Ascending) { //分頁套件: Install-Package PagedList.Mvc var pageIndex = page.HasValue ? page.Value < 1 ? 1 : page.Value : 1; var pageSize = 10; //為了範例最簡化,因此直接在 Controller 操作 DB ,實務上請盡量避免 var source = _AccountBookSvc.Lookup().AsQueryable();//_dbContext.AccountBook.AsQueryable(); if (string.IsNullOrWhiteSpace(q) == false) { // 只是單純示範搜尋條件應該如何累加 var category = Convert.ToInt32(q); source = source.Where(d => d.Category == category); } var result = new QueryOption <AccountBook.Models.AccountBook> { Order = order, Column = column, Page = pageIndex, PageSize = pageSize, Keyword = q }; //利用 SetSource 將資料塞入(塞進去之前不能將資料讀出來) result.SetSource(source); ViewData.Model = result; return(View()); //return View(_AccountBookSvc.Lookup()); }
public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" }, { "MODEL", "true" } }; using (Context ctx = new Context(cfg)) { EnumSort color = ctx.MkEnumSort("Color", new string[] { "red", "green", "blue" }); Expr red = color.Consts[0]; Expr green = color.Consts[1]; Expr blue = color.Consts[2]; Console.WriteLine(ctx.MkEq(green, blue)); Console.WriteLine(ctx.MkEq(green, blue).Simplify()); Expr c = ctx.MkConst("c", color); Solver s = ctx.MkSolver(); s.Assert(ctx.MkNot(ctx.MkEq(c, green))); s.Assert(ctx.MkNot(ctx.MkEq(c, blue))); Console.WriteLine(s.Check()); Console.WriteLine(s.Model); } }
private Expr VisitConstant(ConstantExpression constant, Type enumType = null, MemberInfo stringMemberInfo = null) { if (enumType != null) { var enumValueName = Enum.GetName(enumType, constant.Value); EnumSort enumSort = (EnumSort)_environment.Types[enumType]; return(enumSort.Consts.Single(c => c.FuncDecl.Name.ToString() == enumValueName)); } if (stringMemberInfo != null) { EnumSort enumSort = (EnumSort)_environment.PossibleStringValues; return(enumSort.Consts.Single(c => c.FuncDecl.Name.ToString().Equals(constant.Value))); } if (constant.Type.IsArray) { var itemType = constant.Type.GetElementType(); var set = _context.MkEmptySet(_environment.Types[itemType]); foreach (object item in (IEnumerable)constant.Value) { InstanceInfo outsideMemberInfo = _environment.Instances.Values.SingleOrDefault(i => i.ObjectInstance == item); var element = outsideMemberInfo.EnumConstant; set = _context.MkSetAdd(set, element); } return(set); } if (constant.Type == typeof(bool)) { return((bool)constant.Value ? _context.MkTrue() : _context.MkFalse()); } if (constant.Type == typeof(int)) { return(_context.MkNumeral((int)constant.Value, _context.IntSort)); } if (constant.Type == typeof(long)) { return(_context.MkNumeral((long)constant.Value, _context.RealSort)); } throw new NotSupportedException("Unsupported constant type."); }
public int?[] ExecuteRecursiveFast(int?[] arr, EnumSort sort) { if (arr.Length <= 1) { return(arr); } int?pivot = arr.First(); // Use List for fast write. var less = new List <int?>(); var greater = new List <int?>(); //foreach (var item in arr.ToList().Skip(1)) foreach (var item in _array.GetSubArray(arr, 1, arr.Length - 1)) { if (sort == EnumSort.Asc) { if (item <= pivot) { less.Add(item); } else { greater.Add(item); } } else if (item > pivot) { less.Add(item); } else { greater.Add(item); } } return(ExecuteRecursiveFast(less.ToArray(), sort). Union(new int?[] { pivot }). Union(ExecuteRecursiveFast(greater.ToArray(), sort)).ToArray()); }
public int?[] ExecuteRecursiveFastWithSwitchPivot(int?[] arr, EnumSort sort) { if (arr.Length <= 1) { return(arr); } int?pivot = arr.First(); int pos = 1; // foreach (var item in SubArray(arr, 1, arr.Length-1)) // { // if (sort == EnumSort.Asc) // if (item <= pivot) { pivot = item; break; } // else // if (item > pivot) { pivot = item; break; } // pivot = item; // pos++; // } foreach (var item in _array.GetSubArray(arr, 1, arr.Length - 1)) { if (sort == EnumSort.Asc) { if (item <= arr[pos - 1]) { break; } else if (item > arr[pos - 1]) { break; } } pos++; } pivot = arr[pos]; // Use List for fast write. var less = new List <int?>(); var greater = new List <int?>(); var list = arr.ToList(); list.RemoveAt(pos); //foreach (var item in list) foreach (var item in list.ToArray()) { if (sort == EnumSort.Asc) { if (item <= pivot) { less.Add(item); } else { greater.Add(item); } } else if (item > pivot) { less.Add(item); } else { greater.Add(item); } } return(ExecuteRecursiveFastWithSwitchPivot(less.ToArray(), sort). Union(new int?[] { pivot }). Union(ExecuteRecursiveFastWithSwitchPivot(greater.ToArray(), sort)).ToArray()); }
internal static FuncDecl GetOrAddMemberAccessFunction(Context context, Environment environment, MemberInfo memberInfo) { FuncDecl memberFunc; if (!environment.Members.TryGetValue(memberInfo, out memberFunc)) { Sort memberTypeSort; if (!environment.Types.TryGetValue(memberInfo.DeclaringType, out memberTypeSort)) { throw new KeyNotFoundException(memberInfo.DeclaringType + " could not be found at environment.Types"); } Sort memberReturnTypeEnumSort; var propertyType = ((PropertyInfo)memberInfo).PropertyType; if (propertyType == typeof(bool)) { memberReturnTypeEnumSort = context.MkBoolSort(); } else if (propertyType == typeof(int)) { memberReturnTypeEnumSort = context.MkIntSort(); } else if (propertyType == typeof(long)) { memberReturnTypeEnumSort = context.MkRealSort(); } else if (propertyType == typeof(string)) { memberReturnTypeEnumSort = environment.PossibleStringValues; } else { if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { var listItemType = propertyType.GenericTypeArguments[0]; var listSort = context.MkSetSort(environment.Types[listItemType]); memberReturnTypeEnumSort = listSort; // TODO: add TryGetValue environment.Types.Add(propertyType, listSort); } else if (propertyType.IsEnum) { EnumSort enumSort = context.MkEnumSort(propertyType.Name, Enum.GetNames(propertyType)); memberReturnTypeEnumSort = enumSort; // TODO: add TryGetValue environment.Types.Add(propertyType, enumSort); } else { // TODO throw exception if type is not supported memberReturnTypeEnumSort = environment.Types[propertyType]; } } memberFunc = context.MkFuncDecl(memberInfo.Name, memberTypeSort, memberReturnTypeEnumSort); environment.Members.Add(memberInfo, memberFunc); } return(memberFunc); }
private Environment GenerateEnvironment(Context context) { var environment = new Environment(); // Class instances // TODO: support NULL values foreach (var instancesPerClassType in _instances.GroupBy(_ => _.Value.GetType())) { string classType = instancesPerClassType.Key.Name; EnumSort instancesEnumSort = context.MkEnumSort(classType + "_instances", instancesPerClassType.Select(_ => _.Key).ToArray()); environment.Types.Add(instancesPerClassType.Key, instancesEnumSort); Expr[] instancesEnumSortValues = instancesEnumSort.Consts; int instancesIndex = 0; foreach (KeyValuePair <string, object> instance in instancesPerClassType) { environment.Instances.Add(instance.Key, new InstanceInfo(instancesEnumSortValues[instancesIndex++], objectInstance: instance.Value)); } } // Super Types foreach (var superType in _superTypes) { var subTypeSorts = environment.Types.Where(t => t.Key.IsSubclassOf(superType)).Select(t => t.Value).ToList(); if (subTypeSorts.Count == 0) { continue; } var superTypeConstructors = new List <Constructor>(); foreach (var subTypeSort in subTypeSorts) { var subTypeConstr = context.MkConstructor( name: subTypeSort.Name.ToString(), recognizer: "Is" + subTypeSort.Name, fieldNames: new[] { subTypeSort.Name + "2" + superType.Name }, sorts: new[] { subTypeSort }, sortRefs: null); superTypeConstructors.Add(subTypeConstr); } DatatypeSort superTypeSort = context.MkDatatypeSort(superType.Name, superTypeConstructors.ToArray()); //DatatypeSort = context.MkDatatypeSort("Types", new Constructor[] { // context.MkConstructor("ValTypes", "isValType", new String[] {"Val2Type"}, new Sort[] {ValTypeSort}, null), // context.MkConstructor("RefTypes", "isRefType", new String[] {"Ref2Type"}, new Sort[] {RefTypeSort}, null) //}); environment.Types.Add(superType, superTypeSort); } // Strings if (_possibleStringValues.Any()) { EnumSort enumSort = context.MkEnumSort("Strings", _possibleStringValues.ToArray()); environment.PossibleStringValues = enumSort; } foreach (var member in _members) { LambdaExpressionToConstraintGenerator.GetOrAddMemberAccessFunction(context, environment, member); } return(environment); }