public void Parse()
{
System.IO.StreamReader sr = new System.IO.StreamReader(GetFullPath());
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Parse;
XmlReader reader = XmlReader.Create(sr, settings);
try {
node = new NodeEntity();
node.SetNodeName(fileName);
node.SetNodeID(0);
node.SetDepth(0);
node.Comment(false);
while (reader.Read())
{
ParseElement(reader);
ParseText(reader);
ParseCDATA(reader);
ParseEndElement(reader);
ParseComment(reader);
}
} catch (Exception) {
throw;
} finally {
if (reader != null)
{
reader.Close();
}
if (sr != null)
{
sr.Close();
}
}
}
private void ParseElement(XmlReader reader)
{
if (reader.NodeType != XmlNodeType.Element)
{
return;
}
string nodeName = reader.Name;
NodeEntity newNode = new NodeEntity();
newNode.SetNodeName(nodeName);
newNode.SetNodeID(currentNodeId);
currentNodeId++;
ParseAttributes(reader, newNode);
if (currentNodeId == 1)
{
node = newNode;
}
else
{
node.FindTail(depth).AddChild(newNode);
}
if (!reader.IsEmptyElement)
{
depth++;
}
}
public void AddComment()
{
NodeEntity addNode = new NodeEntity();
addNode.SetNodeName(@"Comment");
addNode.SetDepth(depth + 1);
addNode.Comment(true);
children.Add(addNode);
}
public void AddChild(string name)
{
NodeEntity addNode = new NodeEntity();
addNode.SetNodeName(name);
addNode.SetDepth(depth + 1);
addNode.Comment(false);
children.Add(addNode);
}
public bool IDExists(int arg)
{
NodeEntity r = Root();
if (r.GetNodeID() == arg)
{
return(true);
}
return(IDExists(r, arg));
}
public void Refresh()
{
NodeEntity r = Root();
newDepth = 0;
newNodeId = 0;
r.SetDepth(newDepth);
r.SetNodeID(newNodeId);
Refresh(r);
}
private int TailID(NodeEntity arg)
{
int ret = arg.GetNodeID();
int count = arg.GetChildren().Count;
if (count > 0)
{
ret = TailID(arg.GetChildren()[count - 1]);
}
return(ret);
}
public NodeEntity FindTail(int depth)
{
NodeEntity ret = this;
if (depth == 1)
{
return(ret);
}
depth--;
int count = ret.GetChildren().Count;
return(FindTail(ret.GetChildren()[count - 1], depth));
}
private NodeEntity FindTail(NodeEntity node, int depth)
{
if (depth == 1)
{
return(node);
}
else
{
depth--;
int count = node.GetChildren().Count;
return(FindTail(node.GetChildren()[count - 1], depth));
}
}
private int TailDepth(NodeEntity arg)
{
int ret = arg.GetDepth();
foreach (NodeEntity c in arg.GetChildren())
{
int cd = TailDepth(c);
if (ret < cd)
{
ret = cd;
}
}
return(ret);
}
public void SetWriterSetting(NodeEntity arg)
{
writerSetting = arg;
newLineAfterOpeningBracket = NewLineAfterOpeningBracket();
newLineAfterClosingBracket = NewLineAfterClosingBracket();
newLineAfterAttributes = NewLineAfterAttributes();
newLineAfterNodeValue = NewLineAfterNodeValue();
indentSize = IndentSize();
if (children.Count > 0)
{
children.ForEach(c => {
c.SetWriterSetting(arg);
});
}
}
private void ParseAttributes(XmlReader reader, NodeEntity currentNode)
{
int iLoopCount = reader.AttributeCount;
for (int i = 0; i < iLoopCount; i++)
{
reader.MoveToAttribute(i);
string attrName = reader.LocalName;
string attrValue = reader.GetAttribute(attrName);
AttributeEntity attr = new AttributeEntity();
attr.SetAttrName(attrName);
attr.SetAttrValue(attrValue);
currentNode.AddAttr(attr);
}
}
private void Refresh(NodeEntity node)
{
newDepth++;
foreach (NodeEntity c in node.GetChildren())
{
c.SetDepth(newDepth);
newNodeId++;
c.SetNodeID(newNodeId);
if (c.GetChildren().Count > 0)
{
Refresh(c);
newDepth--;
}
}
}
public NodeEntity()
{
nodeId = 0;
depth = 0;
isComment = false;
attrList = new List <AttributeEntity>();
parent = null;
children = new List <NodeEntity>();
writerSetting = null;
newLineAfterOpeningBracket = true;
newLineAfterClosingBracket = true;
newLineAfterAttributes = true;
newLineAfterNodeValue = true;
indentSize = 2;
}
private NodeEntity FindByID(NodeEntity node, int id)
{
foreach (NodeEntity c in node.GetChildren())
{
if (c.GetNodeID() == id)
{
return(c);
}
NodeEntity ret = FindByID(c, id);
if (ret != null)
{
return(ret);
}
}
return(null);
}
public NodeEntity CloneWithoutChildren()
{
NodeEntity ret = new NodeEntity();
attrList.ForEach(v => {
ret.AddAttr(v.Clone());
});
ret.SetNodeName(nodeName);
ret.SetNodeID(nodeId);
ret.SetDepth(depth);
ret.SetNodeValue(nodeValue);
ret.Comment(isComment);
return(ret);
}
protected void ParseComment(XmlReader reader)
{
if (reader.NodeType != XmlNodeType.Comment)
{
return;
}
NodeEntity newNode = new NodeEntity();
newNode.SetNodeName(@"Comment");
newNode.SetNodeID(currentNodeId);
newNode.SetDepth(depth);
newNode.SetNodeValue(reader.Value.Trim());
newNode.Comment(true);
currentNodeId++;
node.FindTail(depth).AddChild(newNode);
}
public void RemoveByID(int arg)
{
NodeEntity p = FindByID(arg).GetParent();
if (p == null)
{
return;
}
for (int i = 0; i < p.GetChildren().Count; i++)
{
if (p.GetChildren()[i].GetNodeID() == arg)
{
p.GetChildren().RemoveAt(i);
Refresh();
return;
}
}
}
private bool IDExists(NodeEntity node, int id)
{
bool ret = false;
foreach (NodeEntity c in node.GetChildren())
{
if (c.GetNodeID() == id)
{
ret = true;
}
ret = IDExists(c, id);
if (ret == true)
{
return(true);
}
}
return(ret);
}
public void MoveByID(int moveFrom, int moveTo)
{
if (moveFrom == moveTo)
{
return;
}
NodeEntity nf = FindByID(moveFrom);
if (nf == null)
{
return;
}
NodeEntity pf = nf.GetParent();
if (pf == null)
{
return;
}
NodeEntity pt = FindByID(moveTo).GetParent();
if (pt == null)
{
return;
}
nf = nf.Clone();
for (int j = 0; j < pf.GetChildren().Count; j++)
{
if (pf.GetChildren()[j].GetNodeID() == moveFrom)
{
pf.GetChildren().RemoveAt(j);
break;
}
}
for (int i = 0; i < pt.GetChildren().Count; i++)
{
if (pt.GetChildren()[i].GetNodeID() == moveTo)
{
pt.GetChildren().Insert(i, nf);
break;
}
}
Refresh();
}
protected void ParseElement(XmlReader reader)
{
if (reader.NodeType != XmlNodeType.Element)
{
return;
}
string nodeName = reader.Name;
NodeEntity newNode = new NodeEntity();
newNode.SetNodeName(nodeName);
newNode.SetNodeID(currentNodeId);
newNode.SetDepth(depth);
newNode.Comment(false);
currentNodeId++;
node.FindTail(depth).AddChild(newNode);
ParseAttributes(reader, newNode);
if (!reader.IsEmptyElement)
{
depth++;
}
}
public void MoveDownByID(int arg)
{
NodeEntity p = FindByID(arg).GetParent();
if (p == null)
{
return;
}
for (int i = 0; i < p.GetChildren().Count; i++)
{
if (p.GetChildren()[i].GetNodeID() == arg)
{
if (i < p.GetChildren().Count - 1)
{
NodeEntity n = p.GetChildren()[i].Clone();
p.GetChildren().RemoveAt(i);
p.GetChildren().Insert(i + 1, n);
Refresh();
return;
}
}
}
}
public void SetNode(NodeEntity arg)
{
node = arg;
}
public void SetParent(NodeEntity arg)
{
parent = arg;
}
public NodeEntity FindByID(int id)
{
NodeEntity r = Root();
return(FindByID(r, id));
}
public void AddChild(NodeEntity arg)
{
arg.SetParent(this);
children.Add(arg);
}
public int TailDepth()
{
NodeEntity r = Root();
return(TailDepth(r));
}
public int TailID()
{
NodeEntity r = Root();
return(TailID(r));
}
