public static void GroupClashes(ClashTest selectedClashTest, GroupingMode groupingMode, GroupingMode subgroupingMode, bool keepExistingGroups) { //Get existing clash result List <ClashResult> clashResults = GetIndividualClashResults(selectedClashTest, keepExistingGroups).ToList(); List <ClashResultGroup> clashResultGroups = new List <ClashResultGroup>(); //Create groups according to the first grouping mode CreateGroup(ref clashResultGroups, groupingMode, clashResults, ""); //Optionnaly, create subgroups if (subgroupingMode != GroupingMode.None) { CreateSubGroups(ref clashResultGroups, subgroupingMode); } //Remove groups with only one clash List <ClashResult> ungroupedClashResults = RemoveOneClashGroup(ref clashResultGroups); //Backup the existing group, if necessary if (keepExistingGroups) { clashResultGroups.AddRange(BackupExistingClashGroups(selectedClashTest)); } //Process these groups and clashes into the clash test ProcessClashGroup(clashResultGroups, ungroupedClashResults, selectedClashTest); }
private static List <ClashResultGroup> GroupByElementOfAGivenSelection(List <ClashResult> results, GroupingMode mode, string initialName) { Dictionary <ModelItem, ClashResultGroup> groups = new Dictionary <ModelItem, ClashResultGroup>(); ClashResultGroup currentGroup; List <ClashResultGroup> emptyClashResultGroups = new List <ClashResultGroup>(); foreach (ClashResult result in results) { //Cannot add original result to new clash test, so I create a copy ClashResult copiedResult = (ClashResult)result.CreateCopy(); ModelItem modelItem = null; if (mode == GroupingMode.SelectionA) { if (copiedResult.CompositeItem1 != null) { modelItem = GetSignificantAncestorOrSelf(copiedResult.CompositeItem1); } else if (copiedResult.CompositeItem2 != null) { modelItem = GetSignificantAncestorOrSelf(copiedResult.CompositeItem2); } } else if (mode == GroupingMode.SelectionB) { if (copiedResult.CompositeItem2 != null) { modelItem = GetSignificantAncestorOrSelf(copiedResult.CompositeItem2); } else if (copiedResult.CompositeItem1 != null) { modelItem = GetSignificantAncestorOrSelf(copiedResult.CompositeItem1); } } string displayName = "Empty clash"; if (modelItem != null) { displayName = modelItem.DisplayName; //Create a group if (!groups.TryGetValue(modelItem, out currentGroup)) { currentGroup = new ClashResultGroup(); if (string.IsNullOrEmpty(displayName)) { displayName = modelItem.Parent.DisplayName; } if (string.IsNullOrEmpty(displayName)) { displayName = "Unnamed Parent"; } currentGroup.DisplayName = initialName + displayName; groups.Add(modelItem, currentGroup); } //Add to the group currentGroup.Children.Add(copiedResult); } else { System.Diagnostics.Debug.WriteLine("test"); ClashResultGroup oneClashResultGroup = new ClashResultGroup(); oneClashResultGroup.DisplayName = "Empty clash"; oneClashResultGroup.Children.Add(copiedResult); emptyClashResultGroups.Add(oneClashResultGroup); } } List <ClashResultGroup> allGroups = groups.Values.ToList(); allGroups.AddRange(emptyClashResultGroups); return(allGroups); }
public void Test_CreateNodeFromExecutionPort_FromOutput(TestingMode testingMode, GroupingMode groupingMode) { var inGroupTest = groupingMode == GroupingMode.Grouped; var stack = GraphModel.CreateStack("Stack", Vector2.zero); var output0 = stack.OutputPorts[0]; var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null; TestPrereqActionPostreq(testingMode, () => { Assert.That(GetStackCount(), Is.EqualTo(1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); return(new CreateNodeFromExecutionPortAction(output0, Vector2.down, groupModel: group)); }, () => { Assert.That(GetStackCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var newStack = GetStack(1); Assert.That(newStack, Is.TypeOf <StackModel>()); Assert.That(newStack.IsGrouped, Is.EqualTo(inGroupTest)); Assert.That(newStack.GroupNodeModel, Is.EqualTo(group)); Assert.That(stack.OutputPorts[0].ConnectionPortModels.First(), Is.EqualTo(newStack.InputPorts[0])); }); }
public void Test_CreateNodeFromLoopPort_CreateLoopStack(TestingMode testingMode, GroupingMode groupingMode) { bool inGroupTest = groupingMode == GroupingMode.Grouped; var stack = GraphModel.CreateStack(string.Empty, Vector2.zero); var loopNode = stack.CreateStackedNode <WhileNodeModel>("loop"); var stackCount = GetStackCount(); var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null; TestPrereqActionPostreq(testingMode, () => { Assert.That(GetStackCount(), Is.EqualTo(stackCount)); var portModel = loopNode.OutputPort; Assert.That(portModel.Connected, Is.False); return(new CreateNodeFromLoopPortAction(loopNode.OutputPort, Vector2.zero, groupModel: group)); }, () => { Assert.That(GetStackCount(), Is.EqualTo(stackCount + 1)); var portModel = loopNode.OutputPort; Assert.That(portModel.Connected, Is.True); var connectedStack = portModel.ConnectionPortModels.Single().NodeModel; Assert.That(connectedStack, Is.TypeOf <WhileHeaderModel>()); Assert.That(connectedStack.IsGrouped, Is.EqualTo(inGroupTest)); Assert.That(connectedStack.GroupNodeModel, Is.EqualTo(group)); }); }
public void Test_CreateEdgeAction_Itemize(TestingMode testingMode, GroupingMode groupingMode, ItemizeOptions options, ItemizeTestType itemizeTest, Func <VSGraphModel, IHasMainOutputPort> makeNode) { // save initial itemize options VSPreferences pref = ((TestState)m_Store.GetState()).Preferences; ItemizeOptions initialOptions = pref.CurrentItemizeOptions; bool inGroupTest = groupingMode == GroupingMode.Grouped; try { // create int node IHasMainOutputPort node0 = makeNode(GraphModel); IPortModel output0 = node0.OutputPort; // create Addition node BinaryOperatorNodeModel opNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GroupNodeModel group = null; if (inGroupTest) { // Create GroupNode group = GraphModel.CreateGroupNode("", Vector2.zero); group.AddNode(opNode); } // enable Itemize depending on the test case var itemizeOptions = ItemizeOptions.Nothing; pref.CurrentItemizeOptions = (itemizeTest == ItemizeTestType.Enabled) ? options : itemizeOptions; // connect int to first input m_Store.Dispatch(new CreateEdgeAction(opNode.InputPortA, output0)); m_Store.Update(); // test how the node reacts to getting connected a second time TestPrereqActionPostreq(testingMode, () => { var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First(); IPortModel input0 = binOp.InputPortA; IPortModel input1 = binOp.InputPortB; IPortModel binOutput = binOp.OutputPort; Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(input0, Is.ConnectedTo(output0)); Assert.That(input1, Is.Not.ConnectedTo(output0)); Assert.That(binOutput.Connected, Is.False); Assert.False(node0.IsGrouped); Assert.That(node0.GroupNodeModel, Is.EqualTo(null)); return(new CreateEdgeAction(input1, output0)); }, () => { var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First(); IPortModel input0 = binOp.InputPortA; IPortModel input1 = binOp.InputPortB; IPortModel binOutput = binOp.OutputPort; Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(input0, Is.ConnectedTo(output0)); Assert.That(binOutput.Connected, Is.False); Assert.False(node0.IsGrouped); Assert.That(node0.GroupNodeModel, Is.EqualTo(null)); if (itemizeTest == ItemizeTestType.Enabled) { Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 4 : 3)); IHasMainOutputPort newNode = GetNode(inGroupTest ? 3 : 2) as IHasMainOutputPort; Assert.That(newNode, Is.Not.Null); Assert.That(newNode, Is.TypeOf(node0.GetType())); // ReSharper disable once PossibleNullReferenceException Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest)); Assert.That(newNode.GroupNodeModel, Is.EqualTo(group)); IPortModel output1 = newNode.OutputPort; Assert.That(input1, Is.ConnectedTo(output1)); } else { Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3: 2)); } }); } finally { // restore itemize options pref.CurrentItemizeOptions = initialOptions; } }
public void Test_CreateNodeFromOutputPort_NoConnection(TestingMode testingMode, GroupingMode groupingMode) { var db = new GraphElementSearcherDatabase(Stencil).AddMethods(typeof(Vector2), BindingFlags.Static | BindingFlags.Public).Build(); var item = (GraphNodeModelSearcherItem)db.Search("distance", out _).First(); var inGroupTest = groupingMode == GroupingMode.Grouped; var node0 = GraphModel.CreateNode <Type1FakeNodeModel>("Node0", Vector2.zero); var output0 = node0.Output; var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null; TestPrereqActionPostreq(testingMode, () => { Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2 : 1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item, null, group)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); var newNode = GetNode(inGroupTest ? 2 : 1); Assert.That(newNode, Is.TypeOf <FunctionCallNodeModel>()); Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest)); Assert.That(newNode.GroupNodeModel, Is.EqualTo(group)); var portModel = node0.OutputsByDisplayOrder.First(); Assert.That(portModel.ConnectionPortModels.Count(), Is.EqualTo(0)); }); }
private static void CreateSubGroups(ref List <ClashResultGroup> clashResultGroups, GroupingMode mode) { List <ClashResultGroup> clashResultSubGroups = new List <ClashResultGroup>(); foreach (ClashResultGroup group in clashResultGroups) { List <ClashResult> clashResults = new List <ClashResult>(); foreach (SavedItem item in group.Children) { ClashResult clashResult = item as ClashResult; if (clashResult != null) { clashResults.Add(clashResult); } } List <ClashResultGroup> clashResultTempSubGroups = new List <ClashResultGroup>(); CreateGroup(ref clashResultTempSubGroups, mode, clashResults, group.DisplayName + "_"); clashResultSubGroups.AddRange(clashResultTempSubGroups); } clashResultGroups = clashResultSubGroups; }
static object[] MakeItemizeTestCase(TestingMode testingMode, GroupingMode groupingMode, ItemizeOptions options, ItemizeTestType itemizeTest, Func <VSGraphModel, IHasMainOutputPort> makeNode) { return(new object[] { testingMode, groupingMode, options, itemizeTest, makeNode }); }
private static void CreateGroup(ref List <ClashResultGroup> clashResultGroups, GroupingMode groupingMode, List <ClashResult> clashResults, string initialName) { //group all clashes switch (groupingMode) { case GroupingMode.None: return; case GroupingMode.Level: clashResultGroups = GroupByLevel(clashResults, initialName); break; case GroupingMode.GridIntersection: clashResultGroups = GroupByGridIntersection(clashResults, initialName); break; case GroupingMode.SelectionA: case GroupingMode.SelectionB: clashResultGroups = GroupByElementOfAGivenSelection(clashResults, groupingMode, initialName); break; case GroupingMode.ModelA: case GroupingMode.ModelB: clashResultGroups = GroupByElementOfAGivenModel(clashResults, groupingMode, initialName); break; case GroupingMode.ApprovedBy: case GroupingMode.AssignedTo: case GroupingMode.Status: clashResultGroups = GroupByProperties(clashResults, groupingMode, initialName); break; } }
private static List <ClashResultGroup> GroupByProperties(List <ClashResult> results, GroupingMode mode, string initialName) { Dictionary <string, ClashResultGroup> groups = new Dictionary <string, ClashResultGroup>(); ClashResultGroup currentGroup; foreach (ClashResult result in results) { //Cannot add original result to new clash test, so I create a copy ClashResult copiedResult = (ClashResult)result.CreateCopy(); string clashProperty = null; if (mode == GroupingMode.ApprovedBy) { clashProperty = copiedResult.ApprovedBy; } else if (mode == GroupingMode.AssignedTo) { clashProperty = copiedResult.AssignedTo; } else if (mode == GroupingMode.Status) { clashProperty = copiedResult.Status.ToString(); } if (string.IsNullOrEmpty(clashProperty)) { clashProperty = "Unspecified"; } if (!groups.TryGetValue(clashProperty, out currentGroup)) { currentGroup = new ClashResultGroup(); currentGroup.DisplayName = initialName + clashProperty; groups.Add(clashProperty, currentGroup); } currentGroup.Children.Add(copiedResult); } return(groups.Values.ToList()); }
private void OnGUI() { // Create the string input field for providing the parent name ParentName = EditorGUILayout.TextField("Parent Name", ParentName); // If the ParentName is invalid, revert it to the default if (string.IsNullOrEmpty(ParentName)) { ParentName = "Root"; } // Create the enum pop-up list for specifying the grouping mode GroupAt = (GroupingMode)EditorGUILayout.EnumPopup("Group At", GroupAt); // Supply a pair of labels explaining what the choice of grouping mode does var description = GroupingModeDescriptions[GroupAt]; EditorGUILayout.LabelField("Places the parent at the"); EditorGUILayout.LabelField(description); // Only create the Vector3 input fields for the specified position // if GroupAt is equal to GroupingMode.SpecifiedPosition if (GroupAt == GroupingMode.SpecifiedPosition) { SpecifiedPosition = EditorGUILayout.Vector3Field("Position", SpecifiedPosition); } // Create the boolean check box for specifying whether to close the window at the end CloseWhenFinished = EditorGUILayout.Toggle("Close When Finished", CloseWhenFinished); // Grouping can only happen if there is at least one object selected var relevantObjects = Selection.GetFiltered <GameObject>(SelectionMode.Editable); var notEnoughObjects = relevantObjects.Length == 0; // Create a flexible space to align the Group button at the bottom of the window GUILayout.FlexibleSpace(); // The Group button will be grayed out if there isn't at least one object selected EditorGUI.BeginDisabledGroup(notEnoughObjects); // Create the button to do the actual grouping. If it's pressed, run the Group function if (GUILayout.Button("Group", GUILayout.Height(ButtonHeight))) { Group(); } EditorGUI.EndDisabledGroup(); // If there are enough objects... if (!notEnoughObjects) { // ... Process the keyboard input to check for the Enter key var e = Event.current; // if the Return or Enter key is pressed, run the Group function if (e.type == EventType.KeyDown) { if (e.keyCode == KeyCode.Return || e.keyCode == KeyCode.KeypadEnter) { Group(); } } } }
static void Main(string[] args) { try { bool show_help = false; HashSet <string> typeFilter = new HashSet <string>(); HashSet <int> pidFilter = new HashSet <int>(); HashSet <string> nameFilter = new HashSet <string>(); bool noquery = false; GroupingMode mode = GroupingMode.Pid; ShareMode shareMode = ShareMode.None; bool showsd = false; OptionSet opts = new OptionSet() { { "t|type=", "An object type to filter on, can be repeated", v => typeFilter.Add(v.Trim().ToLower()) }, { "p|pid=", "A PID to filter on, can be repeated", v => pidFilter.Add(int.Parse(v.Trim())) }, { "n|name=", "Specify a process by name", v => nameFilter.Add(v.ToLower()) }, { "q|noquery", "Don't query for names/typenames", v => noquery = v != null }, { "g|group=", "Specify a grouping, defaults to pid, can be object,name,type", v => mode = (GroupingMode)Enum.Parse(typeof(GroupingMode), v, true) }, { "s|share=", "When grouping, filter on shared, can be none,partial or all", v => shareMode = (ShareMode)Enum.Parse(typeof(ShareMode), v, true) }, { "sd", "Display the security descriptor associated with the kernel object", v => showsd = v != null }, { "h|help", "show this message and exit", v => show_help = v != null }, }; opts.Parse(args); if (show_help) { ShowHelp(opts); } else { IEnumerable <NtProcess> filtered = NtProcess.GetProcesses(ProcessAccessRights.MaximumAllowed); if (pidFilter.Count > 0) { filtered = filtered.Where(ps => pidFilter.Contains(ps.ProcessId)); } if (nameFilter.Count > 0) { filtered = filtered.Where(ps => nameFilter.Contains(ps.FullPath, StringComparer.OrdinalIgnoreCase)); } HashSet <int> pids = new HashSet <int>(filtered.Select(process => process.ProcessId)); Dictionary <int, string> pidToName = filtered.ToDictionary(pk => pk.ProcessId, pv => pv.FullPath); List <NtHandle> totalHandles = new List <NtHandle>(); foreach (int pid in pids) { if (pid == Process.GetCurrentProcess().Id) { continue; } IEnumerable <NtHandle> handles = NtSystemInfo.GetHandles(pid, true).Where(ent => (typeFilter.Count == 0) || typeFilter.Contains(ent.ObjectType.ToLower())); totalHandles.AddRange(handles); if (mode == GroupingMode.Pid) { Console.WriteLine("Process ID: {0} - Name: {1}", pid, pidToName[pid]); foreach (NtHandle ent in handles) { Console.WriteLine("{0:X04}: {1:X016} {2:X08} {3,20} {4}", ent.Handle, ent.Object, ent.GrantedAccess, ent.ObjectType, ent.Name); if (showsd && ent.SecurityDescriptor != null) { Console.WriteLine("SDDL: {0}", ent.SecurityDescriptor.ToSddl()); } } Console.WriteLine(); } } switch (mode) { case GroupingMode.Type: PrintGrouping(totalHandles.GroupBy(f => f.ObjectType), pidToName, k => String.Format("Type: {0}", k), e => String.Format("{0:X08} {1:X08} {2}", e.Object, e.GrantedAccess, e.Name), shareMode, pids.Count, showsd); break; case GroupingMode.Object: PrintGrouping(totalHandles.GroupBy(f => f.Object), pidToName, k => String.Format("Object: {0:X08}", k), e => String.Format("{0,20} {1:X08} {2}", e.ObjectType, e.GrantedAccess, e.Name), shareMode, pids.Count, showsd); break; case GroupingMode.Name: PrintGrouping(totalHandles.GroupBy(f => f.ObjectType), pidToName, k => String.Format("Name: {0:X08}", k), e => String.Format("{0:X08} {1,20} {2:X08} {2}", e.Object, e.Name, e.GrantedAccess), shareMode, pids.Count, showsd); break; } } } catch (Exception ex) { Console.WriteLine(ex); } }
public GroupingByFeature() { GroupingMode = GroupingMode.Feature; }