DataRepXML.cxx

Go to the documentation of this file.
00001 
00012 // for truncation warning
00013 #ifdef _MSC_VER
00014 #include "msdevstudio/MSconfig.h"
00015 #endif
00016 
00017 #include "DataRepXML.h"
00018 
00019 #include "BinningProjectorXML.h"
00020 #include "NTupleProjectorXML.h"
00021 #include "FunctionProjectorXML.h"
00022 #include "MapMatrixProjectorXML.h"
00023 #include "PointRepXML.h"
00024 #include "XmlController.h"
00025 #include "XmlDocument.h"
00026 #include "XmlElement.h"
00027 
00028 #include "controllers/DataRepController.h"
00029 #include "controllers/FunctionController.h"
00030 
00031 #include "datareps/DataRepException.h"
00032 #include "datareps/FunctionRep.h"
00033 #include "datareps/TextDataRep.h"
00034 
00035 #include "datasrcs/DataSource.h"
00036 #include "plotters/PlotterBase.h"
00037 
00038 #include "projectors/BinningProjector.h"
00039 #include "projectors/MapMatrixProjector.h"
00040 #include "projectors/FunctionProjector.h"
00041 
00042 #include "reps/RepBase.h"
00043 
00044 #include <cassert>
00045 
00046 using std::string;
00047 using std::vector;
00048 
00049 
00050 using namespace hippodraw;
00051 
00052 DataRepXML::DataRepXML ( XmlController * controller )
00053   : BaseXML ( "DataRep", controller ),
00054     m_contours ( "contours" )
00055 {
00056   m_pointrep  = new PointRepXML ( controller );
00057   m_nTupleProjector = new NTupleProjectorXML ( controller );
00058   m_binningProjectorXML = new BinningProjectorXML ( controller );
00059   m_functionProjector = new FunctionProjectorXML ( controller );
00060   m_mapMatrixProjectorXML = new MapMatrixProjectorXML ( controller );
00061 }
00062 
00063 DataRepXML::
00064 ~DataRepXML ()
00065 {
00066   delete m_pointrep;
00067   delete m_nTupleProjector;
00068   delete m_binningProjectorXML;
00069   delete m_functionProjector;
00070   delete m_mapMatrixProjectorXML;
00071 }
00072 
00073 XmlElement * DataRepXML::createElement ( const hippodraw::DataRep & rep )
00074 {
00075   XmlElement * tag = BaseXML::createElement ();
00076 
00077   const void * addr = reinterpret_cast < const void * > ( & rep );
00078   int id = m_controller -> getId ( addr );
00079 
00080   setId ( *tag, id );
00081   tag->setAttribute ( m_type, rep.name() );
00082 
00083   createChildren ( *tag, rep );
00084 
00085   return tag;
00086 }
00087 
00088 
00089 void DataRepXML::createChildren ( XmlElement & tag,
00090                                   const NTupleProjector * projector )
00091 {
00092   NTupleProjectorXML * qt_projector 
00093     = dynamic_cast < NTupleProjectorXML * > ( m_nTupleProjector );
00094   XmlElement * element = qt_projector->createElement ( *projector );
00095 
00096   tag.appendChild ( *element );
00097   delete element;
00098 }
00099 
00100 void 
00101 DataRepXML::
00102 createChildren ( XmlElement & tag, const BinningProjector * projector )
00103 {
00104   XmlElement * element 
00105     = m_binningProjectorXML -> createElement ( *projector );
00106   tag.appendChild ( *element );
00107   delete element;
00108 }
00109 
00110 void 
00111 DataRepXML::
00112 createChildren ( XmlElement & tag, const MapMatrixProjector * projector )
00113 {
00114   XmlElement * element 
00115     = m_mapMatrixProjectorXML -> createElement ( *projector );
00116   tag.appendChild ( *element );
00117   delete element;
00118 }
00119 
00120 void DataRepXML::createChildren ( XmlElement & tag, 
00121                                   const FunctionProjector * projector )
00122 {
00123   FunctionProjectorXML * qt_projector 
00124     = dynamic_cast < FunctionProjectorXML * > ( m_functionProjector );
00125   XmlElement * element = qt_projector->createElement ( *projector );
00126 
00127   tag.appendChild ( *element );
00128   delete element;
00129 }
00130 
00131 void DataRepXML::createChildren ( XmlElement & tag,
00132                                   const hippodraw::DataRep & rep )
00133 {
00134   RepBase * pointrep = rep.getRepresentation ();
00135   XmlElement * element = m_pointrep->createElement ( *pointrep );
00136 
00137   tag.appendChild ( *element );
00138   delete element;
00139 
00140   ProjectorBase * projbase = rep.getProjector ();
00141 
00142   if ( rep.hasNTupleBindings () ) 
00143     {
00144       const NTupleProjector * projector
00145         = dynamic_cast < const NTupleProjector * > ( projbase );
00146       createChildren ( tag, projector );
00147     }
00148 
00149   const BinningProjector * binProjector 
00150     = dynamic_cast < const BinningProjector * > ( projbase );
00151   if ( binProjector != 0 ) 
00152     {
00153       createChildren ( tag, binProjector );
00154     }
00155 
00156   const FunctionProjector * functionProjector
00157     = dynamic_cast < const FunctionProjector * > ( projbase );
00158   if ( functionProjector != 0  ) 
00159     {
00160       createFunctionTargetChild ( tag, rep );
00161       createChildren ( tag, functionProjector );
00162     }
00163 
00164   const MapMatrixProjector * mapMatrixProjector 
00165     = dynamic_cast < const MapMatrixProjector * > ( projbase );
00166   if ( mapMatrixProjector != 0 ) {
00167     createChildren ( tag, mapMatrixProjector );
00168   }
00169 
00170 }
00171 
00172 void DataRepXML::
00173 createFunctionTargetChild ( XmlElement & tag,
00174                             const hippodraw::DataRep & rep )
00175 {
00176   const FunctionRep & frep = dynamic_cast < const FunctionRep & > ( rep );
00177   hippodraw::DataRep * target = frep.getTarget ();
00178   const void * addr = reinterpret_cast < const void * > ( target );
00179   int id = m_controller -> getId ( addr );
00180   XmlElement * element 
00181     = XmlController::m_xml_doc->createElement ( "FunctionTarget" );
00182   element->setAttribute ( "id", id );
00183   tag.appendChild ( *element );
00184   delete element;
00185 }
00186 
00187 hippodraw::DataRep *
00188 DataRepXML::
00189 createDataRep ( const XmlElement * element )
00190 {
00191   DataRep * rep = 0;
00192 
00193   string type;
00194   bool ok = element -> attribute ( m_type, type );
00195   assert ( ok );
00196 
00197   if ( type == "Z Plot" ) {
00198     type = "Image";  // name has changed.
00199   }
00200 
00201   DataRepController * controller = DataRepController::instance ();
00202   try {
00203     rep = controller -> createDataRep ( type );
00204   }
00205   catch ( const DataRepException & ) {
00206     // do nothing
00207   }
00208 
00209   return rep;
00210 }
00211 
00212 DataRep * 
00213 DataRepXML::
00214 createDataRep ( const XmlElement * element, const XmlElement * ntp_element )
00215 {
00216   string  type;
00217   bool ok = element->attribute ( m_type, type );
00218   assert ( ok );
00219 
00220   int ref = m_nTupleProjector->getNTupleReference ( ntp_element );
00221   const DataSource * ntuple = m_controller->getDataSource ( ref );
00222   assert ( ntuple != 0 );
00223 
00224   vector < string > bindings;
00225   m_nTupleProjector->getBindings ( ntp_element, bindings );
00226       
00227   DataRepController * controller = DataRepController::instance();
00228   DataRep * rep 
00229     = controller->createDataRep ( type, ntuple, bindings );
00230 
00231   return rep;
00232 }
00233 
00236 DataRep *
00237 DataRepXML::
00238 getTextRepObject ( const XmlElement * )
00239 {
00240   TextDataRep * rep = new TextDataRep ();
00241 
00242   return rep;
00243 }
00244 
00245 DataRep * DataRepXML::createObject ( const XmlElement * dr_element )
00246 {
00247   DataRep * rep = 0;
00248 
00249   const XmlElement * element
00250     = m_nTupleProjector->getNode ( dr_element );
00251 
00252   if ( element != 0 ) { // bound to ntuple
00253       rep = createDataRep ( dr_element, element );
00254       ProjectorBase * projector = rep->getProjector ();
00255       m_binningProjectorXML->getObject ( dr_element, projector );
00256   }
00257 
00258   element = m_mapMatrixProjectorXML -> getNode ( dr_element );
00259   if ( element != 0 ) {
00260     ProjectorBase * projector = rep -> getProjector ();
00261     m_mapMatrixProjectorXML -> setAttributes ( element, projector );
00262   }
00263 
00264   element = m_functionProjector->getNode ( dr_element );
00265   if ( element != 0 ) {
00266     XmlElement * targetelement = dr_element->getNode ( "FunctionTarget" );
00267     assert ( targetelement );
00268     int id = targetelement->getID ();
00269     DataRep * target = m_controller->getDataRep ( id );
00270     assert ( target );
00271     rep = m_functionProjector -> createFunctionRep ( element, target );
00272   }
00273 
00274   if ( element == 0 ) { // not any of above
00275     const XmlElement * element
00276       = m_nTupleProjector->getNode ( dr_element );
00277     if ( element == 0 ) {
00278       rep = createDataRep ( dr_element );
00279       if ( rep != 0 ) {
00280         ProjectorBase * projector = rep -> getProjector ();
00281         m_binningProjectorXML -> getObject ( dr_element, projector );
00282         m_binningProjectorXML -> setBins ( dr_element, projector );
00283       }
00284     }
00285   }
00286 
00287   string type;
00288   bool ok = dr_element->attribute ( m_type, type );
00289   assert ( ok );
00290 
00291   if ( type == "TextDataRep" ) {
00292     rep = getTextRepObject ( dr_element );
00293   }
00294 
00295   if ( rep == 0 ) return 0;
00296   
00297   const XmlElement * pr_element = m_pointrep->getNode ( dr_element );
00298   assert ( pr_element );
00299   RepBase * pr = m_pointrep->createObject ( pr_element );
00300   rep->setPointRep ( pr );
00301   
00302   return rep;
00303 }

Generated for HippoDraw Class Library by doxygen