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

/magnus/back_end/SessionManager/include/SMList.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: SMList.h,v 1.4 2000/09/21 21:17:14 alex Exp $
00003  */
00004 
00005 // Copyright (C) 1997 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 
00008 // Contents: Declaration of class SMEnumerator
00009 //
00010 // Principal Author: Alexei Myasnikov
00011 //
00012 // Status: in progress
00013 //
00014 // Revision History:
00015 //
00016 
00017 #ifndef _SMLIST_H_
00018 #define _SMLIST_H_
00019 
00020 #include "AlgebraicObject.h"
00021 #include "SMFPGroup.h"
00022 #include "Word.h"
00023 #include "Associations.h"
00024 #include "SMEnumerator.h"
00025 
00026 template <class T> class SMList;
00027 
00028 
00029 //--------------------------------------------------------------------------//
00030 //---------------------------- SMListType ----------------------------------//
00031 //--------------------------------------------------------------------------//
00032 
00033 
00034 template <class T> class SMList;
00035 
00036 template <class T>  class SMListType {
00037 public:
00038   SMListType() {
00039     ostrstream ostr;
00040     ostr << "SMList" << T::type() << '\0' << flush;
00041     strcpy(s, ostr.str());
00042   }
00043 private:
00044   friend class SMList<T>;
00045   char s[100];
00046 };
00047 
00048 // ------------------------------- LIC -------------------------------- //
00049 
00050 
00051 class LIC : protected FEData
00052 {  
00053 public:
00054   
00055   /////////////////////////////////////////////////////////////////////////
00056   //                                                                     //
00057   // Constructors:                                                       //
00058   //                                                                     //
00059   /////////////////////////////////////////////////////////////////////////
00060   
00061   LIC( OID, int );
00062 
00063   ~LIC( );
00064 
00065   /////////////////////////////////////////////////////////////////////////
00066   //                                                                     //
00067   // Trivality information:                                              //
00068   //                                                                     //
00069   /////////////////////////////////////////////////////////////////////////
00070 
00071   Trichotomy getTrivialStatus( int, GIC::AlgorithmID&, Chars& ) const;
00072   Trichotomy getTrivialStatus( int i ) const {
00073     GIC::AlgorithmID al;
00074     Chars s;
00075     return getTrivialStatus( i, al, s );
00076   }
00077 
00078   void setTrivialStatus( int i, Trichotomy is_trivial, 
00079                          GIC::AlgorithmID al = GIC::NONE  );
00080   
00081   bool IsTrivialChecked() const;
00082 
00083   bool hasTrivialStatusBuffer() const;
00084 
00085   void putIsTrivialFiles( const Chars& is_trivial,
00086                         const Chars& is_not_trivial ){
00087     isTrivialFName = is_trivial;
00088     isNonTrivialFName = is_not_trivial;
00089   }
00090 
00091 
00092   Chars getListOfTrivial() const { return isTrivialFName; }
00093   Chars getListOfNonTrivial() const { return isNonTrivialFName; }
00094 
00095   /////////////////////////////////////////////////////////////////////////
00096   //                                                                     //
00097   // ''Is abelian'' information:                                         //
00098   //                                                                     //
00099   /////////////////////////////////////////////////////////////////////////
00100 
00101   Trichotomy getAbelianStatus( int, GIC::AlgorithmID&, Chars& ) const;
00102 
00103   Trichotomy getAbelianStatus( int i ) const {
00104     GIC::AlgorithmID al;
00105     Chars s;
00106     return getAbelianStatus( i, al, s );
00107   }
00108 
00109   void setAbelianStatus( int i, Trichotomy is_abelian, 
00110                          GIC::AlgorithmID al = GIC::NONE  );
00111   
00112   bool IsAbelianChecked() const;
00113 
00114   bool hasAbelianStatusBuffer( ) const;
00115 
00116   void putAbelianFiles( const Chars& is_abelian,
00117                         const Chars& is_not_abelian ){
00118     isAbelianFName = is_abelian;
00119     isNonAbelianFName = is_not_abelian;
00120   }
00121 
00122 
00123   Chars getListOfAbelian() const { return isAbelianFName; }
00124   Chars getListOfNonAbelian() const { return isNonAbelianFName; }
00125 
00126   /////////////////////////////////////////////////////////////////////////
00127   //                                                                     //
00128   // ''Is central'' information:                                         //
00129   //                                                                     //
00130   /////////////////////////////////////////////////////////////////////////
00131 
00132   Trichotomy getIsCentralStatus( int, GIC::AlgorithmID&, Chars& ) const;
00133 
00134   Trichotomy getIsCentralStatus( int i ) const {
00135     GIC::AlgorithmID al;
00136     Chars s;
00137     return getIsCentralStatus( i, al, s );
00138   }
00139 
00140   void setIsCentralStatus( int i, Trichotomy is_abelian, 
00141                          GIC::AlgorithmID al = GIC::NONE  );
00142   
00143   bool IsCentralChecked() const;
00144 
00145   bool hasIsCentralStatusBuffer( ) const;
00146 
00147   void putIsCentralFiles( const Chars& is_central,
00148                           const Chars& is_not_central ){
00149     isCentralFName = is_central;
00150     isNonCentralFName = is_not_central;
00151   }
00152 
00153 
00154   Chars getListOfCentral() const { return isCentralFName; }
00155   Chars getListOfNonCentral() const { return isNonCentralFName; }
00156 
00157   /////////////////////////////////////////////////////////////////////////
00158   //                                                                     //
00159   // General accessors:                                                  //
00160   //                                                                     //
00161   /////////////////////////////////////////////////////////////////////////
00162 
00163   int numberOfElements() const { return number_of_elements; }
00164 
00165 private:
00166 
00167   struct status_type {
00168     status_type( int );
00169     ~status_type();
00170 
00171     Trichotomy getStatus( int, GIC::AlgorithmID& ) const;
00172     void setStatus( int i, Trichotomy is_abelian, 
00173                     GIC::AlgorithmID al = GIC::NONE  );
00174   
00175     bool isChecked() const;
00176 
00177   private:
00178     char* status_buffer;
00179     int status_file;    
00180     int size;
00181   };
00182   
00183   Chars explanation( GIC::AlgorithmID ) const;
00184   
00185   /////////////////////////////////////////////////////////////////////////
00186   //                                                                     //
00187   // Data Members:                                                       //
00188   //                                                                     //
00189   /////////////////////////////////////////////////////////////////////////
00190 
00191   OID listOID;
00192   // Need this for composing messages about what has been found.
00193                                
00194   int number_of_elements;
00195 
00196   status_type* abStatus;
00197   status_type* wpStatus;
00198   status_type* centStatus;
00199   
00200   Chars isAbelianFName;
00201   Chars isNonAbelianFName;
00202 
00203   Chars isTrivialFName;
00204   Chars isNonTrivialFName;
00205 
00206   Chars isCentralFName;
00207   Chars isNonCentralFName;
00208 };
00209 
00210 //--------------------------------------------------------------------------//
00211 //-------------------------- SMList ----------------------------------------//
00212 //--------------------------------------------------------------------------//
00213 
00214 template <class T> class SMList : public AlgebraicObject
00215 {
00216 public:
00217 
00218   /////////////////////////////////////////////////////////////////////////
00219   //                                                                     //
00220   // Constructors:                                                       //
00221   //                                                                     //
00222   /////////////////////////////////////////////////////////////////////////
00223 
00224   SMList( class EnumeratorProblem< T >& P, const Chars heritage);
00225 
00226   SMList( const SMFPGroup& ao, const SMListData& d, const Chars heritage );
00227   
00228 //  SMList( EnumeratorProblem< T >& P) : AlgebraicObject(""), 
00229 //    theParent(P.getBoss().getParentObject())
00230 //    theGroup(){ }
00231   
00232   //@Rn Bogus ctor; see But no  comment in Menu.h.
00233   
00234 
00235   ~SMList();
00236 
00237   /////////////////////////////////////////////////////////////////////////
00238   //                                                                     //
00239   // Accessors:                                                          //
00240   //                                                                     //
00241   /////////////////////////////////////////////////////////////////////////
00242   
00243   const SMListData& getData() const { return theData; }
00244 
00245   const SMFPGroup& getGroup() const;
00246 
00247   const AlgebraicObject& getParent()const { return theParent; }
00248 
00249   LIC& lic() { return *theLic; }
00250  
00251   /////////////////////////////////////////////////////////////////////////
00252   //                                                                     //
00253   // Front End Interfacing:                                              //
00254   //                                                                     //
00255   /////////////////////////////////////////////////////////////////////////
00256   
00257   static const char* type( )  { return theType.s; } 
00258   
00259   const char* typeID( ) const { return type(); };        // overrides SMObject
00260   
00261   const IconID iconID( ) const { return IconID::list_object; };
00262   // overrides SMObject
00263   
00264   void printProperties(ostream& ostr) const;
00265   
00266   void viewStructure(ostream& ostr) const;
00267   
00268   void printDefinition(ostream& ostr) const;            // overrides SMObject
00269   
00270 
00271 public:
00272  
00273 protected:
00274 
00275   void readMessage(istream&) { };                     // overrides SMObject
00276 
00277   /////////////////////////////////////////////////////////////////////////
00278   //                                                                     //
00279   // Restricted Access:                                                  //
00280   //                                                                     //
00281   /////////////////////////////////////////////////////////////////////////
00282   const AlgebraicObject& theParent;                                                         
00283   static SMListType<T> theType;
00284   
00285   SMListData theData;
00286   LIC* theLic;
00287 
00288 };
00289 
00290 
00291 #endif

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