private void MakeEdges(IGraphLoader <TV, TE> loader, int vid, Dictionary <VfEdge, VfEdge> dctEdge, List <int> mpIvtxGraphIvtxVf)
{
var ivtxGraph = loader.PosFromId(vid);
var vfeKey = new VfEdge(mpIvtxGraphIvtxVf[ivtxGraph], 0, null);
MakeOutEdges(loader, vid, dctEdge, mpIvtxGraphIvtxVf, ref vfeKey);
MakeInEdges(loader, vid, dctEdge, mpIvtxGraphIvtxVf, ref vfeKey);
}
/// <summary>
/// Add edge to a vertex that is defined only by its mandatory fields
/// </summary>
/// <typeparam name="V"></typeparam>
/// <typeparam name="E"></typeparam>
/// <param name="loader"></param>
/// <param name="outVertex"></param>
/// <param name="edge"></param>
/// <param name="inVId"></param>
/// <param name="inVLabel"></param>
/// <param name="inVPk"></param>
/// <returns></returns>
public static Task AddEdgeAsync <V, E>(this IGraphLoader loader,
V outVertex, E edge, string inVId, string inVLabel, string inVPk = null)
{
return(loader.AddEdgeAsync(outVertex, edge, new {
id = inVId,
label = inVLabel,
__pk = inVPk
}));
}
internal VfnNode(IGraphLoader loader, int inodGraph, Dictionary <VfeNode, VfeNode> dctEdge, int[] mpInodGraphInodVf)
{
int nid = loader.IdFromPos(inodGraph);
_objAttr = loader.GetNodeAttr(nid);
_arvfeEdgeOut = new VfeNode[loader.OutEdgeCount(nid)];
_arvfeEdgeIn = new VfeNode[loader.InEdgeCount(nid)];
MakeEdges(loader, nid, dctEdge, mpInodGraphInodVf);
}
internal VfVertex(IGraphLoader <TV, TE> loader, int ivtxGraph, Dictionary <VfEdge, VfEdge> dctEdge, List <int> mpIvtxGraphIvtxVf)
{
var vid = loader.IdFromPos(ivtxGraph);
_attribute = loader.GetVertexAttr(vid);
_outEdges = new VfEdge[loader.OutEdgeCount(vid)];
_inEdges = new VfEdge[loader.InEdgeCount(vid)];
MakeEdges(loader, vid, dctEdge, mpIvtxGraphIvtxVf);
}
/// <summary>
/// Add edge from a vertex that is defined only by its mandatory fields
/// </summary>
/// <typeparam name="E"></typeparam>
/// <typeparam name="V"></typeparam>
/// <param name="loader"></param>
/// <param name="outVId"></param>
/// <param name="outVLabel"></param>
/// <param name="edge"></param>
/// <param name="outVertex"></param>
/// <param name="outVPk"></param>
/// <returns></returns>
public static Task AddEdgeAsync <E, V>(this IGraphLoader loader,
string outVId, string outVLabel, E edge, V outVertex, string outVPk = null)
{
return(loader.AddEdgeAsync(new {
id = outVId,
label = outVLabel,
__pk = outVPk
}, edge, outVertex));
}
public ETLContext(
GraphExtractor graphExtractor,
GraphTransformer graphTransformer,
IGraphLoader graphLoader,
Presenter presenter)
{
this.graphExtractor = graphExtractor;
this.graphTransformer = graphTransformer;
this.graphLoader = graphLoader;
this.presenter = presenter;
}
/// <summary>
/// Create node stream decoder
/// </summary>
/// <param name="loader"></param>
/// <param name="deviceId"></param>
/// <param name="tags"></param>
/// <param name="revision"></param>
/// <param name="codec"></param>
/// <param name="logger"></param>
internal NodeSetStreamLoader(IGraphLoader loader, string deviceId,
IDictionary <string, string> tags, long revision, IVariantEncoderFactory codec,
ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_codec = codec?.Default ?? throw new ArgumentNullException(nameof(codec));
_deviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
_tags = tags ?? throw new ArgumentNullException(nameof(tags));
_loader = loader ?? throw new ArgumentNullException(nameof(loader));
_revision = revision;
}
private void MakeEdges(IGraphLoader loader, int nid, Dictionary <VfeNode, VfeNode> dctEdge, int[] mpInodGraphInodVf)
{
int inodGraph = loader.PosFromId(nid);
int inodVf = mpInodGraphInodVf[inodGraph];
VfeNode vfeKey = new VfeNode(0, 0, null);
vfeKey._inodFrom = inodVf;
MakeOutEdges(loader, nid, dctEdge, mpInodGraphInodVf, ref vfeKey);
vfeKey._inodTo = inodVf;
MakeInEdges(loader, nid, dctEdge, mpInodGraphInodVf, ref vfeKey);
}
internal VfGraph(IGraphLoader loader, int[] mpInodVfInodGraph)
{
_arNodes = new VfnNode[loader.NodeCount];
int[] mpInodGraphInodVf = ReversePermutation(mpInodVfInodGraph);
Dictionary <VfeNode, VfeNode> dctEdge = new Dictionary <VfeNode, VfeNode>();
for (int inodVf = 0; inodVf < loader.NodeCount; inodVf++)
{
_arNodes[inodVf] = new VfnNode(loader, mpInodVfInodGraph[inodVf], dctEdge, mpInodGraphInodVf);
}
}
public VfState(
IGraphLoader <TV, TE> loader1,
IGraphLoader <TV, TE> loader2,
bool fIsomorphism = false,
bool fContextCheck = false)
{
LstIn1 = new SortedListNoValue <int>();
LstOut1 = new SortedListNoValue <int>();
LstIn2 = new SortedListNoValue <int>();
LstOut2 = new SortedListNoValue <int>();
LstDisconnected2 = new SortedListNoValue <int>();
LstDisconnected1 = new SortedListNoValue <int>();
_ldr1 = loader1;
_ldr2 = loader2;
_fContextCheck = fContextCheck;
if (fIsomorphism)
{
// normal isomorphism - degrees must match exactly
FnCompareDegrees = CmpIsomorphism;
}
else
{
// Subgraph isomorphism - degrees in graph2 must be less than
// those of graph1.
FnCompareDegrees = CmpSubgraphIsomorphism;
}
// Vertex indices in VfGraphs are sorted by vertex degree
_degreeSortedToOriginal1 = new CmpVertexDegrees <TV, TE>(loader1).Permutation;
_degreeSortedToOriginal2 = new CmpVertexDegrees <TV, TE>(loader2).Permutation;
VfGraph1 = new VfGraph <TV, TE>(loader1, _degreeSortedToOriginal1);
VfGraph2 = new VfGraph <TV, TE>(loader2, _degreeSortedToOriginal2);
// Set up space for isomorphism mappings
_vfGraphIvtx1To2Isomorphism = new Dictionary <int, int>(loader1.VertexCount);
_vfGraphIvtx2To1Isomorphism = new Dictionary <int, int>(loader2.VertexCount);
// When we start no isomorphic mappings and all vertices are disconnected
// from the isomorphism.
for (var i = 0; i < loader1.VertexCount; i++)
{
_vfGraphIvtx1To2Isomorphism[i] = MapIllegal;
LstDisconnected1.Add(i);
}
for (var i = 0; i < loader2.VertexCount; i++)
{
_vfGraphIvtx2To1Isomorphism[i] = MapIllegal;
LstDisconnected2.Add(i);
}
}
internal VfGraph(IGraphLoader <TVAttr, TEAttr> loader, List <int> mpIvtxVfIvtxGraph = null)
{
if (mpIvtxVfIvtxGraph == null)
{
mpIvtxVfIvtxGraph = (new CmpVertexDegrees <TVAttr, TEAttr>(loader)).Permutation;
}
_arNodes = new VfVertex <TVAttr, TEAttr> [loader.VertexCount];
var mpIvtxGraphIvtxVf = ReversePermutation(mpIvtxVfIvtxGraph);
var dctEdge = new Dictionary <VfEdge, VfEdge>();
for (var ivtxVf = 0; ivtxVf < loader.VertexCount; ivtxVf++)
{
_arNodes[ivtxVf] = new VfVertex <TVAttr, TEAttr>(loader, mpIvtxVfIvtxGraph[ivtxVf], dctEdge, mpIvtxGraphIvtxVf);
}
}
private static void ProcessGraph(IArgumentsParser parser, TextWriter writer)
{
IGraphLoader loader = ServiceLocator.Current.GetInstance <IGraphLoader>();
IList <Node> graph = loader.LoadGraph(parser.Path, writer);
IGraphStorageService storage = ServiceLocator.Current.GetInstance <IGraphStorageService>();
if (parser.UseRecreationMode)
{
storage.DeleteGraph();
writer.WriteLine("Old graph has been deleted.");
}
storage.SaveGraph(graph);
writer.WriteLine("Graph data has been saved.");
writer.Flush();
}
private void MakeInEdges(IGraphLoader <TV, TE> loader, int vid, Dictionary <VfEdge, VfEdge> dctEdge, List <int> mpIvtxGraphIvtxVf, ref VfEdge vfeKey)
{
for (var i = 0; i < loader.InEdgeCount(vid); i++)
{
TE attr;
vfeKey.IvtxFrom = mpIvtxGraphIvtxVf[loader.PosFromId(loader.GetInEdge(vid, i, out attr))];
if (!dctEdge.ContainsKey(vfeKey))
{
_inEdges[i] = dctEdge[vfeKey] = new VfEdge(vfeKey.IvtxFrom, vfeKey.IvtxTo, attr);
vfeKey = new VfEdge(vfeKey.IvtxFrom, vfeKey.IvtxTo, null);
}
else
{
_inEdges[i] = dctEdge[vfeKey];
}
}
}
private void MakeInEdges(IGraphLoader loader, int nid, Dictionary <VfeNode, VfeNode> dctEdge, int[] mpInodGraphInodVf, ref VfeNode vfeKey)
{
object attr;
for (int i = 0; i < loader.InEdgeCount(nid); i++)
{
vfeKey._inodFrom = mpInodGraphInodVf[loader.PosFromId(loader.GetInEdge(nid, i, out attr))];
if (!dctEdge.ContainsKey(vfeKey))
{
_arvfeEdgeIn[i] = dctEdge[vfeKey] = new VfeNode(vfeKey._inodFrom, vfeKey._inodTo, attr);
vfeKey = new VfeNode(vfeKey._inodFrom, vfeKey._inodTo, null);
}
else
{
_arvfeEdgeIn[i] = dctEdge[vfeKey];
}
}
}
public VfState(IGraphLoader loader1, IGraphLoader loader2, bool fIsomorphism, bool fContextCheck, bool fFindAll)
{
_ldr1 = loader1;
_ldr2 = loader2;
_fContextCheck = fContextCheck;
_fFindAll = fFindAll;
if (fIsomorphism)
{
fnCmp = new FCompareDegreesDelegate(CmpIsomorphism);
}
else
{
fnCmp = new FCompareDegreesDelegate(CmpSubgraphIsomorphism);
}
// Salmon commend becuase never used.
// _fIsomorphism = fIsomorphism;
_armpInodVfInodGraph1 = new CmpNodeDegrees(loader1).Permutation;
_armpInodVfInodGraph2 = new CmpNodeDegrees(loader2).Permutation;
_vfgr1 = new VfGraph(loader1, _armpInodVfInodGraph1);
_vfgr2 = new VfGraph(loader2, _armpInodVfInodGraph2);
_arinodMap1To2 = new int[loader1.NodeCount];
_arinodMap2To1 = new int[loader2.NodeCount];
for (int i = 0; i < loader1.NodeCount; i++)
{
_arinodMap1To2[i] = map_Illegal;
_lstDisconnected1.Add(i);
}
for (int i = 0; i < loader2.NodeCount; i++)
{
_arinodMap2To1[i] = map_Illegal;
_lstDisconnected2.Add(i);
}
}
/*
* // void Load() {
* public void Load() {
* GraphLoader graphLoader = new GraphLoader(GRAPH_XML);
* states = graphLoader.LoadStateGraph();
* }
*/
public void Load(IGraphLoader graphLoader)
{
states = graphLoader.LoadStateGraph();
}
public VfState(IGraphLoader loader1, IGraphLoader loader2, bool fIsomorphism, bool fContextCheck) : this(loader1, loader2, fIsomorphism, fContextCheck, false)
{
}
public VfState(IGraphLoader loader1, IGraphLoader loader2, bool fIsomorphism) : this(loader1, loader2, fIsomorphism, false, false)
{
}
public VfState(IGraphLoader loader1, IGraphLoader loader2) : this(loader1, loader2, false, false, false)
{
}
internal CmpVertexDegrees(IGraphLoader <TV, TE> loader)
{
_loader = loader;
}
internal CmpNodeDegrees(IGraphLoader loader)
{
_loader = loader;
}