Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

/magnus/back_end/Enumerators/include/FreeListProblems.h

Go to the documentation of this file.
00001 #include "Supervisor.h"
00002 #include "SMList.h"
00003 #include "File.h"
00004 #include "FPGroup.h"
00005 #include "OutMessages.h"
00006 #include "SMListIterator.h"
00007 #include "ListProblems.h"
00008 
00009 #ifndef _FREE_LIST_PROBLEMS_H_
00010 #define _FREE_LIST_PROBLEMS_H_
00011 
00012 // ------------------- SMListProperPowerInFreeARCer ------------------ //
00013 
00014 class SMListProperPowerInFreeARCer : public ARCer
00015 {
00016 public:
00017   SMListProperPowerInFreeARCer( ComputationManager& boss ) 
00018     : ARCer( boss ),
00019       theIterator( NULL ) { } 
00020 
00021   /////////////////////////////////////////////////////////////////////////
00022   //                                                                     //
00023   // Accessors:                                                          //
00024   //                                                                     //
00025   /////////////////////////////////////////////////////////////////////////
00026 
00027   // Inherited from ARCer:
00028   // bool takeControl( );
00029 
00030   void setArguments( const SMList<Word>& );
00031   const SMListData& getData() const { return theData; }
00032 
00033   void runComputation( );
00034 
00035   void writeResults( ostream& o ) { o < theData; };
00036   void readResults( istream& i) { i > theData; };
00037  
00038  
00039 private:
00040   SMListIterator<Word>* theIterator;
00041   FPGroup theGroup;
00042   SMListData theData;
00043 };
00044 
00045 // --------------------- SMListExtractProperPowerInFree  ------------------ //
00046 
00047 
00048 class SMListExtractProperPowerInFree  : public SMListSupervisor
00049 {
00050 public:
00051 
00052   /////////////////////////////////////////////////////////////////////////
00053   //                                                                     //
00054   // Constructors:                                                       //
00055   //                                                                     //
00056   /////////////////////////////////////////////////////////////////////////
00057  
00058   SMListExtractProperPowerInFree( SMList<Word>& );
00059   
00060   ~SMListExtractProperPowerInFree() {
00061 
00062   }
00063   /////////////////////////////////////////////////////////////////////////
00064   //                                                                     //
00065   // Front End Interfacing:                                              //
00066   //                                                                     //
00067   /////////////////////////////////////////////////////////////////////////
00068 
00069   void viewStructure(ostream& ostr) const;  // overrides SMObject
00070 
00071 
00072   /////////////////////////////////////////////////////////////////////////
00073   //                                                                     //
00074   // Control:                                                            //
00075   //                                                                     //
00076   /////////////////////////////////////////////////////////////////////////
00077 
00078   void takeControl( );         // overrides ComputationManager
00079 
00080   /////////////////////////////////////////////////////////////////////////
00081   //                                                                     //
00082   // State Transitions:                                                  //
00083   //                                                                     //
00084   /////////////////////////////////////////////////////////////////////////
00085 
00086   void start( ); 
00087 
00088   void terminate( ) { }        // overrides ComputationManager
00089 
00090 
00091 private:
00092 
00093   /////////////////////////////////////////////////////////////////////////
00094   //                                                                     //
00095   // Data Members:                                                       //
00096   //                                                                     //
00097   /////////////////////////////////////////////////////////////////////////
00098 
00099   SMList<Word>& theList;                                    
00100 
00101   SMListProperPowerInFreeARCer arcer;
00102 
00103 };
00104 
00105 
00106 
00107 // ------------------- SMListCommutatorsInFreeARCer ------------------ //
00108 
00109 class SMListCommutatorsInFreeARCer : public ARCer
00110 {
00111 public:
00112   SMListCommutatorsInFreeARCer( ComputationManager& boss ) 
00113     : ARCer( boss ),
00114       theIterator( NULL ) { } 
00115 
00116   /////////////////////////////////////////////////////////////////////////
00117   //                                                                     //
00118   // Accessors:                                                          //
00119   //                                                                     //
00120   /////////////////////////////////////////////////////////////////////////
00121 
00122   // Inherited from ARCer:
00123   // bool takeControl( );
00124 
00125   void setArguments( const SMList<Word>& );
00126   const SMListData& getData() const { return theData; }
00127 
00128   void runComputation( );
00129 
00130   void writeResults( ostream& o ) { o < theData; };
00131   void readResults( istream& i) { i > theData;};
00132  
00133  
00134 private:
00135   SMListIterator<Word>* theIterator;
00136   FreeGroup theGroup;
00137   SMListData theData;
00138 };
00139 
00140 // --------------------- SMListExtractCommutatorsInFree  ------------------ //
00141 
00142 
00143 class SMListExtractCommutatorsInFree  : public SMListSupervisor
00144 {
00145 public:
00146 
00147   /////////////////////////////////////////////////////////////////////////
00148   //                                                                     //
00149   // Constructors:                                                       //
00150   //                                                                     //
00151   /////////////////////////////////////////////////////////////////////////
00152  
00153   SMListExtractCommutatorsInFree( SMList<Word>& );
00154   
00155   ~SMListExtractCommutatorsInFree() {
00156 
00157   }
00158   /////////////////////////////////////////////////////////////////////////
00159   //                                                                     //
00160   // Front End Interfacing:                                              //
00161   //                                                                     //
00162   /////////////////////////////////////////////////////////////////////////
00163 
00164   void viewStructure(ostream& ostr) const;  // overrides SMObject
00165 
00166 
00167   /////////////////////////////////////////////////////////////////////////
00168   //                                                                     //
00169   // Control:                                                            //
00170   //                                                                     //
00171   /////////////////////////////////////////////////////////////////////////
00172 
00173   void takeControl( );         // overrides ComputationManager
00174 
00175   /////////////////////////////////////////////////////////////////////////
00176   //                                                                     //
00177   // State Transitions:                                                  //
00178   //                                                                     //
00179   /////////////////////////////////////////////////////////////////////////
00180 
00181   void start( ); 
00182 
00183   void terminate( ) { }        // overrides ComputationManager
00184 
00185 
00186 private:
00187 
00188   /////////////////////////////////////////////////////////////////////////
00189   //                                                                     //
00190   // Data Members:                                                       //
00191   //                                                                     //
00192   /////////////////////////////////////////////////////////////////////////
00193 
00194   SMList<Word>& theList;                                    
00195 
00196   SMListCommutatorsInFreeARCer arcer;
00197 
00198 };
00199 // ---------------------- SGListExtractOfRankARCer --------------------- //
00200 
00201 
00202 class SGListExtractOfRankARCer : public ARCer
00203 {
00204 public:
00205 
00206   /////////////////////////////////////////////////////////////////////////
00207   //                                                                     //
00208   // Constructors:                                                       //
00209   //                                                                     //
00210   /////////////////////////////////////////////////////////////////////////
00211   
00212   SGListExtractOfRankARCer( ComputationManager& boss ) 
00213     : ARCer( boss ),
00214     minRank( 1 ), 
00215     maxRank( 0 ) { }
00216   
00217   ~SGListExtractOfRankARCer( ) { 
00218     if (theIterator)
00219       delete theIterator;
00220   }
00221  
00222   
00223 
00224   /////////////////////////////////////////////////////////////////////////
00225   //                                                                     //
00226   // Accessors:                                                          //
00227   //                                                                     //
00228   /////////////////////////////////////////////////////////////////////////
00229 
00230   void setArguments( const SMList<Subgroup>&);
00231 
00232   const SMListData& getData() const { return theData; }
00233   void setMinimalRank(int  min ) { minRank = min; }
00234   void setMaximalRank(int  max ) { maxRank = max; }
00235   int indexInFreeGroup( const VectorOf<Word>& s )const;
00236  
00237   // Inherited from ARCer:
00238   // bool takeControl( );
00239   
00240    
00241   /////////////////////////////////////////////////////////////////////////
00242   //                                                                     //
00243   // IPC interaction members:                                            //
00244   //                                                                     //
00245   /////////////////////////////////////////////////////////////////////////
00246 
00247   void runComputation( );
00248  
00249   void writeResults( ostream& );
00250 
00251   void readResults( istream& );
00252 
00253 
00254 private:
00255 
00256   /////////////////////////////////////////////////////////////////////////
00257   //                                                                     //
00258   // Data Members:                                                       //
00259   //                                                                     //
00260   /////////////////////////////////////////////////////////////////////////
00261 
00262   SMListIterator<Subgroup>* theIterator;
00263   SMListData theData;
00264   const SMFPGroup* theGroup;
00265   int minRank; 
00266   int maxRank;
00267 };
00268 
00269 
00270 
00271 // --------------------- SGListExtractOfRank ---------------------- //
00272 
00273 
00274 class SGListExtractOfRank  : public Supervisor
00275 {
00276 public:
00277 
00278   /////////////////////////////////////////////////////////////////////////
00279   //                                                                     //
00280   // Constructors:                                                       //
00281   //                                                                     //
00282   /////////////////////////////////////////////////////////////////////////
00283 
00284  SGListExtractOfRank( SMList<Subgroup>& );
00285 
00286 
00287   /////////////////////////////////////////////////////////////////////////
00288   //                                                                     //
00289   // Front End Interfacing:                                              //
00290   //                                                                     //
00291   /////////////////////////////////////////////////////////////////////////
00292 
00293   void viewStructure(ostream& ostr) const;  // overrides SMObject
00294 
00295 
00296   /////////////////////////////////////////////////////////////////////////
00297   //                                                                     //
00298   // Control:                                                            //
00299   //                                                                     //
00300   /////////////////////////////////////////////////////////////////////////
00301 
00302   void takeControl( );         // overrides ComputationManager
00303 
00304 
00305   /////////////////////////////////////////////////////////////////////////
00306   //                                                                     //
00307   // State Transitions:                                                  //
00308   //                                                                     //
00309   /////////////////////////////////////////////////////////////////////////
00310 
00311   void start( );            // overrides ComputationManager
00312 
00313   void terminate( ) { }        // overrides ComputationManager
00314 
00315 
00316 private:
00317 
00318   /////////////////////////////////////////////////////////////////////////
00319   //                                                                     //
00320   // Data Members:                                                       //
00321   //                                                                     //
00322   /////////////////////////////////////////////////////////////////////////
00323 
00324   SMList<Subgroup>& theList;
00325   bool started;
00326   SGListExtractOfRankARCer arcer;
00327 };
00328 
00329 // ---------------------- SGListExtractNormalARCer --------------------- //
00330 
00331 
00332 class SGListExtractNormalARCer : public ARCer
00333 {
00334 public:
00335 
00336   /////////////////////////////////////////////////////////////////////////
00337   //                                                                     //
00338   // Constructors:                                                       //
00339   //                                                                     //
00340   /////////////////////////////////////////////////////////////////////////
00341   
00342   SGListExtractNormalARCer( ComputationManager& boss ) 
00343     : ARCer( boss ) { } 
00344   
00345   ~SGListExtractNormalARCer( ) { 
00346     if (theIterator)
00347       delete theIterator;
00348   }
00349  
00350   
00351 
00352   /////////////////////////////////////////////////////////////////////////
00353   //                                                                     //
00354   // Accessors:                                                          //
00355   //                                                                     //
00356   /////////////////////////////////////////////////////////////////////////
00357 
00358   void setArguments( const SMList<Subgroup>&);
00359 
00360   const SMListData& getData() const { return theData; }
00361  
00362   // Inherited from ARCer:
00363   // bool takeControl( );
00364   
00365    
00366   /////////////////////////////////////////////////////////////////////////
00367   //                                                                     //
00368   // IPC interaction members:                                            //
00369   //                                                                     //
00370   /////////////////////////////////////////////////////////////////////////
00371 
00372   void runComputation( );
00373  
00374   void writeResults( ostream& );
00375 
00376   void readResults( istream& );
00377 
00378 
00379 private:
00380 
00381   /////////////////////////////////////////////////////////////////////////
00382   //                                                                     //
00383   // Data Members:                                                       //
00384   //                                                                     //
00385   /////////////////////////////////////////////////////////////////////////
00386 
00387   SMListIterator<Subgroup>* theIterator;
00388   SMListData theData;
00389   FreeGroup theGroup;
00390 };
00391 
00392 
00393 
00394 // --------------------- SGListExtractNormal ---------------------- //
00395 
00396 
00397 class SGListExtractNormal  : public Supervisor
00398 {
00399 public:
00400 
00401   /////////////////////////////////////////////////////////////////////////
00402   //                                                                     //
00403   // Constructors:                                                       //
00404   //                                                                     //
00405   /////////////////////////////////////////////////////////////////////////
00406 
00407  SGListExtractNormal( SMList<Subgroup>& );
00408 
00409 
00410   /////////////////////////////////////////////////////////////////////////
00411   //                                                                     //
00412   // Front End Interfacing:                                              //
00413   //                                                                     //
00414   /////////////////////////////////////////////////////////////////////////
00415 
00416   void viewStructure(ostream& ostr) const;  // overrides SMObject
00417 
00418 
00419   /////////////////////////////////////////////////////////////////////////
00420   //                                                                     //
00421   // Control:                                                            //
00422   //                                                                     //
00423   /////////////////////////////////////////////////////////////////////////
00424 
00425   void takeControl( );         // overrides ComputationManager
00426 
00427 
00428   /////////////////////////////////////////////////////////////////////////
00429   //                                                                     //
00430   // State Transitions:                                                  //
00431   //                                                                     //
00432   /////////////////////////////////////////////////////////////////////////
00433 
00434   void start( );            // overrides ComputationManager
00435 
00436   void terminate( ) { }        // overrides ComputationManager
00437 
00438 
00439 private:
00440 
00441   /////////////////////////////////////////////////////////////////////////
00442   //                                                                     //
00443   // Data Members:                                                       //
00444   //                                                                     //
00445   /////////////////////////////////////////////////////////////////////////
00446 
00447   SMList<Subgroup>& theList;
00448   bool started;
00449   SGListExtractNormalARCer arcer;
00450 };
00451 // ---------------------- SGListExtractMalnormalARCer --------------------- //
00452 
00453 
00454 class SGListExtractMalnormalARCer : public ARCer
00455 {
00456 public:
00457 
00458   /////////////////////////////////////////////////////////////////////////
00459   //                                                                     //
00460   // Constructors:                                                       //
00461   //                                                                     //
00462   /////////////////////////////////////////////////////////////////////////
00463   
00464   SGListExtractMalnormalARCer( ComputationManager& boss ) 
00465     : ARCer( boss ) { } 
00466   
00467   ~SGListExtractMalnormalARCer( ) { 
00468     if (theIterator)
00469       delete theIterator;
00470   }
00471  
00472   
00473 
00474   /////////////////////////////////////////////////////////////////////////
00475   //                                                                     //
00476   // Accessors:                                                          //
00477   //                                                                     //
00478   /////////////////////////////////////////////////////////////////////////
00479 
00480   void setArguments( const SMList<Subgroup>&);
00481 
00482   const SMListData& getData() const { return theData; }
00483   //void setMinimalLength(int  min ) { minLength = min; }
00484   //void setMaximalLength(int  max ) { maxLength = max; }
00485  
00486  
00487   // Inherited from ARCer:
00488   // bool takeControl( );
00489   
00490    
00491   /////////////////////////////////////////////////////////////////////////
00492   //                                                                     //
00493   // IPC interaction members:                                            //
00494   //                                                                     //
00495   /////////////////////////////////////////////////////////////////////////
00496 
00497   void runComputation( );
00498  
00499   void writeResults( ostream& );
00500 
00501   void readResults( istream& );
00502 
00503 
00504 private:
00505 
00506   /////////////////////////////////////////////////////////////////////////
00507   //                                                                     //
00508   // Data Members:                                                       //
00509   //                                                                     //
00510   /////////////////////////////////////////////////////////////////////////
00511 
00512   SMListIterator<Subgroup>* theIterator;
00513   SMListData theData;
00514   FreeGroup theGroup;
00515 };
00516 
00517 
00518 
00519 // --------------------- SGListExtractMalnormal ---------------------- //
00520 
00521 
00522 class SGListExtractMalnormal  : public Supervisor
00523 {
00524 public:
00525 
00526   /////////////////////////////////////////////////////////////////////////
00527   //                                                                     //
00528   // Constructors:                                                       //
00529   //                                                                     //
00530   /////////////////////////////////////////////////////////////////////////
00531 
00532  SGListExtractMalnormal( SMList<Subgroup>& );
00533 
00534 
00535   /////////////////////////////////////////////////////////////////////////
00536   //                                                                     //
00537   // Front End Interfacing:                                              //
00538   //                                                                     //
00539   /////////////////////////////////////////////////////////////////////////
00540 
00541   void viewStructure(ostream& ostr) const;  // overrides SMObject
00542 
00543 
00544   /////////////////////////////////////////////////////////////////////////
00545   //                                                                     //
00546   // Control:                                                            //
00547   //                                                                     //
00548   /////////////////////////////////////////////////////////////////////////
00549 
00550   void takeControl( );         // overrides ComputationManager
00551 
00552 
00553   /////////////////////////////////////////////////////////////////////////
00554   //                                                                     //
00555   // State Transitions:                                                  //
00556   //                                                                     //
00557   /////////////////////////////////////////////////////////////////////////
00558 
00559   void start( );            // overrides ComputationManager
00560 
00561   void terminate( ) { }        // overrides ComputationManager
00562 
00563 
00564 private:
00565 
00566   /////////////////////////////////////////////////////////////////////////
00567   //                                                                     //
00568   // Data Members:                                                       //
00569   //                                                                     //
00570   /////////////////////////////////////////////////////////////////////////
00571 
00572   SMList<Subgroup>& theList;
00573   bool started;
00574   SGListExtractMalnormalARCer arcer;
00575 };
00576 
00577 // ---------------------- MapListExtractIAautoARCer --------------------- //
00578 
00579 
00580 class MapListExtractIAautoARCer : public ARCer
00581 {
00582 public:
00583 
00584   /////////////////////////////////////////////////////////////////////////
00585   //                                                                     //
00586   // Constructors:                                                       //
00587   //                                                                     //
00588   /////////////////////////////////////////////////////////////////////////
00589   
00590   MapListExtractIAautoARCer( ComputationManager& boss ) 
00591     : ARCer( boss ) { } 
00592   
00593   ~MapListExtractIAautoARCer( ) { 
00594     if (theIterator)
00595       delete theIterator;
00596   }
00597  
00598   
00599 
00600   /////////////////////////////////////////////////////////////////////////
00601   //                                                                     //
00602   // Accessors:                                                          //
00603   //                                                                     //
00604   /////////////////////////////////////////////////////////////////////////
00605 
00606   void setArguments( const SMList<Map>&);
00607 
00608   const SMListData& getData() const { return theData; }
00609   //void setMinimalLength(int  min ) { minLength = min; }
00610   //void setMaximalLength(int  max ) { maxLength = max; }
00611  
00612  
00613   // Inherited from ARCer:
00614   // bool takeControl( );
00615   
00616    
00617   /////////////////////////////////////////////////////////////////////////
00618   //                                                                     //
00619   // IPC interaction members:                                            //
00620   //                                                                     //
00621   /////////////////////////////////////////////////////////////////////////
00622 
00623   void runComputation( );
00624  
00625   void writeResults( ostream& );
00626 
00627   void readResults( istream& );
00628 
00629 
00630 private:
00631 
00632   /////////////////////////////////////////////////////////////////////////
00633   //                                                                     //
00634   // Data Members:                                                       //
00635   //                                                                     //
00636   /////////////////////////////////////////////////////////////////////////
00637 
00638   SMListIterator<Map>* theIterator;
00639   SMListData theData;
00640   FreeGroup theGroup;
00641 };
00642 
00643 
00644 
00645 // --------------------- MapListExtractIAauto ---------------------- //
00646 
00647 
00648 class MapListExtractIAauto  : public Supervisor
00649 {
00650 public:
00651 
00652   /////////////////////////////////////////////////////////////////////////
00653   //                                                                     //
00654   // Constructors:                                                       //
00655   //                                                                     //
00656   /////////////////////////////////////////////////////////////////////////
00657 
00658  MapListExtractIAauto( SMList<Map>& );
00659 
00660 
00661   /////////////////////////////////////////////////////////////////////////
00662   //                                                                     //
00663   // Front End Interfacing:                                              //
00664   //                                                                     //
00665   /////////////////////////////////////////////////////////////////////////
00666 
00667   void viewStructure(ostream& ostr) const;  // overrides SMObject
00668 
00669 
00670   /////////////////////////////////////////////////////////////////////////
00671   //                                                                     //
00672   // Control:                                                            //
00673   //                                                                     //
00674   /////////////////////////////////////////////////////////////////////////
00675 
00676   void takeControl( );         // overrides ComputationManager
00677 
00678 
00679   /////////////////////////////////////////////////////////////////////////
00680   //                                                                     //
00681   // State Transitions:                                                  //
00682   //                                                                     //
00683   /////////////////////////////////////////////////////////////////////////
00684 
00685   void start( );            // overrides ComputationManager
00686 
00687   void terminate( ) { }        // overrides ComputationManager
00688 
00689 
00690 private:
00691 
00692   /////////////////////////////////////////////////////////////////////////
00693   //                                                                     //
00694   // Data Members:                                                       //
00695   //                                                                     //
00696   /////////////////////////////////////////////////////////////////////////
00697 
00698   SMList<Map>& theList;
00699   bool started;
00700   MapListExtractIAautoARCer arcer;
00701 };
00702 
00703 
00704 // ---------------------- MapListExtractInnerARCer --------------------- //
00705 
00706 
00707 class MapListExtractInnerARCer : public ARCer
00708 {
00709 public:
00710 
00711   /////////////////////////////////////////////////////////////////////////
00712   //                                                                     //
00713   // Constructors:                                                       //
00714   //                                                                     //
00715   /////////////////////////////////////////////////////////////////////////
00716   
00717   MapListExtractInnerARCer( ComputationManager& boss ) 
00718     : ARCer( boss ) { } 
00719   
00720   ~MapListExtractInnerARCer( ) { 
00721     if (theIterator)
00722       delete theIterator;
00723   }
00724  
00725   
00726 
00727   /////////////////////////////////////////////////////////////////////////
00728   //                                                                     //
00729   // Accessors:                                                          //
00730   //                                                                     //
00731   /////////////////////////////////////////////////////////////////////////
00732 
00733   void setArguments( const SMList<Map>&);
00734 
00735   const SMListData& getData() const { return theData; }
00736   //void setMinimalLength(int  min ) { minLength = min; }
00737   //void setMaximalLength(int  max ) { maxLength = max; }
00738  
00739  
00740   // Inherited from ARCer:
00741   // bool takeControl( );
00742   
00743    
00744   /////////////////////////////////////////////////////////////////////////
00745   //                                                                     //
00746   // IPC interaction members:                                            //
00747   //                                                                     //
00748   /////////////////////////////////////////////////////////////////////////
00749 
00750   void runComputation( );
00751  
00752   void writeResults( ostream& );
00753 
00754   void readResults( istream& );
00755 
00756 
00757 private:
00758 
00759   /////////////////////////////////////////////////////////////////////////
00760   //                                                                     //
00761   // Data Members:                                                       //
00762   //                                                                     //
00763   /////////////////////////////////////////////////////////////////////////
00764 
00765   SMListIterator<Map>* theIterator;
00766   SMListData theData;
00767   FreeGroup theGroup;
00768 };
00769 
00770 
00771 
00772 // --------------------- MapListExtractInner ---------------------- //
00773 
00774 
00775 class MapListExtractInner  : public Supervisor
00776 {
00777 public:
00778 
00779   /////////////////////////////////////////////////////////////////////////
00780   //                                                                     //
00781   // Constructors:                                                       //
00782   //                                                                     //
00783   /////////////////////////////////////////////////////////////////////////
00784 
00785  MapListExtractInner( SMList<Map>& );
00786 
00787 
00788   /////////////////////////////////////////////////////////////////////////
00789   //                                                                     //
00790   // Front End Interfacing:                                              //
00791   //                                                                     //
00792   /////////////////////////////////////////////////////////////////////////
00793 
00794   void viewStructure(ostream& ostr) const;  // overrides SMObject
00795 
00796 
00797   /////////////////////////////////////////////////////////////////////////
00798   //                                                                     //
00799   // Control:                                                            //
00800   //                                                                     //
00801   /////////////////////////////////////////////////////////////////////////
00802 
00803   void takeControl( );         // overrides ComputationManager
00804 
00805 
00806   /////////////////////////////////////////////////////////////////////////
00807   //                                                                     //
00808   // State Transitions:                                                  //
00809   //                                                                     //
00810   /////////////////////////////////////////////////////////////////////////
00811 
00812   void start( );            // overrides ComputationManager
00813 
00814   void terminate( ) { }        // overrides ComputationManager
00815 
00816 
00817 private:
00818 
00819   /////////////////////////////////////////////////////////////////////////
00820   //                                                                     //
00821   // Data Members:                                                       //
00822   //                                                                     //
00823   /////////////////////////////////////////////////////////////////////////
00824 
00825   SMList<Map>& theList;
00826   bool started;
00827   MapListExtractInnerARCer arcer;
00828 };
00829 
00830 #endif

Generated at Tue Jun 19 09:49:34 2001 for Magnus Classes by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001