static void Main(string[] args)
{
var input = XDocument.Load("Config.xml");
var output = new XDocument(input.Declaration);
var outputRoot = new XElement(input.Root);
outputRoot.RemoveNodes();
output.Add(outputRoot);
foreach (var node in input.Descendants().Where(n => !n.Elements().Any()))
{
var newNode = new XElement(node.Name);
var p = node.Parent;
int level = 0;
while (p != input.Root)
{
string attrName;
if (level == 0)
{
attrName = "parent";
}
else
{
attrName = string.Join("", Enumerable.Repeat("grand",level));
}
newNode.SetAttributeValue(attrName, p.Name);
level++;
p = p.Parent;
}
newNode.Add(node.Attributes());
outputRoot.Add(newNode);
}
Console.WriteLine(output);
output.Save("output.xml");
Console.Read();
}
internal static void NestContext(XElement importSettingsProperty,
string scriptureBaseDir,
IDictionary<string, SortedDictionary<string, byte[]>> classData,
Dictionary<string, string> guidToClassMapping)
{
if (importSettingsProperty == null)
return;
var importSettings = importSettingsProperty.Elements().ToList();
if (!importSettings.Any())
return;
var root = new XElement(SharedConstants.ImportSettings);
foreach (var importSettingObjSur in importSettings)
{
var styleGuid = importSettingObjSur.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var className = guidToClassMapping[styleGuid];
var importSetting = Utilities.CreateFromBytes(classData[className][styleGuid]);
CmObjectNestingService.NestObject(false, importSetting,
classData,
guidToClassMapping);
root.Add(importSetting);
}
FileWriterService.WriteNestedFile(Path.Combine(scriptureBaseDir, SharedConstants.ImportSettingsFilename), root);
importSettingsProperty.RemoveNodes();
}
internal static void NestContext(XElement archivedDraftsProperty,
string scriptureBaseDir,
IDictionary<string, SortedDictionary<string, byte[]>> classData,
Dictionary<string, string> guidToClassMapping)
{
if (archivedDraftsProperty == null)
return;
var drafts = archivedDraftsProperty.Elements().ToList();
if (!drafts.Any())
return;
foreach (var draftObjSur in drafts)
{
var root = new XElement(SharedConstants.ArchivedDrafts);
var draftGuid = draftObjSur.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var className = guidToClassMapping[draftGuid];
var draft = Utilities.CreateFromBytes(classData[className][draftGuid]);
CmObjectNestingService.NestObject(false, draft,
classData,
guidToClassMapping);
root.Add(draft);
FileWriterService.WriteNestedFile(Path.Combine(scriptureBaseDir, SharedConstants.Draft + "_" + draftGuid.ToLowerInvariant() + "." + SharedConstants.ArchivedDraft), root);
}
archivedDraftsProperty.RemoveNodes();
}
/// <summary>
/// Tests the Parent property on Node.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
//[Variation(Desc = "NodeParent")]
public void NodeParent()
{
// Only elements are returned as parents from the Parent property.
// Documents are not returned.
XDocument document = new XDocument();
XNode[] nodes = new XNode[]
{
new XComment("comment"),
new XElement("element"),
new XProcessingInstruction("target", "data"),
new XDocumentType("name", "publicid", "systemid", "internalsubset")
};
foreach (XNode node in nodes)
{
Validate.IsNull(node.Parent);
document.Add(node);
Validate.IsReferenceEqual(document, node.Document);
// Parent element is null.
Validate.IsNull(node.Parent);
document.RemoveNodes();
}
// Now test the cases where an element is the parent.
nodes = new XNode[]
{
new XComment("abcd"),
new XElement("nested"),
new XProcessingInstruction("target2", "data2"),
new XText("text")
};
XElement root = new XElement("root");
document.ReplaceNodes(root);
foreach (XNode node in nodes)
{
Validate.IsNull(node.Parent);
root.AddFirst(node);
Validate.IsReferenceEqual(node.Parent, root);
root.RemoveNodes();
Validate.IsNull(node.Parent);
}
}
public XElement MergeTemplatesWithConfig(XElement configAsXElement)
{
var newConfifAsXElement = new XElement(configAsXElement);
newConfifAsXElement.RemoveNodes();
configAsXElement.Elements().ForEach(e=>
{
if (e.Name.LocalName != "build-type")
{
newConfifAsXElement.Add(e);
}
});
var buildTypes = configAsXElement.Elements("build-type");
buildTypes.ForEach(bt=>
{
var btElement = new XElement(bt);
btElement.RemoveNodes();
bt.Elements().ForEach(bte=> { if(bte.Name.LocalName!="settings")btElement.Add(bte);});
var settings = bt.Element("settings");
var template = settings.AttributeValueOrDefault("ref",null);
if(template!=null)
{
if(_dictionary.ContainsKey(template))
{
var mergedSettingsXElement = Merge(settings, _dictionary[template]);
btElement.Add(mergedSettingsXElement);
}
else
throw new Exception("Could not find template "+template);
}
else
btElement.Add(settings);
newConfifAsXElement.Add(btElement);
}
);
return newConfifAsXElement;
}
public static XElement Alphabetize(XElement el)
{
Comparison<XElement> comparison = new Comparison<XElement>(Program.Compare);
List<XAttribute> content = new List<XAttribute>(el.Attributes());
List<XElement> list2 = new List<XElement>(el.Elements());
content.Sort((x, y) => string.CompareOrdinal(x.Name.ToString(), y.Name.ToString()));
list2.Sort(comparison);
XElement element = new XElement(el.Name);
element.Add(content);
element.Add(list2);
el.RemoveAttributes();
el.RemoveNodes();
el.Add(new object[] { content, list2 });
if (el.HasElements)
{
foreach (XElement element2 in el.Elements())
{
Alphabetize(element2);
}
}
return el;
}
/// <summary>
/// Internals the process.
/// </summary>
/// <remarks>
/// </remarks>
protected override void InternalProcess() {
foreach (var t in Context.Themas.Values) {
foreach (var item in t.ImportedThemaItems.Union(t.SelfThemaItems)) {
var key = item.Key;
var x = new XElement(item.Value);
XElement s = null;
if (t.SelfThemaItemsSets.ContainsKey(key)) {
s = t.SelfThemaItemsSets[key];
}
else if (t.ImportedThemaItemsSets.ContainsKey(key)) {
s = t.ImportedThemaItemsSets[key];
}
if (null != s) {
x.RemoveNodes();
x.Add(s.Nodes());
foreach (var a in s.Attributes()) {
x.SetAttributeValue(a.Name, a.Value);
}
}
if (t.ImportedThemaItemsExtensions.ContainsKey(key)) {
foreach (var e in t.ImportedThemaItemsExtensions[key]) {
x.Add(e.Nodes());
foreach (var a in e.Attributes()) {
x.SetAttributeValue(a.Name, a.Value);
}
}
}
if (t.SelfThemaItemsExtensions.ContainsKey(key)) {
x.Add(t.SelfThemaItemsExtensions[key].Nodes());
foreach (var a in t.SelfThemaItemsExtensions[key].Attributes()) {
x.SetAttributeValue(a.Name, a.Value);
}
}
t.Items[key] = x;
}
}
}
internal static XElement AddNewPropertyElement(XElement parent, string propertyName)
{
var sortedRecords = new SortedDictionary<string, XElement>(StringComparer.OrdinalIgnoreCase)
{
{propertyName, new XElement(propertyName)}
};
foreach (var propertyNode in parent.Elements())
{
var propName = propertyNode.Name.LocalName;
if (propName == SharedConstants.Custom)
propName = propertyNode.Attribute(SharedConstants.Name).Value;
sortedRecords.Add(propName, propertyNode);
}
parent.RemoveNodes();
foreach (var sortedPropElement in sortedRecords.Values)
parent.Add(sortedPropElement);
return sortedRecords[propertyName];
}
public void XLinq66()
{
XElement elem = new XElement("customer",
"this is an XElement",
new XAttribute("id", "abc"));
Console.WriteLine("Original element {0}", elem);
elem.RemoveNodes();
Console.WriteLine("Updated element {0}", elem);
}
private static XElement copyWithoutChildren(XElement element)
{
var newElement = new XElement(element);
newElement.RemoveNodes();
return newElement;
}
private XElement ProcessElements(IEnumerable<RepeaterElement> elements, DataReader dataReader, XElement start, XElement parent, int index, ref XElement endIfElement, ref XElement nestedRepeaterEndElement, ref XElement currentEndItemTable, bool nested = false)
{
XElement result = null;
XElement previous = start;
//if ((parent != null) && (!parent.Name.Equals(WordMl.TableCellName)))
//{
elements = elements.Where(el => !this.IsItemRepeaterElement(el.XElement)).ToList();
//}
foreach (var repeaterElement in elements )//elements.Where(el => !this.IsItemRepeaterElement(el.XElement)).ToList())
{
if (nestedRepeaterEndElement != null)
{
if (repeaterElement.XElement.Equals(nestedRepeaterEndElement))
{
nestedRepeaterEndElement = null;
}
continue;
}
if (currentEndItemTable != null)
{
if (repeaterElement.XElement.Equals(currentEndItemTable))
{
currentEndItemTable = null;
}
continue;
}
if (repeaterElement.IsEndItemIf /*&& repeaterElement.XElement.Equals(endIfElement)*/)
{
//endIfElement = null;
if (repeaterElement.XElement.Equals(endIfElement))
{
endIfElement = null;
}
continue;
}
if ((endIfElement != null) && !repeaterElement.XElement.Name.Equals(WordMl.ParagraphName))
{
continue;
}
if (repeaterElement.IsItemIf)
{
this.ProcessItemIfElement(repeaterElement, dataReader, ref endIfElement);
continue;
}
if (repeaterElement.IsItemTable)
{
/*currentEndItemTable = RepeaterParser.FindEndTag(repeaterElement.XElement, "itemtable",
"enditemtable");*/
currentEndItemTable = repeaterElement.EndTag;
}
/*
if (repeaterElement.IsEndItemTable /*|| (repeaterElement.XElement.Name.Equals(WordMl.TableName) && repeaterElement.XElement.Descendants().Any(el => el.IsSdt())))
{
continue;
}*/
if (repeaterElement.IsItemHtmlContent)
{
result = HtmlContentProcessor.MakeHtmlContentProcessed(repeaterElement.XElement, dataReader.ReadText(repeaterElement.Expression), true);
}
else if (repeaterElement.IsItemTable)
{
result = ItemTableGenerator.ProcessItemTableElement(repeaterElement.StartTag, repeaterElement.EndTag,
dataReader);
if (nested)
{
previous.AddAfterSelf(result);
previous = result;
result = null;
}
}
else if (repeaterElement.IsItemRepeater)
{
var itemRepeaterTag = new ItemRepeaterTag()
{
StartItemRepeater = repeaterElement.StartTag,
EndItemRepeater = repeaterElement.EndTag,
Source = repeaterElement.Expression
};
var itemRepeaterGenerator = new ItemRepeaterGenerator();
previous = itemRepeaterGenerator.Generate(itemRepeaterTag,
dataReader.GetReaders(repeaterElement.Expression),
previous, parent, true);
result = null;
nestedRepeaterEndElement = repeaterElement.EndTag;
}
else if (repeaterElement.IsIndex)
{
result = DocxHelper.CreateTextElement(repeaterElement.XElement, repeaterElement.XElement.Parent, index.ToString(CultureInfo.CurrentCulture));
}
else if (repeaterElement.IsItem && repeaterElement.HasExpression)
{
result = DocxHelper.CreateTextElement(repeaterElement.XElement, repeaterElement.XElement.Parent, dataReader.ReadText(repeaterElement.Expression), dataReader.ReadAttribute(repeaterElement.Expression, "style"));
}
else
{
var element = new XElement(repeaterElement.XElement);
element.RemoveNodes();
result = element;
if (repeaterElement.HasElements)
{
var parsedLastElement = this.ProcessElements(repeaterElement.Elements, dataReader, previous, result, index, ref endIfElement, ref nestedRepeaterEndElement, ref currentEndItemTable, true);
if (repeaterElement.Elements.Any(re => re.IsItemTable) || repeaterElement.Elements.Any(re => re.IsItemRepeater && !ItemRepeaterGenerator.CheckInlineWrappingMode(re.StartTag, re.EndTag)))
{
previous = parsedLastElement;
result = null;
}
}
else
{
element.Value = repeaterElement.XElement.Value;
}
}
if (result != null)
{
if (!nested)
{
previous.AddAfterSelf(result);
previous = result;
}
else
{
parent.Add(result);
}
}
}
return result ?? previous;
}
private static void setValueElement(XElement element, string value)
{
element.RemoveNodes();
XElement newElement = new XElement("valueElement", new XAttribute("value", value));
element.Add(newElement);
}
private static void SortBasicsOfRangeElement(XElement rangeElement)
{
var description = rangeElement.Element("description");
if (description != null)
{
SortMultiformElement(description);
description.Remove();
}
var label = rangeElement.Element("label");
if (label != null)
{
SortMultiformElement(label);
label.Remove();
}
var abbrev = rangeElement.Element("abbrev");
if (abbrev != null)
{
SortMultiformElement(abbrev);
abbrev.Remove();
}
var leftovers = rangeElement.Elements().ToList();
rangeElement.RemoveNodes();
if (description != null)
rangeElement.Add(description);
if (label != null)
rangeElement.Add(label);
if (abbrev != null)
rangeElement.Add(abbrev);
foreach (var leftover in leftovers)
{
rangeElement.Add(leftover);
}
}
private static void SortRanges(XElement rangesParent)
{
if (!rangesParent.HasElements)
return;
// Optional, multiple <range> elements. Unordered. Key attr: id
var sortedRanges = new SortedDictionary<string, XElement>(StringComparer.InvariantCultureIgnoreCase);
foreach (var rangeElement in rangesParent.Elements("range").ToList())
{
SortRange(rangeElement);
sortedRanges.Add(GetUniqueKey(sortedRanges.Keys, rangeElement.Attribute("id").Value), rangeElement);
rangeElement.Remove();
}
var leftovers = rangesParent.Elements().ToList();
rangesParent.RemoveNodes();
foreach (var rangeElement in sortedRanges.Values)
{
rangesParent.Add(rangeElement);
}
foreach (var leftover in leftovers)
{
rangesParent.Add(leftover);
}
}
public void ExecuteXElementVariation()
{
XNode[] content = Variation.Params as XNode[];
XElement xElem = new XElement("root", InputSpace.GetAttributeElement(10, 1000).Elements().Attributes(), content);
XElement xElemOriginal = new XElement(xElem);
using (UndoManager undo = new UndoManager(xElem))
{
undo.Group();
using (EventsHelper elemHelper = new EventsHelper(xElem))
{
xElem.RemoveNodes();
TestLog.Compare(xElem.IsEmpty, "Not all content were removed");
TestLog.Compare(xElem.HasAttributes, "RemoveNodes removed the attributes");
xElem.Verify();
elemHelper.Verify(XObjectChange.Remove, content);
}
undo.Undo();
TestLog.Compare(xElem.Nodes().SequenceEqual(xElemOriginal.Nodes(), XNode.EqualityComparer), "Undo did not work!");
TestLog.Compare(xElem.Attributes().EqualsAllAttributes(xElemOriginal.Attributes(), Helpers.MyAttributeComparer), "Undo did not work!");
}
}
public void ToCashe(XElement element)
{
CasheStatus = CasheStatus.Sync;
element.SetAttributeValue(TypePropertyName, Type);
element.RemoveNodes();
element.Add(GetAttachmentElement());
}
private static void ReplantAllItems(XElement from, XElement to)
{
if (to.LastNode is XText)
{
to.LastNode.Remove();
}
var fromNodes = from.Nodes().ToArray();
from.RemoveNodes();
foreach (var element in fromNodes)
{
to.Add(element);
}
}
private XElement ProcessElements(IEnumerable<ItemRepeaterElement> elements, DataReader dataReader, XElement start, XElement parent, int index, ref XElement nestedRepeaterEndElement, ref XElement endIfElement, bool nestedElement = false)
{
XElement result = null;
XElement previous = start;
foreach (var itemRepeaterElement in elements)
{
var flgStucturedElementProcessed = this.CheckAndProcessStartIfElementForContinue(itemRepeaterElement,
dataReader,
ref endIfElement)
||
this.CheckAndProcessEndIfElementForContinue(itemRepeaterElement,
ref endIfElement)
||
this.CheckAndProcessEndItemRepeaterElementForContinue(
itemRepeaterElement, ref nestedRepeaterEndElement)
|| this.CheckTableElementForContinue(itemRepeaterElement);
if (!flgStucturedElementProcessed)
{
var flgNestedElementCheckedForContinue = this.CheckNestedConditionElementForContinue(
itemRepeaterElement, endIfElement)
||
this.CheckNestedElementForContinue(elements.First(),
itemRepeaterElement,
nestedRepeaterEndElement);
if (!flgNestedElementCheckedForContinue)
{
if (itemRepeaterElement.IsItemHtmlContent)
{
result = HtmlContentProcessor.MakeHtmlContentProcessed(itemRepeaterElement.XElement,
dataReader.ReadText(
itemRepeaterElement.Expression),
true);
}
else if (itemRepeaterElement.IsItemRepeater)
{
var itemRepeaterTag = new ItemRepeaterTag()
{
StartItemRepeater = itemRepeaterElement.StartTag,
EndItemRepeater = itemRepeaterElement.EndTag,
Source = itemRepeaterElement.Expression
};
var itemRepeaterGenerator = new ItemRepeaterGenerator();
previous = itemRepeaterGenerator.Generate(itemRepeaterTag,
dataReader.GetReaders(itemRepeaterTag.Source),
previous, parent);
nestedRepeaterEndElement = itemRepeaterTag.EndItemRepeater;
result = null;
}
else if (itemRepeaterElement.IsIndex)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
index.ToString(CultureInfo.CurrentCulture),
!nestedElement);
}
else if (itemRepeaterElement.IsItem)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
dataReader.ReadText(itemRepeaterElement.Expression),
dataReader.ReadAttribute(itemRepeaterElement.Expression, "style"),
!nestedElement);
}
else if (itemRepeaterElement.IsItemTable)
{
result = ItemTableGenerator.ProcessItemTableElement(itemRepeaterElement.StartTag, itemRepeaterElement.EndTag,
dataReader);
if (nestedElement)
{
previous.AddAfterSelf(result);
previous = result;
result = null;
}
}
else
{
var element = new XElement(itemRepeaterElement.XElement);
element.RemoveNodes();
result = element;
if (itemRepeaterElement.HasElements)
{
var parsedLastElement = this.ProcessElements(itemRepeaterElement.Elements, dataReader,
previous,
result, index, ref nestedRepeaterEndElement,
ref endIfElement, true);
if (itemRepeaterElement.Elements.Any(ire => ire.XElement.IsSdt()) && DocxHelper.IsEmptyParagraph(result))
{
result = null;
}
if (itemRepeaterElement.Elements.Any(ire => ire.IsItemTable) ||
itemRepeaterElement.Elements.Any(
ire =>
ire.IsItemRepeater && !CheckInlineWrappingMode(ire.StartTag, ire.EndTag)))
{
previous = parsedLastElement;
}
}
else
{
element.Value = itemRepeaterElement.XElement.Value;
}
}
if (result != null)
{
if (!nestedElement)
{
previous.AddAfterSelf(result);
previous = result;
}
else
{
parent.Add(result);
}
}
}
else
{
result = null;
}
}
else
{
result = null;
}
}
return result ?? previous;
}
public void SynchronizeSmilParToWordLevel(XElement smilPar)
{
var smilText = smilPar.Element("text");
if (smilText == null)
{
FireSyncWarning("Found no child <text> of smil par", null, smilPar);
return;
}
if (smilText.Attribute("id") == null || String.IsNullOrWhiteSpace(smilText.Attribute("id").Value))
{
FireSyncWarning("id is missing from smil text", null, smilText);
return;
}
var textElem = GetTextElement(smilText);
if (textElem == null)
{
FireSyncWarning(
String.Format("Found no text file element matching src {0}",
smilText.Attributes("src").Select(a => a.Value).FirstOrDefault() ?? ""),
null,
smilText);
return;
}
if (!XmlUtils.AddWordMarkup(textElem, textElem.Name.Namespace + "span", "word", true))
{
return;
}
var lang = textElem.AncestorsAndSelf().Attributes("lang").Select(a => a.Value).FirstOrDefault();
var syncer = GetXmlSynchronizer(lang);
if (syncer == null)
{
FireSyncWarning("Could not get synchronizer for language " + (lang ?? "<null>"), textElem, smilText);
return;
}
var textFileUri = XmlUtils.GetPathPart(smilText.Attribute("src"));
var parSyncPoint = GetSyncPointFromSmilPar(smilPar, textElem);
var audioSrc = smilPar.Descendants("audio").Attributes("src").Select(a => a.Value).First();
if (parSyncPoint == null)
{
return;//SyncWarning has already been fired
}
var syncPoints = syncer.Synchronize(textElem, parSyncPoint.AudioFile, parSyncPoint.ClipBegin, parSyncPoint.ClipEnd, "word");
foreach (var id in syncPoints.Keys.Where(k => syncPoints[k].ClipBegin>=syncPoints[k].ClipEnd).ToList())
{
syncPoints.Remove(id);
}
if (syncPoints.Values.Count(sp => sp.ClipBegin < sp.ClipEnd) <= 1) return;
var oldSmilParId = smilPar.Attributes("id").Select(a => a.Value).FirstOrDefault();
var oldSmilTextId = smilPar.Descendants("text").Attributes("id").Select(a => a.Value).FirstOrDefault();
XElement firstPar = null, firstText = null;
smilPar.RemoveAttributes();
smilPar.RemoveNodes();
foreach (var sp in syncPoints.Values.OrderBy(o => o))
{
var newText = new XElement(
"text",
new XAttribute("src", String.Concat(textFileUri, "#", sp.Id)));
if (firstText == null)
{
firstText = newText;
}
var newPar = new XElement(
"par",
new XAttribute("endsync", "last"),
newText,
new XElement(
"audio",
new XAttribute("clip-begin", DAISYUtils.GetClipAttributeValue(sp.ClipBegin)),
new XAttribute("clip-end", DAISYUtils.GetClipAttributeValue(sp.ClipEnd)),
new XAttribute("src", audioSrc)));
if (firstPar == null)
{
firstPar = newPar;
}
smilPar.AddBeforeSelf(newPar);
newText.SetAttributeValue("id", XmlUtils.GetId(newText.Document, sp.Id));
}
smilPar.Remove();
if (oldSmilParId != null && firstPar != null)
{
firstPar.SetAttributeValue("id", oldSmilParId);
}
if (oldSmilTextId != null && firstText != null)
{
firstText.SetAttributeValue("id", oldSmilTextId);
}
}
private static XElement MergeSections(XElement parent, XElement child)
{
// check inheritance rules
XAttribute attr = child.Attribute("Inheritance");
string Inheritance = "";
if (attr != null)
Inheritance = attr.Value.ToUpperInvariant();
XElement res = null;
if (Inheritance == "" || Inheritance == "TRUE")
{
res = new XElement(parent);
res.RemoveNodes();
MergeElements(res, parent, child);
}
else if (Inheritance == "FALSE")
res = new XElement(child);
else if (Inheritance == "MERGE")
{
res = new XElement(parent);
foreach (XElement node in child.Elements())
res.Add(new XElement(node));
}
else
throw new CXmlDriverException("Section " + NodeName(child) + " has invalid value for attribute @Inheritance. Expected 'true', 'false' or 'merge'");
return res;
}
private static void MergeElements(XElement res, XElement parent, XElement child)
{
// merge attributes
AppendAttributes(res, child);
// check whether the "parent" node has children elements
if (!HasChildElements(parent))
{
// child append children and return
foreach (XElement cur in child.Elements())
res.Add(new XElement(cur));
return;
}
// build child list
int childListCount = 0;
XElement[] childList = BuildElementList(child, out childListCount);
int childListLeft = childListCount;
// go through all parent elements
foreach (XElement cur in parent.Elements())
{
if (cur.NodeType != XmlNodeType.Element)
continue;
string curName = cur.Name.LocalName;
// check position,
// assume that number of elements is not big, so we could use liner search
int curPos = 0;
for (XElement prev = (XElement)cur.PreviousNode; prev != null; prev = (XElement)prev.PreviousNode)
if (prev.NodeType == XmlNodeType.Element && prev.Name.LocalName == curName)
curPos++;
// search for the element in the child
XElement childElement = childListCount == 0 ? null : FindElementAndRemoveIt(curName, curPos, childList, childListCount);
// if not found
if (childElement == null)
{
res.Add(new XElement(cur));
continue;
}
childListLeft--;
XElement temp = new XElement(cur);
temp.RemoveNodes();
res.Add(temp);
XElement resNextLevel = temp;
MergeElements(resNextLevel, cur, childElement);
}
// add nodes missing in the parent
if (childListLeft > 0)
AppendElements(res, childList, childListCount);
}
/// <summary>
/// Tests the Document property on Node.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
//[Variation(Desc = "NodeDocument")]
public void NodeDocument()
{
XDocument document = new XDocument();
XNode[] topLevelNodes = new XNode[]
{
new XComment("comment"),
new XElement("element"),
new XProcessingInstruction("target", "data"),
};
XNode[] nestedNodes = new XNode[]
{
new XText("abcd"),
new XElement("nested"),
new XProcessingInstruction("target2", "data2")
};
// Test top-level cases.
foreach (XNode node in topLevelNodes)
{
Validate.IsNull(node.Document);
document.Add(node);
Validate.IsReferenceEqual(document, node.Document);
document.RemoveNodes();
}
// Test nested cases.
XElement root = new XElement("root");
document.Add(root);
foreach (XNode node in nestedNodes)
{
Validate.IsNull(node.Document);
root.Add(node);
Validate.IsReferenceEqual(document, root.Document);
root.RemoveNodes();
}
}
public static void TransferDataForSymbol(string symbol)
{
int count = 0;
XElement group = new XElement("quotes", new XAttribute("symbol", symbol));
foreach (string path in Directory.EnumerateFiles(Common.PathToSymbol(symbol)))
{
count++;
if (count % GROUP_SIZE == 0)
{
Console.WriteLine(symbol + "Sending " + count);
while (true)
{
try
{
Send(group.ToString());
group.RemoveNodes();
break;
}
catch (Exception e)
{
Console.WriteLine("Timeout");
Thread.Sleep(1000);
}
}
}
XElement content = XElement.Parse(File.ReadAllText(path));
Filter(content);
group.Add(content);
}
Send(group.ToString());
}
/// <summary>
/// Serializes the annotation as XML to the body of hte given element.
/// </summary>
/// <param name="obj"></param>
/// <param name="annotation"></param>
/// <param name="element"></param>
XElement SerializeToXml(XObject obj, object annotation, XElement element)
{
Contract.Requires<ArgumentNullException>(obj != null);
Contract.Requires<ArgumentNullException>(annotation != null);
Contract.Requires<ArgumentNullException>(element != null);
// configure element
element.SetAttributeValue(NX_FORMAT, NX_FORMAT_XML);
element.SetAttributeValue(NX_TYPE, annotation.GetType().FullName + ", " + annotation.GetType().Assembly.GetName().Name);
element.RemoveNodes();
// serialize anntation into body
using (var wrt = element.CreateWriter())
{
wrt.WriteWhitespace(""); // fixes a bug in XmlSerializer that tries to WriteStartDocument
if (annotation is ISerializableAnnotation)
{
element.Add(((ISerializableAnnotation)annotation).Serialize(this));
}
else if (annotation is IXmlSerializable)
{
var srs = GetXmlSerializer(annotation.GetType());
var ens = new XmlSerializerNamespaces();
ens.Add("", "");
srs.Serialize(wrt, annotation, ens);
}
else if (annotation.GetType().GetCustomAttribute<XmlRootAttribute>() != null)
{
var srs = GetXmlSerializer(annotation.GetType());
var ens = new XmlSerializerNamespaces();
ens.Add("", "");
srs.Serialize(wrt, annotation, ens);
}
else
return null;
}
return element;
}
private void VerifyRemoveNodes(XElement e)
{
bool hadAttributes = e.HasAttributes;
IEnumerable<XAttribute> attributesBefore = e.Attributes().ToList();
IEnumerable<XNode> nodesBefore = e.Nodes().ToList();
e.RemoveNodes();
TestLog.Compare(e.HasAttributes == hadAttributes, "e.HasAttributes == hadAttributes");
TestLog.Compare(!e.HasElements, "!e.HasElements");
TestLog.Compare(e.Nodes().IsEmpty(), "e.Nodes().IsEmpty()");
TestLog.Compare(e.IsEmpty, "e.IsEmpty");
TestLog.Compare(attributesBefore.SequenceEqual(e.Attributes()), "attributesBefore.SequenceEqual(e.Attributes())");
TestLog.Compare(nodesBefore.Where(n => n.Parent != null).IsEmpty(), "nodesBefore.Where(n=>n.Parent!=null).IsEmpty()");
TestLog.Compare(nodesBefore.Where(n => n.Document != null).IsEmpty(), "nodesBefore.Where(n=>n.Parent!=null).IsEmpty()");
}
private static void SortHeader(XElement header)
{
// Has three optional elements: description, ranges, and fields.
// Put them in this order, if present: description, ranges, and fields.
var description = header.Element("description");
if (description != null)
{
description.Remove();
}
var ranges = header.Element("ranges");
if (ranges != null)
{
ranges.Remove();
}
var fields = header.Element("fields");
if (fields != null)
{
fields.Remove();
}
var leftovers = header.Elements().ToList();
header.RemoveNodes();
if (description != null)
{
SortMultiformElement(description);
header.Add(description);
}
if (ranges != null)
{
SortRanges(ranges);
header.Add(ranges);
}
if (fields != null)
{
var sortedFields = SortFields(fields, "tag");
header.Add(fields);
foreach (var field in sortedFields.Values)
{
fields.Add(field);
}
}
foreach (var leftover in leftovers)
{
header.Add(leftover);
}
}
private XElement ProcessElements(IEnumerable<ItemRepeaterElement> itemRepeaterElements, DataReader dataReader, XElement start, XElement parent, int index, out ICollection<XElement> elementsBeforeNestedRepeaters, bool nested = false)
{
XElement result = null;
XElement previous = start;
ICollection<XElement> tempElementsBeforeItemRepeaters = new List<XElement>();
foreach (var itemRepeaterElement in itemRepeaterElements)
{
if (!itemRepeaterElement.IsVisible || itemRepeaterElement.IsItemIf || itemRepeaterElement.IsEndItemIf)
{
continue;
}
if (itemRepeaterElement.IsItemHtmlContent)
{
result = HtmlContentProcessor.MakeHtmlContentProcessed(itemRepeaterElement.XElement, dataReader.ReadText(itemRepeaterElement.Expression), true);
}
else if (itemRepeaterElement.IsIndex)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
index.ToString(CultureInfo.CurrentCulture),
!nested
);
}
else if (itemRepeaterElement.IsItem && itemRepeaterElement.HasExpression)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
dataReader.ReadText(itemRepeaterElement.Expression),
!nested
);
}
else
{
var element = new XElement(itemRepeaterElement.XElement);
element.RemoveNodes();
result = element;
if (itemRepeaterElement.HasElements)
{
ICollection<XElement> bisectNestedElements = new List<XElement>();
this.ProcessElements(itemRepeaterElement.Elements, dataReader, null, result, index, out bisectNestedElements, true);
if (bisectNestedElements.Count != 0)
{
tempElementsBeforeItemRepeaters.Add(bisectNestedElements.ElementAt(0));
}
}
else
{
element.Value = itemRepeaterElement.XElement.Value;
}
}
if (previous != null)
{
previous.AddAfterSelf(result);
previous = result;
}
else
{
parent.Add(result);
}
if (itemRepeaterElement.IsBeforeNestedRepeater)
{
tempElementsBeforeItemRepeaters.Add(result);
}
}
elementsBeforeNestedRepeaters = tempElementsBeforeItemRepeaters;
return result;
}
private static void SortEntry(XElement entry)
{
var lexicalUnit = entry.Element("lexical-unit");
if (lexicalUnit != null)
{
SortMultiformElement(lexicalUnit);
lexicalUnit.Remove();
}
var citation = entry.Element("citation");
if (citation != null)
{
SortMultiformElement(citation);
citation.Remove();
}
var pronunciations = SortPronunciations(entry);
var variants = SortVariantContents(entry);
var sensesInFileOrder = SortSenseContent(entry, "sense");
var sortedEtymologies = SortedEtymologies(entry);
var notes = SortedNotes(entry);
var sortedRelations = SortedRelations(entry);
var sortedExtensibles = SortExtensibleWithField(entry);
var leftovers = entry.Elements().ToList();
entry.RemoveNodes();
if (lexicalUnit != null)
entry.Add(lexicalUnit);
if (citation != null)
entry.Add(citation);
foreach (var pronunciation in pronunciations)
entry.Add(pronunciation);
foreach (var variant in variants)
entry.Add(variant);
foreach (var sense in sensesInFileOrder)
entry.Add(sense);
foreach (var note in notes.Values)
entry.Add(note);
foreach (var relation in sortedRelations.Values)
entry.Add(relation);
foreach (var etymology in sortedEtymologies.Values)
entry.Add(etymology);
RestoreSortedExtensibles(sortedExtensibles, entry);
foreach (var leftover in leftovers)
entry.Add(leftover);
}
internal static void NestStylesPropertyElement(
IDictionary<string, SortedDictionary<string, byte[]>> classData,
Dictionary<string, string> guidToClassMapping,
XElement stylesProperty,
string outputPathname)
{
if (stylesProperty == null)
return;
var styleObjSurElements = stylesProperty.Elements().ToList();
if (!styleObjSurElements.Any())
return;
// Use only one file for all of them.
var root = new XElement(SharedConstants.Styles);
foreach (var styleObjSurElement in styleObjSurElements)
{
var styleGuid = styleObjSurElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var className = guidToClassMapping[styleGuid];
var style = Utilities.CreateFromBytes(classData[className][styleGuid]);
CmObjectNestingService.NestObject(false, style, classData, guidToClassMapping);
root.Add(style);
}
FileWriterService.WriteNestedFile(outputPathname, root);
stylesProperty.RemoveNodes();
}
/// <summary>
/// 使用CDATA的方式将value保存在指定的element中
/// </summary>
/// <param name="element"></param>
/// <param name="value"></param>
public static void SetCDataValue(this System.Xml.Linq.XElement element, string value)
{
element.RemoveNodes();
element.Add(new System.Xml.Linq.XCData(value));
}
private void TestReplacement(XElement e, object[] nodes, int numOfNodes)
{
for (int i = 0; i < e.Nodes().Count(); i++)
{
foreach (var replacement in nodes.NonRecursiveVariations(numOfNodes))
{
XContainer elem = new XElement(e);
XNode toReplace = elem.Nodes().ElementAt(i);
XNode prev = toReplace.PreviousNode;
XNode next = toReplace.NextNode;
bool isReplacementOriginal = replacement.Where(o => o is XNode).Where(o => (o as XNode).Parent != null).IsEmpty();
IEnumerable<ExpectedValue> expValues = ReplaceWithExpValues(elem, toReplace, replacement).ProcessNodes().ToList();
if (_runWithEvents)
{
_eHelper = new EventsHelper(elem);
}
toReplace.ReplaceWith(replacement);
TestLog.Compare(toReplace.Parent == null, "toReplace.Parent == null");
TestLog.Compare(toReplace.Document == null, "toReplace.Document == null");
TestLog.Compare(expValues.EqualAll(elem.Nodes(), XNode.EqualityComparer), "expected values");
if (isReplacementOriginal)
{
TestLog.Compare(replacement.Where(o => o is XNode).Where(o => (o as XNode).Parent != elem).IsEmpty(), "replacement.Where(o=>o is XNode).Where(o=>(o as XNode).Parent!=elem).IsEmpty()");
TestLog.Compare(replacement.Where(o => o is XNode).Where(o => (o as XNode).Document != elem.Document).IsEmpty(), "replacement.Where(o=>o is XNode).Where(o=>(o as XNode).Document!=elem.Document).IsEmpty()");
}
elem.RemoveNodes();
}
}
}
