/// <summary>
/// Writes the collection to a stream using the NodeSet schema.
/// </summary>
public static void SaveAsNodeSet(this NodeStateCollection collection, Stream ostrm,
ISystemContext context)
{
var nodeTable = new NodeTable(context.NamespaceUris, context.ServerUris, null);
foreach (var node in collection)
{
node.Export(context, nodeTable);
}
var nodeSet = new NodeSet();
foreach (ILocalNode node in nodeTable)
{
nodeSet.Add(node, nodeTable.NamespaceUris, nodeTable.ServerUris);
}
var settings = new XmlWriterSettings {
Encoding = Encoding.UTF8,
CloseOutput = true,
ConformanceLevel = ConformanceLevel.Document,
Indent = true
};
using (var writer = XmlWriter.Create(ostrm, settings)) {
var serializer = new DataContractSerializer(typeof(NodeSet));
serializer.WriteObject(writer, nodeSet);
}
}
private void Awake()
{
if (!isHome)
{
nodeSet.Add(this);
}
}
public void SetNodes()
{
if (_nodeSpacing == NodeSpacing.Random)
{
// 1. hash the nodes and data and add to the NodeSet
foreach (var node in _nodes) // add node hashes to set and list
{
var modPos = Math.Abs(node.GetHashCode()) % _nodeSpaceSize;
while (NodeHashes.Any(x => x == modPos)) // To avoid collisions, a basic linear probing
{
modPos += 10;
}
NodeHashes.Add(modPos);
NodeSet.Add(modPos, new List <int>());
NodeMap.Add(modPos, node);
}
NodeHashes.Sort(); // Keeping it sorted for the binary search
}
else
{
//2. Equally spaced nodes
var spacing = _nodeSpaceSize / _nodes.Count;
for (int i = 0; i < _nodes.Count; i++)
{
var pos = (spacing * i) % _nodeSpaceSize;
NodeHashes.Add(pos);
NodeSet.Add(pos, new List <int>());
NodeMap.Add(pos, _nodes[i]);
}
}
foreach (var key in _data)
{
AddData(key);
}
}
private static void plugin_main(
IPXPmx pmx, IPEViewConnector view, IPEFormConnector form)
{
StreamWriter writer = makeWriter();
using (writer) {
int[] selectedBodies = view.PmxView.GetSelectedBodyIndices();
int[] selectedJoints = view.PmxView.GetSelectedJointIndices();
makeIndexDict(pmx);
JointGraph g = makeJointGraph(pmx);
NodeSet subNodes = new NodeSet();
NodeSet selectedNodes = new NodeSet();
// pmxvewの選択情報は選択解除しても残ってしまうので
// form の情報で判断する
if (form.SelectedJointIndex >= 0)
{
foreach (int i in selectedJoints)
{
Node jointNode = makeJointNode(pmx.Joint[i]);
selectedNodes.Add(jointNode);
subNodes.UnionWith(
g.getConnectedNodes(jointNode));
}
}
if (form.SelectedBodyIndex >= 0)
{
foreach (int i in selectedBodies)
{
Node bodyNode = makeBodyNode(pmx.Body[i]);
selectedNodes.Add(bodyNode);
subNodes.UnionWith(
g.getConnectedNodes(bodyNode));
}
}
if (selectedNodes.Count > 0)
{
toDot(g, writer, subNodes, selectedNodes);
}
else
{
toDot(g, writer);
}
return;
}
}
public void AddNode(string node)
{
var nodePos = Math.Abs(node.GetHashCode()) % _nodeSpaceSize;
var nextNode = NodeHashes[SearchNodes(nodePos)]; // get the next node
var dataToMove = NodeSet[nextNode].Where(m => m <= nodePos); //get all data keys belonging to the next node but less than node to be added
NodeSet.Add(nodePos, dataToMove.ToList());
NodeSet[nextNode].RemoveAll(m => m <= nodePos);
NodeMap.Add(nodePos, node);
}
public void AddNode(INode <T> node)
{
NodeSet.Add(node);
}
/// <summary>
/// Exports a node to a nodeset.
/// </summary>
public void ExportNode(ILocalNode node, NodeSet nodeSet, bool instance)
{
lock (m_lock)
{
// check if the node has already been added.
NodeId exportedId = nodeSet.Export(node.NodeId, m_nodes.NamespaceUris);
if (nodeSet.Contains(exportedId))
{
return;
}
// add to nodeset.
Node nodeToExport = nodeSet.Add(node, m_nodes.NamespaceUris, m_nodes.ServerUris);
// follow children.
foreach (ReferenceNode reference in node.References)
{
// export all references.
bool export = true;
// unless it is a subtype reference.
if (m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.HasSubtype))
{
export = false;
}
if (export)
{
nodeSet.AddReference(nodeToExport, reference, m_nodes.NamespaceUris, m_nodes.ServerUris);
}
if (reference.IsInverse || m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.HasSubtype))
{
nodeSet.AddReference(nodeToExport, reference, m_nodes.NamespaceUris, m_nodes.ServerUris);
}
if (m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.Aggregates))
{
if (reference.IsInverse)
{
continue;
}
ILocalNode child = GetLocalNode(reference.TargetId) as ILocalNode;
if (child != null)
{
if (instance)
{
NodeId modellingRule = child.ModellingRule;
if (modellingRule != Objects.ModellingRule_Mandatory)
{
continue;
}
}
ExportNode(child, nodeSet, instance);
}
}
}
}
}
private Node(int value, LinkedList <Node> nodes)
{
Value = value;
Nodes = nodes;
NodeSet.Add(this);
}
public override object Clone()
{
NodeSet copy = new NodeSet();
foreach (object o in this)
{
copy.Add(o);
}
return copy;
}
public void AddNode(Node <MapElement> element)
{
element.Index = index;
NodeSet.Add(element);
index++;
}
public void AddToNodeSet(NodeData node)
{
NodeSet.Add(node.Id, node);
}