/// <summary>
/// Instantiates a new PatternVariable object as a copy from an original variable, used for inlining.
/// </summary>
/// <param name="original">The original pattern variable to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new pattern element will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the pattern variable (to avoid name collisions).</param>
public PatternVariable(PatternVariable original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix)
{
type = original.type;
name = original.name + nameSuffix;
unprefixedName = original.unprefixedName + nameSuffix;
pointOfDefinition = newHost;
defToBeYieldedTo = original.defToBeYieldedTo;
initialization = original.initialization;
annotations = original.annotations;
ParameterIndex = original.ParameterIndex;
originalVariable = original;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
}
/// <summary>
/// Instantiates a new PatternNode object as a copy from an original node, used for subpattern inlining.
/// </summary>
/// <param name="original">The original pattern node to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new pattern node will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the pattern node (to avoid name collisions).</param>
public PatternNode(PatternNode original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix)
: base(original, inlinedSubpatternEmbedding, newHost, nameSuffix)
{
}
/// <summary>
/// Instantiates a new PatternEdge object as a copy from an original edge, used for subpattern inlining.
/// </summary>
/// <param name="original">The original pattern edge to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new pattern element will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the pattern edge (to avoid name collisions).</param>
public PatternEdge(PatternEdge original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix)
: base(original, inlinedSubpatternEmbedding, newHost, nameSuffix)
{
fixedDirection = original.fixedDirection;
}
/// <summary>
/// Instantiates a new iterated object as a copy from an original iterated, used for inlining.
/// </summary>
/// <param name="original">The original iterated to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new iterated will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the iterated and its elements (to avoid name collisions).</param>
/// Elements might have been already copied in the containing pattern(s), their copies have to be reused in this case.
public Iterated(Iterated original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix,
Dictionary<PatternNode, PatternNode> nodeToCopy,
Dictionary<PatternEdge, PatternEdge> edgeToCopy,
Dictionary<PatternVariable, PatternVariable> variableToCopy)
{
iteratedPattern = new PatternGraph(original.iteratedPattern, inlinedSubpatternEmbedding, newHost, nameSuffix,
nodeToCopy, edgeToCopy, variableToCopy);
minMatches = original.minMatches;
maxMatches = original.maxMatches;
originalIterated = original;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
}
/// <summary>
/// Instantiates a new PatternElement object as a copy from an original element, used for subpattern inlining.
/// </summary>
/// <param name="original">The original pattern element to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new pattern element will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the pattern element (to avoid name collisions).</param>
public PatternElement(PatternElement original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix)
{
TypeID = original.TypeID;
typeName = original.typeName;
name = original.name + nameSuffix;
unprefixedName = original.unprefixedName + nameSuffix;
pointOfDefinition = newHost;
defToBeYieldedTo = original.defToBeYieldedTo;
initialization = original.initialization != null ? original.initialization.Copy(nameSuffix) : null;
annotations = original.annotations;
AllowedTypes = original.AllowedTypes;
IsAllowedType = original.IsAllowedType;
Cost = original.Cost;
ParameterIndex = original.ParameterIndex;
MaybeNull = original.MaybeNull;
Storage = original.Storage != null ? new StorageAccess(original.Storage) : null;
StorageIndex = original.StorageIndex != null ? new StorageAccessIndex(original.StorageIndex) : null;
IndexAccess = original.IndexAccess != null ? original.IndexAccess.Copy(nameSuffix) : null;
NameLookup = original.NameLookup != null ? original.NameLookup.Copy(nameSuffix) : null;
UniqueLookup = original.UniqueLookup != null ? original.UniqueLookup.Copy(nameSuffix) : null;
ElementBeforeCasting = original.ElementBeforeCasting;
AssignmentSource = original.AssignmentSource;
originalElement = original;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
}
/// <summary>
/// Instantiates a new alternative object as a copy from an original alternative, used for inlining.
/// </summary>
/// <param name="original">The original alternative to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new alternative will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the alternative and its elements (to avoid name collisions).</param>
/// Elements might have been already copied in the containing pattern(s), their copies have to be reused in this case.
public Alternative(Alternative original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix, String pathPrefix_,
Dictionary<PatternNode, PatternNode> nodeToCopy,
Dictionary<PatternEdge, PatternEdge> edgeToCopy,
Dictionary<PatternVariable, PatternVariable> variableToCopy)
{
name = original.name + nameSuffix + "_in_" + inlinedSubpatternEmbedding.PointOfDefinition.pathPrefix + inlinedSubpatternEmbedding.PointOfDefinition.name;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
pathPrefix = pathPrefix_;
alternativeCases = new PatternGraph[original.alternativeCases.Length];
for(int i = 0; i < original.alternativeCases.Length; ++i)
{
PatternGraph altCase = original.alternativeCases[i];
alternativeCases[i] = new PatternGraph(altCase, inlinedSubpatternEmbedding, newHost, nameSuffix,
nodeToCopy, edgeToCopy, variableToCopy);
}
originalAlternative = original;
}
/// <summary>
/// Instantiates a new pattern graph embedding object as a copy from an original embedding, used for inlining.
/// </summary>
/// <param name="original">The original embedding to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="newHost">The pattern graph the new embedding will be contained in.</param>
/// <param name="nameSuffix">The suffix to be added to the name of the embedding (to avoid name collisions).</param>
/// Elements were already copied in the containing pattern(s), their copies have to be reused here.
public PatternGraphEmbedding(PatternGraphEmbedding original, PatternGraphEmbedding inlinedSubpatternEmbedding, PatternGraph newHost, String nameSuffix)
{
PointOfDefinition = newHost;
name = original.name + nameSuffix;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
matchingPatternOfEmbeddedGraph = original.matchingPatternOfEmbeddedGraph;
annotations = original.annotations;
connections = new Expression[original.connections.Length];
for(int i = 0; i < original.connections.Length; ++i)
{
connections[i] = original.connections[i].Copy(nameSuffix);
}
yields = new String[original.yields.Length];
for(int i = 0; i < original.yields.Length; ++i)
{
yields[i] = original.yields[i] + nameSuffix;
}
neededNodes = new String[original.neededNodes.Length];
for(int i = 0; i < original.neededNodes.Length; ++i)
{
neededNodes[i] = original.neededNodes[i] + nameSuffix;
}
neededEdges = new String[original.neededEdges.Length];
for(int i = 0; i < original.neededEdges.Length; ++i)
{
neededEdges[i] = original.neededEdges[i] + nameSuffix;
}
neededVariables = new String[original.neededVariables.Length];
for(int i = 0; i < original.neededVariables.Length; ++i)
{
neededVariables[i] = original.neededVariables[i] + nameSuffix;
}
neededVariableTypes = (VarType[])original.neededVariableTypes.Clone();
originalEmbedding = original;
}
/// <summary>
/// Instantiates a new PatternYielding object as a copy from an original yielding, used for inlining.
/// </summary>
/// <param name="original">The original yielding to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="renameSuffix">The rename suffix to be applied to all the nodes, edges, and variables used.</param>
public PatternYielding(PatternYielding original, PatternGraphEmbedding inlinedSubpatternEmbedding, string renameSuffix)
{
originalYielding = original;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
Name = original.Name + renameSuffix;
ElementaryYieldings = new Yielding[original.ElementaryYieldings.Length];
for(int i = 0; i < original.ElementaryYieldings.Length; ++i)
ElementaryYieldings[i] = original.ElementaryYieldings[i].Copy(renameSuffix);
NeededNodes = new String[original.NeededNodes.Length];
for(int i = 0; i < original.NeededNodes.Length; ++i)
NeededNodes[i] = original.NeededNodes[i] + renameSuffix;
NeededEdges = new String[original.NeededEdges.Length];
for(int i = 0; i < original.NeededEdges.Length; ++i)
NeededEdges[i] = original.NeededEdges[i] + renameSuffix;
NeededVariables = new String[original.NeededVariables.Length];
for(int i = 0; i < original.NeededVariables.Length; ++i)
NeededVariables[i] = original.NeededVariables[i] + renameSuffix;
NeededVariableTypes = (VarType[])original.NeededVariableTypes.Clone();
}
/// <summary>
/// Instantiates a new PatternCondition object as a copy from an original condition, used for inlining.
/// </summary>
/// <param name="original">The original condition to be copy constructed.</param>
/// <param name="inlinedSubpatternEmbedding">The embedding which just gets inlined.</param>
/// <param name="renameSuffix">The rename suffix to be applied to all the nodes, edges, and variables used.</param>
public PatternCondition(PatternCondition original, PatternGraphEmbedding inlinedSubpatternEmbedding, string renameSuffix)
{
originalCondition = original;
originalSubpatternEmbedding = inlinedSubpatternEmbedding;
ConditionExpression = (Expression)original.ConditionExpression.Copy(renameSuffix);
NeededNodes = new String[original.NeededNodes.Length];
for(int i = 0; i < original.NeededNodes.Length; ++i)
NeededNodes[i] = original.NeededNodes[i] + renameSuffix;
NeededEdges = new String[original.NeededEdges.Length];
for(int i = 0; i < original.NeededEdges.Length; ++i)
NeededEdges[i] = original.NeededEdges[i] + renameSuffix;
NeededVariables = new String[original.NeededVariables.Length];
for(int i = 0; i < original.NeededVariables.Length; ++i)
NeededVariables[i] = original.NeededVariables[i] + renameSuffix;
NeededVariableTypes = (VarType[])original.NeededVariableTypes.Clone();
}
/// <summary>
/// Returns the element from the pattern graph which was inserted by inlining the patternEmbedding
/// and which originally bears the unprefixed name given
/// </summary>
private IPatternElement getInlinedElementByOriginalUnprefixedName(
PatternGraph patternGraph, PatternGraphEmbedding patternEmbedding, string name)
{
foreach(PatternNode node in patternGraph.nodesPlusInlined)
{
if(node.originalNode != null)
{
foreach(PatternNode embeddedNode in patternEmbedding.matchingPatternOfEmbeddedGraph.patternGraph.nodes)
{
if(node.originalNode == embeddedNode
&& embeddedNode.unprefixedName == name)
{
return node;
}
}
}
}
foreach(PatternEdge edge in patternGraph.edgesPlusInlined)
{
if(edge.originalEdge != null)
{
foreach(PatternEdge embeddedEdge in patternEmbedding.matchingPatternOfEmbeddedGraph.patternGraph.edges)
{
if(edge.originalEdge == embeddedEdge
&& embeddedEdge.unprefixedName == name)
{
return edge;
}
}
}
}
foreach(PatternVariable var in patternGraph.variablesPlusInlined)
{
if(var.originalVariable != null)
{
foreach(PatternVariable embeddedVar in patternEmbedding.matchingPatternOfEmbeddedGraph.patternGraph.variables)
{
if(var.originalVariable == embeddedVar
&& embeddedVar.unprefixedName == name)
{
return var;
}
}
}
}
return null;
}
