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