XmlController.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 "XmlController.h"
00018 
00019 #include "DataRepXML.h"
00020 #include "HiNTupleXML.h"
00021 #include "TupleCutXML.h"
00022 #include "ViewBaseXML.h"
00023 #include "XmlDocument.h"
00024 #include "XmlElement.h"
00025 
00026 #include "controllers/CutController.h"
00027 #include "datasrcs/DataSource.h"
00028 #include "datasrcs/DataSourceController.h"
00029 #include "graphics/ViewBase.h"
00030 #include "graphics/ViewFactory.h"
00031 
00032 #include <stdexcept>
00033 #include <cassert>
00034 
00035 using std::map;
00036 using std::list;
00037 using std::string;
00038 using std::vector;
00039 
00040 using namespace hippodraw;
00041 
00042 XmlDocument * XmlController::m_xml_doc = 0;
00043 
00044 XmlController::XmlController ( )
00045   : m_pasteboard ( 0 ),
00046     m_selectboard ( 0 ),
00047     m_id ( 0 )
00048 {
00049   m_datarep_xml = new DataRepXML ( this );
00050   m_ntuple = new HiNTupleXML ( this );
00051   m_tuple_cut_xml = new TupleCutXML ( this );
00052   m_view = new ViewBaseXML ( this );
00053 }
00054 
00055 XmlController::~XmlController ( )
00056 {
00057   delete m_pasteboard;
00058   delete m_datarep_xml;
00059   delete m_ntuple;
00060   delete m_tuple_cut_xml;
00061   delete m_view;
00062 }
00063 
00064 void
00065 XmlController::
00066 createDocument ( const std::string & doc_name )
00067 {
00068   newDocument ( doc_name );
00069   XmlElement * root = m_xml_doc->createElement ( doc_name );
00070 
00071   m_xml_doc->appendChild ( *root );
00072   delete root;
00073 }
00074 
00075 XmlController::Status 
00076 XmlController::
00077 openDocument ( const std::string & filename )
00078 {
00079   newDocument ( "HippoDraw" );
00080 
00081   XmlDocument::Status rc = m_xml_doc->setContent ( filename );
00082   if ( rc == XmlDocument::OpenError ) return OpenError;
00083   if ( rc == XmlDocument::ParseError ) return ParseError;
00084 
00085   return Success;
00086 }
00087 
00088 XmlController::Status 
00089 XmlController::
00090 openFile ( const std::string & filename )
00091 {
00092   Status status = openDocument ( filename );
00093   if ( status != Success ) return status;
00094 
00095   m_views.clear();
00096   m_tuple_map.clear ();
00097   m_tuple_cut_map.clear ();
00098 
00099   return openNTuples ();
00100 }
00101 
00102 XmlController::Status 
00103 XmlController::
00104 openNTuples ( )
00105 {
00106   m_missing_tuples.clear ();
00107   m_missing_ids.clear ();
00108 
00109   XmlElement * root = m_xml_doc->documentElement ();
00110   list < XmlElement * > nodelist;
00111   m_ntuple->fillNodeList ( root, nodelist );
00112 
00113   std::list < XmlElement * >::const_iterator first = nodelist.begin();
00114 
00115   while ( first != nodelist.end() ) {
00116     XmlElement * element = *first++;
00117     int id = element->getID ();
00118     try {
00119       const DataSource * ntuple = m_ntuple->getObject ( *element );
00120       m_tuple_map[id] = ntuple;
00121     }
00122     catch ( const std::runtime_error &  ) {
00123       const string name = m_ntuple->getName ( *element );
00124       m_missing_tuples.push_back ( name );
00125       m_missing_ids.push_back ( id );
00126     }
00127   }
00128   if ( m_missing_tuples.empty () == true ) return Success;
00129 
00130   return NTupleError;
00131 }
00132 
00133 XmlController::Status
00134 XmlController::
00135 openUpdatedNTuples ( )
00136 {
00137   std::list < string >::iterator it;
00138   int i = 0;
00139   for ( it=m_missing_tuples.begin(); 
00140         it!=m_missing_tuples.end(); ++it, ++i )
00141     {
00142       const DataSource * ntuple = m_ntuple->getObject ( *it );
00143       if ( ntuple == 0 ) 
00144         {
00145           return NTupleError;
00146         }
00147       else 
00148         {
00149           int id = m_missing_ids[i];
00150           m_tuple_map[id] = ntuple;
00151         }
00152     }
00153   return Success;
00154 }
00155 
00156 
00157 bool
00158 XmlController::
00159 isPasteboardEmpty ()
00160 {
00161   return m_pasteboard == 0;
00162 }
00163 
00164 const list < ViewBase * > &
00165 XmlController::
00166 getFromPasteboard ( ViewFactory * factory,
00167                     const std::vector < const ViewBase * > & views )
00168 {
00169   m_xml_doc = m_pasteboard;
00170 
00171   return getFromDocument ( factory, views );
00172 }
00173 
00174 const list < ViewBase * > &
00175 XmlController::
00176 getFromSelectionCopy ( ViewFactory * factory,
00177                        const std::vector < const ViewBase * > & views )
00178 {
00179   m_xml_doc = m_selectboard;
00180 
00181   return getFromDocument ( factory, views );
00182 }
00183 
00184 const list < ViewBase * > &
00185 XmlController::
00186 getFromDocument ( ViewFactory * factory, 
00187                   const std::vector < const ViewBase * > & views )
00188 {
00189   fillNTupleMap ();
00190   fillTupleCutMap ( views );
00191   m_view_factory = factory;
00192 
00193   getViews ();
00194 
00195   CutController * controller = CutController::instance ();
00196   controller->connectDataRep ( m_views, views );
00197 
00198   return m_views;
00199 }
00200 
00201 const list < ViewBase * > & 
00202 XmlController::getViews ( ViewFactory * factory )
00203 {
00204   m_view_factory = factory;
00205   getViews ();
00206   delete m_xml_doc; // done with it.
00207 
00208   return m_views;
00209 }
00210 
00211 bool 
00212 XmlController::
00213 areDataSourcesSaved ( const std::vector < const ViewBase * > & views )
00214 {
00215   bool yes = true;
00216 #ifdef ITERATOR_MEMBER_DEFECT
00217   std::
00218 #endif
00219   vector < const ViewBase * > ::const_iterator first = views.begin ();
00220   while ( first != views.end () ) {
00221     const ViewBase * view = *first++;
00222     yes = m_view->areDataSourcesSaved ( *view );
00223     if ( yes == false ) break;
00224   }
00225 
00226   return yes;
00227 }
00228 
00229 bool 
00230 XmlController::
00231 serializeViews ( const std::vector < const ViewBase * > & views )
00232 {
00233   createDocument ( "HippoDraw" );
00234 
00235   if ( m_xml_doc == 0 ) return false;
00236 
00237   addViews ( views );
00238 
00239   return true;
00240 }
00241 
00242 void
00243 XmlController::
00244 clearDataSourceMap ()
00245 {
00246   map < const DataSource *, XmlElement * > ::iterator first 
00247     = m_data.begin();
00248   for ( ; first != m_data.end (); ++ first ) {
00249     delete first->second;
00250   }
00251 
00252   m_data.clear ();
00253 }
00254 
00255 void
00256 XmlController::
00257 saveToDocument ( const std::vector < const ViewBase * > & views )
00258 {
00259   clearDataSourceMap ();
00260   m_addr_map.clear();
00261   serializeViews ( views );
00262 }
00263 
00264 void
00265 XmlController::
00266 saveToPasteboard ( const std::vector < const ViewBase * > & selviews )
00267 {
00268   saveToDocument ( selviews );
00269 
00270   if ( m_pasteboard != 0 ) delete m_pasteboard;
00271   m_pasteboard = m_xml_doc;
00272 }
00273 
00274 void
00275 XmlController::
00276 saveToSelectionCopy ( const std::vector < const ViewBase * > & views )
00277 {
00278   saveToDocument ( views );
00279 
00280   if ( m_selectboard != 0 ) delete m_selectboard;
00281   m_selectboard = m_xml_doc;
00282 }
00283 
00284 XmlController::Status
00285 XmlController::
00286 saveToFile ( const std::vector < const ViewBase * > & views, 
00287              const std::string & filename )
00288 {
00289   clearDataSourceMap ();
00290   m_addr_map.clear();
00291   serializeViews ( views );
00292   XmlDocument::Status status = m_xml_doc->saveToFile ( filename );
00293   delete m_xml_doc;
00294 
00295   if ( status != XmlDocument::Success ) return OpenError;
00296 
00297   return Success;
00298 }
00299 
00300 void 
00301 XmlController::
00302 addViews ( const std::vector < const ViewBase * > & views )
00303 {
00304   XmlElement * root = m_xml_doc->documentElement ();
00305 
00306   std::vector < const ViewBase * >::const_iterator it = views.begin();
00307   for ( ; it != views.end(); ++it ) {
00308     XmlElement * elem = m_view->createElement ( **it );
00309 
00310     root->appendChild ( *elem );
00311     delete elem;
00312   }
00313   delete root;
00314 }
00315 
00316 ViewBase * XmlController::createView ( PlotterBase * plotter )
00317 {
00318   ViewBase * view = m_view_factory->createView ( plotter );
00319   m_views.push_back ( view );
00320 
00321   return view;
00322 }
00323 
00324 FontBase *
00325 XmlController::
00326 createFont () const
00327 {
00328   return m_view_factory -> createFont ();
00329 }
00330 
00331 XmlElement * XmlController::addDataSource ( const DataSource * ntuple )
00332 {
00333   std::map < const DataSource *, XmlElement * >::const_iterator it
00334     = m_data.find ( ntuple );
00335   if ( it != m_data.end () ) {
00336     return it->second;
00337   }
00338   XmlElement * element = m_ntuple->createElement ( *ntuple );
00339 
00340   m_data[ntuple] = element;
00341 
00342   XmlElement * root = m_xml_doc->documentElement ();
00343   root->appendChild ( *element );
00344   delete root;
00345   return element;
00346 }
00347 
00348 const DataSource * XmlController::getDataSource ( int ref )
00349 {
00350   std::map < int, const DataSource * >::const_iterator it
00351     = m_tuple_map.find ( ref );
00352   if ( it == m_tuple_map.end () ) {
00353     return 0;
00354   }
00355 
00356   return it->second;
00357 }
00358 
00359 const TupleCut * XmlController::getTupleCut ( int ref )
00360 {
00361   const TupleCut * cut = 0;
00362 
00363   std::map < int, const TupleCut * >::iterator it
00364     = m_tuple_cut_map.find ( ref );
00365   if ( it == m_tuple_cut_map.end() &&
00366        ref >=0  ) {
00367     it = m_tuple_cut_map.find ( -ref ); // old multiDim TupleCut
00368   }
00369   if ( it != m_tuple_cut_map.end() ) {
00370     cut = it->second;
00371   }
00372 
00373   return cut;
00374 }
00375 
00376 DataRep * XmlController::getDataRep ( int ref )
00377 {
00378   std::map < int, DataRep * >::iterator it
00379     = m_datarep_map.find ( ref );
00380 
00381   if ( it == m_datarep_map.end() ) return 0;
00382 
00383   return it->second;
00384 }
00385 
00386 PlotterBase *
00387 XmlController::
00388 getPlotter ( int ref )
00389 {
00390   std::map < int, PlotterBase * >::iterator it
00391     = m_plotter_map.find ( ref );
00392 
00393   if ( it == m_plotter_map.end() ) return 0;
00394 
00395   return it->second;
00396 }
00397 
00398 void
00399 XmlController::
00400 registerPlotter ( int id, PlotterBase * plotter )
00401 {
00402   m_plotter_map [ id ] = plotter;
00403 }
00404 
00405 void
00406 XmlController::
00407 fillNTupleMap ()
00408 {
00409   m_tuple_map.clear();
00410   DataSourceController * controller = DataSourceController::instance ();
00411   vector < DataSource * > tuples;
00412   controller->getDataSources ( tuples ); // get all
00413 #ifdef ITERATOR_MEMBER_DEFECT
00414   std::
00415 #endif
00416   vector < DataSource * > ::const_iterator first = tuples.begin();
00417   for ( ; first != tuples.end(); ++first ) {
00418     const void * addr = reinterpret_cast < const void * > ( *first );
00419     int ref = getId ( addr );
00420     m_tuple_map[ref] = *first;
00421   }
00422 }
00423 
00424 void XmlController::
00425 fillTupleCutMap ( const std::vector < const ViewBase * > & views )
00426 {
00427   m_tuple_cut_map.clear();
00428   vector < const TupleCut * > cut_list;
00429   CutController * controller = CutController::instance ();
00430 
00431   controller->fillTupleCutList ( views, cut_list );
00432 
00433   vector < const TupleCut * > :: iterator first = cut_list.begin ();
00434   while ( first != cut_list.end () ) {
00435     const TupleCut * cut = *first++;
00436     void * addr = reinterpret_cast < void * > ( &cut );
00437     int id = getId ( addr );
00438     m_tuple_cut_map [ id ] = cut;
00439   }
00440 }
00441 
00442 void XmlController::getDataReps ()
00443 {
00444   XmlElement * root = m_xml_doc->documentElement ();
00445   list < XmlElement * > nodelist;
00446   m_datarep_xml->fillNodeList ( root, nodelist );
00447 
00448 #ifdef ITERATOR_MEMBER_DEFECT
00449   std::
00450 #endif
00451   list < XmlElement * > ::const_iterator first = nodelist.begin();
00452 
00453   for ( ; first != nodelist.end(); ++first ) {
00454     XmlElement * element = *first;
00455     int id = element->getID ();
00456     DataRep * rep = m_datarep_xml->createObject ( element );
00457     m_datarep_map[id] = rep;
00458   }
00459 
00460 }
00461 
00462 void XmlController::getTupleCuts ()
00463 {
00464   XmlElement * root = m_xml_doc->documentElement ();
00465   list < XmlElement * > nodelist;
00466   m_tuple_cut_xml->fillNodeList ( root, nodelist );
00467 
00468   // std:: for MS VC++ 6.0
00469   std::list < XmlElement * >::const_iterator first = nodelist.begin();
00470 
00471   for ( ; first != nodelist.end(); ++first ) {
00472     XmlElement * element = *first;
00473     if ( m_tuple_cut_xml -> hasMultiDimTupleCut ( element ) ) {
00474       vector < TupleCut * > cuts;
00475       m_tuple_cut_xml -> getObjects ( element, cuts );
00476       for ( unsigned int i = 0; i < cuts.size (); i++ ) {
00477         int id = element -> getID ();
00478         if ( i == 1 ) id = -id;
00479         m_tuple_cut_map[id] = cuts[i];
00480       }
00481     }
00482     else {
00483       TupleCut * cut = m_tuple_cut_xml->getObject ( *element );
00484       int id = element->getID ();
00485       m_tuple_cut_map[id] = cut;
00486     }
00487   }
00488 }
00489 
00490 void XmlController::getViews ( )
00491 {
00492   m_views.clear();
00493   if ( m_xml_doc != 0 ) {
00494     getTupleCuts ();
00495     getDataReps ();
00496 
00497     XmlElement * root = m_xml_doc->documentElement ();
00498     list < XmlElement * > nodelist;
00499     m_view->fillNodeList ( root, nodelist );
00500 
00501     if ( nodelist.empty () ) return;
00502 
00503     // std:: for MS VC++ 6.0
00504     std::list < XmlElement * >::const_iterator first = nodelist.begin ();
00505     for ( ; first != nodelist.end(); ++ first ) {
00506       m_view->getObjects ( *first );
00507     }
00508 
00509     m_view -> connectPlotters ( root );
00510   }
00511 }
00512 
00513 int
00514 XmlController::
00515 getId ( const void * addr )
00516 {
00517   int id = 0;
00518   AddrMapIterator_t it = m_addr_map.find ( addr );
00519   if ( it == m_addr_map.end () ) { // not found
00520     id = m_id;
00521     m_addr_map [ addr ] = m_id++;
00522   }
00523   else { // found
00524     id = it -> second;
00525   }
00526 
00527   return id;
00528 }
00529 
00530 std::list < std::string > &
00531 XmlController::
00532 getMissingTuples ( )
00533 {
00534   return m_missing_tuples;
00535 }

Generated for HippoDraw Class Library by doxygen