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);
}
