private static DomObject CreateElement(XmlReader reader, DomMetaElement metaElement)
{
DomComplexType type = metaElement.Type;
// Check for xsi:type attribute, indicating a derived type
string typeName = reader.GetAttribute("xsi:type");
if (typeName != null)
{
// check for qualified type name
string prefix = string.Empty;
int index = typeName.IndexOf(':');
if (index >= 0)
{
prefix = typeName.Substring(0, index);
index++;
typeName = typeName.Substring(index, typeName.Length - index);
}
string ns = reader.LookupNamespace(prefix);
XmlQualifiedName qualifiedName = new XmlQualifiedName(typeName, ns);
type = DomSchemaRegistry.GetComplexType(qualifiedName);
if (type == null)
{
throw new InvalidOperationException("Unknown derived type");
}
}
return(new DomObject(type));
}
private DomObject ReadInternal(Stream stream)
{
DomObject rootDomObject;
using (XmlReader reader = XmlReader.Create(stream))
{
reader.MoveToContent();
string ns = reader.NamespaceURI;
XmlQualifiedName rootElementName = new XmlQualifiedName(reader.LocalName, ns);
DomMetaElement rootElement = DomSchemaRegistry.GetRootElement(rootElementName);
if (rootElement == null)
{
throw new InvalidOperationException("Unknown root element");
}
rootDomObject = new DomObject(rootElement);
ReadElement(rootDomObject, reader);
reader.Close();
}
return(rootDomObject);
}
/// <summary>
/// Run the logic of the copier
/// </summary>
/// <param name="rootProjDomObject">Project file DomObject tree</param>
/// <param name="rootTempDomObject">Temporary settings file DomObject tree</param>
public override void Run(DomObject rootProjDomObject, DomObject rootTempDomObject)
{
List <T> lstProjFiles = new List <T>();
GatherTypes(rootProjDomObject, ref lstProjFiles);
List <T> lstTempFiles = new List <T>();
GatherTypes(rootTempDomObject, ref lstTempFiles);
foreach (T projFile in lstProjFiles)
{
foreach (T tempFile in lstTempFiles)
{
if (m_comparer.Equals(projFile, tempFile))
{
foreach (DomObject domObject in tempFile.InternalObject.Children)
{
if (domObject.CanCreateInterface <TU>())
{
// Search for element to add child to
DomMetaElement metaElement = null;
foreach (DomMetaElement elem in projFile.InternalObject.Type.Children)
{
if (elem.Type == domObject.Type)
{
metaElement = elem;
break;
}
if (!elem.Type.IsAssignableFrom(domObject.Type))
{
continue;
}
metaElement = elem;
break;
}
if (metaElement != null)
{
bool bAdd = true;
if (m_dupComparer != null)
{
// Check for duplicates first!
bool bDuplicate = false;
foreach (DomObject d in projFile.InternalObject.Children)
{
if (!d.CanCreateInterface <TU>())
{
continue;
}
bool bEquals =
m_dupComparer.Equals(
d.CreateInterface <TU>(),
domObject.CreateInterface <TU>());
if (!bEquals)
{
continue;
}
bDuplicate = true;
break;
}
// Don't add duplicates
bAdd = !bDuplicate;
}
// Copy over to project (if it isn't already there)
if (bAdd && !domObject.CanCreateInterface <ISledProjectFilesSaveableSingletonType>())
{
DomObject domClone = domObject.Clone();
projFile.InternalObject.AddChild(metaElement, domClone);
}
}
}
}
}
}
}
}
/// <summary>
/// Read element
/// </summary>
/// <param name="domObject"></param>
/// <param name="reader"></param>
protected void ReadElement(DomObject domObject, XmlReader reader)
{
DomComplexType type = domObject.Type;
// Read attributes
int required = type.RequiredAttributes;
while (reader.MoveToNextAttribute())
{
if (reader.Prefix == string.Empty ||
reader.LookupNamespace(reader.Prefix) == type.Name.Namespace)
{
DomMetaAttribute metaAttribute = type.GetAttribute(reader.LocalName);
if (metaAttribute != null)
{
object value = metaAttribute.Type.Convert(reader.Value);
domObject.SetAttribute(metaAttribute.Name, value);
if (metaAttribute.Required)
{
required--;
}
}
}
}
if (required != 0)
{
throw new InvalidOperationException("Missing required attribute");
}
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
// Read child elements
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
// look up metadata for this element
DomMetaElement metaElement = type.GetChild(reader.LocalName);
if (metaElement != null)
{
DomObject child = CreateElement(reader, metaElement);
ReadElement(child, reader);
// At this point, child is a fully populated sub-tree
domObject.AddChild(metaElement, child);
}
else
{
reader.Skip();
}
}
else if (reader.NodeType == XmlNodeType.Text)
{
if (type.ValueType != null)
{
domObject.Value = type.ValueType.Convert(reader.Value);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
}
reader.MoveToContent();
}
