public bool Contains(string path, int start, StringComparison comparison)
{
if (!HasNodes)
{
return(false);
}
var indexOfDot = path.IndexOf('.', start);
if (indexOfDot < 0)
{
var segment = path.Substring(start);
return(Nodes.Any(n => n.Value.Equals(segment, comparison)));
}
else
{
var segment = path.Substring(start, indexOfDot - start);
foreach (var node in Nodes.Where(n => n.Value.Equals(segment, comparison)))
{
var nextStart = start + segment.Length + 1;
if (nextStart >= path.Length)
{
return(true);
}
else if (node.Contains(path, nextStart, comparison))
{
return(true);
}
}
return(false);
}
}
internal override void WriteBody(EndianBinaryWriter writer, StringSet stringSet, BinaryFormat format)
{
writer.Write(StartIndex);
writer.Write(Nodes.Count);
stringSet.WriteString(writer, ExternalName);
stringSet.WriteString(writer, Name);
bool shouldWriteRotation = format == BinaryFormat.FT && Nodes.Any(x =>
Math.Abs(x.Rotation.X) > 0 ||
Math.Abs(x.Rotation.Y) > 0 ||
Math.Abs(x.Rotation.Z) > 0);
writer.ScheduleWriteOffsetIf(shouldWriteRotation, 4, AlignmentMode.Left, () =>
{
foreach (var bone in Nodes)
{
bone.WriteOsgBlockInfo(writer, stringSet);
}
});
if (writer.AddressSpace == AddressSpace.Int64)
{
writer.WriteNulls(4 * sizeof(ulong));
}
else
{
writer.WriteNulls(5 * sizeof(uint));
}
}
void VerifyNoCyclicDependency()
{
if (Nodes.Any(x => x.HasRecursiveNodes()))
{
throw new InvalidOperationException();
}
}
public void Surround(INode newParent)
{
if (newParent == null)
{
throw new ArgumentNullException(nameof(newParent));
}
if (Nodes.Any(m => m.NodeType != NodeType.Text && IsPartiallyContained(m)))
{
throw new DomException(DomError.InvalidState);
}
var type = newParent.NodeType;
if (type == NodeType.Document || type == NodeType.DocumentType || type == NodeType.DocumentFragment)
{
throw new DomException(DomError.InvalidNodeType);
}
var fragment = ExtractContent();
while (newParent.HasChildNodes)
{
newParent.RemoveChild(newParent.FirstChild);
}
Insert(newParent);
newParent.PreInsert(fragment, null);
Select(newParent);
}
private void CaluclateJointLoadVector()
{
if (NumberOfDegreesOfFreedom != 0)
{
JointLoadVector = Vector <double> .Build.Dense(NumberOfDegreesOfFreedom);
}
for (int i = 0; i < NumberOfDegreesOfFreedom; i++)
{
if (Nodes.Any(n => n.HorizontalMovementNumber == i))
{
JointLoadVector[i] = Nodes.SingleOrDefault(n => n.HorizontalMovementNumber == i)?
.ConcentratedForces.Sum(cf => cf.CalculateJointLoadVectorNormalForceMember()) ?? 0;
}
else if (Nodes.Any(n => n.VerticalMovementNumber == i))
{
JointLoadVector[i] = Nodes.SingleOrDefault(n => n.VerticalMovementNumber == i)?
.ConcentratedForces.Sum(cf => cf.CalculateJointLoadVectorShearMember()) ?? 0;
}
else
{
JointLoadVector[i] = Nodes.SingleOrDefault(n => n.LeftRotationNumber == i || n.RightRotationNumber == i)?
.ConcentratedForces.Sum(cf => cf.CalculateJointLoadVectorBendingMomentMember()) ?? 0;
}
}
}
public bool Contains(string path)
{
path = path.Replace("\\", "/");
int f = path.IndexOf("/");
if (f == -1)
{
string v;
bool hasAttr = Attributes.TryGetValue(path, out v);
if (hasAttr)
{
return(true);
}
return(Nodes.Any(o => o.Name == path));
}
string name = path.Substring(0, f);
SettingNode node = Nodes.FirstOrDefault(o => o.Name == name);
if (node == null)
{
return(false);
}
return(node.Contains(path.Substring(f + 1)));
}
/// <summary>
/// Удаление "висячих" точек и рёбер
/// </summary>
private void RemovePendentEdges()
{
while (Nodes.Any(pn => pn.Edges.Count == 1))
{
foreach (var pn in Nodes.ToList().Where(pn => pn.Edges.Count == 1))
{
if (pn.Edges.Count == 0)
{
continue;
}
var edge = pn.Edges[0];
// "висящее" ребро на главном периметре не должно удаляться
var masterEdge = (edge.IsHorizontal && (edge.Node1.Offset.Y == Area.Top && edge.Node2.Offset.Y == Area.Top ||
edge.Node1.Offset.Y == Area.Bottom && edge.Node2.Offset.Y == Area.Bottom)) ||
(edge.IsVertical && (edge.Node1.Offset.X == Area.Left && edge.Node2.Offset.X == Area.Left ||
edge.Node1.Offset.X == Area.Right && edge.Node2.Offset.X == Area.Right));
if (masterEdge)
{
goto exit;
}
var pnOther = edge.Node1 == pn ? edge.Node2 : edge.Node1;
pnOther.Edges.Remove(edge);
Edges.Remove(edge);
Nodes.Remove(pn);
RemoveIsAnadromousNode(pnOther);
}
}
exit:
// удаление одиноких узловых точек
Nodes.RemoveAll(pn => pn.IsEmpty);
}
/// <summary>
/// Removes a node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
bool IObservableGraphSource.RemoveNode(object node)
{
IsDirty = true;
if (Nodes.Contains(node))
{
var nodeVm = node as NodeViewModel;
Nodes.Remove(nodeVm);
var connections = Connections.Where(x =>
!Nodes.Any(y => y.Id == x.SourceViewModel?.Id) ||
!Nodes.Any(y => y.Id == x.TargetViewModel?.Id)).ToList();
foreach (var connection in connections)
{
Connections.Remove(connection);
}
return(true);
}
else
{
return(false);
}
}
public override string ToString()
{
var builder = new StringBuilder();
builder.Append(Message);
if (Nodes.Any())
{
if (!Message.EndsWith("."))
{
builder.Append(". ");
}
builder.Append("At ");
foreach (var node in Nodes)
{
if (node.Location != null)
{
builder.Append($"{node.Kind}@{node.Location}");
}
else
{
builder.Append($"{node.Kind}");
}
builder.Append(", ");
}
}
return(builder.ToString().Trim().TrimEnd(','));
}
private bool CheckIfMetInMiddle()
{
// This is the most optimal way that I found to check for matching nodes
var destSet = DestinationSet;
var sourceSet = SourceSet;
destSet.UnionWith(DestinationGraph.Nodes.Select(s => s.CubeNode));
sourceSet.UnionWith(Nodes.Select(f => f.CubeNode));
var intersect = destSet.Intersect(sourceSet, CubeComparer).Any(); // Intersects both sets to check for any matched
if (!intersect)
{
return(true);
}
var all = DestinationGraph.Nodes.Where(b => Nodes.Any(a => a.IsEqual(b))); // Checks which node matched
var sourceNode = all.First(); // Gets the matching node
if (sourceNode == null)
{
return(true);
}
MiddleNode = sourceNode; // Set the middle propety to the matching node
DestinationGraph.SolvedNode = SolvedNode; // Set the destination solved node to this node
return(false);
}
private void AddNodeViewModel(Node viewModel)
{
Nodes.Add(viewModel);
ShowBoundingBox = Nodes.Any();
AddWiresForNode(viewModel);
UpdateDiagramBoundingBox();
NotifyOfPropertyChange(nameof(Nodes));
}
/// <summary>
/// Removes a node from the diagram.
/// </summary>
/// <param name="node">The node to remove.</param>
public void RemoveNode(Node node)
{
DiagramModel.RemoveNode(node.Model);
Nodes.Remove(node);
UpdateDiagramBoundingBox();
ShowBoundingBox = Nodes.Any();
NotifyOfPropertyChange(nameof(Nodes));
}
public void Visit(Action <BackTrackingNode> function)
{
function.Invoke(this);
if (Nodes != null && Nodes.Any())
{
Nodes.ForEach(d => d.Visit(function));
}
}
public bool HasChildrens()
{
if (nodesDirty)
{
RebuildChildrensCore();
}
return(Nodes.Any());
}
private void AddNodeViewModel(Node viewModel)
{
Nodes.Add(viewModel);
BoundingBoxVisible = Nodes.Any();
AddWiresForNode(viewModel);
viewModel.Initialize();
UpdateDiagramBoundingBox();
NotifyOfPropertyChange(nameof(AreInstructionsVisible));
}
private int FindIndexOfNodeThatShouldPrecede(ProcessGroupNode aNodeGroup)
{
Func <Node, bool> textPrecedesNodeText = node => aNodeGroup.Text.CompareTo(node.Text) > 0;
if (!Nodes.Any(textPrecedesNodeText))
{
return(-1);
}
return(Nodes.Last(textPrecedesNodeText).Index);
}
public void AddNode(SwimNode node)
{
lock (_nodesLock)
{
if (!Nodes.Any(x => x.Endpoint == node.Endpoint))
{
Nodes.Enqueue(node);
}
}
}
public void SetStatus()
{
if (!Nodes.Any())
{
Status = ClusterStatus.NoThresholdsSet;
return;
}
Status = (ClusterStatus)Nodes.SelectMany(n => n.Metrics).Select(m => m.Status).Max();
}
public bool ContainsVector2(Vector2 position)
{
bool contains = false;
if (Nodes.Any(x => x.Position == position))
{
contains = true;
}
return(contains);
}
public override string ToString()
{
var print = base.ToString();
if (!Nodes.Any() && !Properties.Any())
{
print += $": {TypeHelper.ToStringOrNull(Value)}";
}
return(print);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public string NextNodeID()
{
int i = 1;
while (Nodes.Any(a => a.Name == $"Node {i}"))
{
i++;
}
return($"Node {i}");
}
public void UpdateWires()
{
do
{
foreach (Wire wire in Wires)
{
wire.Update();
UpdateCount++;
}
} while (Nodes.Any(node => node.RequiresUpdate));
}
public IEnumerator <Tuple <ConversationNode, IConversationEditorControlData <ConversationNode, TransitionNoduleUIInfo> > > MakeEnumerator()
{
if (Nodes.Any())
{
return(Nodes.Select(n => new Tuple <ConversationNode, IConversationEditorControlData <ConversationNode, TransitionNoduleUIInfo> >(n, File)).InfiniteRepeat().GetEnumerator());
}
else
{
return(null);
}
}
public Node AddNodeAt(Vector3 vector)
{
var node = new Node()
{
Id = Nodes.Any() ? Nodes.Max(n => n.Id) + 1 : 1,
Location = vector
};
Nodes.Add(node);
return(node);
}
public static void DebugStatus()
{
Log.Message("duplicated positions:\n " +
string.Join(
"\n",
Nodes.Where(n => Nodes.Any(n2 => n != n2 && n.X == n2.X && n.Y == n2.Y))
.Select(n => n.X + ", " + n.Y + ": " + n.Label).ToArray()));
Log.Message("out-of-bounds nodes:\n" +
string.Join(
"\n", Nodes.Where(n => n.X < 1 || n.Y < 1).Select(n => n.ToString()).ToArray()));
Log.Trace(ToString());
}
protected string GetPath(bool moreMarker)
{
var more = moreMarker && Nodes.Any() ? ">" : string.Empty;
var value = Parent?.GetPath(false);
var parentPath = string.IsNullOrEmpty(value) ? string.Empty : $"{value}/";
if (GetType() == typeof(SubMenu))
{
return(string.Empty);
}
return($"{parentPath}{Name}{more}");
}
public void PrintNodes()
{
if (!Nodes.Any())
{
throw new Exception("There's no nodes.");
}
int index = 0;
foreach (Node node in Nodes)
{
Console.WriteLine(String.Format("Node {0}: {1}", ++index, node));
}
}
private MergerCompareResult Evaluate()
{
if (!Nodes.Any() && !Properties.Any())
{
return(MergerCompareEngine.Evaluate(Instance, Compare));
}
var results = Properties.SelectMany(k => k.Value).Select(p => p.Result)
.Union(Nodes.SelectMany(k => k.Value).Select(n => n.Result))
.Distinct()
.ToList();
return(results.Count > 1 ? MergerCompareResult.Different : results.First());
}
public Dgml AddNode(string id, string label)
{
if (!Nodes.Any(node => node.Id == id))
{
Nodes.Add(new DgmlNode
{
Id = id,
Label = label
});
}
return(this);
}
public void RemoveNode(Node viewModel)
{
var wiresConnectedToNode = viewModel.Terminals.SelectMany(t => t.Model.ConnectedWires);
var wiresToRemove = Wires.Where(w => wiresConnectedToNode.Contains(w.Model));
wiresToRemove.ForEach(RemoveWire);
Model.RemoveNode(viewModel.Model);
Nodes.Remove(viewModel);
viewModel.DisconnectAllTerminals();
viewModel.Uninitialize();
UpdateDiagramBoundingBox();
BoundingBoxVisible = Nodes.Any();
NotifyOfPropertyChange(nameof(AreInstructionsVisible));
}
