private void IndexDiff(DbRepresentation other, DiffReport diff)
{
foreach (IndexDefinition schemaIndex in _schemaIndexes)
{
if (!other._schemaIndexes.Contains(schemaIndex))
{
diff.Add("I have schema index " + schemaIndex + " which other doesn't");
}
}
foreach (IndexDefinition otherSchemaIndex in other._schemaIndexes)
{
if (!_schemaIndexes.Contains(otherSchemaIndex))
{
diff.Add("Other has schema index " + otherSchemaIndex + " which I don't");
}
}
}
private void ConstraintDiff(DbRepresentation other, DiffReport diff)
{
foreach (ConstraintDefinition constraint in _constraints)
{
if (!other._constraints.Contains(constraint))
{
diff.Add("I have constraint " + constraint + " which other doesn't");
}
}
foreach (ConstraintDefinition otherConstraint in other._constraints)
{
if (!_constraints.Contains(otherConstraint))
{
diff.Add("Other has constraint " + otherConstraint + " which I don't");
}
}
}
protected internal virtual void CompareWith(PropertiesRep other, DiffReport diff)
{
bool equals = Props.Equals(other.Props);
if (!equals)
{
diff.Add("Properties diff for " + EntityToString + " mine:" + Props + ", other:" + other.Props);
}
}
/*
* Yes, this is not the best way to do it - hash map does a deep equals. However,
* if things go wrong, this way give the ability to check where the inequality
* happened. If you feel strongly about this, feel free to change.
* Admittedly, the implementation could use some cleanup.
*/
internal virtual void CompareIndex(NodeRep other, DiffReport diff)
{
if (other.Index == Index)
{
return;
}
ICollection <string> allIndexes = new HashSet <string>();
allIndexes.addAll(Index.Keys);
allIndexes.addAll(other.Index.Keys);
foreach (string indexName in allIndexes)
{
if (!Index.ContainsKey(indexName))
{
diff.Add(this + " isn't indexed in " + indexName + " for mine");
continue;
}
if (!other.Index.ContainsKey(indexName))
{
diff.Add(this + " isn't indexed in " + indexName + " for other");
continue;
}
IDictionary <string, Serializable> thisIndex = Index[indexName];
IDictionary <string, Serializable> otherIndex = other.Index[indexName];
if (thisIndex.Count != otherIndex.Count)
{
diff.Add("other index had a different mapping count than me for node " + this + " mine:" + thisIndex + ", other:" + otherIndex);
continue;
}
foreach (KeyValuePair <string, Serializable> indexEntry in thisIndex.SetOfKeyValuePairs())
{
if (!indexEntry.Value.Equals(otherIndex[indexEntry.Key]))
{
diff.Add("other index had a different value indexed for " + indexEntry.Key + "=" + indexEntry.Value + ", namely " + otherIndex[indexEntry.Key] + " for " + this);
}
}
}
}
internal virtual void CompareRelationships(NodeRep other, DiffReport diff)
{
foreach (PropertiesRep rel in OutRelationships.Values)
{
PropertiesRep otherRel = other.OutRelationships[rel.EntityId];
if (otherRel == null)
{
diff.Add("I have relationship " + rel.EntityId + " which other don't");
continue;
}
rel.CompareWith(otherRel, diff);
}
foreach (long?id in other.OutRelationships.Keys)
{
if (!OutRelationships.ContainsKey(id))
{
diff.Add("Other has relationship " + id + " which I don't");
}
}
}
private void NodeDiff(DbRepresentation other, DiffReport diff)
{
foreach (NodeRep node in _nodes.Values)
{
NodeRep otherNode = other._nodes[node.Id];
if (otherNode == null)
{
diff.Add("I have node " + node.Id + " which other doesn't");
continue;
}
node.CompareWith(otherNode, diff);
}
foreach (long?id in other._nodes.Keys)
{
if (!_nodes.ContainsKey(id))
{
diff.Add("Other has node " + id + " which I don't");
}
}
}
internal virtual void CompareWith(NodeRep other, DiffReport diff)
{
if (other.Id != Id)
{
diff.Add("Id differs mine:" + Id + ", other:" + other.Id);
}
Properties.compareWith(other.Properties, diff);
if (Index != null && other.Index != null)
{
CompareIndex(other, diff);
}
CompareRelationships(other, diff);
}