public Metis(Set set, Proximity diss) : base(set, diss) { Name = "Metis"; //ProximityType = ProximityType.Both; ProximityType = ProximityType.Similarity; }
/*************************/ // Selecting initial vertices /*************************/ // Returns a vertex on the last level of a Breadth-first search (BFS) public static int BFS(Graph graph, int init) { // BFS working queue Queue<int> queue = new Queue<int>(); // Vertices that have already been visited Set<int> visited = new Set<int>(); // Initial vertex is given as input visited.Add(init); queue.Enqueue(init); int current = init; // While there is still a vertex in the queue... while (queue.Count > 0) { //... select the first vertex and process it current = queue.Dequeue(); foreach (int w in graph.OpenNeighborhood(current)) { // Enqueue all neighbors that have not been processed yet if (!visited.Contains(w)) { visited.Add(w); queue.Enqueue(w); } } } // This is the last vertex that has been processed, thus a vertex that is on the last level of the BFS search return current; }
// Uses depth-first search to check if the graph induced by the subgraph given as a parameter is connected // In other words, we retreive all edges from the original graph and check the subgraph for connectedness public static bool Connected(Datastructures.Graph graph, BitSet subgraph) { // Vertices that are visited Set<int> visited = new Set<int>(); // Stack of vertices yet to visit Stack<int> stack = new Stack<int>(); // Initial vertex int s = subgraph.First(); stack.Push(s); // Continue while there are vertices on the stack while (stack.Count > 0) { int v = stack.Pop(); // If we have not encountered this vertex before, then we check for all neighbors if they are part of the subgraph // If a neighbor is part of the subgraph it means that we have to push it on the stack to explore it at a later stage if (!visited.Contains(v)) { visited.Add(v); foreach (int w in graph.OpenNeighborhood(v)) if (subgraph.Contains(w)) stack.Push(w); } } // If we visited an equal number of vertices as there are vertices in the subgraph then the subgraph is connected return visited.Count == subgraph.Count; }
public void Graph_with_one_edge_has_size_1() { var vertices = 1.Upto(2).ToSet(); var edges = new Set<IDirectedEdge<int>> { new DirectedEdge<int>(1, 2) }; var graph = new DirectedGraph<int>(vertices, edges); graph.Size().ShouldEqual(1); }
// <summary> // Fixes the range of the restriction in accordance with <paramref name="range" />. // Member restriction must be complete for this operation. // </summary> internal override DomainBoolExpr FixRange(Set<Constant> range, MemberDomainMap memberDomainMap) { Debug.Assert(IsComplete, "Ranges are fixed only for complete scalar restrictions."); var newPossibleValues = memberDomainMap.GetDomain(RestrictedMemberSlot.MemberPath); BoolLiteral newLiteral = new ScalarRestriction(RestrictedMemberSlot, new Domain(range, newPossibleValues)); return newLiteral.GetDomainBoolExpression(memberDomainMap); }
public static List<CFGEdge> IsolateNodes(Set<CFGNode> nodes) { if (nodes.Count == 0) { return new List<CFGEdge>(); } CFG graph = nodes[0].Graph; List<CFGEdge> removedEdges = new List<CFGEdge>(); foreach (CFGNode node in nodes) { foreach (CFGEdge edge in graph.OutEdges(node)) { if (!nodes.Contains(edge.Target)) { removedEdges.Add(edge); } } foreach (CFGEdge edge in graph.InEdges(node)) { if (!nodes.Contains(edge.Source)) { removedEdges.Add(edge); } } } foreach (CFGEdge edge in removedEdges) { graph.RemoveEdge(edge); } return removedEdges; }
public void When_Key_Exists_Append_Succeeds() { const string key = "Hello"; const string expected = "Hello!"; //clean up old keys var deleteOperation = new Delete(key, GetVBucket(), Converter, Serializer); IOStrategy.Execute(deleteOperation); deleteOperation = new Delete(key + "!", GetVBucket(), Converter, Serializer); IOStrategy.Execute(deleteOperation); //create the key var set = new Set<string>(key, "Hello", GetVBucket(), Converter); var addResult = IOStrategy.Execute(set); Assert.IsTrue(addResult.Success); var append = new Append<string>(key, "!", Serializer, GetVBucket(), Converter); var result = IOStrategy.Execute(append); Assert.IsTrue(result.Success); Assert.AreEqual(string.Empty, result.Value); var get = new Get<string>(key, GetVBucket(), Converter, Serializer); var getResult = IOStrategy.Execute(get); Assert.AreEqual(expected, getResult.Value); }
private static void BFS(ref string[,] arr, AllowedCoords start) { var set = new Set<int>(); var queue = new Queue<AllowedCoords>(); var set = new HashSet<AllowedCoords>(); int depth = 1; queue.Enqueue(start); set.Add(start); while (queue.Count > 0) { var coords = queue.Dequeue(); if (arr[coords.Row, coords.Col] == "0") { arr[coords.Row, coords.Col] = depth.ToString(); } var neighbors = coords.GetAdjacent(); for (int i = 0; i < neighbors.Count; i++) { var coordinates = neighbors[i]; if (!set.Contains(coordinates)) { depth++; set.Add(coordinates); queue.Enqueue(coordinates); } } } }
public GameDB(params Type[] types) { if (types == null || types.Length == 0) throw new Exception("Need at least one type"); foreach (Type type in types) entities[type] = new Set<object>(); }
/// <summary> /// This is the main entry point. /// </summary> public XmlNode Merge(XmlNode newMaster, XmlNode oldConfigured, XmlDocument dest, string oldLayoutSuffix) { // As a result of LT-14650, certain bits of logic regarding copied views and duplicated nodes // were brought inside of the Merge. m_newMaster = newMaster; m_oldConfigured = oldConfigured; m_dest = dest; m_insertedMissing = new Set<XmlNode>(); m_output = m_dest.CreateElement(newMaster.Name); m_layoutParamAttrSuffix = oldLayoutSuffix; CopyAttributes(m_newMaster, m_output); int startIndex = 0; BuildOldConfiguredPartsDicts(); while (startIndex < m_newMaster.ChildNodes.Count) { XmlNode currentChild = m_newMaster.ChildNodes[startIndex]; if (IsMergeableNode(currentChild)) { int limIndex = startIndex + 1; while (limIndex < m_newMaster.ChildNodes.Count && m_newMaster.ChildNodes[limIndex].Name == currentChild.Name) limIndex++; CopyParts(startIndex, limIndex); startIndex = limIndex; } else { CopyToOutput(currentChild); startIndex++; } } return m_output; }
public void Test_Timed_Execution() { var converter = new DefaultConverter(); var transcoder = new DefaultTranscoder(converter); var vbucket = GetVBucket(); int n = 1000; //set to a higher # if needed using (new OperationTimer()) { var key = string.Format("key{0}", 111); for (var i = 0; i < n; i++) { var set = new Set<int?>(key, 111, vbucket, transcoder, OperationLifespanTimeout); var get = new Get<int?>(key, vbucket, transcoder, OperationLifespanTimeout); var result = IOService.Execute(set); Assert.IsTrue(result.Success); var result1 = IOService.Execute(get); Assert.IsTrue(result1.Success); Assert.AreEqual(111, result1.Value); } } }
public static Dictionary<CFGBlock, List<CFGBlock>> ComputeContainingLoopMap(ICFG cfg) { Contract.Requires(cfg != null); Contract.Ensures(Contract.Result<Dictionary<CFGBlock, List<CFGBlock>>>() != null); var result = new Dictionary<CFGBlock, List<CFGBlock>>(); var visitedSubroutines = new Set<int>(); var pendingSubroutines = new Stack<Subroutine>(); var pendingAPCs = new Stack<APC>(); var graph = cfg.AsBackwardGraph(includeExceptionEdges:false, skipContracts:true); foreach (var loophead in cfg.LoopHeads) { // push back-edge sources var loopPC = new APC(loophead, 0, null); foreach (var pred in cfg.Predecessors(loopPC)) { if (cfg.IsForwardBackEdge(pred, loopPC)) { var normalizedPred = new APC(pred.Block, 0, null); pendingAPCs.Push(normalizedPred); } } var visit = new DepthFirst.Visitor<APC, Unit>(graph, (APC pc) => { if (pc.SubroutineContext != null) { // push continuation PC pendingAPCs.Push(new APC(pc.SubroutineContext.Head.One, 0, null)); if (visitedSubroutines.AddQ(pc.Block.Subroutine.Id)) { pendingSubroutines.Push(pc.Block.Subroutine); } return false; // stop exploration } return !pc.Equals(loopPC); }); while (pendingAPCs.Count > 0) { var root = pendingAPCs.Pop(); visit.VisitSubGraphNonRecursive(root); while (pendingSubroutines.Count > 0) { var sub = pendingSubroutines.Pop(); pendingAPCs.Push(new APC(sub.Exit, 0, null)); } } foreach (var visited in visit.Visited) { if (visited.SubroutineContext != null) continue; // ignore non-primary pcs MaterializeContainingLoop(result, visited.Block).AssumeNotNull().Add(loophead); } } return result; }
public TemplateOptions() { Usings = new Set<string>(new[] { "System", "System.IO", "System.Web", "NHaml", "NHaml.Utils", "System.Collections.Generic" }); References = new Set<string>(new[] { typeof(TemplateEngine).Assembly.Location, // NHaml typeof(INotifyPropertyChanged).Assembly.Location, // System typeof(HttpUtility).Assembly.Location // System.Web }); AutoClosingTags = new Set<string>(new[] { "META", "IMG", "LINK", "BR", "HR", "INPUT" }); ReferencedTypeHandles = new List<RuntimeTypeHandle>(); MarkupRules = new List<MarkupRule>(); _indentSize = 2; _templateBaseType = typeof(Template); _templateCompiler = new CSharp3TemplateCompiler(); TemplateContentProvider = new FileTemplateContentProvider(); AddRule(new EofMarkupRule()); AddRule(new MetaMarkupRule()); AddRule(new DocTypeMarkupRule()); AddRule(new TagMarkupRule()); AddRule(new ClassMarkupRule()); AddRule(new IdMarkupRule()); AddRule(new EvalMarkupRule()); AddRule(new EncodedEvalMarkupRule()); AddRule(new SilentEvalMarkupRule()); AddRule(new PreambleMarkupRule()); AddRule(new CommentMarkupRule()); AddRule(new EscapeMarkupRule()); AddRule(new PartialMarkupRule()); AddRule(new NotEncodedEvalMarkupRule()); }
public ClusterAlgorithm(Set set, Proximity diss) { if (set == null || diss == null) throw new ArgumentNullException("Parametro Incorrecto en el constructor de la clase ClusterAlgorithm"); this.Set = set; this.Proximity = diss; }
/// <summary> /// This function takes a set of peaks, a lookup mass, and /// finds the closest peak with in a certain tolerance. If /// multiple peaks exists with in the window, most closest peak /// is selected /// </summary> /// <param name="peaks">A spectrum</param> /// <param name="mz">Look up m/z</param> /// <param name="tolerance">Mass tolerance for look-up</param> /// <returns>Peak if found</returns> public static Peak findClose(Set<Peak> peaks, double mz, double tolerance) { Set<Peak>.Enumerator cur, min, max; min = peaks.LowerBound(new Peak(mz - tolerance)); max = peaks.LowerBound(new Peak(mz + tolerance)); if (!min.IsValid && !max.IsValid) return null; if (!min.IsValid && max.IsValid) return max.Current; if (min.IsValid && !max.IsValid) return min.Current; if (min.Current == max.Current) return null; // If we found multiple matching peaks, // return the closest peak. Peak best = min.Current; //find the peak closest to the desired mz double minDiff = Math.Abs(mz - best.mz); for (cur = min; cur.Current != max.Current; cur.MoveNext()) { double curDiff = Math.Abs(mz - cur.Current.mz); if (curDiff < minDiff) { minDiff = curDiff; best = cur.Current; } } return best; }
public void OnExclude () { //if all of the selection is already checked, then toggle checks them off //else it turns them on. hence we need to find if they're all checked, bool allChecked = true; foreach (ITreeNavigator node in CurrentNodes) { ProjectFile file = (ProjectFile) node.DataItem; if (file.Project != null) { MakefileData data = file.Project.ExtendedProperties [infoProperty] as MakefileData; if (data != null && data.IsFileIntegrationEnabled (file.BuildAction)) { if (data.IsFileExcluded (file.FilePath)) { allChecked = false; break; } } } } Set<SolutionEntityItem> projects = new Set<SolutionEntityItem> (); foreach (ITreeNavigator node in CurrentNodes) { ProjectFile file = (ProjectFile) node.DataItem; if (file.Project != null) { projects.Add (file.Project); MakefileData data = file.Project.ExtendedProperties [infoProperty] as MakefileData; if (data != null && data.IntegrationEnabled) { data.SetFileExcluded (file.FilePath, allChecked); } } } IdeApp.ProjectOperations.Save (projects); }
public void AddColumns() { Column[] columns = new Column[] { new Column("Name", ColumnType.String), new Column("Age", ColumnType.Integer) }; Set set = new Set(columns); NameValues values = new NameValues(); values.Add("Name", "Adam"); values.Add("Age", 800); set = set.AddTuple(values); Column[] newcolumns = new Column[] { new Column("Height", ColumnType.Integer), new Column("Weight", ColumnType.Integer) }; var result = set.AddColumns(newcolumns); Assert.AreNotEqual(result, set); Assert.IsNotNull(result.Tuples); Assert.AreEqual(1, result.Tuples.Count()); Assert.AreEqual(4, result.Columns.Count()); Tuple tuple = result.Tuples.First(); Assert.AreEqual("Adam", tuple[0]); Assert.AreEqual(800, tuple[1]); Assert.IsNull(tuple[2]); Assert.IsNull(tuple[3]); }
/// <summary> /// Returns difference of two sets. /// </summary> /// <remarks> /// Difference contains elements present in first set, but not in the second.<br/> /// Difference is not symmetric. Difference(a,b) is not equal to Difference(b,a) /// </remarks> public static Set Difference(Set a, Set b) { a.CheckComparer(b); var result = new Set(a.Comparer); SetOp.Difference(a, b, a.Comparer, new Inserter(result)); return result; }
public bool Remove(string url, ArrayList<ulong> hashCodes, bool fullPath, bool unique, bool decDocCount) { Set<ulong> hashCodesUnique = new Set<ulong>(hashCodes); int numDomainParts, numTldParts; ArrayList<string> path = GetPath(url, out numDomainParts, out numTldParts, fullPath); if (path == null) { return false; } Node node = mRoot; if (decDocCount) { node.mCount--; } if (unique) { node.mHashCodes.RemoveRange(hashCodesUnique); } else { node.mHashCodes.RemoveRange(hashCodes); } if (node.mCount == 0) // cut the branch? { node.mChildren.Clear(); return true; } for (int i = 0; i < path.Count; i++) { Node child = node.GetChildNode(path[i]); if (child == null) { return false; } if (decDocCount) { child.mCount--; } if (unique) { child.mHashCodes.RemoveRange(hashCodesUnique); } else { child.mHashCodes.RemoveRange(hashCodes); } if (child.mCount == 0) // cut the branch? { child.mChildren.Clear(); return true; } node = child; } return true; }
/// <summary> /// some other jumpers may stop being ones if the jump /// was just in to their destination layer, so before the actual /// jump we have to recheck if the jump makes sense /// /// </summary> /// <param name="jumperLayer">old layer of jumper</param> /// <param name="jumper"></param> void UpdateRegionsForPossibleJumpersAndInsertJumpers(int jumperLayer, int jumper) { Set<int> neighborPossibleJumpers = new Set<int>(); //update possible jumpers neighbors foreach (int v in new Pred(dag, jumper)) if (IsJumper(v)) { this.CalculateRegionAndInsertJumper(v); neighborPossibleJumpers.Insert(v); } foreach (int v in new Succ(dag, jumper)) if (IsJumper(v)) { this.CalculateRegionAndInsertJumper(v); neighborPossibleJumpers.Insert(v); } List<int> possibleJumpersToUpdate = new List<int>(); foreach (KeyValuePair<int, IntPair> kv in this.possibleJumperFeasibleIntervals) { if (!neighborPossibleJumpers.Contains(kv.Key)) if (kv.Value.x > jumperLayer && kv.Value.y < jumperLayer) possibleJumpersToUpdate.Add(kv.Key); } foreach (int v in possibleJumpersToUpdate) this.CalculateRegionAndInsertJumper(v); }
internal PreGraph(EdgeGeometry[] egs, Set<ICurve> nodeBoundaries) { edgeGeometries = new List<EdgeGeometry>(egs); this.nodeBoundaries = new Set<ICurve>(nodeBoundaries); boundingBox = Rectangle.CreateAnEmptyBox(); foreach (var curve in nodeBoundaries) boundingBox.Add(curve.BoundingBox); }
public NameSupply(IImSet<string> globals, NameSupply parent) { this.globals = globals ?? Constants.EmptyStringSet; boundInThisScope = new Set<string>(); boundInChildScope = new Set<string>(); this.parent = parent; }
public void SymmetricTest() { var a = new Set<int>(1, 2, 3); var b = new Set<int>(2, 3, 4); Console.WriteLine(a.Symmetric(b)); }
public void AddSets() { var a = new Set<int>(1, 2, 3, 4, 5); var b = new Set<int>(6, 7, 8, 9, 10); Console.WriteLine(a.Add(b).ToString()); }
public void IntersectionTest() { var a = new Set<int>(1, 2, 3); var b = new Set<int>(2, 3, 4); Console.WriteLine(a.Intersection(b)); }
public void TestDirectedGraphEmptyHasEdgeTrue() { var vertices = 1.Upto(3).ToSet(); var edges = new Set<IDirectedEdge<int>> { new DirectedEdge<int>(1, 2) }; var graph = new DirectedGraph<int>(vertices, edges); graph.HasEdge(1, 2).ShouldBeTrue(); }
/// <summary> /// Given a Set, produces a CSS property. /// Implementers can override this method to customize support for CSS properties given a Set. /// For example if you want a Setter of "Foo" to produce a CSS property "Bar", you can filter it here. /// You must call this methods for Setter properties you don't wish to filter, so that the default implementation /// can generate CSS. /// </summary> /// <param name="set">The target Set.</param> /// <returns>The CSS property, in string form.</returns> public virtual string TransformSet(Set set) { // TODO: Some more type checking. I really don't like this entire method. switch (set.Property.ToLower()) { case "width": int widthResult; if (int.TryParse(set.To, out widthResult)) return string.Format("width: {0}px;", widthResult); break; case "height": int heightResult; if (int.TryParse(set.To, out heightResult)) return string.Format("height: {0}px;", heightResult); break; case "background": return string.Format("background-color: {0};", set.To); case "foreground": return string.Format("color: {0};", set.To); case "padding": return string.Format("padding: {0}px;", set.To); case "margin": return string.Format("margin: {0}px;", set.To); } return string.Empty; }
public static void Res(int m, int c) { for (int i = 1; i <= c; i++) window = window.Add(maxId + i); requests = requests.RemoveKey(m); maxId = maxId + c; }
public void Graph_with_one_vertex_has_order_1() { var vertices = 1.WrapInList().ToSet(); var edges = new Set<IDirectedEdge<int>>(); var graph = new DirectedGraph<int>(vertices, edges); graph.Order().ShouldEqual(1); }
public static ChartSet PopulateChartSet(Set set, IEnumerable<int> monthsInSetsData, IEnumerable<int> weeksInSetsData, DateTime startDate, DateTime endDate) { ChartSet chartSet = new ChartSet(); chartSet.Name = set.Name; chartSet.Id = set.Id; //####################################################################### // Start Building the set month statistics (NOTICE: that the calculation is intended to calculate by aggregating all activities by month regardless of the year the month belongs to) //####################################################################### chartSet.ChartSetMonthsData = new List<ChartSetMonthData>(); foreach (var month in monthsInSetsData) { chartSet.ChartSetMonthsData.Add(new ChartSetMonthData { ActivityCount = set.Exercises.Where(o => o.ExerciseRecords.Any(m => m.Date.Month == month)).Count(), StartDate = DateTime.Now.StartOfMonth(month), EndDate = DateTime.Now.EndOfMonth(month), MonthNumber = month }); } //chartSet.ChartSetMonthsData.OrderBy(o => o.MonthNumber); //####################################################################### //####################################################################### // Start Building the set weeks statistics (NOTICE: that the calculation is intended to calculate by aggregating all activities by week regardless of the year the week belongs to) //####################################################################### chartSet.ChartSetWeeksData = new List<ChartSetWeekData>(); foreach (var week in weeksInSetsData) { //var er = set.Exercises.Select(o => o.ExerciseRecords.Where(m => m.Date.WeekOfDate() == week && m.Date >= startDate && m.Date <= endDate)).ElementAtOrDefault(0); var er = set.Exercises.Select(o => o.ExerciseRecords.FirstOrDefault( m => m.Date.WeekOfDate() == week)).ElementAtOrDefault(0); chartSet.ChartSetWeeksData.Add(new ChartSetWeekData { ActivityCount = set.Exercises.Where(o => o.ExerciseRecords.Any(m => m.Date.WeekOfDate() == week)).Count(), StartDate = DateTimeExtensions.StartOfWeekNumber(er != null ? er.Date.Year : DateTime.Now.Year, week), EndDate = DateTimeExtensions.EndOfWeekNumber(er != null ? er.Date.Year : DateTime.Now.Year, week), WeekNumber = week }); } //chartSet.ChartSetWeeksData.OrderBy(o => o.WeekNumber); chartSet.TotalActivityCount = chartSet.ChartSetMonthsData.Sum(ac => ac.ActivityCount); //####################################################################### //####################################################################### // Start creating chart data for excercises //####################################################################### chartSet.ChartSetExercises = new List<ChartExercise>(); foreach (var exercise in set.Exercises) { ChartExercise chartExercise = ChartsHelper.PopulateChartExercise(exercise, monthsInSetsData, weeksInSetsData, startDate, endDate); // Final step is to add the loaded exercise data into the corresponding set that is to be returned to the client chartSet.ChartSetExercises.Add(chartExercise); } //####################################################################### // Final step is to add the loaded set data that is to be returned to the client return (chartSet); }
public Task <User> FindByUserNameAsync(string username) { return(Set.FirstOrDefaultAsync(x => x.UserName == username)); }
private void Compile( out List <ProviderCommandInfo> providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Set <EntitySet> entitySets) { this.Initialize(); string empty1 = string.Empty; string empty2 = string.Empty; string empty3 = string.Empty; string empty4 = string.Empty; string empty5 = string.Empty; string empty6 = string.Empty; string empty7 = string.Empty; string empty8 = string.Empty; string empty9 = string.Empty; string empty10 = string.Empty; string empty11 = string.Empty; string empty12 = string.Empty; string empty13 = string.Empty; string empty14 = string.Empty; string empty15 = string.Empty; this.m_neededPhases = 593; this.SwitchToPhase(PlanCompilerPhase.PreProcessor); StructuredTypeInfo typeInfo; Dictionary <EdmFunction, EdmProperty[]> tvfResultKeys; PreProcessor.Process(this, out typeInfo, out tvfResultKeys); entitySets = typeInfo.GetEntitySets(); if (this.IsPhaseNeeded(PlanCompilerPhase.AggregatePushdown)) { this.SwitchToPhase(PlanCompilerPhase.AggregatePushdown); AggregatePushdown.Process(this); } if (this.IsPhaseNeeded(PlanCompilerPhase.Normalization)) { this.SwitchToPhase(PlanCompilerPhase.Normalization); Normalizer.Process(this); } if (this.IsPhaseNeeded(PlanCompilerPhase.NTE)) { this.SwitchToPhase(PlanCompilerPhase.NTE); NominalTypeEliminator.Process(this, typeInfo, tvfResultKeys); } if (this.IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) { this.SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } if (this.IsPhaseNeeded(PlanCompilerPhase.NestPullup)) { this.SwitchToPhase(PlanCompilerPhase.NestPullup); NestPullup.Process(this); this.SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } if (this.IsPhaseNeeded(PlanCompilerPhase.Transformations) && this.ApplyTransformations(ref empty8, TransformationRulesGroup.All)) { this.SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); this.ApplyTransformations(ref empty10, TransformationRulesGroup.Project); } if (this.IsPhaseNeeded(PlanCompilerPhase.NullSemantics)) { this.SwitchToPhase(PlanCompilerPhase.NullSemantics); if (!this.m_ctree.UseDatabaseNullSemantics && NullSemantics.Process(this.Command)) { this.ApplyTransformations(ref empty12, TransformationRulesGroup.NullSemantics); } } if (this.IsPhaseNeeded(PlanCompilerPhase.JoinElimination)) { for (int index = 0; index < 10; ++index) { this.SwitchToPhase(PlanCompilerPhase.JoinElimination); if (JoinElimination.Process(this) || this.TransformationsDeferred) { this.TransformationsDeferred = false; this.ApplyTransformations(ref empty14, TransformationRulesGroup.PostJoinElimination); } else { break; } } } this.SwitchToPhase(PlanCompilerPhase.CodeGen); CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount); }
public Spot FindClosestSpot(Location l_d, Set <Spot> Not) { return(FindClosestSpot(l_d, 30.0f, Not)); }
public void SymbolResolutionTest() { ExpressionScope ast; // // Test schema. "Set A" -> b/c -> "Set B" -> d/i -> "Double"/"Integer" // SetTop top = new SetTop("Top"); Set setInteger = top.GetPrimitive("Integer"); Set setDouble = top.GetPrimitive("Double"); Set setA = new Set("Set A"); top.Root.AddSubset(setA); Set setB = new Set("Set B"); top.Root.AddSubset(setB); Dim dimB = top.CreateColumn("b", setA, setB, true); dimB.Add(); Dim dimC = top.CreateColumn("Function c", setA, setB, true); dimC.Add(); Dim dimD = top.CreateColumn("d", setB, setDouble, true); dimD.Add(); Dim dimI = top.CreateColumn("i", setB, setInteger, true); dimI.Add(); // // Test symbol resolution, type resolution and validation // string functionStr = "[Set B] [Function c]([Set A] this, [Integer] [param 2], [Set B] [param 3]) { return b().d() * this.b().d() + [param 2] / [param 3] <- b(); } "; ast = (ExpressionScope)BuildFunction(functionStr); // Bind ast to the real schema ast.ResolveFunction(top); Assert.AreEqual(ast.Input.OutputSet, setA); Assert.AreEqual(ast.Operands[0].OutputSet, setInteger); Assert.AreEqual(ast.Operands[1].OutputSet, setB); Assert.AreEqual(ast.OutputSet, setB); Assert.AreEqual(ast.Dimension, dimC); // Resolve all symboles used in the function definition ast.Resolve(); Assert.AreEqual(ast.Statements[0].Input.Operands[0].Operands[0].OutputSet, setDouble); Assert.AreEqual(ast.Statements[0].Input.Operands[0].Operands[0].Input.OutputSet, setB); Assert.AreEqual(ast.Statements[0].Input.Operands[0].Operands[0].Input.Input.OutputSet, setA); Assert.AreEqual(ast.Statements[0].Input.Operands[0].Operands[1].Input.Input.OutputSet, setA); Assert.AreEqual(ast.Statements[0].Input.Operands[1].Operands[0].OutputSet, setInteger); Assert.AreEqual(ast.Statements[0].Input.Operands[1].Operands[1].OutputSet, setA); Assert.AreEqual(ast.Statements[0].Input.Operands[1].Operands[1].Input.OutputSet, setB); }
/// <summary> /// Tworzy enumerator nad wêz³em w ramach kompozytu. /// </summary> /// <param name="node">wêze³ do przechodzenia</param> /// <param name="visited">zbiór do zapisywania odwiedzonych wêz³ów</param> public ComponentEnumerator(Object head, Set visited) { _head = head; _visited = visited; }
public SetViewModel() { this.set = new Set(); this.CollectionChanged += ViewModelCollectionChanged; this.set.CollectionChanged += ModelCollectionChanged; }
public Task <User> FindByUserNameAsync(System.Threading.CancellationToken cancellationToken, string username) { return(Set.FirstOrDefaultAsync(x => x.UserName == username, cancellationToken)); }
public Mul(Set left, Set right) : base(left, right) { }
internal static void AddTransitions(FSM fsm, int state, CodeStatementCollection stmts, Set <int> visited) { if (visited.Contains(state)) { return; } else { visited.Add(state); } Transitions currTrans = null; fsm.Trans.TryGetValue(state, out currTrans); if (currTrans == null || currTrans.Count == 0) { return; } CreateAddTransitionStmts(fsm, stmts, state, currTrans, visited); }
public User FindByUserName(string username) { return(Set.FirstOrDefault(x => x.UserName == username)); }
private bool CheckIfConstraintMappedToForeignKeyAssociation( QueryRewriter childRewriter, Set <Cell> cells) { var childContext = childRewriter.ViewgenContext; //First collect the sets of properties that the principal and dependant ends of this FK //are mapped to in the Edm side. var childPropertiesSet = new List <Set <EdmProperty> >(); var parentPropertiesSet = new List <Set <EdmProperty> >(); foreach (var cell in cells) { if (cell.CQuery.Extent.BuiltInTypeKind != BuiltInTypeKind.AssociationSet) { var childProperties = cell.GetCSlotsForTableColumns(ChildColumns); if ((childProperties != null) && (childProperties.Count != 0)) { childPropertiesSet.Add(childProperties); } var parentProperties = cell.GetCSlotsForTableColumns(ParentColumns); if ((parentProperties != null) && (parentProperties.Count != 0)) { parentPropertiesSet.Add(parentProperties); } } } //Now Check if the properties on the Edm side are connected via an FK relationship. if ((childPropertiesSet.Count != 0) && (parentPropertiesSet.Count != 0)) { var foreignKeyAssociations = childContext.EntityContainerMapping.EdmEntityContainer.BaseEntitySets.OfType <AssociationSet>().Where( it => it.ElementType.IsForeignKey).Select(it => it.ElementType); foreach (var association in foreignKeyAssociations) { var refConstraint = association.ReferentialConstraints.FirstOrDefault(); //We need to check to see if the dependent properties that were mapped from S side are present as //dependant properties of this ref constraint on the Edm side. We need to do the same for principal side but //we can not enforce equality since the order of the properties participating in the constraint on the S side and //C side could be different. This is OK as long as they are mapped appropriately. We also can not use Existance as a sufficient //condition since it will allow invalid mapping where FK columns could have been flipped when mapping to the Edm side. So //we make sure that the index of the properties in the principal and dependant are same on the Edm side even if they are in //different order for ref constraints for Edm and store side. var childRefPropertiesCollection = childPropertiesSet.Where(it => it.SetEquals(new Set <EdmProperty>(refConstraint.ToProperties))); var parentRefPropertiesCollection = parentPropertiesSet.Where(it => it.SetEquals(new Set <EdmProperty>(refConstraint.FromProperties))); if ((childRefPropertiesCollection.Count() != 0 && parentRefPropertiesCollection.Count() != 0)) { foreach (var parentRefProperties in parentRefPropertiesCollection) { var parentIndexes = GetPropertyIndexes(parentRefProperties, refConstraint.FromProperties); foreach (var childRefProperties in childRefPropertiesCollection) { var childIndexes = GetPropertyIndexes(childRefProperties, refConstraint.ToProperties); if (childIndexes.SequenceEqual(parentIndexes)) { return(true); } } } } } } return(false); }
private void Compile( out List <ProviderCommandInfo> providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Set <md.EntitySet> entitySets) { Initialize(); // initialize the ITree var beforePreProcessor = String.Empty; var beforeAggregatePushdown = String.Empty; var beforeNormalization = String.Empty; var beforeNTE = String.Empty; var beforeProjectionPruning1 = String.Empty; var beforeNestPullup = String.Empty; var beforeProjectionPruning2 = String.Empty; var beforeTransformationRules1 = String.Empty; var beforeProjectionPruning3 = String.Empty; var beforeTransformationRules2 = String.Empty; var beforeNullSemantics = String.Empty; var beforeTransformationRules3 = String.Empty; var beforeJoinElimination = String.Empty; var beforeTransformationRules4 = String.Empty; var beforeCodeGen = String.Empty; // // We always need the pre-processor and the codegen phases. // It is generally a good thing to run through the transformation rules, and // the projection pruning phases. // The "optional" phases are AggregatePushdown, Normalization, NTE, NestPullup and JoinElimination // m_neededPhases = (1 << (int)PlanCompilerPhase.PreProcessor) | // (1 << (int)PlanCompilerPhase.AggregatePushdown) | // (1 << (int)PlanCompilerPhase.Normalization) | // (1 << (int)PlanCompilerPhase.NTE) | (1 << (int)PlanCompilerPhase.ProjectionPruning) | // (1 << (int)PlanCompilerPhase.NestPullup) | (1 << (int)PlanCompilerPhase.Transformations) | // (1 << (int)PlanCompilerPhase.JoinElimination) | // (1 << (int)PlanCompilerPhase.NullSemantics) | (1 << (int)PlanCompilerPhase.CodeGen); // Perform any necessary preprocessing StructuredTypeInfo typeInfo; Dictionary <md.EdmFunction, md.EdmProperty[]> tvfResultKeys; beforePreProcessor = SwitchToPhase(PlanCompilerPhase.PreProcessor); PreProcessor.Process(this, out typeInfo, out tvfResultKeys); entitySets = typeInfo.GetEntitySets(); if (IsPhaseNeeded(PlanCompilerPhase.AggregatePushdown)) { beforeAggregatePushdown = SwitchToPhase(PlanCompilerPhase.AggregatePushdown); AggregatePushdown.Process(this); } if (IsPhaseNeeded(PlanCompilerPhase.Normalization)) { beforeNormalization = SwitchToPhase(PlanCompilerPhase.Normalization); Normalizer.Process(this); } // Eliminate "structured" types. if (IsPhaseNeeded(PlanCompilerPhase.NTE)) { beforeNTE = SwitchToPhase(PlanCompilerPhase.NTE); NominalTypeEliminator.Process(this, typeInfo, tvfResultKeys); } // Projection pruning - eliminate unreferenced expressions if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) { beforeProjectionPruning1 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } // Nest Pull-up on the ITree if (IsPhaseNeeded(PlanCompilerPhase.NestPullup)) { beforeNestPullup = SwitchToPhase(PlanCompilerPhase.NestPullup); NestPullup.Process(this); //If we do Nest Pull-up, we should again do projection pruning beforeProjectionPruning2 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } // Run transformations on the tree if (IsPhaseNeeded(PlanCompilerPhase.Transformations)) { var projectionPrunningNeeded = ApplyTransformations(ref beforeTransformationRules1, TransformationRulesGroup.All); if (projectionPrunningNeeded) { beforeProjectionPruning3 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); ApplyTransformations(ref beforeTransformationRules2, TransformationRulesGroup.Project); } } if (IsPhaseNeeded(PlanCompilerPhase.NullSemantics)) { beforeNullSemantics = SwitchToPhase(PlanCompilerPhase.NullSemantics); if (!m_ctree.UseDatabaseNullSemantics && NullSemantics.Process(Command)) { ApplyTransformations(ref beforeTransformationRules3, TransformationRulesGroup.NullSemantics); } } // Join elimination if (IsPhaseNeeded(PlanCompilerPhase.JoinElimination)) { const int maxIterations = 10; for (var i = 0; i < maxIterations; i++) { beforeJoinElimination = SwitchToPhase(PlanCompilerPhase.JoinElimination); var modified = JoinElimination.Process(this); if (modified || TransformationsDeferred) { TransformationsDeferred = false; ApplyTransformations(ref beforeTransformationRules4, TransformationRulesGroup.PostJoinElimination); } else { break; } } } // Code generation beforeCodeGen = SwitchToPhase(PlanCompilerPhase.CodeGen); CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount); #if DEBUG // GC.KeepAlive makes FxCop Grumpy. var size = beforePreProcessor.Length; size = beforeAggregatePushdown.Length; size = beforeNormalization.Length; size = beforeNTE.Length; size = beforeProjectionPruning1.Length; size = beforeNestPullup.Length; size = beforeProjectionPruning2.Length; size = beforeTransformationRules1.Length; size = beforeProjectionPruning3.Length; size = beforeTransformationRules2.Length; size = beforeNullSemantics.Length; size = beforeTransformationRules3.Length; size = beforeJoinElimination.Length; size = beforeTransformationRules4.Length; size = beforeCodeGen.Length; #endif }
// effects: Checks that this foreign key constraints for all the // tables are being ensured on the C-side as well. If not, adds // errors to the errorLog internal void CheckConstraint( Set <Cell> cells, QueryRewriter childRewriter, QueryRewriter parentRewriter, ErrorLog errorLog, ConfigViewGenerator config) { if (IsConstraintRelevantForCells(cells) == false) { // if the constraint does not deal with any cell in this group, ignore it return; } if (config.IsNormalTracing) { Trace.WriteLine(String.Empty); Trace.WriteLine(String.Empty); Trace.Write("Checking: "); Trace.WriteLine(this); } if (childRewriter == null && parentRewriter == null) { // Neither table is mapped - so we are fine return; } // If the child table has not been mapped, we used to say that we // are fine. However, if we have SPerson(pid) and SAddress(aid, // pid), where pid is an FK into SPerson, we are in trouble if // SAddress is not mapped - SPerson could get deleted. So we // check for it as well // if the parent table is not mapped, we also have a problem if (childRewriter == null) { var message = Strings.ViewGen_Foreign_Key_Missing_Table_Mapping( ToUserString(), ChildTable.Name); // Get the cells from the parent table var record = new ErrorLog.Record( ViewGenErrorCode.ForeignKeyMissingTableMapping, message, parentRewriter.UsedCells, String.Empty); errorLog.AddEntry(record); return; } if (parentRewriter == null) { var message = Strings.ViewGen_Foreign_Key_Missing_Table_Mapping( ToUserString(), ParentTable.Name); // Get the cells from the child table var record = new ErrorLog.Record( ViewGenErrorCode.ForeignKeyMissingTableMapping, message, childRewriter.UsedCells, String.Empty); errorLog.AddEntry(record); return; } // Note: we do not check if the parent columns correspond to the // table's keys - metadata checks for that //First check if the FK is covered by Foreign Key Association //If we find this, we don't need to check for independent associations. If user maps the Fk to both FK and independent associations, //the regular round tripping validation will catch the error. if (CheckIfConstraintMappedToForeignKeyAssociation(childRewriter, cells)) { return; } // Check if the foreign key in the child table corresponds to the primary key, i.e., if // the foreign key (e.g., pid, pid2) is a superset of the actual key members (e.g., pid), it means // that the foreign key is also the primary key for this table -- so we can propagate the queries upto C-Space // rather than doing the cell check var initialErrorLogSize = errorLog.Count; if (IsForeignKeySuperSetOfPrimaryKeyInChildTable()) { GuaranteeForeignKeyConstraintInCSpace(childRewriter, parentRewriter, errorLog); } else { GuaranteeMappedRelationshipForForeignKey(childRewriter, parentRewriter, cells, errorLog, config); } if (initialErrorLogSize == errorLog.Count) { // Check if the order of columns in foreign key correponds to the // mappings in m_cellGroup, e.g., if <pid1, pid2> in SAddress is // a foreign key into <pid1, pid2> of the SPerson table, make // sure that this order is preserved through the mappings in m_cellGroup CheckForeignKeyColumnOrder(cells, errorLog); } }
// requires: all columns in constraint.ParentColumns and // constraint.ChildColumns must have been mapped in some cell in m_cellGroup // effects: Given the foreign key constraint, checks if the // constraint.ChildColumns are mapped to the constraint.ParentColumns // in m_cellGroup in the right oder. If not, adds an error to m_errorLog and returns // false. Else returns true private bool CheckForeignKeyColumnOrder(Set <Cell> cells, ErrorLog errorLog) { // Go through every cell and find the cells that are relevant to // parent and those that are relevant to child // Then for each cell pair (parent, child) make sure that the // projected foreign keys columns in C-space are aligned var parentCells = new List <Cell>(); var childCells = new List <Cell>(); foreach (var cell in cells) { if (cell.SQuery.Extent.Equals(ChildTable)) { childCells.Add(cell); } if (cell.SQuery.Extent.Equals(ParentTable)) { parentCells.Add(cell); } } // Make sure that all child cells and parent cells align on // the columns, i.e., for each DISTINCT pair C and P, get the columns // on the S-side. Then get the corresponding fields on the // C-side. The fields on the C-side should match var foundParentCell = false; var foundChildCell = false; foreach (var childCell in childCells) { var allChildSlotNums = GetSlotNumsForColumns(childCell, ChildColumns); if (allChildSlotNums.Count == 0) { // slots in present in S-side, ignore continue; } List <MemberPath> childPaths = null; List <MemberPath> parentPaths = null; Cell errorParentCell = null; foreach (var childSlotNums in allChildSlotNums) { foundChildCell = true; // Get the fields on the C-side childPaths = new List <MemberPath>(childSlotNums.Count); foreach (var childSlotNum in childSlotNums) { // Initial slots only have JoinTreeSlots var childSlot = (MemberProjectedSlot)childCell.CQuery.ProjectedSlotAt(childSlotNum); Debug.Assert(childSlot != null); childPaths.Add(childSlot.MemberPath); } foreach (var parentCell in parentCells) { var allParentSlotNums = GetSlotNumsForColumns(parentCell, ParentColumns); if (allParentSlotNums.Count == 0) { // * Parent and child cell are the same - we do not // need to check since we want to check the foreign // key constraint mapping across cells // * Some slots not in present in S-side, ignore continue; } foreach (var parentSlotNums in allParentSlotNums) { foundParentCell = true; parentPaths = new List <MemberPath>(parentSlotNums.Count); foreach (var parentSlotNum in parentSlotNums) { var parentSlot = (MemberProjectedSlot)parentCell.CQuery.ProjectedSlotAt(parentSlotNum); Debug.Assert(parentSlot != null); parentPaths.Add(parentSlot.MemberPath); } // Make sure that the last member of each of these is the same // or the paths are essentially equivalent via referential constraints // We need to check that the last member is essentially the same because it could // be a regular scenario where aid is mapped to PersonAddress and Address - there // is no ref constraint. So when projected into C-Space, we will get Address.aid // and PersonAddress.Address.aid if (childPaths.Count == parentPaths.Count) { var notAllPathsMatched = false; for (var i = 0; i < childPaths.Count && !notAllPathsMatched; i++) { var parentPath = parentPaths[i]; var childPath = childPaths[i]; if (!parentPath.LeafEdmMember.Equals(childPath.LeafEdmMember)) //Child path did not match { if (parentPath.IsEquivalentViaRefConstraint(childPath)) { //Specifying the referential constraint once in the C space should be enough. //This is the only way possible today. //We might be able to derive more knowledge by using boolean logic return(true); } else { notAllPathsMatched = true; } } } if (!notAllPathsMatched) { return(true); //all childPaths matched parentPaths } else { //If not this one, some other Parent Cell may match. errorParentCell = parentCell; } } } } //foreach parentCell } //If execution is at this point, no parent cell's end has matched (otherwise it would have returned true) Debug.Assert(childPaths != null, "child paths should be set"); Debug.Assert(parentPaths != null, "parent paths should be set"); Debug.Assert(errorParentCell != null, "errorParentCell should be set"); var message = Strings.ViewGen_Foreign_Key_ColumnOrder_Incorrect( ToUserString(), MemberPath.PropertiesToUserString(ChildColumns, false), ChildTable.Name, MemberPath.PropertiesToUserString(childPaths, false), childCell.CQuery.Extent.Name, MemberPath.PropertiesToUserString(ParentColumns, false), ParentTable.Name, MemberPath.PropertiesToUserString(parentPaths, false), errorParentCell.CQuery.Extent.Name); var record = new ErrorLog.Record( ViewGenErrorCode.ForeignKeyColumnOrderIncorrect, message, new[] { errorParentCell, childCell }, String.Empty); errorLog.AddEntry(record); return(false); } Debug.Assert(foundParentCell, "Some cell that mapped the parent's key must be present!"); Debug.Assert( foundChildCell == true, "Some cell that mapped the child's foreign key must be present according to the requires clause!"); return(true); }
public override Task <Aid> GetByIDAsync(Guid key) { return(Set.Include(c => c.Case.City.Region.Country) .Include(c => c.Case.District).FirstOrDefaultAsync(c => c.Id == key)); }
// effects: Ensures that there is a relationship mapped into the C-space for some cell in m_cellGroup. Else // adds an error to errorLog private void GuaranteeMappedRelationshipForForeignKey( QueryRewriter childRewriter, QueryRewriter parentRewriter, IEnumerable <Cell> cells, ErrorLog errorLog, ConfigViewGenerator config) { var childContext = childRewriter.ViewgenContext; var parentContext = parentRewriter.ViewgenContext; // Find a cell where this foreign key is mapped as a relationship var prefix = new MemberPath(ChildTable); var primaryKey = ExtentKey.GetPrimaryKeyForEntityType(prefix, ChildTable.ElementType); var primaryKeyFields = primaryKey.KeyFields; var foundCell = false; var foundValidParentColumnsForForeignKey = false; //we need to find only one, dont error on any one check being false List <ErrorLog.Record> errorListForInvalidParentColumnsForForeignKey = null; foreach (var cell in cells) { if (cell.SQuery.Extent.Equals(ChildTable) == false) { continue; } // The childtable is mapped to a relationship in the C-space in cell // Check that all the columns of the foreign key and the primary key in the child table are mapped to some // property in the C-space var parentEnd = GetRelationEndForColumns(cell, ChildColumns); if (parentEnd != null && CheckParentColumnsForForeignKey(cell, cells, parentEnd, ref errorListForInvalidParentColumnsForForeignKey) == false) { // Not an error unless we find no valid case continue; } else { foundValidParentColumnsForForeignKey = true; } var childEnd = GetRelationEndForColumns(cell, primaryKeyFields); Debug.Assert( childEnd == null || parentEnd != childEnd, "Ends are same => PKey and child columns are same - code should gone to other method"); // Note: If both of them are not-null, they are mapped to the // same association set -- since we checked that particular cell if (childEnd != null && parentEnd != null && FindEntitySetForColumnsMappedToEntityKeys(cells, primaryKeyFields).Count > 0) { foundCell = true; CheckConstraintWhenParentChildMapped(cell, errorLog, parentEnd, config); break; // Done processing for the foreign key - either it was mapped correctly or it was not } else if (parentEnd != null) { // At this point, we know cell corresponds to an association set var assocSet = (AssociationSet)cell.CQuery.Extent; foundCell = CheckConstraintWhenOnlyParentMapped(assocSet, parentEnd, childRewriter, parentRewriter); if (foundCell) { break; } } } //CheckParentColumnsForForeignKey has returned no matches, Error. if (!foundValidParentColumnsForForeignKey) { Debug.Assert( errorListForInvalidParentColumnsForForeignKey != null && errorListForInvalidParentColumnsForForeignKey.Count > 0); foreach (var errorRecord in errorListForInvalidParentColumnsForForeignKey) { errorLog.AddEntry(errorRecord); } return; } if (foundCell == false) { // No cell found -- Declare error var message = Strings.ViewGen_Foreign_Key_Missing_Relationship_Mapping(ToUserString()); IEnumerable <LeftCellWrapper> parentWrappers = GetWrappersFromContext(parentContext, ParentTable); IEnumerable <LeftCellWrapper> childWrappers = GetWrappersFromContext(childContext, ChildTable); var bothExtentWrappers = new Set <LeftCellWrapper>(parentWrappers); bothExtentWrappers.AddRange(childWrappers); var record = new ErrorLog.Record( ViewGenErrorCode.ForeignKeyMissingRelationshipMapping, message, bothExtentWrappers, String.Empty); errorLog.AddEntry(record); } }
public Cache Get() { var cache = Set.FirstOrDefault(); return(cache == null || cache.HasExpired() ? Refresh() : cache); }
internal DomainVariable(T_Variable identifier, Set <T_Element> domain) : this(identifier, domain, null) { }
private void AsCql( Action <NegatedConstant, IEnumerable <Constant> > negatedConstantAsCql, Action <Set <Constant> > varInDomain, Action varIsNotNull, Action varIsNull, bool skipIsNotNull) { Debug.Assert(this.RestrictedMemberSlot.MemberPath.IsScalarType(), "Expected scalar."); // If domain values contain a negated constant, delegate Cql generation into that constant. Debug.Assert(this.Domain.Values.Count(c => c is NegatedConstant) <= 1, "Multiple negated constants?"); NegatedConstant negated = (NegatedConstant)this.Domain.Values.FirstOrDefault(c => c is NegatedConstant); if (negated != null) { negatedConstantAsCql(negated, this.Domain.Values); } else // We have only positive constants. { // 1. Generate "var in domain" // 2. If var is not nullable, append "... and var is not null". // This is needed for boolean _from variables that must never evaluate to null because view generation assumes 2-valued boolean logic. // 3. If domain contains null, prepend "var is null or ...". // // A complete generation pattern: // (var is null or ( var in domain and var is not null)) // ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ // generated by #3 generated by #1 generated by #2 // Copy the domain values for simplification changes. Set <Constant> domainValues = new Set <Constant>(this.Domain.Values, Constant.EqualityComparer); bool includeNull = false; if (domainValues.Contains(Constant.Null)) { includeNull = true; domainValues.Remove(Constant.Null); } // Constraint counter-example could contain undefined cellconstant. E.g for booleans (for int its optimized out due to negated constants) // we want to treat undefined as nulls. if (domainValues.Contains(Constant.Undefined)) { includeNull = true; domainValues.Remove(Constant.Undefined); } bool excludeNull = !skipIsNotNull && this.RestrictedMemberSlot.MemberPath.IsNullable; Debug.Assert(!includeNull || !excludeNull, "includeNull and excludeNull can't be true at the same time."); // #1: Generate "var in domain" if (domainValues.Count > 0) { varInDomain(domainValues); } // #2: Append "... and var is not null". if (excludeNull) { varIsNotNull(); } // #3: Prepend "var is null or ...". if (includeNull) { varIsNull(); } } }
private ITag LoadTag(XmlNode xmlNode, IList <Include> includes) { ITag tag = null; var prepend = xmlNode.Attributes?["Prepend"]?.Value.Trim(); var property = xmlNode.Attributes?["Property"]?.Value.Trim(); var compareValue = xmlNode.Attributes?["CompareValue"]?.Value.Trim(); #region Init Tag switch (xmlNode.Name) { case "#text": case "#cdata-section": { var bodyText = " " + xmlNode.InnerText.Replace("\n", "").Trim(); return(new SqlText { BodyText = bodyText }); } case "Include": { var refId = xmlNode.Attributes?["RefId"]?.Value; var include_tag = new Include { RefId = refId, Prepend = prepend }; includes.Add(include_tag); tag = include_tag; break; } case "IsEmpty": { tag = new IsEmpty { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsEqual": { tag = new IsEqual { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsGreaterEqual": { tag = new IsGreaterEqual { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsGreaterThan": { tag = new IsGreaterThan { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsLessEqual": { tag = new IsLessEqual { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsLessThan": { tag = new IsLessThan { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsNotEmpty": { tag = new IsNotEmpty { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsNotEqual": { tag = new IsNotEqual { Prepend = prepend, Property = property, CompareValue = compareValue, ChildTags = new List <ITag>() }; break; } case "IsNotNull": { tag = new IsNotNull { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsNull": { tag = new IsNull { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsTrue": { tag = new IsTrue { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsFalse": { tag = new IsFalse { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "IsProperty": { tag = new IsProperty { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "Placeholder": { tag = new Placeholder { Prepend = prepend, Property = property, ChildTags = new List <ITag>() }; break; } case "Switch": { tag = new Switch { Property = property, //Prepend = prepend, ChildTags = new List <ITag>() }; break; } case "Case": { var switchNode = xmlNode.ParentNode; var switchProperty = switchNode.Attributes?["Property"]?.Value.Trim(); var switchPrepend = switchNode.Attributes?["Prepend"]?.Value.Trim(); tag = new Switch.Case { CompareValue = compareValue, Property = switchProperty, Prepend = switchPrepend, ChildTags = new List <ITag>() }; break; } case "Default": { var switchNode = xmlNode.ParentNode; var switchProperty = switchNode.Attributes?["Property"]?.Value.Trim(); var switchPrepend = switchNode.Attributes?["Prepend"]?.Value.Trim(); tag = new Switch.Defalut { Property = switchProperty, Prepend = switchPrepend, ChildTags = new List <ITag>() }; break; } case "Dynamic": { tag = new Dynamic { Prepend = prepend, ChildTags = new List <ITag>() }; break; } case "Where": { tag = new Where { ChildTags = new List <ITag>() }; break; } case "Set": { tag = new Set { ChildTags = new List <ITag>() }; break; } case "For": { var open = xmlNode.Attributes?["Open"]?.Value.Trim(); var separator = xmlNode.Attributes?["Separator"]?.Value.Trim(); var close = xmlNode.Attributes?["Close"]?.Value.Trim(); var key = xmlNode.Attributes?["Key"]?.Value.Trim(); tag = new For { Prepend = prepend, Property = property, Open = open, Close = close, Separator = separator, Key = key, ChildTags = new List <ITag>() }; break; } case "Env": { var dbProvider = xmlNode.Attributes?["DbProvider"]?.Value.Trim(); tag = new Env { Prepend = prepend, DbProvider = dbProvider, ChildTags = new List <ITag>() }; break; } case "#comment": { break; } default: { throw new SmartSqlException($"Statement.LoadTag unkonw tagName:{xmlNode.Name}."); }; } #endregion foreach (XmlNode childNode in xmlNode) { ITag childTag = LoadTag(childNode, includes); if (childTag != null && tag != null) { (tag as Tag).ChildTags.Add(childTag); } } return(tag); }
public IEnumerator <TableExporter.ITableRow> GetEnumerator() { IEnumerable exportedRows; IList <int> exportedColumns; if (exportSelectedCellsOnly && treeDataGridView.SelectedCells.Count > 0 && !treeDataGridView.AreAllCellsSelected(false)) { var selectedRows = new Set <DataGridViewRow>(); var selectedColumns = new Map <int, int>(); // ordered by DisplayIndex foreach (DataGridViewCell cell in treeDataGridView.SelectedCells) { selectedRows.Add(cell.OwningRow); selectedColumns[cell.OwningColumn.DisplayIndex] = cell.ColumnIndex; } exportedRows = selectedRows; exportedColumns = selectedColumns.Values; } else { exportedRows = treeDataGridView.Rows; exportedColumns = treeDataGridView.GetVisibleColumnsInDisplayOrder().Select(o => o.Index).ToList(); } // add column headers var Headers = new List <string>(); foreach (var columnIndex in exportedColumns) { Headers.Add(treeDataGridView.Columns[columnIndex].HeaderText); } foreach (DataGridViewRow row in exportedRows) { var exportedRow = new ExportedTableRow(); exportedRow.Headers = Headers; /* TODO: how to handle non-root rows? * var row = rows[rowIndex]; * * // skip non-root rows or filtered rows * if (rowIndexHierarchy.Count > 1 || getRowFilterState(row) == RowFilterState.Out) * continue;*/ if (rows.Count > row.Index) { Row row2 = rows[row.Index]; if (getRowFilterState(row2) == RowFilterState.Out) { continue; } } var rowIndexHierarchy = treeDataGridView.GetRowHierarchyForRowIndex(row.Index); exportedRow.Cells = new List <string>(); foreach (var columnIndex in exportedColumns) { // empty cells are exported as blank except for pivot columns which are exported as zeros object value = row.Cells[columnIndex].Value ?? (treeDataGridView.Columns[columnIndex].Name.StartsWith("pivot") ? "0" : String.Empty); var sb = new StringBuilder(value.ToString()); if (columnIndex == 0 && rowIndexHierarchy.Count > 1) { int indent = (rowIndexHierarchy.Count - 1) * 2; sb.Insert(0, new string(' ', indent)); } exportedRow.Cells.Add(sb.ToString()); } yield return(exportedRow); } }
public void RoutingWithThreeGroups() { var graph = LoadGraph("abstract.msagl.geom"); var root = graph.RootCluster; var a = new Cluster { UserData = "a" }; foreach (string id in new[] { "17", "39", "13", "19", "28", "12" }) { a.AddChild(graph.FindNodeByUserData(id)); } var b = new Cluster { UserData = "b" }; b.AddChild(a); b.AddChild(graph.FindNodeByUserData("18")); root.AddChild(b); var c = new Cluster { UserData = "c" }; foreach (string id in new[] { "30", "5", "6", "7", "8" }) { c.AddChild(graph.FindNodeByUserData(id)); } root.AddChild(c); var clusterNodes = new Set <Node>(root.AllClustersDepthFirst().SelectMany(cl => cl.Nodes)); foreach (var node in graph.Nodes.Where(n => clusterNodes.Contains(n) == false)) { root.AddChild(node); } FixClusterBoundariesWithNoRectBoundaries(root, 5); var defaultSettings = new FastIncrementalLayoutSettings(); var rootSettings = new FastIncrementalLayoutSettings() { AvoidOverlaps = true }; var initialLayout = new InitialLayoutByCluster(graph, new[] { graph.RootCluster }, cl => cl == root ? rootSettings : defaultSettings); initialLayout.Run(); const double Padding = 5; SplineRouter splineRouter = new SplineRouter(graph, Padding / 3, Padding, Math.PI / 6); splineRouter.Run(); #if TEST_MSAGL if (!DontShowTheDebugViewer()) { graph.UpdateBoundingBox(); DisplayGeometryGraph.ShowGraph(graph); } #endif }
/// <summary> /// Initialize a sentence given the appropriate sentence clauses. Produces /// an equivalent expression by composing the clause expressions using /// the given tree type. /// </summary> /// <param name="clauses">Sentence clauses</param> /// <param name="treeType">Tree type for sentence (and generated expression)</param> protected Sentence(Set <T_Clause> clauses, ExprType treeType) : base(ConvertClausesToExpr(clauses, treeType)) { _clauses = clauses.AsReadOnly(); }
public virtual List <List <string> > GetFormTable(bool selected) { var exportTable = new List <List <string> >(); IList <int> exportedRows, exportedColumns; if (selected && treeDataGridView.SelectedCells.Count > 0 && !treeDataGridView.AreAllCellsSelected(false)) { var selectedRows = new Set <int>(); var selectedColumns = new Map <int, int>(); // ordered by DisplayIndex foreach (DataGridViewCell cell in treeDataGridView.SelectedCells) { selectedRows.Add(cell.RowIndex); selectedColumns[cell.OwningColumn.DisplayIndex] = cell.ColumnIndex; } exportedRows = selectedRows.ToList(); exportedColumns = selectedColumns.Values; } else { exportedRows = treeDataGridView.Rows.Cast <DataGridViewRow>().Select(o => o.Index).ToList(); exportedColumns = treeDataGridView.GetVisibleColumnsInDisplayOrder().Select(o => o.Index).ToList(); } // add column headers exportTable.Add(new List <string>()); foreach (var columnIndex in exportedColumns) { exportTable.Last().Add(treeDataGridView.Columns[columnIndex].HeaderText); } foreach (int rowIndex in exportedRows) { /* TODO: how to handle non-root rows? * var row = rows[rowIndex]; * * // skip non-root rows or filtered rows * if (rowIndexHierarchy.Count > 1 || getRowFilterState(row) == RowFilterState.Out) * continue;*/ var rowIndexHierarchy = treeDataGridView.GetRowHierarchyForRowIndex(rowIndex); var rowText = new List <string>(); foreach (var columnIndex in exportedColumns) { object value = treeDataGridView[columnIndex, rowIndex].Value ?? String.Empty; rowText.Add(value.ToString()); if (columnIndex == 0 && rowIndexHierarchy.Count > 1) { int indent = (rowIndexHierarchy.Count - 1) * 2; rowText[rowText.Count - 1] = new string(' ', indent) + rowText[rowText.Count - 1]; } } exportTable.Add(rowText); } return(exportTable); }
// Initializes a new DNF sentence given its clauses. internal DnfSentence(Set <DnfClause <T_Identifier> > clauses) : base(clauses, ExprType.Or) { }
/// <summary> /// don't let this be constructed publicly; /// </summary> /// <exception cref="EntityCommandCompilationException">Cannot prepare the command definition for execution; consult the InnerException for more information.</exception> /// <exception cref="NotSupportedException">The ADO.NET Data Provider you are using does not support CommandTrees.</exception> internal EntityCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree) { EntityUtil.CheckArgumentNull(storeProviderFactory, "storeProviderFactory"); EntityUtil.CheckArgumentNull(commandTree, "commandTree"); DbProviderServices storeProviderServices = DbProviderServices.GetProviderServices(storeProviderFactory); try { if (DbCommandTreeKind.Query == commandTree.CommandTreeKind) { // Next compile the plan for the command tree List <ProviderCommandInfo> mappedCommandList = new List <ProviderCommandInfo>(); ColumnMap columnMap; int columnCount; PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets); _columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) }; // Note: we presume that the first item in the ProviderCommandInfo is the root node; Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen. // Then, generate the store commands from the resulting command tree(s) _mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count); foreach (ProviderCommandInfo providerCommandInfo in mappedCommandList) { DbCommandDefinition providerCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandInfo.CommandTree); if (null == providerCommandDefinition) { throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderReturnedNullForCreateCommandDefinition); } _mappedCommandDefinitions.Add(providerCommandDefinition); } } else { Debug.Assert(DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported"); DbFunctionCommandTree entityCommandTree = (DbFunctionCommandTree)commandTree; // Retrieve mapping and metadata information for the function import. FunctionImportMappingNonComposable mapping = GetTargetFunctionMapping(entityCommandTree); IList <FunctionParameter> returnParameters = entityCommandTree.EdmFunction.ReturnParameters; int resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1; _columnMapGenerators = new IColumnMapGenerator[resultSetCount]; TypeUsage storeResultType = DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, 0, out _columnMapGenerators[0]); for (int i = 1; i < resultSetCount; i++) { DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, i, out _columnMapGenerators[i]); } // Copy over parameters (this happens through a more indirect route in the plan compiler, but // it happens nonetheless) List <KeyValuePair <string, TypeUsage> > providerParameters = new List <KeyValuePair <string, TypeUsage> >(); foreach (KeyValuePair <string, TypeUsage> parameter in entityCommandTree.Parameters) { providerParameters.Add(parameter); } // Construct store command tree usage. DbFunctionCommandTree providerCommandTree = new DbFunctionCommandTree(entityCommandTree.MetadataWorkspace, DataSpace.SSpace, mapping.TargetFunction, storeResultType, providerParameters); DbCommandDefinition storeCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandTree); _mappedCommandDefinitions = new List <DbCommandDefinition>(1) { storeCommandDefinition }; EntitySet firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault(); if (firstResultEntitySet != null) { _entitySets = new Set <EntitySet>(); _entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault()); _entitySets.MakeReadOnly(); } } // Finally, build a list of the parameters that the resulting command should have; List <EntityParameter> parameterList = new List <EntityParameter>(); foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters) { EntityParameter parameter = CreateEntityParameterFromQueryParameter(queryParameter); parameterList.Add(parameter); } _parameters = new System.Collections.ObjectModel.ReadOnlyCollection <EntityParameter>(parameterList); } catch (EntityCommandCompilationException) { // No need to re-wrap EntityCommandCompilationException throw; } catch (Exception e) { // we should not be wrapping all exceptions if (EntityUtil.IsCatchableExceptionType(e)) { // we don't wan't folks to have to know all the various types of exceptions that can // occur, so we just rethrow a CommandDefinitionException and make whatever we caught // the inner exception of it. throw EntityUtil.CommandCompilation(System.Data.Entity.Strings.EntityClient_CommandDefinitionPreparationFailed, e); } throw; } }
/// <summary> /// /// </summary> public StringAbstraction(Set <SimpleCharacterAbstraction> /*!*/ characters) { this.content = ContentType.SetOfCharacters; this.characters = characters; }
// Initializes a new CNF sentence given its clauses. internal CnfSentence(Set <CnfClause <T_Identifier> > clauses) : base(clauses, ExprType.And) { }
static private IAbstractDomain /*!*/ HelperForSetOfCharactersJoin(Set <SimpleCharacterAbstraction> /*!*/ iSet1, Set <SimpleCharacterAbstraction> /*!*/ iSet2) { Set <SimpleCharacterAbstraction> union = iSet1.Union(iSet2); return(new StringAbstraction(union)); }
public bool LessEqual(IAbstractDomain /*!*/ a) { bool tryResult; if (AbstractDomainsHelper.TryTrivialLessEqual(this, a, out tryResult)) { return(tryResult); } StringAbstraction right = a as StringAbstraction; //^ assert right != null; Debug.Assert(right != null, "I was expecting a " + this.GetType().ToString()); bool result; if (this.content == right.content) { switch (this.content) { #region All the cases case ContentType.Prefix: result = this.prefix.StartsWith(right.prefix); // it is larger if it is a substring break; case ContentType.SetOfCharacters: result = this.characters.IsSubset(right.characters); // it is larger if it is a subset break; case ContentType.String: result = this.fullstring.CompareTo(right.fullstring) == 0; // must be the same string break; case ContentType.Bottom: case ContentType.Top: default: throw new AbstractInterpretationException("Unexpected case : " + this.content); #endregion } } else { switch (this.content) { #region All the cases case ContentType.Prefix: if (right.content == ContentType.SetOfCharacters) { result = false; } else if (right.content == ContentType.String) { result = false; } else { goto default; } break; case ContentType.SetOfCharacters: if (right.content == ContentType.Prefix) { result = false; } else if (right.content == ContentType.String) { result = false; } else { goto default; } break; case ContentType.String: if (right.content == ContentType.Prefix) { result = this.fullstring.StartsWith(right.prefix); } else if (right.content == ContentType.SetOfCharacters) { Set <SimpleCharacterAbstraction> tmp = AlphaToSetOfCharacters(this.fullstring); result = tmp.IsSubset(right.characters); } else { goto default; } break; case ContentType.Bottom: case ContentType.Top: default: throw new AbstractInterpretationException("Unexpected case : " + this.content); #endregion } } return(result); }