/// <summary> /// Get the absolute path of the node <code>node</code> starting from the root. /// </summary> /// <param name="node">The node for which the path is retrieved.</param> /// <returns>The absolute path of the node. The first element is a "/" to mark this as absolute path.</returns> public static DocumentPath GetAbsolutePath(IDocumentNode node) { DocumentPath path = GetPath(node, int.MaxValue); path.IsAbsolutePath = true; return(path); }
public DocumentPath(DocumentPath from) { this._IsAbsolutePath = from._IsAbsolutePath; foreach (string s in from) { Add(s); } }
/// <summary> /// Resolves the path by first using startnode as starting point. If that failed, try using documentRoot as starting point. /// </summary> /// <param name="path">The path to resolve.</param> /// <param name="startnode">The node object which is considered as the starting point of the path.</param> /// <param name="documentRoot">An alternative node which is used as starting point of the path if the first try failed.</param> /// <returns>The resolved object. If the resolving process failed, the return value is null.</returns> public static object GetObject(DocumentPath path, object startnode, object documentRoot) { object retval = GetObject(path, startnode); if (null == retval && null != documentRoot) { retval = GetObject(path, documentRoot); } return(retval); }
public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info) { DocumentPath s = (DocumentPath)obj; info.AddValue("IsAbsolute", s._IsAbsolutePath); info.CreateArray("Path", s.Count); for (int i = 0; i < s.Count; i++) { info.AddValue("e", s[i]); } info.CommitArray(); }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { DocumentPath s = null != o ? (DocumentPath)o : new DocumentPath(); s._IsAbsolutePath = info.GetBoolean("IsAbsolute"); int count = info.OpenArray(); for (int i = 0; i < count; i++) { s.Add(info.GetString()); } info.CloseArray(count); return(s); }
/// <summary> /// Get the absolute path of the node <code>node</code> starting either from the root, or from the object in the depth /// <code>maxDepth</code>, whatever is reached first. /// </summary> /// <param name="node">The node for which the path is to be retrieved.</param> /// <param name="maxDepth">The maximal hierarchie depth (the maximal number of path elements returned).</param> /// <returns>The path from the root or from the node in the depth <code>maxDepth</code>, whatever is reached first. The path is <b>not</b> prepended /// by a "/". /// </returns> public static DocumentPath GetPath(IDocumentNode node, int maxDepth) { DocumentPath path = new DocumentPath(); int depth = 0; object root = node; while (root != null && root is IDocumentNode) { if (depth >= maxDepth) { break; } string name = ((IDocumentNode)root).Name; path.Insert(0, name); root = ((IDocumentNode)root).ParentObject; ++depth; } return(path); }
public static object GetObject(DocumentPath path, object startnode) { object node = startnode; if (path.IsAbsolutePath && node is IDocumentNode) { node = GetRootNode((IDocumentNode)node); } for (int i = 0; i < path.Count; i++) { if (path[i] == "..") { if (node is Main.IDocumentNode) { node = ((Main.IDocumentNode)node).ParentObject; } else { return(null); } } else { if (node is Main.INamedObjectCollection) { node = ((Main.INamedObjectCollection)node).GetChildObjectNamed(path[i]); } else { return(null); } } } // end for return(node); }