IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(
XmlPathSegment pathSegment, IPathSegment parentPathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (parentNode.CurrentValue is XDocument)
{
var document = parentNode.CurrentValue as XDocument;
newIndexedValueTreeNode.CurrentValue = document.Root;
}
else
{
XElementSegment(pathSegment, parentPathSegment, parentNode, newIndexedValueTreeNode);
}
}
return(newIndexedValueTreeNode);
}
protected override IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (pathSegment.IsEnumarable)
{
newIndexedValueTreeNode = IndexedEnumarablePathSegmentTreeNode(newIndexedValueTreeNode, pathSegment, parentNode);
}
else
{
newIndexedValueTreeNode.CurrentValue = GetScalarValueForPathSegement(pathSegment,
parentNode.CurrentValue);
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
return(newIndexedValueTreeNode);
}
static void ActualXElementSegment(XmlPathSegment pathSegment, IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode, XElement parentCurentElement)
{
var childElements =
parentCurentElement.Elements(pathSegment.ActualSegment).ToList();
newIndexedValueTreeNode.EnumerableValue = childElements;
if (childElements.Count == 0)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator =
newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
IndexedPathSegmentTreeNode <string> IndexedEnumarablePathSegmentTreeNode(IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode, IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment,
parentNode.CurrentValue);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
return(newIndexedValueTreeNode);
}
protected override void WriteToResults(IList <IPath> paths, Dictionary <IPath, List <IPathSegment> > indexedPathSegments, IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode, Dictionary <IPath, IList <object> > results)
{
foreach (IPath path in paths)
{
List <IPathSegment> list = indexedPathSegments[path];
IndexedPathSegmentTreeNode <string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode[list.Select(p => p.ActualSegment).ToList()];
XElement element = IndexedPathSegmentTreeNode.CurrentValue as XElement;
if (element != null)
{
results[path].Add(element.Value);
}
else
{
XAttribute value = IndexedPathSegmentTreeNode.CurrentValue as XAttribute;
if (value != null)
{
results[path].Add(value.Value);
}
else
{
results[path].Add(IndexedPathSegmentTreeNode.CurrentValue.ToString());
}
}
}
}
protected long EnumerateIndexedTree(IndexedPathSegmentTreeNode <string> node)
{
long enumerationCount = 0;
foreach (var childNode in node.Values)
{
enumerationCount += EnumerateIndexedTree(childNode);
}
if (node.Enumerator != null && enumerationCount == 0)
{
node.EnumerationComplete = !node.Enumerator.MoveNext();
if (node.EnumerationComplete)
{
node.CurrentValue = string.Empty;
}
else
{
node.CurrentValue = node.Enumerator.Current;
enumerationCount++;
}
node.Clear();
}
return(enumerationCount);
}
protected virtual void BuildIndexedTree(IList <IPath> paths,
Dictionary <IPath, List <IPathSegment> > indexedPathSegments,
IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode)
{
foreach (IPath path in paths)
{
IndexedPathSegmentTreeNode <string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode;
int pathSegmentCount = 0;
while (pathSegmentCount < indexedPathSegments[path].Count)
{
IndexedPathSegmentTreeNode <string> tmpIndexedPathSegmentTreeNode;
IPathSegment pathSegment = indexedPathSegments[path][pathSegmentCount];
if (
!IndexedPathSegmentTreeNode.TryGetValue(pathSegment.ActualSegment,
out tmpIndexedPathSegmentTreeNode))
{
IndexedPathSegmentTreeNode <string> newIndexedPathSegmentTreeNode =
CreatePathSegmentIndexedPathSegmentTreeNode(pathSegment, IndexedPathSegmentTreeNode);
IndexedPathSegmentTreeNode.Add(pathSegment.ActualSegment, newIndexedPathSegmentTreeNode);
IndexedPathSegmentTreeNode = newIndexedPathSegmentTreeNode;
}
else
{
IndexedPathSegmentTreeNode = tmpIndexedPathSegmentTreeNode;
}
pathSegmentCount++;
}
}
}
public Dictionary <IPath, IList <object> > SelectEnumerablesAsRelated(IList <IPath> paths)
{
IList <IPath> validPaths = new List <IPath>(paths.OfType <XmlPath>().ToList());
var results = new Dictionary <IPath, IList <object> >();
BuildResultsStructure(validPaths, results);
if (validPaths.Count == 1 && validPaths[0].ActualPath == XmlPath.NodeSeperatorSymbol)
{
results[validPaths[0]].Add(Data);
return(results);
}
var document = Data as XDocument;
// Create the root node
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string> {
CurrentValue = document
};
// Index the segments of all the paths, this is done so that they don't have to be regenerated for every use.
var indexedPathSegments = new Dictionary <IPath, List <IPathSegment> >();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
}while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
return(results);
}
protected virtual void BuildIndexedTree(IList<IPath> paths,
Dictionary<IPath, List<IPathSegment>> indexedPathSegments,
IndexedPathSegmentTreeNode<string> rootIndexedValueTreeNode)
{
foreach (IPath path in paths)
{
IndexedPathSegmentTreeNode<string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode;
int pathSegmentCount = 0;
while (pathSegmentCount < indexedPathSegments[path].Count)
{
IndexedPathSegmentTreeNode<string> tmpIndexedPathSegmentTreeNode;
IPathSegment pathSegment = indexedPathSegments[path][pathSegmentCount];
if (
!IndexedPathSegmentTreeNode.TryGetValue(pathSegment.ActualSegment,
out tmpIndexedPathSegmentTreeNode))
{
IndexedPathSegmentTreeNode<string> newIndexedPathSegmentTreeNode =
CreatePathSegmentIndexedPathSegmentTreeNode(pathSegment, IndexedPathSegmentTreeNode);
IndexedPathSegmentTreeNode.Add(pathSegment.ActualSegment, newIndexedPathSegmentTreeNode);
IndexedPathSegmentTreeNode = newIndexedPathSegmentTreeNode;
}
else
{
IndexedPathSegmentTreeNode = tmpIndexedPathSegmentTreeNode;
}
pathSegmentCount++;
}
}
}
protected override void BuildIndexedTree(IList <IPath> paths,
Dictionary <IPath, List <IPathSegment> > indexedPathSegments,
IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode)
{
foreach (IPath path in paths)
{
var indexedPathSegmentTreeNode = rootIndexedValueTreeNode;
var pathSegmentCount = 0;
while (pathSegmentCount < indexedPathSegments[path].Count)
{
IndexedPathSegmentTreeNode <string> tmpIndexedPathSegmentTreeNode = null;
var pathSegment = indexedPathSegments[path][pathSegmentCount] as XmlPathSegment;
XmlPathSegment parentPathSegment;
parentPathSegment = pathSegmentCount > 0 ? indexedPathSegments[path][pathSegmentCount - 1] as XmlPathSegment : null;
if (indexedPathSegmentTreeNode != null && pathSegment != null && !indexedPathSegmentTreeNode.TryGetValue(pathSegment.ActualSegment,
out tmpIndexedPathSegmentTreeNode))
{
var newIndexedPathSegmentTreeNode =
CreatePathSegmentIndexedPathSegmentTreeNode(pathSegment, parentPathSegment,
indexedPathSegmentTreeNode);
indexedPathSegmentTreeNode.Add(pathSegment.ActualSegment, newIndexedPathSegmentTreeNode);
indexedPathSegmentTreeNode = newIndexedPathSegmentTreeNode;
}
else
{
indexedPathSegmentTreeNode = tmpIndexedPathSegmentTreeNode;
}
pathSegmentCount++;
}
}
}
protected virtual void WriteToResults(IList <IPath> paths, Dictionary <IPath, List <IPathSegment> > indexedPathSegments, IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode, Dictionary <IPath, IList <object> > results)
{
foreach (IPath path in paths)
{
IndexedPathSegmentTreeNode <string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode[indexedPathSegments[path].Select(p => p.ActualSegment).ToList()];
results[path].Add(IndexedPathSegmentTreeNode.CurrentValue);
}
}
public Dictionary <IPath, IList <object> > SelectEnumerablesAsRelated(IList <IPath> paths)
{
//
// Get valid paths
//
IList <IPath> validPaths = new List <IPath>(paths.OfType <PocoPath>().ToList());
//
// Setup results structure
//
var results = new Dictionary <IPath, IList <object> >();
BuildResultsStructure(validPaths, results);
if (validPaths.Count == 1 && validPaths[0].ActualPath == PocoPath.SeperatorSymbol)
{
results[validPaths[0]].Add(Data);
}
else if (validPaths.Count == 1 &&
validPaths[0].ActualPath == PocoPath.EnumerableSymbol + PocoPath.SeperatorSymbol)
{
var enumerableData = Data as IEnumerable;
if (enumerableData != null)
{
IEnumerator enumerator = enumerableData.GetEnumerator();
enumerator.Reset();
while (enumerator.MoveNext())
{
results[validPaths[0]].Add(enumerator.Current);
}
}
}
else
{
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string> {
CurrentValue = Data
};
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary <IPath, List <IPathSegment> >();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
return(results);
}
protected override void WriteToResults(IList <IPath> paths, Dictionary <IPath, List <IPathSegment> > indexedPathSegments, IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode, Dictionary <IPath, IList <object> > results)
{
foreach (IPath path in paths)
{
List <IPathSegment> indexedPathSegment = indexedPathSegments[path];
List <string> complexKey = indexedPathSegment.Select(p => p.ActualSegment).ToList();
IndexedPathSegmentTreeNode <string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode[complexKey];
results[path].Add(IndexedPathSegmentTreeNode.CurrentValue.ToString());
}
}
public Dictionary <IPath, IList <object> > SelectEnumerablesAsRelated(IList <IPath> paths)
{
//
// Get valid paths
//
IList <IPath> validPaths = new List <IPath>(paths.OfType <XmlPath>().ToList());
//
// Setup results structure
//
var results = new Dictionary <IPath, IList <object> >();
BuildResultsStructure(validPaths, results);
if (validPaths.Count == 1 && validPaths[0].ActualPath == XmlPath.NodeSeperatorSymbol)
{
results[validPaths[0]].Add(Data);
}
else
{
var document = Data as XDocument;
if (document == null)
{
throw new Exception(
string.Format("Type of {0} was expected for data, type of {1} was found instead.",
typeof(XDocument), Data.GetType()));
}
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string> {
CurrentValue = document
};
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary <IPath, List <IPathSegment> >();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
return(results);
}
protected override IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (pathSegment.IsEnumarable)
{
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment, parentNode.CurrentValue);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
else
{
newIndexedValueTreeNode.CurrentValue = GetScalarValueForPathSegement(pathSegment, parentNode.CurrentValue);
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
return(newIndexedValueTreeNode);
}
private void GetEnumerableValueForPathSegment(IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode, IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode)
{
var data = parentNode.CurrentValue as JToken;
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment, data);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
var isPrimitiveArray = false;
if (data is JObject jObject)
{
var property = jObject.Property(pathSegment.ActualSegment);
isPrimitiveArray = property.IsEnumerableOfPrimitives();
}
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (isPrimitiveArray)
{
var valueBuilder = new StringBuilder();
while (newIndexedValueTreeNode.Enumerator.MoveNext())
{
valueBuilder.Append(newIndexedValueTreeNode.Enumerator.Current);
valueBuilder.Append(",");
}
newIndexedValueTreeNode.EnumerationComplete = true;
newIndexedValueTreeNode.CurrentValue = valueBuilder.ToString().TrimEnd(',');
}
else
{
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
}
protected void CreateRootNode(IList <IPath> validPaths, Dictionary <IPath, IList <object> > results)
{
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
rootIndexedValueTreeNode.CurrentValue = Data;
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary <IPath, List <IPathSegment> >();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
protected virtual IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
return(null);
}
protected override IndexedPathSegmentTreeNode<string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode<string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (pathSegment.IsEnumarable)
{
var data = parentNode.CurrentValue as JToken;
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment, data);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
bool isPrimitiveArray = false;
var jObject = data as JObject;
if (jObject != null)
{
JProperty property = jObject.Property(pathSegment.ActualSegment);
isPrimitiveArray = property.IsEnumerableOfPrimitives();
}
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (isPrimitiveArray)
{
var valueBuilder = new StringBuilder();
while (newIndexedValueTreeNode.Enumerator.MoveNext())
{
valueBuilder.Append(newIndexedValueTreeNode.Enumerator.Current);
valueBuilder.Append(",");
}
newIndexedValueTreeNode.EnumerationComplete = true;
newIndexedValueTreeNode.CurrentValue = valueBuilder.ToString().TrimEnd(',');
}
else
{
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
}
else
{
newIndexedValueTreeNode.CurrentValue = GetScalarValueForPathSegement(pathSegment,
parentNode.CurrentValue as JToken);
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
return newIndexedValueTreeNode;
}
protected override void WriteToResults(IList<IPath> paths,
Dictionary<IPath, List<IPathSegment>> indexedPathSegments,
IndexedPathSegmentTreeNode<string> rootIndexedValueTreeNode, Dictionary<IPath, IList<object>> results)
{
foreach (IPath path in paths)
{
List<IPathSegment> indexedPathSegment = indexedPathSegments[path];
List<string> complexKey = indexedPathSegment.Select(p => p.ActualSegment).ToList();
IndexedPathSegmentTreeNode<string> IndexedPathSegmentTreeNode = rootIndexedValueTreeNode[complexKey];
results[path].Add(IndexedPathSegmentTreeNode.CurrentValue.ToString());
}
}
protected long EnumerateIndexedTree(IndexedPathSegmentTreeNode<string> node)
{
long enumerationCount = 0;
foreach (var childNode in node.Values)
{
enumerationCount += EnumerateIndexedTree(childNode);
}
if (node.Enumerator != null && enumerationCount == 0)
{
node.EnumerationComplete = !node.Enumerator.MoveNext();
if (node.EnumerationComplete)
{
node.CurrentValue = string.Empty;
}
else
{
node.CurrentValue = node.Enumerator.Current;
enumerationCount++;
}
node.Clear();
}
return enumerationCount;
}
protected override IndexedPathSegmentTreeNode<string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode<string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (pathSegment.IsEnumarable)
{
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment,
parentNode.CurrentValue);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
else
{
newIndexedValueTreeNode.CurrentValue = GetScalarValueForPathSegement(pathSegment,
parentNode.CurrentValue);
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
return newIndexedValueTreeNode;
}
public Dictionary<IPath, IList<object>> SelectEnumerablesAsRelated(IList<IPath> paths)
{
//
// Get valid paths
//
IList<IPath> validPaths = new List<IPath>(paths.OfType<XmlPath>().ToList());
//
// Setup results structure
//
var results = new Dictionary<IPath, IList<object>>();
BuildResultsStructure(validPaths, results);
if (validPaths.Count == 1 && validPaths[0].ActualPath == XmlPath.NodeSeperatorSymbol)
{
results[validPaths[0]].Add(Data);
}
else
{
var document = Data as XDocument;
if (document == null)
{
throw new Exception(
string.Format("Type of {0} was expected for data, type of {1} was found instead.",
typeof (XDocument), Data.GetType()));
}
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string> {CurrentValue = document};
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary<IPath, List<IPathSegment>>();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
return results;
}
protected override void BuildIndexedTree(IList<IPath> paths,
Dictionary<IPath, List<IPathSegment>> indexedPathSegments,
IndexedPathSegmentTreeNode<string> rootIndexedValueTreeNode)
{
foreach (IPath path in paths)
{
IndexedPathSegmentTreeNode<string> indexedPathSegmentTreeNode = rootIndexedValueTreeNode;
int pathSegmentCount = 0;
while (pathSegmentCount < indexedPathSegments[path].Count)
{
IndexedPathSegmentTreeNode<string> tmpIndexedPathSegmentTreeNode = null;
var pathSegment = indexedPathSegments[path][pathSegmentCount] as XmlPathSegment;
XmlPathSegment parentPathSegment;
if (pathSegmentCount > 0)
{
parentPathSegment = indexedPathSegments[path][pathSegmentCount - 1] as XmlPathSegment;
}
else
{
parentPathSegment = null;
}
if (indexedPathSegmentTreeNode != null && pathSegment != null && !indexedPathSegmentTreeNode.TryGetValue(pathSegment.ActualSegment,
out tmpIndexedPathSegmentTreeNode))
{
IndexedPathSegmentTreeNode<string> newIndexedPathSegmentTreeNode =
CreatePathSegmentIndexedPathSegmentTreeNode(pathSegment, parentPathSegment,
indexedPathSegmentTreeNode);
indexedPathSegmentTreeNode.Add(pathSegment.ActualSegment, newIndexedPathSegmentTreeNode);
indexedPathSegmentTreeNode = newIndexedPathSegmentTreeNode;
}
else
{
indexedPathSegmentTreeNode = tmpIndexedPathSegmentTreeNode;
}
pathSegmentCount++;
}
}
}
protected override void WriteToResults(IList<IPath> paths,
Dictionary<IPath, List<IPathSegment>> indexedPathSegments,
IndexedPathSegmentTreeNode<string> rootIndexedValueTreeNode, Dictionary<IPath, IList<object>> results)
{
foreach (IPath path in paths)
{
List<IPathSegment> list = indexedPathSegments[path];
IndexedPathSegmentTreeNode<string> indexedPathSegmentTreeNode =
rootIndexedValueTreeNode[list.Select(p => p.ActualSegment).ToList()];
var element = indexedPathSegmentTreeNode.CurrentValue as XElement;
if (element != null)
{
results[path].Add(element.Value);
}
else
{
var value = indexedPathSegmentTreeNode.CurrentValue as XAttribute;
results[path].Add(value != null ? value.Value : indexedPathSegmentTreeNode.CurrentValue.ToString());
}
}
}
protected virtual void WriteToResults(IList<IPath> paths,
Dictionary<IPath, List<IPathSegment>> indexedPathSegments,
IndexedPathSegmentTreeNode<string> rootIndexedValueTreeNode, Dictionary<IPath, IList<object>> results)
{
foreach (IPath path in paths)
{
IndexedPathSegmentTreeNode<string> IndexedPathSegmentTreeNode =
rootIndexedValueTreeNode[indexedPathSegments[path].Select(p => p.ActualSegment).ToList()];
results[path].Add(IndexedPathSegmentTreeNode.CurrentValue);
}
}
protected override void WriteToResults(IList <IPath> paths, Dictionary <IPath, List <IPathSegment> > indexedPathSegments, IndexedPathSegmentTreeNode <string> rootIndexedValueTreeNode, Dictionary <IPath, IList <object> > results)
{
foreach (var path in paths)
{
var list = indexedPathSegments[path];
var indexedPathSegmentTreeNode = rootIndexedValueTreeNode[list.Select(p => p.ActualSegment).ToList()];
if (indexedPathSegmentTreeNode.CurrentValue is XElement element)
{
results[path].Add(element.Value);
}
else
{
var value = indexedPathSegmentTreeNode.CurrentValue as XAttribute;
results[path].Add(value?.Value ?? indexedPathSegmentTreeNode.CurrentValue.ToString());
}
}
}
private IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(XmlPathSegment pathSegment, IPathSegment parentPathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (parentNode.CurrentValue is XDocument)
{
XDocument document = parentNode.CurrentValue as XDocument;
newIndexedValueTreeNode.CurrentValue = document.Root;
}
else
{
XElement parentCurentElement = parentNode.CurrentValue as XElement;
if (parentPathSegment != null && parentPathSegment.IsEnumarable)
{
if (parentCurentElement != null)
{
List <XElement> childElements = parentCurentElement.Elements(pathSegment.ActualSegment).ToList();
newIndexedValueTreeNode.EnumerableValue = childElements;
if (childElements.Count == 0)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
}
else
{
if (pathSegment.IsAttribute)
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue = parentCurentElement.Attribute(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
else
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue = parentCurentElement.Element(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
}
}
return(newIndexedValueTreeNode);
}
protected virtual IndexedPathSegmentTreeNode<string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode<string> parentNode)
{
return null;
}
private IndexedPathSegmentTreeNode<string> CreatePathSegmentIndexedPathSegmentTreeNode(
XmlPathSegment pathSegment, IPathSegment parentPathSegment, IndexedPathSegmentTreeNode<string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (parentNode.CurrentValue is XDocument)
{
var document = parentNode.CurrentValue as XDocument;
newIndexedValueTreeNode.CurrentValue = document.Root;
}
else
{
var parentCurentElement = parentNode.CurrentValue as XElement;
if (parentPathSegment != null && parentPathSegment.IsEnumarable)
{
if (parentCurentElement != null)
{
List<XElement> childElements =
parentCurentElement.Elements(pathSegment.ActualSegment).ToList();
newIndexedValueTreeNode.EnumerableValue = childElements;
if (childElements.Count == 0)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.Enumerator =
newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
}
else
{
if (pathSegment.IsAttribute)
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue =
parentCurentElement.Attribute(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
else
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue =
parentCurentElement.Element(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
}
}
return newIndexedValueTreeNode;
}
static void XElementSegment(XmlPathSegment pathSegment, IPathSegment parentPathSegment, IndexedPathSegmentTreeNode <string> parentNode, IndexedPathSegmentTreeNode <string> newIndexedValueTreeNode)
{
var parentCurentElement = parentNode.CurrentValue as XElement;
if (parentPathSegment != null && parentPathSegment.IsEnumarable)
{
if (parentCurentElement != null)
{
ActualXElementSegment(pathSegment, newIndexedValueTreeNode, parentCurentElement);
}
}
else
{
if (pathSegment.IsAttribute)
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue =
parentCurentElement.Attribute(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
else
{
if (parentCurentElement != null)
{
newIndexedValueTreeNode.CurrentValue =
parentCurentElement.Element(pathSegment.ActualSegment);
}
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
}
protected void CreateRootNode(IList<IPath> validPaths, Dictionary<IPath, IList<object>> results)
{
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string>();
rootIndexedValueTreeNode.CurrentValue = Data;
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary<IPath, List<IPathSegment>>();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
protected override IndexedPathSegmentTreeNode <string> CreatePathSegmentIndexedPathSegmentTreeNode(
IPathSegment pathSegment, IndexedPathSegmentTreeNode <string> parentNode)
{
var newIndexedValueTreeNode = new IndexedPathSegmentTreeNode <string>();
if (parentNode.EnumerationComplete)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
if (pathSegment.IsEnumarable)
{
var data = parentNode.CurrentValue as JToken;
newIndexedValueTreeNode.EnumerableValue = GetEnumerableValueForPathSegment(pathSegment, data);
if (newIndexedValueTreeNode.EnumerableValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
bool isPrimitiveArray = false;
var jObject = data as JObject;
if (jObject != null)
{
JProperty property = jObject.Property(pathSegment.ActualSegment);
isPrimitiveArray = property.IsEnumerableOfPrimitives();
}
newIndexedValueTreeNode.Enumerator = newIndexedValueTreeNode.EnumerableValue.GetEnumerator();
newIndexedValueTreeNode.Enumerator.Reset();
if (isPrimitiveArray)
{
var valueBuilder = new StringBuilder();
while (newIndexedValueTreeNode.Enumerator.MoveNext())
{
valueBuilder.Append(newIndexedValueTreeNode.Enumerator.Current);
valueBuilder.Append(",");
}
newIndexedValueTreeNode.EnumerationComplete = true;
newIndexedValueTreeNode.CurrentValue = valueBuilder.ToString().TrimEnd(',');
}
else
{
if (!newIndexedValueTreeNode.Enumerator.MoveNext())
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
else
{
newIndexedValueTreeNode.CurrentValue = newIndexedValueTreeNode.Enumerator.Current;
}
}
}
}
else
{
newIndexedValueTreeNode.CurrentValue = GetScalarValueForPathSegement(pathSegment,
parentNode.CurrentValue as JToken);
if (newIndexedValueTreeNode.CurrentValue == null)
{
newIndexedValueTreeNode.CurrentValue = string.Empty;
newIndexedValueTreeNode.EnumerationComplete = true;
}
}
}
return(newIndexedValueTreeNode);
}
public Dictionary<IPath, IList<object>> SelectEnumerablesAsRelated(IList<IPath> paths)
{
//
// Get valid paths
//
IList<IPath> validPaths = new List<IPath>(paths.OfType<PocoPath>().ToList());
//
// Setup results structure
//
var results = new Dictionary<IPath, IList<object>>();
BuildResultsStructure(validPaths, results);
if (validPaths.Count == 1 && validPaths[0].ActualPath == PocoPath.SeperatorSymbol)
{
results[validPaths[0]].Add(Data);
}
else if (validPaths.Count == 1 &&
validPaths[0].ActualPath == PocoPath.EnumerableSymbol + PocoPath.SeperatorSymbol)
{
var enumerableData = Data as IEnumerable;
if (enumerableData != null)
{
IEnumerator enumerator = enumerableData.GetEnumerator();
enumerator.Reset();
while (enumerator.MoveNext())
{
results[validPaths[0]].Add(enumerator.Current);
}
}
}
else
{
//
// Create the root node
//
var rootIndexedValueTreeNode = new IndexedPathSegmentTreeNode<string> {CurrentValue = Data};
//
// Index the segments of all the paths, this is done so that they don't have to be
// regenerated for every use.
//
var indexedPathSegments = new Dictionary<IPath, List<IPathSegment>>();
IndexPathSegments(validPaths, indexedPathSegments);
do
{
BuildIndexedTree(validPaths, indexedPathSegments, rootIndexedValueTreeNode);
WriteToResults(validPaths, indexedPathSegments, rootIndexedValueTreeNode, results);
} while (EnumerateIndexedTree(rootIndexedValueTreeNode) > 0);
}
return results;
}
