rdbModel::XercesBuilder

rdbModel::XercesBuilder Class Reference

#include <XercesBuilder.h>

Inheritance diagram for rdbModel::XercesBuilder:

rdbModel::Builder List of all members.

Public Member Functions

 XercesBuilder ()
virtual ~XercesBuilder ()
virtual unsigned int parseInput (const std::string &inputPath)
virtual int buildRdb ()
void setRdb (Rdb *pRdb)
Rdb * getRdb ()

Protected Attributes

Rdb * m_currentRdb

Private Member Functions

Table * buildTable (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e)
Column * buildColumn (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
Index * buildIndex (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, bool primary, Table *t)
Assertion * buildAssertion (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
Assertion::Operator * buildOperator (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
Datatype * buildDatatype (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e)
Set * buildSet (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
InsertNew * buildInsertNew (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
InterRow * buildInterRow (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
Query * buildQuery (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)
Supersede * buildSupersede (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *e, Table *t)

Private Attributes

XERCES_CPP_NAMESPACE_QUALIFIER
DOMDocument * 		m_doc
Rdb * m_rdb

Detailed Description

This class is a concrete Builder that use the Xerces parser and the DOM functionalities to parse the xml file and build the generic model hierarchy
Author:
D.Favretto & R.Giannitrapani

Definition at line 26 of file XercesBuilder.h.

Constructor & Destructor Documentation

rdbModel::XercesBuilder::XercesBuilder (  ) 

The constructor

Definition at line 27 of file XercesBuilder.cxx.

00027                                : Builder(), m_doc(0), m_rdb(0) {
00028   }

virtual rdbModel::XercesBuilder::~XercesBuilder (  )  [inline, virtual]

Definition at line 34 of file XercesBuilder.h.

00034 {};

Member Function Documentation

Assertion* rdbModel::XercesBuilder::buildAssertion ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Column* rdbModel::XercesBuilder::buildColumn ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

build a Column from its xml description

Datatype* rdbModel::XercesBuilder::buildDatatype ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e  )  [private]

Index* rdbModel::XercesBuilder::buildIndex ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
bool  primary,
Table *  t 
) [private]

build an Index object (corresponding to MySQL index or key) from its xml description

InsertNew * rdbModel::XercesBuilder::buildInsertNew ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Definition at line 592 of file XercesBuilder.cxx.

References rdbModel::InsertNew::addInterRow(), buildInterRow(), ir, deljobs::string, and t().

00593                                           {
00594     using xmlBase::Dom;
00595 
00596     std::string internalStr = Dom::getAttribute(e, "internalCond");
00597     Assertion* internal = t->getAssertionByName(internalStr);
00598 
00599     std::string officialStr = Dom::getAttribute(e, "official");
00600     Assertion* official = t->getAssertionByName(officialStr);
00601 
00602     InsertNew* in = new InsertNew(t, internal, official);
00603     e = Dom::findFirstChildByName(e, "*");
00604     while (e != 0) {  // process <interRow>
00605       InterRow* ir = buildInterRow(e, t);
00606       
00607       in->addInterRow(ir);
00608       e = Dom::getSiblingElement(e);
00609     }
00610     return in;
00611   }

InterRow * rdbModel::XercesBuilder::buildInterRow ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Definition at line 614 of file XercesBuilder.cxx.

References rdbModel::InterRow::addSet(), buildQuery(), buildSet(), q, s, and t().

Referenced by buildInsertNew().

00615                                          {
00616     using xmlBase::Dom;
00617 
00618 
00619     XERCES_CPP_NAMESPACE_QUALIFIER DOMElement* queryElt =
00620       Dom::findFirstChildByName(e, "*");
00621     Query* q = buildQuery(queryElt, t);
00622 
00623     XERCES_CPP_NAMESPACE_QUALIFIER DOMElement* sib = 
00624       Dom::getSiblingElement(queryElt);
00625     bool quit = Dom::checkTagName(sib, "quit");
00626 
00627     InterRow* inter = new InterRow(t, q, quit);
00628     if (quit) return inter;
00629     
00630     // else we have one or more <set>
00631     while (sib != 0) {
00632       Set* s = buildSet(sib, t);
00633       inter->addSet(*s);
00634       sib  = Dom::getSiblingElement(sib);
00635       
00636     }
00637     return inter;
00638   }

Assertion::Operator* rdbModel::XercesBuilder::buildOperator ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Query * rdbModel::XercesBuilder::buildQuery ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Definition at line 576 of file XercesBuilder.cxx.

References q, deljobs::string, t(), and boss::where().

Referenced by buildInterRow().

00577                                       {
00578     using xmlBase::Dom;
00579     std::string whereStr = Dom::getAttribute(e, "assertRef");
00580     Assertion* where = t->getAssertionByName(whereStr);
00581 
00582     Query* q = new Query(t, 0, where);
00583     e = Dom::findFirstChildByName(e, "*");
00584     while (e != 0) {
00585       q->addSelect(Dom::getTextContent(e));
00586       e = Dom::getSiblingElement(e);
00587     }
00588     return q;
00589   }

int rdbModel::XercesBuilder::buildRdb (  )  [virtual]

Concrete implementation of pure virtual Builder::buildRdb

Implements rdbModel::Builder.

Definition at line 41 of file XercesBuilder.cxx.

References rdbModel::Rdb::addTable(), buildTable(), rdbModel::Manager::getManager(), rdbModel::Manager::getRdb(), rdbModel::Rdb::m_CVSid, rdbModel::Rdb::m_dbName, m_doc, rdbModel::Rdb::m_majorVersion, rdbModel::Rdb::m_minorVersion, m_rdb, SCHEMA_MAJOR_VERSION, and deljobs::string.

00041                               {
00042     using xmlBase::Dom;
00043 
00044     Manager* man = Manager::getManager();
00045 
00046     if (m_doc == 0 ) return 0;
00047     m_rdb = man->getRdb();
00048     DOMElement* docElt = m_doc->getDocumentElement();
00049 
00050     
00051     //  save attribute information associated with outermost (rdbms) element.
00052     m_rdb->m_dbName = Dom::getAttribute(docElt, "dbs");
00053     m_rdb->m_majorVersion = 0;
00054     m_rdb->m_minorVersion = 0;
00055 
00056     std::string versionString = Dom::getAttribute(docElt, "SchemaVersion");
00057     if (!versionString.size()) {
00058       versionString = Dom::getAttribute(docElt, "DTDversion");
00059     }
00060 
00061     unsigned dotPos = versionString.find('.');
00062 
00063     std::string minorStr = std::string(versionString, dotPos+1);
00064     //                               versionString.size() - (dotPos+1));
00065     versionString.resize(dotPos);    // now contains just major #
00066 
00067     try {
00068       m_rdb->m_majorVersion = facilities::Util::stringToInt(versionString);
00069       m_rdb->m_minorVersion = facilities::Util::stringToInt(minorStr);
00070     }
00071     catch (facilities::WrongType ex) {
00072       std::cerr << "rdbModel::XercesBuilder: Bad version string " << std::endl;
00073     }
00074     m_rdb->m_CVSid = Dom::getAttribute(docElt, "CVSid");
00075     if (m_rdb->m_majorVersion != SCHEMA_MAJOR_VERSION) {
00076       std::cerr << "Schema major version " << m_rdb->m_majorVersion 
00077                 << " doesn't match expected " << SCHEMA_MAJOR_VERSION 
00078                 << std::endl;
00079       std::cerr << "Bye for now";
00080       std::cerr.flush();
00081       exit(1);
00082     }
00083 
00084     // Get vector of table elements.  
00085     std::vector<DOMElement*> tables;
00086     Dom::getChildrenByTagName(docElt, "table", tables);
00087     unsigned int nTable = tables.size();
00088     unsigned int processed = 0;
00089 
00090     for (unsigned int iTable = 0; iTable < nTable; iTable++) {
00091       Table* newTable = buildTable(tables[iTable]);
00092 
00093       if (newTable) {
00094         m_rdb->addTable(newTable);
00095         processed++;
00096       }
00097     }
00098     return nTable - processed;
00099   }

Set * rdbModel::XercesBuilder::buildSet ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Definition at line 509 of file XercesBuilder.cxx.

References rdbModel::FIELDTYPEask, rdbModel::FIELDTYPElit, rdbModel::FIELDTYPEold, rdbModel::FIELDTYPEoldDef, rdbModel::FIELDTYPEtoBe, rdbModel::FIELDTYPEtoBeDef, deljobs::string, t(), and add_one_line::tag.

Referenced by buildInterRow(), and buildSupersede().

00510                                          {
00511     using xmlBase::Dom;
00512 
00513     std::string destCol = Dom::getAttribute(e, "destCol");
00514 
00515     std::string destRow = Dom::getAttribute(e, "destRow");
00516     FIELDTYPE destType = (destRow == std::string("old") ) ? FIELDTYPEold :
00517       FIELDTYPEtoBe;
00518 
00519     // Now find out what kind of source there is for the <set>
00520     FIELDTYPE srcType;
00521     std::string srcValue;
00522     std::string interp("");
00523     DOMElement* srcElt = Dom::findFirstChildByName(e, "*"); 
00524     std::string tag = Dom::getTagName(srcElt);
00525     if (tag == std::string("ask")) {
00526       srcType = FIELDTYPEask;
00527       srcValue = "";
00528     }
00529     else if (tag == std::string("value") ) {
00530       srcType = FIELDTYPElit;
00531       srcValue = Dom::getTextContent(srcElt);
00532       interp = Dom::getAttribute(srcElt, "interp");
00533     }
00534     else { // it's a setColRef element
00535       std::string forceStr= Dom::getAttribute(srcElt, "force"); 
00536       bool force = (forceStr == std::string("true"));
00537       srcValue = Dom::getAttribute(srcElt, "col");
00538       std::string which = Dom::getAttribute(srcElt, "which");
00539       srcType = (which == std::string("old")) ? FIELDTYPEold 
00540         : FIELDTYPEtoBe;
00541       if (!force) {
00542         if  (srcType == FIELDTYPEold) srcType = FIELDTYPEoldDef;
00543         else srcType = FIELDTYPEtoBeDef;
00544       }
00545     }
00546     return new Set(t, destCol, destType, srcValue, srcType, interp);
00547   }

Supersede * rdbModel::XercesBuilder::buildSupersede ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e,
Table *  t 
) [private]

Definition at line 551 of file XercesBuilder.cxx.

References rdbModel::Supersede::addSet(), buildSet(), rdbModel::Supersede::normalize(), s, deljobs::string, and t().

00552                                           {
00553     using xmlBase::Dom;
00554 
00555     // <supersede> has an optional attribute which is a reference to
00556     // an assertion.  If the attribute is there, it refers to an
00557     // assertion which will already have been processed by XercesBuilder,
00558     // so we can look it up by name.
00559     std::string onlyIfStr = Dom::getAttribute(e, "onlyIf");
00560     Assertion* onlyIf = t->getAssertionByName(onlyIfStr);
00561     Supersede* super = new Supersede(t, onlyIf);
00562 
00563     // Now handle child elements:  a bunch of <set>s.  Sort into two
00564     // lists, depending on whether destination is old row or new
00565     e = Dom::findFirstChildByName(e, "*");
00566     while (e != 0) {
00567       Set* s = buildSet(e, t);
00568       super->addSet(s);
00569       e = Dom::getSiblingElement(e);
00570     }
00571     super->normalize();
00572     return super;
00573   }

Table* rdbModel::XercesBuilder::buildTable ( XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *  e  )  [private]

Build an individual Table object from its xml description

Referenced by buildRdb().

Rdb* rdbModel::Builder::getRdb (  )  [inline, inherited]

This method return a pointer to the internal Rdb

Definition at line 45 of file Builder.h.

00045 { return m_currentRdb; };

unsigned int rdbModel::XercesBuilder::parseInput ( const std::string &  inputPath  )  [virtual]

Invoke xml parser to produce DOM (in-memory) representation Concrete implementation of Builder::parseInput

Implements rdbModel::Builder.

Definition at line 30 of file XercesBuilder.cxx.

References xmlBase::XmlParser::doSchema(), m_doc, and xmlBase::XmlParser::parse().

00030                                                                   {
00031     xmlBase::XmlParser parser;
00032 
00033     parser.doSchema(true);
00034 
00035     //    m_doc = parser.parse(filename.c_str(), "rdbms");
00036     m_doc = parser.parse(filename.c_str());
00037 
00038     return (m_doc == 0) ? 0xffffffff : 0;
00039   }

void rdbModel::Builder::setRdb ( Rdb *  pRdb  )  [inline, inherited]

Definition at line 40 of file Builder.h.

References rdbModel::Builder::m_currentRdb.

00040 {m_currentRdb = pRdb;}

Member Data Documentation

Rdb* rdbModel::Builder::m_currentRdb [protected, inherited]

This is a private pointer to an Rdb used during the building

Definition at line 45 of file Builder.h.

Referenced by rdbModel::Builder::setRdb().

XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* rdbModel::XercesBuilder::m_doc [private]

Definition at line 85 of file XercesBuilder.h.

Referenced by buildRdb(), and parseInput().

Rdb* rdbModel::XercesBuilder::m_rdb [private]

Definition at line 86 of file XercesBuilder.h.

Referenced by buildRdb().

Generated on Tue Nov 29 23:36:36 2016 for BOSS_7.0.2 by  doxygen 1.4.7