Util/SemWeb/XPathSemWebNavigator.cs

   1 using System;
   2 using System.Collections;
   3 using System.Xml;
   4 using System.Xml.Xsl;
   5 using System.Xml.XPath;
   6
   7 using SemWeb;
   8
   9 namespace SemWeb.Util {
  10         public class XPathSemWebNavigator : XPathNavigator {
  11                 Store model;
  12                 NamespaceManager nsmgr;
  13                 NSWrap nswrap;
  14
  15                 ArrayList stack = new ArrayList();
  16                 Position current;
  17
  18                 private static Entity ExpandEntitiesOfType = new Entity(null);
  19
  20                 Entity rdfType = NS.RDF+"type";
  21
  22                 private class Position {
  23                         public int Index;
  24                         public bool FirstChild, LastChild;
  25
  26                         public Entity Predicate;
  27                         public Resource Object;
  28
  29                         public Position[] Children;
  30                 }
  31
  32                 private class NSWrap : XsltContext {
  33                         NamespaceManager nsmgr;
  34
  35                         public NSWrap(NamespaceManager nsmgr) : base(new NameTable()) { this.nsmgr = nsmgr; }
  36
  37                         public override bool HasNamespace (string prefix) {
  38                                 return LookupNamespace(prefix) != null;
  39                         }
  40
  41                         public override string LookupNamespace (string prefix) {
  42                                 return nsmgr.GetNamespace(prefix);
  43                         }
  44                         public override string LookupPrefix (string uri) {
  45                                 return nsmgr.GetPrefix(uri);
  46                         }
  47
  48                         // These don't really do anything (yet?).
  49
  50                         public override bool Whitespace {
  51                                 get { return false; }
  52                         }
  53
  54                         public override int CompareDocument (string baseUri, string nextbaseUri) {
  55                                 return baseUri.CompareTo(nextbaseUri);
  56                         }
  57
  58                         public override bool PreserveWhitespace (System.Xml.XPath.XPathNavigator node) {
  59                                 return false;
  60                         }
  61
  62                         public override IXsltContextFunction ResolveFunction (string prefix, string name, System.Xml.XPath.XPathResultType[] ArgTypes) {
  63                                 return null;
  64                         }
  65
  66                         public override IXsltContextVariable ResolveVariable (string prefix, string name) {
  67                                 return null;
  68                         }
  69                 }
  70
  71                 public XPathSemWebNavigator(Store model, NamespaceManager namespaces) : this(ExpandEntitiesOfType, model, namespaces, null) { }
  72
  73                 public XPathSemWebNavigator(Entity root, Store model, NamespaceManager namespaces) : this(root, model, namespaces, null) { }
  74
  75                 private XPathSemWebNavigator(Entity root, Store model, NamespaceManager namespaces, string exapandThisPredicate) {
  76                         this.model = model;
  77
  78                         if (!(namespaces is SemWeb.IO.AutoPrefixNamespaceManager))
  79                                 namespaces = new SemWeb.IO.AutoPrefixNamespaceManager(namespaces);
  80                         this.nsmgr = namespaces;
  81                         nswrap = new NSWrap(nsmgr);
  82
  83                         Position start = new Position();
  84                         start.FirstChild = true;
  85                         start.LastChild = true;
  86                         start.Predicate = root; // a trick to make sure the URI info for the root reflects the root
  87                         start.Object = root;
  88                         if (exapandThisPredicate != null)
  89                                 Expand(start, exapandThisPredicate);
  90                         current = start;
  91                 }
  92
  93                 private XPathSemWebNavigator(XPathSemWebNavigator clone) {
  94                         MoveTo(clone);
  95                 }
  96
  97                 private void Expand(Position p) {
  98                         Expand(p, null);
  99                 }
 100
 101                 private void Expand(Position p, string expandOnlyThisPredicate) {
 102                         if (!(p.Object is Entity)) {
 103                                 p.Children = new Position[0];
 104                                 return;
 105                         }
 106
 107                         ArrayList children = new ArrayList();
 108                         int ctr = 0;
 109
 110                         if (p.Object == ExpandEntitiesOfType) {
 111                                 if (expandOnlyThisPredicate == null) {
 112                                         // Get a list of entities and their types.
 113                                         foreach (Statement s in model.Select(new Statement(null, rdfType, null))) {
 114                                                 if (!(s.Object is Entity)) continue;
 115                                                 Position c = new Position();
 116                                                 c.Index = ctr++;
 117                                                 c.Predicate = (Entity)s.Object;
 118                                                 c.Object = s.Subject;
 119                                                 children.Add(c);
 120                                         }
 121                                 } else {
 122                                         foreach (Entity e in model.GetEntitiesOfType(expandOnlyThisPredicate)) {
 123                                                 Position c = new Position();
 124                                                 c.Predicate = expandOnlyThisPredicate;
 125                                                 c.Index = ctr++;
 126                                                 c.Object = e;
 127                                                 children.Add(c);
 128                                         }
 129                                 }
 130                         } else {
 131
 132                         if (expandOnlyThisPredicate == null || !expandOnlyThisPredicate.StartsWith("!")) {
 133                                 Statement q = new Statement(
 134                                         (Entity)p.Object,
 135                                         expandOnlyThisPredicate == null ? (Entity)null : (Entity)expandOnlyThisPredicate,
 136                                         null);
 137
 138                                 foreach (Statement s in model.Select(q)) {
 139                                         Position c = new Position();
 140                                         c.Index = ctr++;
 141                                         c.Predicate = s.Predicate;
 142                                         c.Object = s.Object;
 143                                         children.Add(c);
 144                                 }
 145                         }
 146
 147                         if (expandOnlyThisPredicate == null || expandOnlyThisPredicate.StartsWith("!")) {
 148                                 Statement q = new Statement(
 149                                         null,
 150                                         expandOnlyThisPredicate == null ? (Entity)null : (Entity)expandOnlyThisPredicate.Substring(1),
 151                                         p.Object);
 152
 153                                 foreach (Statement s in model.Select(q)) {
 154                                         Position c = new Position();
 155                                         c.Index = ctr++;
 156                                         c.Predicate = "!" + s.Predicate;
 157                                         c.Object = s.Subject;
 158                                         children.Add(c);
 159                                 }
 160                         }
 161
 162                         }
 163
 164                         p.Children = (Position[])children.ToArray(typeof(Position));
 165
 166                         if (p.Children.Length > 0) {
 167                                 p.Children[0].FirstChild = true;
 168                                 p.Children[p.Children.Length-1].LastChild = true;
 169                         }
 170                 }
 171
 172                 public override string BaseURI { get { return ""; } }
 173
 174                 public override bool HasAttributes { get { return false; } }
 175
 176                 public override bool HasChildren { get { return true; } }
 177
 178                 public override bool IsEmptyElement { get { return false; } }
 179
 180                 public override string LocalName {
 181                         get {
 182                                 string p, l;
 183                                 if (current.Predicate == ExpandEntitiesOfType)
 184                                         return "root";
 185                                 if (current.Predicate.Uri == null)
 186                                         return "anonymous";
 187                                 if (nsmgr.Normalize(current.Predicate.Uri, out p, out l))
 188                                         return l;
 189                                 throw new InvalidOperationException("The local name of " + current.Predicate.Uri + " could not be determined.");
 190                         }
 191                 }
 192
 193                 public override string Name {
 194                         get {
 195                                 if (current.Predicate == ExpandEntitiesOfType)
 196                                         return "root";
 197                                 if (current.Predicate.Uri == null)
 198                                         return "anonymous";
 199                                 return nsmgr.Normalize(current.Predicate.Uri);
 200                         }
 201                 }
 202
 203                 public override string NamespaceURI {
 204                         get {
 205                                 string p, l;
 206                                 if (current.Predicate.Uri == null)
 207                                         return "anonymous";
 208                                 if (nsmgr.Normalize(current.Predicate.Uri, out p, out l))
 209                                         return nsmgr.GetNamespace(p);
 210                                 throw new InvalidOperationException("The namespace URI of " + current.Predicate.Uri + " could not be determined.");
 211                         }
 212                 }
 213
 214                 public override XmlNameTable NameTable {
 215                         get {
 216                                 return null;
 217                         }
 218                 }
 219
 220                 public override XPathNodeType NodeType {
 221                         get {
 222                                 if (stack.Count == 0)
 223                                         return XPathNodeType.Root;
 224                                 return XPathNodeType.Element;
 225                         }
 226                 }
 227
 228                 public override string Prefix {
 229                         get {
 230                                 string p, l;
 231                                 if (nsmgr.Normalize(current.Predicate.Uri, out p, out l))
 232                                         return p;
 233                                 throw new InvalidOperationException("The prefix of " + current.Predicate.Uri + " could not be determined.");
 234                         }
 235                 }
 236
 237                 public override string Value {
 238                         get {
 239                                 if (current.Predicate == ExpandEntitiesOfType)
 240                                         return "root";
 241                                 if (current.Object is Literal)
 242                                         return ((Literal)current.Object).Value;
 243                                 if (current.Object.Uri == null)
 244                                         return "";
 245                                 return current.Object.Uri;
 246                         }
 247                 }
 248
 249                 public override string XmlLang { get { return ""; } }
 250
 251                 public override XPathNavigator Clone () {
 252                         return new XPathSemWebNavigator(this);
 253                 }
 254
 255                 //public virtual XmlNodeOrder ComparePosition (XPathNavigator nav)
 256
 257                 public override string GetAttribute (string localName, string namespaceURI) {
 258                         return "";
 259                 }
 260
 261                 public override string GetNamespace (string name) {
 262                         return nsmgr.GetNamespace(name);
 263                 }
 264
 265                 public override bool IsSamePosition (XPathNavigator other) {
 266                         if (!(other is XPathSemWebNavigator)) return false;
 267                         XPathSemWebNavigator o = (XPathSemWebNavigator)other;
 268                         return (o.current == current);
 269                 }
 270
 271                 public override bool MoveTo (XPathNavigator other) {
 272                         XPathSemWebNavigator clone = other as XPathSemWebNavigator;
 273                         if (clone == null) return false;
 274                         this.model = clone.model;
 275                         this.nsmgr = clone.nsmgr;
 276                         this.nswrap = clone.nswrap;
 277                         this.stack = (ArrayList)clone.stack.Clone();
 278                         this.current = clone.current;
 279                         return true;
 280                 }
 281
 282                 public override bool MoveToAttribute (string localName, string namespaceURI) { return false; }
 283
 284                 public override bool MoveToNamespace (string name) { return false; }
 285
 286                 public override bool MoveToFirst () {
 287                         return MoveToFirstChild();
 288                 }
 289
 290                 public override void MoveToRoot () {
 291                         if (stack.Count == 0) return;
 292                         current = (Position)stack[0];
 293                         stack.Clear();
 294                 }
 295
 296                 public override bool MoveToFirstAttribute () { return false; }
 297
 298                 public override bool MoveToFirstChild () {
 299                         if (current.Children == null) Expand(current);
 300                         if (current.Children.Length == 0) return false;
 301                         stack.Add(current);
 302                         current = current.Children[0];
 303                         return true;
 304                 }
 305
 306                 public override bool MoveToFirstNamespace (XPathNamespaceScope namespaceScope) { return false; }
 307
 308                 public override bool MoveToId (string id) { return false; }
 309
 310                 public override bool MoveToNext () {
 311                         if (current.LastChild) return false;
 312                         current = ((Position)stack[stack.Count-1]).Children[current.Index+1];
 313                         return true;
 314                 }
 315
 316                 public override bool MoveToNextAttribute () { return false; }
 317
 318                 public override bool MoveToNextNamespace (XPathNamespaceScope namespaceScope) { return false; }
 319
 320                 public override bool MoveToParent () {
 321                         if (stack.Count == 0) return false;
 322                         current = (Position)stack[stack.Count-1];
 323                         stack.RemoveAt(stack.Count-1);
 324                         return true;
 325                 }
 326
 327                 public override bool MoveToPrevious () {
 328                         if (current.FirstChild) return false;
 329                         current = ((Position)stack[stack.Count-1]).Children[current.Index-1];
 330                         return true;
 331                 }
 332
 333                 public override XPathNodeIterator SelectChildren (string name, string namespaceURI) {
 334                         if (current.Object is Literal) throw new InvalidOperationException("The navigator is positioned on a literal element.");
 335                         return new XPathSemWebNavigator((Entity)current.Object, model, nsmgr, namespaceURI + name).SelectChildren(XPathNodeType.All);
 336                 }
 337
 338                 public override XPathNodeIterator Select (XPathExpression expr) {
 339                         expr.SetContext(nswrap);
 340                         return base.Select(expr);
 341                 }
 342
 343                 public override object Evaluate (XPathExpression expr) {
 344                         expr.SetContext(nswrap);
 345                         return base.Evaluate(expr);
 346                 }
 347
 348                 public override object Evaluate (XPathExpression expr, XPathNodeIterator context) {
 349                         expr.SetContext(nswrap);
 350                         return base.Evaluate(expr, context);
 351                 }
 352         }
 353 }