src/com/interrupt/bob/base/Bob.java

   1 package com.interrupt.bob.base;
   2
   3 import org.apache.log4j.Logger;
   4 import org.xml.sax.Attributes;
   5 import org.xml.sax.helpers.AttributesImpl;
   6
   7 import java.io.ByteArrayOutputStream;
   8 import java.io.File;
   9 import java.io.InputStream;
  10 import java.io.IOException;
  11 import java.io.ByteArrayInputStream;
  12 import java.io.InputStreamReader;
  13 import java.io.ObjectInputStream;
  14 import java.io.ObjectOutputStream;
  15 import java.io.PipedInputStream;
  16 import java.io.PipedOutputStream;
  17 import java.io.PushbackReader;
  18 import java.io.Serializable;
  19 import java.util.List;
  20 import java.util.ArrayList;
  21 import java.util.ListIterator;
  22 import java.util.TreeSet;
  23 import java.util.HashMap;
  24 import java.util.Iterator;
  25 import java.util.Properties;
  26 import java.util.Stack;
  27
  28 import com.interrupt.IAncestor;
  29 import com.interrupt.bob.FindFiles;
  30 //import com.interrupt.bob.Attributes;
  31 /*import com.interrupt.bob.base.IBob;
  32 import com.interrupt.bob.base.BobException;
  33 import com.interrupt.bob.base.ToXMLVisitorPass1;
  34 import com.interrupt.bob.base.ToXMLVisitorPass2;
  35 */
  36 import com.interrupt.bob.core.IMemory;
  37 import com.interrupt.bob.core.IMemoryField;
  38 import com.interrupt.bob.core.Memory;
  39 import com.interrupt.bob.core.MemoryField;
  40 import com.interrupt.bob.core.Queue;
  41 import com.interrupt.bob.handler.DocumentHandler;
  42 import com.interrupt.bob.handler.DefinitionHandler;
  43 import com.interrupt.bob.handler.BobHandler;
  44 import com.interrupt.bob.util.StringUtil;
  45 import com.interrupt.bob.processor.ProcessorException;
  46 import com.interrupt.bob.processor.DocumentProcessor;
  47 import com.interrupt.bob.processor.cc.DepthFirstVisitor;
  48
  49 import com.interrupt.bob.util.Util;
  50 import com.interrupt.cc.xpath.lexer.Lexer;
  51 import com.interrupt.cc.xpath.lexer.LexerException;
  52 import com.interrupt.cc.xpath.node.Node;
  53 import com.interrupt.cc.xpath.node.Start;
  54 import com.interrupt.cc.xpath.parser.Parser;
  55 import com.interrupt.cc.xpath.parser.ParserException;
  56
  57 import org.xml.sax.XMLReader;
  58 import org.xml.sax.helpers.XMLReaderFactory;
  59 import org.xml.sax.SAXException;
  60 import org.xml.sax.InputSource;
  61
  62
  63 public class Bob implements IBob {
  64
  65
  66         private Logger logger = Logger.getLogger(Bob.class);
  67
  68     // '_genchildren' used when compiling definitions
  69     protected TreeSet _genchildren = null;
  70     protected List _children = null;
  71     protected IBob _parent = null;
  72
  73     private Properties _properties = null;
  74     private boolean _nsVisible = true;
  75     private String _name = null;
  76     protected String _namespaceURI = null;
  77     private HashMap _namespaceMap = null;
  78
  79     private HashMap _nsPrefixMappings = null;
  80     private String nsPrefix = null;
  81
  82     protected Attributes _attributes = null;
  83
  84     private String _text = null;
  85     private String _openString = null;
  86     private String _closeString = null;
  87
  88     public Bob() {
  89
  90                 _name = "bob";
  91                 _namespaceURI = "";
  92
  93                 _properties = new Properties();
  94
  95                 _children = new ArrayList();
  96                 _genchildren = new TreeSet(new BobComparator());
  97                 _namespaceMap = new HashMap();
  98                 _attributes = new AttributesImpl();
  99                 this.resetPull();
 100     }
 101     public Bob(String namespace, String tagName) {
 102
 103                 _name = tagName;
 104                 _namespaceURI = namespace;
 105
 106                 _properties = new Properties();
 107
 108                 _children = new ArrayList();
 109                 _genchildren = new TreeSet(new BobComparator());
 110                 _namespaceMap = new HashMap();
 111                 _attributes = new AttributesImpl();
 112                 this.resetPull();
 113     }
 114
 115         public void overwriteShallow(IBob overwritor) {
 116
 117         this.setAttributes(overwritor.getAttributes());
 118         this.setChildren(overwritor.getChildren());
 119
 120     }
 121
 122
 123     public void setProperty(String name, String value) {
 124
 125         _properties.setProperty(name, value);
 126     }
 127         public String getProperty(String name) {
 128
 129                 return (String)_properties.getProperty(name);
 130         }
 131
 132
 133
 134         public boolean isNSVisible() {
 135                 return _nsVisible;
 136         }
 137         public void setNSVisible(boolean visible)  {
 138                 this._nsVisible = visible;
 139         }
 140
 141
 142         public void setNSPrefix(String prefix) {
 143                 this.nsPrefix = prefix;
 144         }
 145     public String getNSPrefix() {
 146         return nsPrefix;
 147     }
 148
 149
 150
 151     public IBob getParent() {
 152                 return _parent;
 153         }
 154         public void setParent(IBob _parent) {
 155                 this._parent = _parent;
 156         }
 157
 158         public void addChild(IBob child) {
 159                 this._children.add(child);
 160     }
 161         public void addChildren(List children) {
 162                 this._children.addAll(children);
 163     }
 164
 165     public List allChildren() {
 166                 return new ArrayList(_children);
 167     }
 168         public void removeAllChildren() {
 169                 this._children.clear();
 170         }
 171         public boolean  removeChild(IBob child) {
 172
 173                 // can't do this as an 'equals' comparison is not working
 174                 //return this._children.remove(child);
 175                 if(child == null) {
 176                         return false;
 177                 }
 178
 179                 // TODO - this is much more inefficient!!!
 180                 Iterator liter = this._children.iterator();
 181                 IBob eachbob = null;
 182                 while(liter.hasNext()) {
 183
 184                         eachbob = (IBob)liter.next();
 185                         if(child.equals(eachbob)) {
 186                                 liter.remove();
 187                                 return true;
 188                         }
 189                 }
 190                 return false;
 191         }
 192
 193         public boolean remove(String tagName, String attName, String attValue) {
 194
 195
 196         logger.debug("remove 1 / tname["+ tagName +"] / attName["+ attName +"] / attValue["+ attValue +"]");
 197
 198         Iterator iter = this.getChildren().iterator();
 199
 200         IBob eachBob = null;
 201         boolean matchFound = false;
 202
 203         //** only loop if there's children
 204         while(iter.hasNext()) {
 205
 206                 eachBob = (IBob)iter.next();
 207                 boolean mfound = eachBob.remove(tagName, attName, attValue);
 208                         if(mfound) {
 209                                 return mfound;
 210                         }
 211
 212                         logger.debug(" 2 EACH / tname["+ eachBob.getTagName() +"] / attName["+ attName +"] / attValue["+ eachBob.getAttributeValue(attName) +"] / MATCH["+ (eachBob.getTagName().equals( tagName ) && eachBob.getAttributeValue(attName).equals(attValue)) +"]");
 213                         if(     eachBob.getTagName().equals( tagName ) &&
 214                         eachBob.getAttributeValue(attName).equals(attValue) ) {
 215
 216                         iter.remove();
 217                         matchFound = true;
 218                         logger.debug("MATCH FOUND!! / tname["+ tagName +"] / attName["+ attName +"] / attValue["+ attValue +"]");
 219                         logger.debug("Bob.logger.debugg ["+ eachBob +"] ");
 220
 221                         break;
 222                 }
 223
 224         }
 225
 226         return matchFound;
 227         }
 228
 229         public boolean remove(String tagName, String tagId) {
 230
 231                 return this.remove(tagName, "id", tagId);
 232         }
 233
 234
 235     public List allGenChildren() {
 236                 return new ArrayList(_genchildren);
 237     }
 238     public void addGenChild(IBob child) {
 239                 this._genchildren.add(child);
 240     }
 241         public void removeAllGenChildren() {
 242                 this._genchildren.clear();
 243         }
 244         public boolean removeGenChild(IBob child) {
 245
 246
 247                 // can't do this as an 'equals' comparison is not working
 248                 //return this._genchildren.remove(child);
 249
 250                 // TODO - this is much more inefficient!!!
 251                 Iterator liter = this._genchildren.iterator();
 252                 IBob eachbob = null;
 253                 while(liter.hasNext()) {
 254
 255                         eachbob = (IBob)liter.next();
 256                         if(child.equals(eachbob)) {
 257                                 liter.remove();
 258                                 return true;
 259                         }
 260                 }
 261                 return false;
 262         }
 263
 264
 265         /**
 266          * find methods
 267          */
 268         public IBob find(String xpath) {
 269
 270                 //if(true)
 271                 //      throw new RuntimeException("XPath 2.0 evaluation not yet implemented");
 272
 273                 ByteArrayInputStream baInputStream = new ByteArrayInputStream( xpath.getBytes() );
 274                 PushbackReader pbreader =
 275                         new PushbackReader( new InputStreamReader(baInputStream), 1024 );
 276
 277                 IBob xdmResults = new Bob();
 278                 DepthFirstVisitor rdvisitor = new DepthFirstVisitor();
 279                 rdvisitor.setDocument(this);
 280
 281                 System.out.println("xpath > start");
 282                 try {
 283
 284                         //** parse the syntax and provide the MODEL
 285                         Lexer lexer = new Lexer(pbreader);
 286                         Parser parser = new Parser(lexer);
 287
 288                         System.out.println("xpath > parsing input");
 289
 290                         // parse the input
 291                         Start tree = parser.parse();
 292
 293                         System.out.println("");
 294                         System.out.println("xpath > running analyser");
 295
 296                         // apply the Visitor
 297                         tree.apply(rdvisitor);
 298                         if(rdvisitor.getXdmList() instanceof Bob) {
 299                                   xdmResults = rdvisitor.getXdmList();
 300                         }
 301                         else {
 302                                 xdmResults.addChild(rdvisitor.getXdmList());
 303                         }
 304
 305                         System.out.println("xpath > finished");
 306
 307                 }
 308                 catch(java.io.IOException e) {
 309                         e.printStackTrace();
 310                 }
 311                 catch(LexerException e) {
 312                         e.printStackTrace();
 313                 }
 314                 catch(ParserException e) {
 315                         e.printStackTrace();
 316                 }
 317                 catch(Exception e) {
 318                         e.printStackTrace();
 319                 }
 320
 321                 return xdmResults;
 322         }
 323         public String xpath() {
 324
 325                 return xpath(false);
 326
 327         }
 328         public String xpath(boolean relative) {
 329
 330                 StringBuffer sbuffer = new StringBuffer();
 331
 332                 // get parent axis string
 333                 if(!relative) {
 334
 335                         IBob parent = this.getParent();
 336                         while(parent != null) {
 337
 338                                 sbuffer.insert(0, "/");
 339                                 sbuffer.insert(0, parent.buildAxisString());
 340                                 parent = parent.getParent();
 341                         }
 342                         sbuffer.insert(0, "/");
 343                 }
 344
 345                 // append the axis string
 346                 sbuffer.append(this.buildAxisString());
 347                 return sbuffer.toString();
 348
 349         }
 350
 351         public String buildAxisString() {
 352
 353                 // take node name & append predicates
 354                 String axisString = this.getTagName() + this.buildPredicateString(this.getAttributes());
 355                 return axisString;
 356         }
 357         public String buildPredicateString(Attributes attributes) {
 358
 359                 // construct predicate based on attributes. should look something like...
 360                 // [ @attr='value' and @attr='value' ]
 361
 362                 StringBuffer pbuffer = new StringBuffer();
 363                 pbuffer.append("[ ");
 364                 for(int i = 0; i < attributes.getLength(); i++) {
 365
 366                         String avalue = attributes.getValue(i).trim();
 367                         if(avalue != null) {
 368
 369                                 String aname = attributes.getLocalName(i);
 370                                 pbuffer.append("@");
 371                                 pbuffer.append(aname);
 372                                 pbuffer.append("=");
 373                                 pbuffer.append("'");
 374                                 pbuffer.append(avalue);
 375                                 pbuffer.append("'");
 376
 377                                 if(i < (attributes.getLength() - 1)) {
 378
 379                                         pbuffer.append(" and ");
 380                                 }
 381                         }
 382                 }
 383                 pbuffer.append(" ]");
 384
 385                 return pbuffer.toString();
 386         }
 387
 388
 389     public void replace(IBob replacor) {
 390
 391         // the parent should stay the same
 392         IBob parent = this.getParent();
 393
 394         replacor.setParent(parent);
 395         if( parent != null ) {
 396                 parent.removeChild(this);
 397                 parent.addChild(replacor);
 398         }
 399     }
 400
 401     /**
 402      * ** a weakness of this method is that it cannot replace itself
 403      * /
 404     public boolean replace(String tagName, String tagId, IBob replacor) {
 405
 406         logger.debug("Bob.replace["+ tagName +"] / tagId["+ tagId +"] / replacor["+ replacor.getClass() +"]");
 407         Iterator iter = this.getChildren().iterator();
 408
 409         IBob eachBob = null;
 410         boolean matchFound = false;
 411
 412         //** only loop if there's children
 413         while(iter.hasNext()) {
 414
 415                 eachBob = (IBob)iter.next();
 416                 boolean mfound = eachBob.replace(tagName, tagId, replacor);
 417                         if(mfound) {
 418                                 return mfound;
 419                         }
 420
 421                         logger.debug("Bob.replace 2 / logger.debugteValue(id)["+ eachBob.getAttributeValue("id") +"] / MATCH["+ (eachBob.getTagName().equals( tagName ) &&
 422                                 eachBob.getAttributeValue("id").equals( tagId )) +"]");
 423
 424                 if(     eachBob.getTagName().equals( tagName ) &&
 425                         eachBob.getAttributeValue("id").equals( tagId ) ) {
 426
 427                         //logger.debug("Bob.replace 3");
 428                         iter.remove();
 429                         matchFound = true;
 430                         //logger.debug("Bob.replace 2 / MATCH FOUND!logger.debugme +"] / id["+ tagId +"]");
 431                         //logger.debug("Bob.replace 3 / replacing["+ eachBob +"]");
 432
 433                         break;
 434                 }
 435
 436         }
 437
 438         if(matchFound) {
 439                 this.addChild(replacor);
 440         }
 441
 442         return matchFound;
 443         }
 444         */
 445
 446     public IBob getRoot() {
 447
 448         if(this._parent != null) {
 449             return this._parent.getRoot();
 450         }
 451         return this;
 452     }
 453
 454     /*public IBob searchTree(String tag, String attributeName, String attributeValue) {
 455
 456         return this.getRoot().search(tag, attributeName, attributeValue);
 457     }
 458         */
 459
 460
 461     public void accept(IVisitor visitor) throws BobException {
 462
 463         //logger.debug("");
 464         //logger.debug("Bob.accept: children["+_children+"] / children.size["+_children.size()+"] / iterator["+_children.iterator()+"]");
 465                 Iterator iter = _children.iterator();
 466                 IBob next = null;
 467                 while(iter.hasNext()) {
 468
 469                         try {
 470                                 next = (IBob)iter.next();
 471                         }
 472                         catch(Throwable e) {
 473
 474                                 logger.debug("Cause: "+ e.getCause());
 475                                 logger.debug("Message: "+ e.getMessage());
 476                                 e.printStackTrace(System.out);
 477                                 //logger.debug("Bob.accept: next["+next+"]");
 478                                 //logger.debug("Bob.accept: children["+_children+"] / children.size["+_children.size()+"] / iterator["+_children.iterator()+"]");
 479                                 throw new BobException(e);
 480                         }
 481
 482                     next.accept(visitor);
 483                 }
 484                 visitor.visit(this);
 485     }
 486     public void acceptFirst(IVisitor visitor) throws BobException {
 487
 488                 visitor.visit(this);
 489
 490                 Iterator iter = _children.iterator();
 491                 IBob next = null;
 492                 while(iter.hasNext()) {
 493
 494                     next = (IBob)iter.next();
 495                         next.acceptFirst(visitor);
 496                 }
 497     }
 498     public void acceptSax(ISaxVisitor visitor) throws BobException {
 499
 500                 visitor.visitStart(this);
 501
 502                 Iterator iter = _children.iterator();
 503                 IBob next = null;
 504                 while(iter.hasNext()) {
 505
 506                     next = (IBob)iter.next();
 507                         next.acceptSax(visitor);
 508                 }
 509                 visitor.visitEnd(this);
 510     }
 511
 512
 513         /* some methods to pull through the entire tree of objects
 514          */
 515         private Stack _pullStack = null;
 516         public IBob pullNext() {
 517
 518                 if(this._pullStack == null) {
 519                         return null;
 520                 }
 521                 if(this._pullStack.empty()) {
 522                         return null;
 523                 }
 524                 return (IBob)this._pullStack.pop();
 525         }
 526         public boolean canPull() {
 527
 528                 if(this._pullStack == null) {
 529                         return false;
 530                 }
 531                 if(this._pullStack.empty()) {
 532                         return false;
 533                 }
 534                 return !this._pullStack.empty();
 535         }
 536         public void resetPull() {
 537
 538                 class PullVisitor implements IVisitor {
 539
 540                         private Stack pullStack = new Stack();
 541                         public void setStack(Stack stack) {
 542                                 this.pullStack = stack;
 543                         }
 544                         public Stack getStack() {
 545                                 return this.pullStack;
 546                         }
 547
 548                         public void visit(IBob bob) {
 549
 550                                 this.pullStack.push(bob);
 551                         }
 552
 553                 }
 554                 PullVisitor pvisitor = new PullVisitor();
 555                 this.accept(pvisitor);
 556
 557                 this._pullStack = pvisitor.getStack();
 558
 559         }
 560
 561
 562         /* search the tree for the first IBob node with this
 563          */
 564         public IBob search( String tag, String attributeName, String attributeValue ) {
 565
 566
 567                 SearchVisitor svisitor = new SearchVisitor();
 568                 svisitor.setTagName(tag);
 569                 svisitor.setAttributeName(attributeName);
 570                 svisitor.setAttributeValue(attributeValue);
 571
 572                 this.accept(svisitor);
 573                 return svisitor.getResult();
 574
 575         }
 576
 577
 578
 579     /* toXML
 580      */
 581     public void toXML(java.io.PrintStream ps) {
 582         this.toXML(true,ps);
 583     }
 584     public void toXML(boolean inlineNS, java.io.PrintStream ps) {
 585         ps.print(toXML(inlineNS));
 586                 ps.flush();
 587     }
 588         public String toXML() {
 589         return this.toXML(true);
 590     }
 591     public String toXML(boolean inlineNS) {
 592
 593         //** clear XML String
 594         ToXMLVisitorEraser veraser = new ToXMLVisitorEraser();
 595         this.accept(veraser);
 596
 597         //** compose XML String
 598         ToXMLVisitorPass1 txVisitor1 = new ToXMLVisitorPass1();
 599         txVisitor1.setInlineNS(inlineNS);
 600
 601         String depth_s = this.getProperty(IBob.XML_DEPTH);
 602         if((depth_s != null) && (depth_s.length() > 0)) {
 603                 int depth = Integer.parseInt(depth_s);
 604                 txVisitor1.setDepth(depth);
 605         }
 606         ToXMLVisitorPass2 txVisitor2 = new ToXMLVisitorPass2();
 607
 608                 this.acceptSax(txVisitor1);
 609                 this.acceptSax(txVisitor2);
 610                 return txVisitor2.getXML();
 611
 612     }
 613
 614
 615     /* namespaces
 616      */
 617     public void setNamespace(String namespaceURI) {
 618         _namespaceURI = namespaceURI;
 619     }
 620     public String getNamespace() {
 621         return _namespaceURI;
 622     }
 623     public void addNamespace(String ns, String value) {
 624         _namespaceMap.put(ns,value);
 625     }
 626     public String getNamespace(String ns) {
 627         return (String)_namespaceMap.get(ns);
 628     }
 629     public HashMap getNamespaces() {
 630         return new HashMap(_namespaceMap);
 631     }
 632     public boolean hasNamespaces() {
 633         return !_namespaceMap.isEmpty();
 634     }
 635
 636
 637     /* namespace preix mappings
 638      */
 639     public void setPrefixMappings(HashMap prefixMappings) {
 640         this._nsPrefixMappings = prefixMappings;
 641     }
 642     public HashMap getPrefixMappings() {
 643         return this._nsPrefixMappings;
 644     }
 645
 646
 647     /* attribute accessors
 648      */
 649     public void setTagName(String localName) {
 650         _name = localName;
 651     }
 652     public String getTagName() {
 653         return _name;
 654     }
 655
 656     //public void setQName(String qName) {
 657     //_qname = qName;
 658     //}
 659     public String getQName() {
 660
 661         StringBuffer temp = new StringBuffer();
 662         if(this._namespaceURI != null) {
 663             if(!this._namespaceURI.equals("")) {
 664                 temp.append(this._namespaceURI);
 665                 temp.append(":");
 666             }
 667             temp.append(this._name);
 668         }
 669         return temp.toString();
 670     }
 671
 672     public void setAttributes(Attributes attribs) {
 673         _attributes = attribs;
 674     }
 675     public Attributes getAttributes() {
 676         return _attributes;
 677     }
 678     public String getAttributeValue(String avalue) {
 679
 680         return _attributes.getValue(avalue);
 681     }
 682
 683     public void setContent(String text) {
 684         _text = text;
 685     }
 686     public String getContent() {
 687         return _text;
 688     }
 689
 690
 691
 692     public IBob getChild(int cindex) {
 693         return (IBob)_children.get(cindex);
 694     }
 695     public List getChildren() {
 696                 return _children;
 697         }
 698         public void setChildren(List _children) {
 699                 this._children = _children;
 700         }
 701
 702
 703         public void _setOpenString(String os) {
 704         _openString = os;
 705     }
 706     public String _getOpenString() {
 707         return _openString;
 708     }
 709     public void _setCloseString(String cs) {
 710         _closeString = cs;
 711     }
 712     public String _getCloseString() {
 713         return _closeString;
 714     }
 715
 716
 717     public IBob make() {
 718         return new Bob();
 719     }
 720
 721     public static IBob make(String namespace, String localName) {
 722
 723
 724                 //logger.debug("Bob:: make / namespace["+namespace+"] / localname["+localName+"]");
 725
 726                 /* TODO *** KLUDGE *** CLASS CREATION
 727                  * - there should be a 'createGName' / 'createIName'
 728                  */
 729                 String ns = StringUtil.namespaceToPackage(namespace);
 730                 String cname = StringUtil.upperFirstLetter(localName);
 731                 //logger.debug("1. Bob:: make / classname["+ ns + "." + cname +"]");
 732
 733                 Class bobClass = null;
 734                 try {
 735
 736                                 //logger.debug("A");
 737                     if(ns.trim().length() > 0) {
 738                                 //logger.debug("B");
 739                         bobClass = Class.forName( ns + "." + cname );
 740                     }
 741                     else {
 742                                 //logger.debug("C");
 743                         bobClass = Class.forName( cname );
 744                     }
 745                         //logger.debug("1.5. Bob:: make / class["+ bobClass +"]");
 746                 }
 747                 catch(ClassNotFoundException e) {
 748
 749                     //e.printStackTrace();
 750                     try {
 751
 752                 //logger.debug("2. Bob:: make / classname["+ ns + "." + "G" + cname +"]");
 753                         if(ns.length() > 0) {
 754
 755                             bobClass = Class.forName( ns + "." + "G" + cname );
 756                         }
 757                         else {
 758                             bobClass = Class.forName( "G" + cname );
 759                         }
 760                     }
 761                     catch(ClassNotFoundException ex) {
 762                         ex.printStackTrace();
 763                     }
 764                 }
 765
 766                                 //logger.debug("D");
 767
 768                 IBob result = null;
 769                 try {
 770
 771                                 //logger.debug("E");
 772
 773                     result = (IBob)bobClass.newInstance();
 774                     result.setNamespace( namespace );
 775
 776                                 //logger.debug("F: "+ result);
 777
 778                 }
 779                 catch(InstantiationException e) {
 780                     e.printStackTrace();
 781                 }
 782                 catch(IllegalAccessException e) {
 783                     e.printStackTrace();
 784                 }
 785                 //logger.debug("3. Bob:: generated class["+ result +"]");
 786
 787                 return result;
 788     }
 789
 790
 791
 792     public static IBob make( String fqclassname ) {
 793
 794
 795                 Class bobClass = null;
 796                 try {
 797
 798                         //logger.debug("make / fqclassname["+fqclassname+"]");
 799                 bobClass = Class.forName( fqclassname );
 800
 801                 }
 802                 catch(ClassNotFoundException e) {
 803
 804                     e.printStackTrace();
 805
 806                 }
 807
 808
 809                 String package_s = fqclassname.substring( 0, fqclassname.lastIndexOf(".") );
 810                 String namespace = StringUtil.packageToNamespace( package_s );
 811                 IBob result = null;
 812                 try {
 813                     result = (IBob)bobClass.newInstance();
 814                     result.setNamespace( namespace );
 815                 }
 816                 catch(InstantiationException e) {
 817                     e.printStackTrace();
 818                 }
 819                 catch(IllegalAccessException e) {
 820                     e.printStackTrace();
 821                 }
 822
 823                 return result;
 824
 825     }
 826
 827
 828     public static IBob loadS(String xmlString) {
 829
 830                 String def_s = System.getProperties().getProperty(Util.DEF);
 831                 return Bob.loadS( xmlString, def_s );
 832         }
 833     public static IBob loadS(String xmlString, String definitionFiles) {
 834
 835
 836         Logger.getLogger(Bob.class).debug("Bob.load("+xmlString+", "+definitionFiles+")");
 837
 838         //System.out
 839                 ByteArrayInputStream bs = null;
 840                 try {
 841                         bs = new ByteArrayInputStream(xmlString.getBytes("UTF-8"));
 842                 }
 843                 catch(java.io.UnsupportedEncodingException e) {
 844                         e.printStackTrace();
 845                 }
 846                 return Bob.loadS( bs, definitionFiles );
 847         }
 848
 849
 850
 851     public static IBob loadS(File xmlFile) {
 852
 853                 java.io.FileInputStream fis = null;
 854                 try {
 855                         fis = new java.io.FileInputStream(xmlFile);
 856                 }
 857                 catch(java.io.FileNotFoundException e) {
 858                         Logger.getLogger(Bob.class).error(e,e);
 859                 }
 860                 return Bob._loadS( fis );
 861         }
 862     public static IBob loadS(File xmlFile, String definitionFiles) {
 863
 864                 java.io.FileInputStream fis = null;
 865                 try {
 866                         fis = new java.io.FileInputStream(xmlFile);
 867                 }
 868                 catch(java.io.FileNotFoundException e) {
 869                         Logger.getLogger(Bob.class).error(e,e);
 870                 }
 871                 return Bob._loadS( fis, definitionFiles );
 872         }
 873
 874
 875
 876     public static IBob loadS(InputStream xmlis) {
 877                 return Bob._loadS( xmlis );
 878         }
 879     public static IBob loadS(InputStream xmlis, String definitionFiles) {
 880                 return Bob._loadS( xmlis, definitionFiles );
 881         }
 882
 883
 884
 885         private static IBob _loadS( Object inputSource ) {
 886
 887                 String def_s = System.getProperties().getProperty(Util.DEF);
 888                 return Bob._loadS( inputSource, def_s );
 889         }
 890
 891         private static IBob _loadS( Object inputSource, String definitionFiles ) {
 892
 893                 Logger.getLogger(Bob.class).debug("Bob._load("+inputSource+", "+definitionFiles+")");
 894
 895                 // check NULLs
 896                 if( definitionFiles == null || definitionFiles.trim().length() < 1 ) {
 897                         Logger.getLogger(Bob.class).error("ERROR. definition files not specified for [_loadS( Object inputSource, String definitionFiles )]. Stopping.");
 898                         return null;
 899                 }
 900
 901                 // create a BobHandler and its Listener
 902                 class LoadHandler implements com.interrupt.bob.DocumentHandler {
 903
 904                         private Logger logger = Logger.getLogger(Bob.class);
 905                         private IBob bobToChange = null;
 906                         public void endHandle(com.interrupt.callback.CallbackEvent cevent) {
 907
 908                                 Object result = cevent.getMessage();
 909                                 if( result instanceof IBob) {
 910
 911                                         Bob rootBob = (Bob)result;
 912                                         logger.debug("LoadHandler.endHandle / bobResult / ["+ rootBob.toXML() +"]");
 913                                         bobToChange = (IBob)rootBob.allChildren().get(0);
 914
 915                                 }
 916                         }
 917
 918                         public IBob getBobToChange() {
 919                                 return bobToChange;
 920                         }
 921                         public void setBobToChange(IBob bob) {
 922                                 bobToChange = bob;
 923                         }
 924
 925                 }
 926                 LoadHandler lhandler = new LoadHandler();
 927                 lhandler.setBobToChange(new Bob());
 928
 929                 com.interrupt.bob.handler.DocumentHandler definitionHandler = new com.interrupt.bob.handler.DefinitionHandler();
 930                 definitionHandler.setNamespace("com.interrupt.bob.handler");
 931                 definitionHandler.setType("com.interrupt.bob.handler.DefinitionHandler");
 932                 definitionHandler.setFiles(definitionFiles);
 933                 definitionHandler.setOut("definition.list");
 934
 935
 936                 com.interrupt.bob.handler.IHandlerField handlerField = new com.interrupt.bob.handler.HandlerField();
 937                 handlerField.setName("tagList");
 938                 handlerField.setValue("${definition.list}");
 939
 940                 com.interrupt.bob.handler.DocumentHandler bobHandler = new com.interrupt.bob.handler.BobHandler();
 941                 bobHandler.setNamespace("com.interrupt.bob.handler");
 942                 bobHandler.setType("com.interrupt.bob.handler.BobHandler");
 943                 bobHandler.setFiles("${bob.files}");
 944                 bobHandler.setOut("bob.tree");
 945                 bobHandler.addHandlerField(handlerField);
 946                 bobHandler.addListener(lhandler);
 947
 948                 com.interrupt.bob.core.Queue queue = new com.interrupt.bob.core.Queue();
 949                 queue.addDocumentHandler(definitionHandler);
 950                 queue.addDocumentHandler(bobHandler);
 951
 952
 953                 MemoryField mfield = new MemoryField();
 954                 mfield.setName("bob.files");
 955                 mfield.setValue(inputSource);
 956                 queue.getMemory().addMemoryField(mfield);
 957                 try {
 958
 959                         Logger.getLogger(Bob.class).debug("BEGIN execute");
 960                         queue.execute();
 961                         Logger.getLogger(Bob.class).debug("END execute");
 962
 963                 }
 964                 catch(ProcessorException e) {
 965                         e.printStackTrace(System.out);
 966                 }
 967
 968
 969                 return lhandler.getBobToChange();
 970
 971         }
 972
 973
 974         public IBob load(String xmlString) { return Bob.loadS(xmlString); }
 975         public IBob load(String xmlString, String definitionFiles) { return Bob.loadS(xmlString, definitionFiles); }
 976
 977     public IBob load(File xmlFile) { return Bob.loadS(xmlFile); }
 978         public IBob load(File xmlFile, String definitionFiles) { return Bob.loadS(xmlFile, definitionFiles); }
 979
 980     public IBob load(InputStream xmlis) { return Bob.loadS(xmlis); }
 981         public IBob load(InputStream xmlis, String definitionFiles) { return Bob.loadS(xmlis, definitionFiles); }
 982
 983
 984     public boolean equals(Object bob) {
 985
 986         if( !(bob instanceof IBob) ) {
 987
 988                 //object for comparison is not an instance of 'IBob'
 989                 return false;
 990         }
 991         IBob ibob = (IBob)bob;
 992
 993         // the specific XML structure must match
 994                 //return super.equals(bob);
 995         String thisXML = this.toXML();
 996         String bobXML = ibob.toXML();
 997
 998         return thisXML.equals(bobXML);
 999
1000     }
1001
1002     public int hashCode() {
1003
1004         /*String xmls = this.toXML(false);
1005         int intValue = this..intValue();
1006         return intValue * 178345;
1007         */
1008         return 178345;
1009     }
1010
1011     public String toString() {
1012
1013         return this.toXML(false);
1014     }
1015
1016
1017     public static void main(String args[]) {
1018
1019         System.getProperties().setProperty(Util.BASE, ".");
1020                 System.getProperties().setProperty(Util.END, ".xml");
1021                 System.getProperties().setProperty(Util.DEF, "xml");
1022
1023             IBob bobby = new Bob();
1024             com.interrupt.bookkeeping.GBookkeeping bkeeping = (com.interrupt.bookkeeping.GBookkeeping)bobby.load(new File("test/xml/bookkeeping.2.system.xml"),"test/xml/bookkeeping.2.system.xml");
1025             bkeeping.setProperty(IBob.XML_DEPTH, "-1");
1026
1027             class XOutput implements IVisitor {
1028
1029                 public void visit(IBob bob) {
1030                         System.out.println("");
1031                         System.out.println("Visiting ["+ bob.getTagName() +"]");
1032                         System.out.println(bob.xpath(false));
1033                 }
1034         }
1035         XOutput xout = new XOutput();
1036         //bkeeping.accept(xout); // print out the xpaths
1037
1038
1039         // credit[ @id='' and @amount='11.50' and @entryid='' and @accountid='3' and @account='' ]
1040         //IBob result = bkeeping.find("credit[ @id='' and @amount='11.50' and @entryid='' and @accountid='3' and @account='' ][ @zzz='timmy' ]");
1041
1042         // /bookkeeping[ @id='' ]/journals[ @id='' ]/journal[ @id='j1' and @name='generalledger' and @type='' and @balance='' ]
1043
1044         //IBob result = bkeeping.find("/bookkeeping[ @id='' ]/journals[ @id='' ]/journal[ @id='j1' and @name='generalledger' and @type='' or @balance='' ] [ @zzz='timmy' ]");
1045         IBob result = bkeeping.find("/bookkeeping[ @id='' ]");
1046         //IBob result = bkeeping.find("/bookkeeping");
1047         //IBob result = bkeeping.find("/");
1048
1049         System.out.println("\n\n\nFind RESULTS...");
1050         result.toXML(System.out);
1051
1052         // needs to return an XDM 1. Bob, text, sequence, etc
1053
1054     }
1055
1056 }
1057
1058