private static IDataNode ElementConstructor(string slotName, INode parentNode, IDataNode dataNode)
{
if (dataNode != null) return dataNode;
var newType = typeof (Note).Assembly.GetTypes().Single(type => type.Name.ToLower() == parentNode.Name.ToLower());
return parentNode.DataNodes.Register(slotName, () => newType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{}));
}
public void Load(IDataNode dataNode, IResourceManager resourceManager)
{
_shaderName = dataNode.ReadParameter("key");
_vertexShader = dataNode.ReadParameter("vertex");
_fragmentShader = dataNode.ReadParameter("fragment");
if (dataNode.HasParameter("numbers"))
{
var floats = dataNode.ReadParameterList("numbers");
foreach (var f in floats)
{
_numericParameters.Add(f, default(float));
}
}
if (dataNode.HasParameter("vectors"))
{
var vectors = dataNode.ReadParameterList("vectors");
foreach (var v in vectors)
{
_vectorParameters.Add(v, default(Vector3));
}
}
if (dataNode.HasParameter("textures"))
{
var textures = dataNode.ReadParameterList("textures");
foreach (var t in textures)
{
_textureParameters.Add(t, null);
}
}
}
// Used to add to the pre-filter stream.
public void AddData(Guid streamId, IDataNode data)
{
DataStream dataStream = GetDataStream(streamId);
if (dataStream != null) {
dataStream.AddData(data);
}
}
internal void SetDataNode(IDataNode dataNode, string name, string ns)
{
SetNextElement(dataNode, name, ns, null);
_element = _nextElement;
_nextElement = null;
SetElement();
}
public TelemetryDriver(IDataNode pool)
{
Pool = pool;
if (Pool is MemoryPool)
{
BaseAddress = ((MemoryPool) Pool).Address;
}
}
private void AddDeserializedDataNode(IDataNode node)
{
if ((node.Id != Globals.NewObjectId) && ((node.Value == null) || !node.IsFinalValue))
{
if (this.deserializedDataNodes == null)
{
this.deserializedDataNodes = new Queue<IDataNode>();
}
this.deserializedDataNodes.Enqueue(node);
}
}
public LogGroup(LogFileWriter writer, string name, IDataNode dataSource)
{
FileWriter = writer;
Name = name;
DataSource = dataSource;
Subscribed = true;
TimeStream = new LogGroupStream(this, LogFileType.Time, 1024 * 1024);
DataStream = new LogGroupStream(this, LogFileType.Data, 1024 * 1024);
_fields = dataSource.GetDataFields().Select(x => new LogField(this, x, GetNewFieldId())).ToList();
}
public void Load(IDataNode dataNode, IResourceManager resourceManager)
{
_name = dataNode.ReadParameter("key");
_path = dataNode.ReadParameter("path");
_minFilter = TextureMinFilter.Linear;
if (dataNode.HasParameter("minFilter"))
_minFilter = (TextureMinFilter)Enum.Parse(typeof(TextureMinFilter), dataNode.ReadParameter("minFilter"));
_magFilter = TextureMagFilter.Linear;
if (dataNode.HasParameter("magFilter"))
_magFilter = (TextureMagFilter)Enum.Parse(typeof(TextureMagFilter), dataNode.ReadParameter("magFilter"));
_image = (Bitmap) System.Drawing.Image.FromFile(_path);
_index = resourceManager.GetTextures().Count();
}
private bool CheckIfNodeHandled(IDataNode node)
{
bool flag = false;
if (node.Id != Globals.NewObjectId)
{
flag = this.cache[node] != null;
if (flag)
{
if (this.nextElement == null)
{
this.nextElement = this.GetNextElement();
}
this.nextElement.attributeCount = 0;
this.nextElement.AddAttribute("z", "http://schemas.microsoft.com/2003/10/Serialization/", "Ref", node.Id.ToString(NumberFormatInfo.InvariantInfo));
this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
return flag;
}
this.cache.Add(node, node);
}
return flag;
}
private bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
{
bool flag = true;
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>) dataNode).GetValue() : ((bool) dataNode.Value));
break;
case TypeCode.Char:
this.value = XmlConvert.ToString(isTypedNode ? ((int) ((DataNode<char>) dataNode).GetValue()) : ((char) dataNode.Value));
break;
case TypeCode.SByte:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>) dataNode).GetValue() : ((sbyte) dataNode.Value));
break;
case TypeCode.Byte:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>) dataNode).GetValue() : ((byte) dataNode.Value));
break;
case TypeCode.Int16:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>) dataNode).GetValue() : ((short) dataNode.Value));
break;
case TypeCode.UInt16:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>) dataNode).GetValue() : ((ushort) dataNode.Value));
break;
case TypeCode.Int32:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>) dataNode).GetValue() : ((int) dataNode.Value));
break;
case TypeCode.UInt32:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>) dataNode).GetValue() : ((uint) dataNode.Value));
break;
case TypeCode.Int64:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>) dataNode).GetValue() : ((long) dataNode.Value));
break;
case TypeCode.UInt64:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ulong>) dataNode).GetValue() : ((ulong) dataNode.Value));
break;
case TypeCode.Single:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>) dataNode).GetValue() : ((float) dataNode.Value));
break;
case TypeCode.Double:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>) dataNode).GetValue() : ((double) dataNode.Value));
break;
case TypeCode.Decimal:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<decimal>) dataNode).GetValue() : ((decimal) dataNode.Value));
break;
case TypeCode.DateTime:
this.value = (isTypedNode ? ((DataNode<DateTime>) dataNode).GetValue() : ((DateTime) dataNode.Value)).ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
break;
case TypeCode.String:
this.value = isTypedNode ? ((DataNode<string>) dataNode).GetValue() : ((string) dataNode.Value);
break;
default:
if (type == Globals.TypeOfByteArray)
{
byte[] inArray = isTypedNode ? ((DataNode<byte[]>) dataNode).GetValue() : ((byte[]) dataNode.Value);
this.value = (inArray == null) ? string.Empty : Convert.ToBase64String(inArray);
}
else if (type == Globals.TypeOfTimeSpan)
{
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<TimeSpan>) dataNode).GetValue() : ((TimeSpan) dataNode.Value));
}
else if (type == Globals.TypeOfGuid)
{
this.value = (isTypedNode ? ((DataNode<Guid>) dataNode).GetValue() : ((Guid) dataNode.Value)).ToString();
}
else if (type == Globals.TypeOfUri)
{
this.value = (isTypedNode ? ((DataNode<Uri>) dataNode).GetValue() : ((Uri) dataNode.Value)).GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
}
else
{
flag = false;
}
break;
}
if (flag)
{
this.internalNodeType = ExtensionDataNodeType.Text;
}
return flag;
}
private void SetNextElement(IDataNode node, string name, string ns, string prefix)
{
throw NotImplemented.ByDesign;
}
/// <summary>
/// Parses the specified node.
/// </summary>
/// <param name="node">The node.</param>
public override void Parse(XmlNode node)
{
m_Name = Helper.AttributeValue(node, "name", m_Name);
m_ActiveConfig = Helper.AttributeValue(node, "activeConfig", m_ActiveConfig);
m_Path = Helper.AttributeValue(node, "path", m_Path);
m_FullPath = m_Path;
try
{
m_FullPath = Helper.ResolvePath(m_FullPath);
}
catch
{
throw new WarningException("Could not resolve solution path: {0}", m_Path);
}
Kernel.Instance.CurrentWorkingDirectory.Push();
try
{
Helper.SetCurrentDir(m_FullPath);
if (node == null)
{
throw new ArgumentNullException("node");
}
foreach (XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if (dataNode is OptionsNode)
{
m_Options = (OptionsNode)dataNode;
}
else if (dataNode is FilesNode)
{
m_Files = (FilesNode)dataNode;
}
else if (dataNode is ConfigurationNode)
{
m_Configurations[((ConfigurationNode)dataNode).Name] = dataNode;
}
else if (dataNode is ProjectNode)
{
m_Projects[((ProjectNode)dataNode).Name] = dataNode;
m_ProjectsOrder.Add(dataNode);
}
else if (dataNode is SolutionNode)
{
m_Solutions[((SolutionNode)dataNode).Name] = dataNode;
}
else if (dataNode is ProcessNode)
{
ProcessNode p = (ProcessNode)dataNode;
Kernel.Instance.ProcessFile(p, this);
}
else if (dataNode is DatabaseProjectNode)
{
m_DatabaseProjects[((DatabaseProjectNode)dataNode).Name] = dataNode;
}
}
}
finally
{
Kernel.Instance.CurrentWorkingDirectory.Pop();
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override void Parse(XmlNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
string path = Helper.AttributeValue(node, "path", ".");
string pattern = Helper.AttributeValue(node, "pattern", "*");
bool recurse = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "recurse", "false"));
bool useRegex = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "useRegex", "false"));
string buildAction = Helper.AttributeValue(node, "buildAction", String.Empty);
if (buildAction != string.Empty)
{
m_BuildAction = (BuildAction)Enum.Parse(typeof(BuildAction), buildAction);
}
//TODO: Figure out where the subtype node is being assigned
//string subType = Helper.AttributeValue(node, "subType", string.Empty);
//if (subType != String.Empty)
// m_SubType = (SubType)Enum.Parse(typeof(SubType), subType);
m_ResourceName = Helper.AttributeValue(node, "resourceName", m_ResourceName);
m_CopyToOutput = (CopyToOutput)Enum.Parse(typeof(CopyToOutput), Helper.AttributeValue(node, "copyToOutput", m_CopyToOutput.ToString()));
m_Link = bool.Parse(Helper.AttributeValue(node, "link", bool.FalseString));
if (m_Link)
{
m_LinkPath = Helper.AttributeValue(node, "linkPath", string.Empty);
}
m_PreservePath = bool.Parse(Helper.AttributeValue(node, "preservePath", bool.FalseString));
if (path != null && path.Length == 0)
{
path = "."; //use current directory
}
//throw new WarningException("Match must have a 'path' attribute");
if (pattern == null)
{
throw new WarningException("Match must have a 'pattern' attribute");
}
path = Helper.NormalizePath(path);
if (!Directory.Exists(path))
{
throw new WarningException("Match path does not exist: {0}", path);
}
try
{
if (useRegex)
{
m_Regex = new Regex(pattern);
}
}
catch (ArgumentException ex)
{
throw new WarningException("Could not compile regex pattern: {0}", ex.Message);
}
foreach (XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if (dataNode is ExcludeNode)
{
ExcludeNode excludeNode = (ExcludeNode)dataNode;
m_Exclusions.Add(excludeNode);
}
}
RecurseDirectories(path, pattern, recurse, useRegex, m_Exclusions);
if (m_Files.Count < 1)
{
// Include the project name when the match node returns no matches to provide extra
// debug info.
ProjectNode project = Parent.Parent as ProjectNode;
string projectName = "";
if (project != null)
{
projectName = " in project " + project.AssemblyName;
}
throw new WarningException("Match" + projectName + " returned no files: {0}{1}", Helper.EndPath(path), pattern);
}
m_Regex = null;
}
public void Add(IDataNode pool)
{
_pools.Add((MemoryPool)pool);
((MemoryPool)pool).SetProvider(this);
}
/// <summary>
/// Parses the specified node.
/// </summary>
/// <param name="node">The node.</param>
public override void Parse(XmlNode node)
{
m_Name = Helper.AttributeValue(node, "name", m_Name);
m_Path = Helper.AttributeValue(node, "path", m_Path);
m_FilterGroups = Helper.AttributeValue(node, "filterGroups", m_FilterGroups);
m_Version = Helper.AttributeValue(node, "version", m_Version);
m_AppIcon = Helper.AttributeValue(node, "icon", m_AppIcon);
m_ApplicationManifest = Helper.AttributeValue(node, "appmanifest", m_ApplicationManifest);
m_ConfigFile = Helper.AttributeValue(node, "configFile", m_ConfigFile);
m_DesignerFolder = Helper.AttributeValue(node, "designerFolder", m_DesignerFolder);
m_AssemblyName = Helper.AttributeValue(node, "assemblyName", m_AssemblyName);
m_Language = Helper.AttributeValue(node, "language", m_Language);
m_Type = (ProjectType)Helper.EnumAttributeValue(node, "type", typeof(ProjectType), m_Type);
m_Runtime = (ClrRuntime)Helper.EnumAttributeValue(node, "runtime", typeof(ClrRuntime), m_Runtime);
if (m_useFramework)
{
m_Framework = (FrameworkVersion)Helper.EnumAttributeValue(node, "frameworkVersion", typeof(FrameworkVersion), m_Framework);
}
m_StartupObject = Helper.AttributeValue(node, "startupObject", m_StartupObject);
m_RootNamespace = Helper.AttributeValue(node, "rootNamespace", m_RootNamespace);
int hash = m_Name.GetHashCode();
Guid guidByHash = new Guid(hash, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
string guid = Helper.AttributeValue(node, "guid", guidByHash.ToString());
m_Guid = new Guid(guid);
m_GenerateAssemblyInfoFile = Helper.ParseBoolean(node, "generateAssemblyInfoFile", false);
m_DebugStartParameters = Helper.AttributeValue(node, "debugStartParameters", string.Empty);
if (string.IsNullOrEmpty(m_AssemblyName))
{
m_AssemblyName = m_Name;
}
if (string.IsNullOrEmpty(m_RootNamespace))
{
m_RootNamespace = m_Name;
}
m_FullPath = m_Path;
try
{
m_FullPath = Helper.ResolvePath(m_FullPath);
}
catch
{
throw new WarningException("Could not resolve Solution path: {0}", m_Path);
}
Kernel.Instance.CurrentWorkingDirectory.Push();
try
{
Helper.SetCurrentDir(m_FullPath);
if (node == null)
{
throw new ArgumentNullException("node");
}
foreach (XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if (dataNode is ConfigurationNode)
{
HandleConfiguration((ConfigurationNode)dataNode);
}
else if (dataNode is ReferencePathNode)
{
m_ReferencePaths.Add((ReferencePathNode)dataNode);
}
else if (dataNode is ReferenceNode)
{
m_References.Add((ReferenceNode)dataNode);
}
else if (dataNode is AuthorNode)
{
m_Authors.Add((AuthorNode)dataNode);
}
else if (dataNode is FilesNode)
{
m_Files = (FilesNode)dataNode;
}
}
}
finally
{
Kernel.Instance.CurrentWorkingDirectory.Pop();
}
}
internal override void WriteExtensionDataTypeInfo(XmlWriterDelegator xmlWriter, IDataNode dataNode)
{
Type dataType = dataNode.DataType;
if ((dataType == Globals.TypeOfClassDataNode) || (dataType == Globals.TypeOfISerializableDataNode))
{
xmlWriter.WriteAttributeString(null, "type", null, "object");
base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
}
else if (dataType == Globals.TypeOfCollectionDataNode)
{
xmlWriter.WriteAttributeString(null, "type", null, "array");
}
else if ((dataType != Globals.TypeOfXmlDataNode) && (((dataType == Globals.TypeOfObject) && (dataNode.Value != null)) && RequiresJsonTypeInfo(base.GetDataContract(dataNode.Value.GetType()))))
{
base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
}
}
public virtual void Load(IDataNode dataNode, IResourceManager resourceManager)
{
var shaderName = dataNode.ReadParameter("shader");
_shader = resourceManager.GetShader(shaderName);
_name = dataNode.ReadParameter("key");
var textureParameters = new Dictionary<string, string>();
dataNode.ReadAllParameters(_vectorParameters, _numericParameters, textureParameters);
foreach (var textureParameter in textureParameters)
{
if(resourceManager.HasTexture(textureParameter.Value))
_textureParameters.Add(textureParameter.Key, resourceManager.GetTexture(textureParameter.Value));
}
}
private void SetNextElement(IDataNode node, string name, string ns, string prefix)
{
this.internalNodeType = ExtensionDataNodeType.Element;
this.nextElement = this.GetNextElement();
this.nextElement.localName = name;
this.nextElement.ns = ns;
this.nextElement.prefix = prefix;
if (node == null)
{
this.nextElement.attributeCount = 0;
this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
this.internalNodeType = ExtensionDataNodeType.NullElement;
}
else if (!this.CheckIfNodeHandled(node))
{
this.AddDeserializedDataNode(node);
node.GetData(this.nextElement);
if (node is XmlDataNode)
{
this.MoveNextInXml((XmlDataNode) node);
}
}
}
internal void SetDataNode(IDataNode dataNode, string name, string ns)
{
this.SetNextElement(dataNode, name, ns, null);
this.element = this.nextElement;
this.nextElement = null;
this.SetElement();
}
internal void WriteExtensionData(IDataNode dataNode)
{
bool flag = true;
Type dataType = dataNode.DataType;
switch (Type.GetTypeCode(dataType))
{
case TypeCode.Boolean:
this.WriteBoolean(((DataNode<bool>) dataNode).GetValue());
break;
case TypeCode.Char:
this.WriteChar(((DataNode<char>) dataNode).GetValue());
break;
case TypeCode.SByte:
this.WriteSignedByte(((DataNode<sbyte>) dataNode).GetValue());
break;
case TypeCode.Byte:
this.WriteUnsignedByte(((DataNode<byte>) dataNode).GetValue());
break;
case TypeCode.Int16:
this.WriteShort(((DataNode<short>) dataNode).GetValue());
break;
case TypeCode.UInt16:
this.WriteUnsignedShort(((DataNode<ushort>) dataNode).GetValue());
break;
case TypeCode.Int32:
this.WriteInt(((DataNode<int>) dataNode).GetValue());
break;
case TypeCode.UInt32:
this.WriteUnsignedInt(((DataNode<uint>) dataNode).GetValue());
break;
case TypeCode.Int64:
this.WriteLong(((DataNode<long>) dataNode).GetValue());
break;
case TypeCode.UInt64:
this.WriteUnsignedLong(((DataNode<ulong>) dataNode).GetValue());
break;
case TypeCode.Single:
this.WriteFloat(((DataNode<float>) dataNode).GetValue());
break;
case TypeCode.Double:
this.WriteDouble(((DataNode<double>) dataNode).GetValue());
break;
case TypeCode.Decimal:
this.WriteDecimal(((DataNode<decimal>) dataNode).GetValue());
break;
case TypeCode.DateTime:
this.WriteDateTime(((DataNode<DateTime>) dataNode).GetValue());
break;
case TypeCode.String:
this.WriteString(((DataNode<string>) dataNode).GetValue());
break;
default:
if (dataType == Globals.TypeOfByteArray)
{
this.WriteBase64(((DataNode<byte[]>) dataNode).GetValue());
}
else if (dataType == Globals.TypeOfObject)
{
object obj2 = dataNode.Value;
if (obj2 != null)
{
this.WriteAnyType(obj2);
}
}
else if (dataType == Globals.TypeOfTimeSpan)
{
this.WriteTimeSpan(((DataNode<TimeSpan>) dataNode).GetValue());
}
else if (dataType == Globals.TypeOfGuid)
{
this.WriteGuid(((DataNode<Guid>) dataNode).GetValue());
}
else if (dataType == Globals.TypeOfUri)
{
this.WriteUri(((DataNode<Uri>) dataNode).GetValue());
}
else if (dataType == Globals.TypeOfXmlQualifiedName)
{
this.WriteQName(((DataNode<XmlQualifiedName>) dataNode).GetValue());
}
else
{
flag = false;
}
break;
}
if (!flag)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateInvalidPrimitiveTypeException(dataType));
}
}
public void Test_Building_A_Tree_For_A_Class_With_A_String_Inline()
{
IDataNode rootNode = TreeBuilder.BuildTreeForType(typeof(ClassWithStringInline));
ClassWithStringInline.BuildSample().VerifyTree(rootNode);
}
internal override void WriteExtensionDataTypeInfo(XmlWriterDelegator xmlWriter, IDataNode dataNode)
{
Type dataType = dataNode.DataType;
if (dataType == Globals.TypeOfClassDataNode ||
dataType == Globals.TypeOfISerializableDataNode)
{
xmlWriter.WriteAttributeString(null, JsonGlobals.typeString, null, JsonGlobals.objectString);
base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
}
else if (dataType == Globals.TypeOfCollectionDataNode)
{
xmlWriter.WriteAttributeString(null, JsonGlobals.typeString, null, JsonGlobals.arrayString);
// Don't write __type for collections
}
else if (dataType == Globals.TypeOfXmlDataNode)
{
// Don't write type or __type for XML types because we serialize them to strings
}
else if ((dataType == Globals.TypeOfObject) && (dataNode.Value != null))
{
DataContract dc = GetDataContract(dataNode.Value.GetType());
if (RequiresJsonTypeInfo(dc))
{
base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="file"></param>
/// <param name="solutions"></param>
/// <returns></returns>
public void ProcessFile(string file, IList <SolutionNode> solutions)
{
m_CurrentWorkingDirectory.Push();
string path = file;
try
{
try
{
path = Helper.ResolvePath(path);
}
catch (ArgumentException)
{
m_Log.Write("Could not open Prebuild file: " + path);
m_CurrentWorkingDirectory.Pop();
return;
}
Helper.SetCurrentDir(Path.GetDirectoryName(path));
XmlTextReader reader = new XmlTextReader(path);
Core.Parse.Preprocessor pre = new Core.Parse.Preprocessor();
//register command line arguments as XML variables
IEnumerator <KeyValuePair <string, string> > dict = m_CommandLine.GetEnumerator();
while (dict.MoveNext())
{
string name = dict.Current.Key.Trim();
if (name.Length > 0)
{
pre.RegisterVariable(name, dict.Current.Value);
}
}
string xml = pre.Process(reader); //remove script and evaulate pre-proccessing to get schema-conforming XML
// See if the user put into a pseudo target of "prebuild:preprocessed-input" to indicate they want to see the
// output before the system processes it.
if (m_CommandLine.WasPassed("ppi"))
{
// Get the filename if there is one, otherwise use a default.
string ppiFile = m_CommandLine["ppi"];
if (ppiFile == null || ppiFile.Trim().Length == 0)
{
ppiFile = "preprocessed-input.xml";
}
// Write out the string to the given stream.
try
{
using (StreamWriter ppiWriter = new StreamWriter(ppiFile))
{
ppiWriter.WriteLine(xml);
}
}
catch (IOException ex)
{
Console.WriteLine("Could not write PPI file '{0}': {1}", ppiFile, ex.Message);
}
// Finish processing this special tag.
return;
}
m_CurrentDoc = new XmlDocument();
try
{
#if NO_VALIDATE
XmlReader validator = XmlReader.Create(new StringReader(xml));
m_CurrentDoc.Load(validator);
#else
XmlValidatingReader validator = new XmlValidatingReader(new XmlTextReader(new StringReader(xml)));
//validate while reading from string into XmlDocument DOM structure in memory
foreach (XmlSchema schema in m_Schemas)
{
validator.Schemas.Add(schema);
}
m_CurrentDoc.Load(validator);
#endif
}
catch (XmlException e)
{
throw new XmlException(e.ToString());
}
//is there a purpose to writing it? An syntax/schema problem would have been found during pre.Process() and reported with details
if (m_CommandLine.WasPassed("ppo"))
{
string ppoFile = m_CommandLine["ppo"];
if (ppoFile == null || ppoFile.Trim().Length < 1)
{
ppoFile = "preprocessed.xml";
}
StreamWriter writer = null;
try
{
writer = new StreamWriter(ppoFile);
writer.Write(xml);
}
catch (IOException ex)
{
Console.WriteLine("Could not write PPO file '{0}': {1}", ppoFile, ex.Message);
}
finally
{
if (writer != null)
{
writer.Close();
}
}
return;
}
//start reading the xml config file
XmlElement rootNode = m_CurrentDoc.DocumentElement;
//string suggestedVersion = Helper.AttributeValue(rootNode,"version","1.0");
Helper.CheckForOSVariables = Helper.ParseBoolean(rootNode, "checkOsVars", false);
foreach (XmlNode node in rootNode.ChildNodes) //solutions or if pre-proc instructions
{
IDataNode dataNode = ParseNode(node, null);
if (dataNode is ProcessNode)
{
ProcessNode proc = (ProcessNode)dataNode;
if (proc.IsValid)
{
ProcessFile(proc.Path);
}
}
else if (dataNode is SolutionNode)
{
solutions.Add((SolutionNode)dataNode);
}
}
}
catch (XmlSchemaException xse)
{
m_Log.Write("XML validation error at line {0} in {1}:\n\n{2}",
xse.LineNumber, path, xse.Message);
}
finally
{
m_CurrentWorkingDirectory.Pop();
}
}
private void MoveNext(IDataNode dataNode)
{
throw NotImplemented.ByDesign;
}
internal bool TryWriteDeserializedExtensionData(XmlWriterDelegator xmlWriter, IDataNode dataNode)
{
object?o = dataNode.Value;
if (o == null)
{
return(false);
}
Type declaredType = (dataNode.DataContractName == null) ? o.GetType() : Globals.TypeOfObject;
InternalSerialize(xmlWriter, o, false /*isDeclaredType*/, false /*writeXsiType*/, -1, declaredType.TypeHandle);
return(true);
}
private void SetNextElement(IDataNode node, string name, string ns, string prefix)
{
throw NotImplemented.ByDesign;
}
/// <summary>
/// 设置数据结点的数据。
/// </summary>
/// <typeparam name="T">要设置的数据类型。</typeparam>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="data">要设置的数据。</param>
/// <param name="node">查找起始结点。</param>
public void SetData <T>(string path, T data, IDataNode node) where T : Variable
{
IDataNode current = GetOrAddNode(path, node);
current.SetData(data);
}
/// <summary>
/// 设置数据结点的数据。
/// </summary>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="data">要设置的数据。</param>
/// <param name="node">查找起始结点。</param>
public void SetData(string path, Variable data, IDataNode node)
{
m_DataNodeManager.SetData(path, data, node);
}
//Create an instance of the data node type that is mapped to the name of the xml DOM node
/// <summary>
/// Parses the node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="parent">The parent.</param>
/// <param name="preNode">The pre node.</param>
/// <returns></returns>
public IDataNode ParseNode(XmlNode node, IDataNode parent, IDataNode preNode)
{
IDataNode dataNode = null;
try
{
if( node == null )
{
throw new ArgumentNullException("node");
}
if(preNode == null)
{
if(!m_Nodes.ContainsKey(node.Name))
{
//throw new XmlException("Unknown XML node: " + node.Name);
return null;
}
NodeEntry ne = (NodeEntry)m_Nodes[node.Name];
Type type = ne.Type;
//DataNodeAttribute dna = ne.Attribute;
dataNode = (IDataNode)type.Assembly.CreateInstance(type.FullName);
if(dataNode == null)
{
throw new System.Reflection.TargetException("Could not create new parser instance: " + type.FullName);
}
}
else
dataNode = preNode;
dataNode.Parent = parent;
dataNode.Parse(node);
}
catch(WarningException wex)
{
m_Log.Write(LogType.Warning, wex.Message);
return null;
}
catch(FatalException fex)
{
m_Log.WriteException(LogType.Error, fex);
throw;
}
catch(Exception ex)
{
m_Log.WriteException(LogType.Error, ex);
throw;
}
return dataNode;
}
/// <summary>
/// 移除数据结点。
/// </summary>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="node">查找起始结点。</param>
public void RemoveNode(string path, IDataNode node)
{
m_DataNodeManager.RemoveNode(path, node);
}
internal void WriteExtensionData(IDataNode dataNode)
{
bool handled = true;
Type valueType = dataNode.DataType;
switch (Type.GetTypeCode(valueType))
{
case TypeCode.Boolean:
WriteBoolean(((DataNode <bool>)dataNode).GetValue());
break;
case TypeCode.Char:
WriteChar(((DataNode <char>)dataNode).GetValue());
break;
case TypeCode.Byte:
WriteUnsignedByte(((DataNode <byte>)dataNode).GetValue());
break;
case TypeCode.Int16:
WriteShort(((DataNode <short>)dataNode).GetValue());
break;
case TypeCode.Int32:
WriteInt(((DataNode <int>)dataNode).GetValue());
break;
case TypeCode.Int64:
WriteLong(((DataNode <long>)dataNode).GetValue());
break;
case TypeCode.Single:
WriteFloat(((DataNode <float>)dataNode).GetValue());
break;
case TypeCode.Double:
WriteDouble(((DataNode <double>)dataNode).GetValue());
break;
case TypeCode.Decimal:
WriteDecimal(((DataNode <decimal>)dataNode).GetValue());
break;
case TypeCode.DateTime:
WriteDateTime(((DataNode <DateTime>)dataNode).GetValue());
break;
case TypeCode.String:
WriteString(((DataNode <string>)dataNode).GetValue());
break;
case TypeCode.SByte:
WriteSignedByte(((DataNode <sbyte>)dataNode).GetValue());
break;
case TypeCode.UInt16:
WriteUnsignedShort(((DataNode <ushort>)dataNode).GetValue());
break;
case TypeCode.UInt32:
WriteUnsignedInt(((DataNode <uint>)dataNode).GetValue());
break;
case TypeCode.UInt64:
WriteUnsignedLong(((DataNode <ulong>)dataNode).GetValue());
break;
case TypeCode.Empty:
case TypeCode.DBNull:
case TypeCode.Object:
default:
if (valueType == Globals.TypeOfByteArray)
{
WriteBase64(((DataNode <byte[]>)dataNode).GetValue());
}
else if (valueType == Globals.TypeOfObject)
{
object obj = dataNode.Value;
if (obj != null)
{
WriteAnyType(obj);
}
}
else if (valueType == Globals.TypeOfTimeSpan)
{
WriteTimeSpan(((DataNode <TimeSpan>)dataNode).GetValue());
}
else if (valueType == Globals.TypeOfGuid)
{
WriteGuid(((DataNode <Guid>)dataNode).GetValue());
}
else if (valueType == Globals.TypeOfUri)
{
WriteUri(((DataNode <Uri>)dataNode).GetValue());
}
else if (valueType == Globals.TypeOfXmlQualifiedName)
{
WriteQName(((DataNode <XmlQualifiedName>)dataNode).GetValue());
}
else
{
handled = false;
}
break;
}
if (!handled)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateInvalidPrimitiveTypeException(valueType));
}
}
/// <summary>
/// 获取数据结点的数据。
/// </summary>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="node">查找起始结点。</param>
/// <returns>数据结点的数据。</returns>
public Variable GetData(string path, IDataNode node)
{
return(m_DataNodeManager.GetData(path, node));
}
private void MoveNext(IDataNode dataNode)
{
throw NotImplemented.ByDesign;
}
private void ProcessFile(string file)
{
m_CurrentWorkingDirectory.Push();
string path = file;
try
{
try
{
path = Helper.ResolvePath(path);
}
catch (ArgumentException)
{
m_Log.Write("Could not open Prebuild file: " + path);
m_CurrentWorkingDirectory.Pop();
return;
}
m_CurrentFile = path;
Helper.SetCurrentDir(Path.GetDirectoryName(path));
XmlTextReader reader = new XmlTextReader(path);
Core.Parse.Preprocessor pre = new Core.Parse.Preprocessor();
//register command line arguments as XML variables
IDictionaryEnumerator dict = m_CommandLine.GetEnumerator();
while (dict.MoveNext())
{
string name = dict.Key.ToString().Trim();
if (name.Length > 0)
{
pre.RegisterVariable(name, dict.Value.ToString());
}
}
string xml = pre.Process(reader); //remove script and evaulate pre-proccessing to get schema-conforming XML
XmlDocument doc = new XmlDocument();
try
{
XmlValidatingReader validator = new XmlValidatingReader(new XmlTextReader(new StringReader(xml)));
//validate while reading from string into XmlDocument DOM structure in memory
foreach (XmlSchema schema in m_Schemas)
{
validator.Schemas.Add(schema);
}
doc.Load(validator);
}
catch (XmlException e)
{
throw new XmlException(e.ToString());
}
//is there a purpose to writing it? An syntax/schema problem would have been found during pre.Process() and reported with details
if (m_CommandLine.WasPassed("ppo"))
{
string ppoFile = m_CommandLine["ppo"];
if (ppoFile == null || ppoFile.Trim().Length < 1)
{
ppoFile = "preprocessed.xml";
}
StreamWriter writer = null;
try
{
writer = new StreamWriter(ppoFile);
writer.Write(xml);
}
catch (IOException ex)
{
Console.WriteLine("Could not write PPO file '{0}': {1}", ppoFile, ex.Message);
}
finally
{
if (writer != null)
{
writer.Close();
}
}
return;
}
//start reading the xml config file
XmlElement rootNode = doc.DocumentElement;
//string suggestedVersion = Helper.AttributeValue(rootNode,"version","1.0");
Helper.CheckForOSVariables = Helper.ParseBoolean(rootNode, "checkOsVars", false);
foreach (XmlNode node in rootNode.ChildNodes) //solutions or if pre-proc instructions
{
IDataNode dataNode = ParseNode(node, null);
if (dataNode is ProcessNode)
{
ProcessNode proc = (ProcessNode)dataNode;
if (proc.IsValid)
{
ProcessFile(proc.Path);
}
}
else if (dataNode is SolutionNode)
{
m_Solutions.Add(dataNode);
}
}
}
catch (XmlSchemaException xse)
{
m_Log.Write("XML validation error at line {0} in {1}:\n\n{2}",
xse.LineNumber, path, xse.Message);
}
finally
{
m_CurrentWorkingDirectory.Pop();
}
}
/// <summary>
/// 设置数据结点的数据。
/// </summary>
/// <typeparam name="T">要设置的数据类型。</typeparam>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="data">要设置的数据。</param>
/// <param name="node">查找起始结点。</param>
public void SetData <T>(string path, T data, IDataNode node) where T : Variable
{
m_DataNodeManager.SetData(path, data, node);
}
private void MoveNext(IDataNode dataNode)
{
switch (this.internalNodeType)
{
case ExtensionDataNodeType.Text:
case ExtensionDataNodeType.ReferencedElement:
case ExtensionDataNodeType.NullElement:
this.internalNodeType = ExtensionDataNodeType.EndElement;
return;
}
Type dataType = dataNode.DataType;
if (dataType == Globals.TypeOfClassDataNode)
{
this.MoveNextInClass((ClassDataNode) dataNode);
}
else if (dataType == Globals.TypeOfCollectionDataNode)
{
this.MoveNextInCollection((CollectionDataNode) dataNode);
}
else if (dataType == Globals.TypeOfISerializableDataNode)
{
this.MoveNextInISerializable((ISerializableDataNode) dataNode);
}
else if (dataType == Globals.TypeOfXmlDataNode)
{
this.MoveNextInXml((XmlDataNode) dataNode);
}
else
{
if (dataNode.Value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.Runtime.Serialization.SR.GetString("InvalidStateInExtensionDataReader")));
}
this.MoveToDeserializedObject(dataNode);
}
}
/// <summary>
/// 获取或增加数据结点。
/// </summary>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="node">查找起始结点。</param>
/// <returns>指定位置的数据结点，如果没有找到，则增加相应的数据结点。</returns>
public IDataNode GetOrAddNode(string path, IDataNode node)
{
return(m_DataNodeManager.GetOrAddNode(path, node));
}
void MoveNext(IDataNode dataNode)
{
switch (this.internalNodeType)
{
case ExtensionDataNodeType.Text:
case ExtensionDataNodeType.ReferencedElement:
case ExtensionDataNodeType.NullElement:
this.internalNodeType = ExtensionDataNodeType.EndElement;
return;
default:
Type dataNodeType = dataNode.DataType;
if (dataNodeType == Globals.TypeOfClassDataNode)
MoveNextInClass((ClassDataNode)dataNode);
else if (dataNodeType == Globals.TypeOfCollectionDataNode)
MoveNextInCollection((CollectionDataNode)dataNode);
else if (dataNodeType == Globals.TypeOfISerializableDataNode)
MoveNextInISerializable((ISerializableDataNode)dataNode);
else if (dataNodeType == Globals.TypeOfXmlDataNode)
MoveNextInXml((XmlDataNode)dataNode);
else if (dataNode.Value != null)
MoveToDeserializedObject(dataNode);
else
{
Fx.Assert("Encountered invalid data node when deserializing unknown data");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.InvalidStateInExtensionDataReader)));
}
break;
}
}
/// <summary>
/// 根据类型获取数据结点的数据。
/// </summary>
/// <typeparam name="T">要获取的数据类型。</typeparam>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="node">查找起始结点。</param>
/// <returns>指定类型的数据。</returns>
public T GetData <T>(string path, IDataNode node) where T : Variable
{
return(m_DataNodeManager.GetData <T>(path, node));
}
void SetNextElement(IDataNode node, string name, string ns, string prefix)
{
this.internalNodeType = ExtensionDataNodeType.Element;
nextElement = GetNextElement();
nextElement.localName = name;
nextElement.ns = ns;
nextElement.prefix = prefix;
if (node == null)
{
nextElement.attributeCount = 0;
nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
this.internalNodeType = ExtensionDataNodeType.NullElement;
}
else if (!CheckIfNodeHandled(node))
{
AddDeserializedDataNode(node);
node.GetData(nextElement);
if (node is XmlDataNode)
MoveNextInXml((XmlDataNode)node);
}
}
/// <inheritdoc />
public BranchDataNode(NodeTypeInfo typeInfo, IDataNode parentNode, string name) : base(typeInfo,
parentNode, name)
{
}
void AddDeserializedDataNode(IDataNode node)
{
if (node.Id != Globals.NewObjectId && (node.Value == null || !node.IsFinalValue))
{
if (deserializedDataNodes == null)
deserializedDataNodes = new Queue<IDataNode>();
deserializedDataNodes.Enqueue(node);
}
}
public void Test_Building_A_Tree_For_A_Class_With_A_String_At_Offset()
{
IDataNode rootNode = TreeBuilder.BuildTreeForType(typeof(ClassWithStringAtOffset));
ClassWithStringAtOffset.BuildSample().VerifyTree(rootNode);
}
bool CheckIfNodeHandled(IDataNode node)
{
bool handled = false;
if (node.Id != Globals.NewObjectId)
{
handled = (cache[node] != null);
if (handled)
{
if (nextElement == null)
nextElement = GetNextElement();
nextElement.attributeCount = 0;
nextElement.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.RefLocalName, node.Id.ToString(NumberFormatInfo.InvariantInfo));
nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
}
else
{
cache.Add(node, node);
}
}
return handled;
}
public void Test_Building_A_Tree_For_A_Class_With_Nested_Class_With_Primitive_Properties()
{
IDataNode rootNode = TreeBuilder.BuildTreeForType(typeof(ClassWithNestedClassWithPrimitiveProperties));
ClassWithNestedClassWithPrimitiveProperties.BuildSample().VerifyTree(rootNode);
}
void MoveToDeserializedObject(IDataNode dataNode)
{
Type type = dataNode.DataType;
bool isTypedNode = true;
if (type == Globals.TypeOfObject)
{
type = dataNode.Value.GetType();
if (type == Globals.TypeOfObject)
{
this.internalNodeType = ExtensionDataNodeType.EndElement;
return;
}
isTypedNode = false;
}
if (!MoveToText(type, dataNode, isTypedNode))
{
if (dataNode.IsFinalValue)
{
this.internalNodeType = ExtensionDataNodeType.EndElement;
}
else
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type))));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="parent"></param>
/// <returns></returns>
public IDataNode ParseNode(XmlNode node, IDataNode parent)
{
return(ParseNode(node, parent, null));
}
bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
{
bool handled = true;
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>)dataNode).GetValue() : (bool)dataNode.Value);
break;
case TypeCode.Char:
this.value = XmlConvert.ToString((int)(isTypedNode ? ((DataNode<char>)dataNode).GetValue() : (char)dataNode.Value));
break;
case TypeCode.Byte:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>)dataNode).GetValue() : (byte)dataNode.Value);
break;
case TypeCode.Int16:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>)dataNode).GetValue() : (short)dataNode.Value);
break;
case TypeCode.Int32:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>)dataNode).GetValue() : (int)dataNode.Value);
break;
case TypeCode.Int64:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>)dataNode).GetValue() : (long)dataNode.Value);
break;
case TypeCode.Single:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>)dataNode).GetValue() : (float)dataNode.Value);
break;
case TypeCode.Double:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>)dataNode).GetValue() : (double)dataNode.Value);
break;
case TypeCode.Decimal:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<decimal>)dataNode).GetValue() : (decimal)dataNode.Value);
break;
case TypeCode.DateTime:
DateTime dateTime = isTypedNode ? ((DataNode<DateTime>)dataNode).GetValue() : (DateTime)dataNode.Value;
this.value = dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
break;
case TypeCode.String:
this.value = isTypedNode ? ((DataNode<string>)dataNode).GetValue() : (string)dataNode.Value;
break;
case TypeCode.SByte:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>)dataNode).GetValue() : (sbyte)dataNode.Value);
break;
case TypeCode.UInt16:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>)dataNode).GetValue() : (ushort)dataNode.Value);
break;
case TypeCode.UInt32:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>)dataNode).GetValue() : (uint)dataNode.Value);
break;
case TypeCode.UInt64:
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ulong>)dataNode).GetValue() : (ulong)dataNode.Value);
break;
case TypeCode.Object:
default:
if (type == Globals.TypeOfByteArray)
{
byte[] bytes = isTypedNode ? ((DataNode<byte[]>)dataNode).GetValue() : (byte[])dataNode.Value;
this.value = (bytes == null) ? String.Empty : Convert.ToBase64String(bytes);
}
else if (type == Globals.TypeOfTimeSpan)
this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<TimeSpan>)dataNode).GetValue() : (TimeSpan)dataNode.Value);
else if (type == Globals.TypeOfGuid)
{
Guid guid = isTypedNode ? ((DataNode<Guid>)dataNode).GetValue() : (Guid)dataNode.Value;
this.value = guid.ToString();
}
else if (type == Globals.TypeOfUri)
{
Uri uri = isTypedNode ? ((DataNode<Uri>)dataNode).GetValue() : (Uri)dataNode.Value;
this.value = uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
}
else
handled = false;
break;
}
if (handled)
this.internalNodeType = ExtensionDataNodeType.Text;
return handled;
}
internal virtual void WriteExtensionDataTypeInfo(XmlWriterDelegator xmlWriter, IDataNode dataNode)
{
if (dataNode.DataContractName != null)
{
WriteTypeInfo(xmlWriter, dataNode.DataContractName, dataNode.DataContractNamespace);
}
WriteClrTypeInfo(xmlWriter, dataNode.DataType, dataNode.ClrTypeName, dataNode.ClrAssemblyName);
}
private DataNodeAccuracy PruneDecisionTree(IDataNode node)
{
if (node is DataLeaf)
{
return(new DataNodeAccuracy {
Node = node,
CorrectWeight = node.ClassDistribution.Max(),
TotalWeight = node.ClassDistribution.Sum(),
});
}
else if (node is IDataSplit)
{
IDataSplit split = (IDataSplit)node;
DataNodeAccuracy leftAccuracy = PruneDecisionTree(split.Left);
DataNodeAccuracy rightAccuracy = PruneDecisionTree(split.Right);
float splitCorrect = leftAccuracy.CorrectWeight + rightAccuracy.CorrectWeight;
float splitTotal = leftAccuracy.TotalWeight + rightAccuracy.TotalWeight;
float leafCorrect = node.ClassDistribution.Max();
float leafTotal = node.ClassDistribution.Sum();
#if DEBUGCUDA
Assert.AreEqual(leafTotal, splitTotal, 1.0f);
#endif
float accuracyIncrease = splitCorrect - leafCorrect;
float requiredIncrease = Context.TotalWeight * GPUConstants.RequiredImprovementToSplit;
if (accuracyIncrease < requiredIncrease)
{
// Split not justified, revert back to leaf at this level
return(new DataNodeAccuracy {
Node = new DataLeaf {
ClassDistribution = node.ClassDistribution
},
CorrectWeight = leafCorrect,
TotalWeight = leafTotal,
});
}
else
{
// Take the split with the pruned nodes
if (split is AttributeSplit)
{
AttributeSplit attributeSplit = (AttributeSplit)split;
attributeSplit.Left = leftAccuracy.Node;
attributeSplit.Right = rightAccuracy.Node;
}
else if (split is CategoricalSplit)
{
CategoricalSplit categoricalSplit = (CategoricalSplit)split;
categoricalSplit.Left = leftAccuracy.Node;
categoricalSplit.Right = rightAccuracy.Node;
}
else
{
throw new ArgumentException("Unknown split type: " + split);
}
return(new DataNodeAccuracy {
Node = split,
CorrectWeight = splitCorrect,
TotalWeight = splitTotal,
});
}
}
else
{
throw new ArgumentException("Unknown node type: " + node);
}
}
/// <summary>
/// Parses the specified node.
/// </summary>
/// <param name="node">The node.</param>
public override void Parse(XmlNode node)
{
m_Name = Helper.AttributeValue(node, "name", m_Name);
m_ActiveConfig = Helper.AttributeValue(node, "activeConfig", m_ActiveConfig);
m_Path = Helper.AttributeValue(node, "path", m_Path);
m_Version = Helper.AttributeValue(node, "version", m_Version);
m_FullPath = m_Path;
try
{
m_FullPath = Helper.ResolvePath(m_FullPath);
}
catch
{
throw new WarningException("Could not resolve solution path: {0}", m_Path);
}
Kernel.Instance.CurrentWorkingDirectory.Push();
try
{
Helper.SetCurrentDir(m_FullPath);
if (node == null)
{
throw new ArgumentNullException("node");
}
foreach (XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if (dataNode is OptionsNode)
{
m_Options = (OptionsNode)dataNode;
}
else if (dataNode is FilesNode)
{
m_Files = (FilesNode)dataNode;
}
else if (dataNode is ConfigurationNode)
{
ConfigurationNode configurationNode = (ConfigurationNode)dataNode;
m_Configurations[configurationNode.NameAndPlatform] = configurationNode;
// If the active configuration is null, then we populate it.
if (ActiveConfig == null)
{
ActiveConfig = configurationNode.Name;
}
}
else if (dataNode is ProjectNode)
{
m_Projects[((ProjectNode)dataNode).Name] = (ProjectNode)dataNode;
m_ProjectsOrder.Add((ProjectNode)dataNode);
}
else if (dataNode is SolutionNode)
{
m_Solutions[((SolutionNode)dataNode).Name] = (SolutionNode)dataNode;
}
else if (dataNode is ProcessNode)
{
ProcessNode p = (ProcessNode)dataNode;
Kernel.Instance.ProcessFile(p, this);
}
else if (dataNode is DatabaseProjectNode)
{
m_DatabaseProjects[((DatabaseProjectNode)dataNode).Name] = (DatabaseProjectNode)dataNode;
}
else if (dataNode is CleanupNode)
{
if (m_Cleanup != null)
{
throw new WarningException("There can only be one Cleanup node.");
}
m_Cleanup = (CleanupNode)dataNode;
}
}
}
finally
{
Kernel.Instance.CurrentWorkingDirectory.Pop();
}
}
public void Add(IDataNode pool)
{
_pools.Add((MemoryPool) pool);
((MemoryPool)pool).SetProvider(this);
}
public void Remove(IDataNode pool)
{
_pools.Remove((MemoryPool)pool);
}
public void Remove(IDataNode pool)
{
_pools.Remove((MemoryPool) pool);
}
/// <summary>
/// 设置数据结点的数据。
/// </summary>
/// <param name="path">相对于 node 的查找路径。</param>
/// <param name="data">要设置的数据。</param>
/// <param name="node">查找起始结点。</param>
public void SetData(string path, Variable data, IDataNode node)
{
IDataNode current = GetOrAddNode(path, node);
current.SetData(data);
}
public DataNodeManager()
{
root = new DataNode(RootName, null);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="parent"></param>
/// <returns></returns>
public IDataNode ParseNode(XmlNode node, IDataNode parent)
{
return ParseNode(node, parent, null);
}
public void Shutdown()
{
Clear();
root = null;
}
internal void WriteExtensionData(IDataNode dataNode)
{
bool handled = true;
Type valueType = dataNode.DataType;
switch (Type.GetTypeCode(valueType))
{
case TypeCode.Boolean:
WriteBoolean(((DataNode<bool>)dataNode).GetValue());
break;
case TypeCode.Char:
WriteChar(((DataNode<char>)dataNode).GetValue());
break;
case TypeCode.Byte:
WriteUnsignedByte(((DataNode<byte>)dataNode).GetValue());
break;
case TypeCode.Int16:
WriteShort(((DataNode<short>)dataNode).GetValue());
break;
case TypeCode.Int32:
WriteInt(((DataNode<int>)dataNode).GetValue());
break;
case TypeCode.Int64:
WriteLong(((DataNode<long>)dataNode).GetValue());
break;
case TypeCode.Single:
WriteFloat(((DataNode<float>)dataNode).GetValue());
break;
case TypeCode.Double:
WriteDouble(((DataNode<double>)dataNode).GetValue());
break;
case TypeCode.Decimal:
WriteDecimal(((DataNode<decimal>)dataNode).GetValue());
break;
case TypeCode.DateTime:
WriteDateTime(((DataNode<DateTime>)dataNode).GetValue());
break;
case TypeCode.String:
WriteString(((DataNode<string>)dataNode).GetValue());
break;
case TypeCode.SByte:
WriteSignedByte(((DataNode<sbyte>)dataNode).GetValue());
break;
case TypeCode.UInt16:
WriteUnsignedShort(((DataNode<ushort>)dataNode).GetValue());
break;
case TypeCode.UInt32:
WriteUnsignedInt(((DataNode<uint>)dataNode).GetValue());
break;
case TypeCode.UInt64:
WriteUnsignedLong(((DataNode<ulong>)dataNode).GetValue());
break;
case TypeCode.Empty:
case TypeCode.DBNull:
case TypeCode.Object:
default:
if (valueType == Globals.TypeOfByteArray)
WriteBase64(((DataNode<byte[]>)dataNode).GetValue());
else if (valueType == Globals.TypeOfObject)
{
object obj = dataNode.Value;
if (obj != null)
WriteAnyType(obj);
}
else if (valueType == Globals.TypeOfTimeSpan)
WriteTimeSpan(((DataNode<TimeSpan>)dataNode).GetValue());
else if (valueType == Globals.TypeOfGuid)
WriteGuid(((DataNode<Guid>)dataNode).GetValue());
else if (valueType == Globals.TypeOfUri)
WriteUri(((DataNode<Uri>)dataNode).GetValue());
else if (valueType == Globals.TypeOfXmlQualifiedName)
WriteQName(((DataNode<XmlQualifiedName>)dataNode).GetValue());
else
handled = false;
break;
}
if (!handled)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateInvalidPrimitiveTypeException(valueType));
}
public void SetData <T>(string path, T t, IDataNode dataNode)
{
IDataNode current = GetOrAddNode(path, dataNode);
current.SetData <T>(t);
}
