Hauptseite   Liste aller Namensbereiche   Klassenhierarchie   Alphabetische Liste   Übersicht   Auflistung der Dateien   Elemente eines Namensbereiches   Datenstruktur-Elemente   Datei-Elemente  

SflexConfig Klassenreferenz

Diese Klasse kümmert sich um die Konfiguration des Systems. Mehr...

#include <SflexConfig.hpp>

Zusammengehörigkeiten von SflexConfig:

Collaboration graph
[Legende]
Aufstellung aller Elemente

Öffentliche Datenelemente

 ~SflexConfig ()
bool isSuccess () const
 Liefert den Status. Mehr...

const std::string getError () const
 Liefert im Falle eines Fehlers die Fehlermeldung. Mehr...

const std::string getValue (std::string pool, std::string key) const
 Liefert einen Wert aus der Konfiguration (falls er vorhanden ist). Mehr...

const std::map< std::string,
std::string > & 		getCgiValues () const
 Liefert den Container mit den CGI-Werten. Mehr...

const std::vector< std::string > & getModuleParameterList () const
 Liefert die Parameter eines Moduls. Mehr...

void addValue (std::string pool, std::string key, std::string value)
 Hinzufügen eines Eintrages. Mehr...

void addPathInfo (std::string pathInfo)
 Hinzufügen der PATH_INFO-Variable. Mehr...

void addCgiValues (const std::map< std::string, std::string > &cgiValueList)
 Methode zum Übergeben der CGI-Werte. Mehr...

void parseConfig (std::string configFile)
 Parst die Konfigurations-Datei. Mehr...


Öffentliche, statische Datenelemente

SflexConfig * getConfig ()
 Liefert den Zeiger auf das Konfigurations-Objekt. Mehr...


Private Datenelemente

 SflexConfig ()
 Paranoia. Mehr...

void parsePath (std::string pathInfo)
 Parst den PATH_INFO String. Mehr...

bool checkChar (char c)
 Überprüft ein Zeichen auf Zugehörigkeit zu einer Menge. Mehr...


Private Attribute

bool isSuccess_
 der interne Zustand. Mehr...

std::ostringstream errorStream_
 die Fehlermeldung(en). Mehr...

std::map< std::string, std::vector<
std::string > > 		configDataList_
 die Werte aus der Konfigurations Datei. Mehr...

std::map< std::string, std::string > cgiValueList_
 die CGI-Werte. Mehr...

std::vector< std::string > moduleParameterList_
 die Parameter des Moduls. Mehr...


Statische private Attribute

SflexConfig * config_ = 0
 Der Zeiger mit der Adresse des Konfigurations-Objektes. Mehr...

Ausführliche Beschreibung

Diese Klasse kümmert sich um die Konfiguration des Systems.

Dies geschieht, durch das Parsen der Konfigurationsdatei (der Dateiname wird dem Konstruktor übergeben) und dem Parsen des PATH_INFO Strings. Außerdem enthält diese Klasse Methoden, um wieder an die Daten heranzukommen. Sie ist als "Singleton" implementiert, d.h. es wird nur ein statisches Exemplar erstellt, so daß das ganze System auf die gleichen Daten zugreifen kann.

Beschreibung der Konstruktoren und Destruktoren

SflexConfig::~SflexConfig (    ) 
  

00037 {
00038     delete config_;
00039 }

SflexConfig::SflexConfig (    )  [private]
 

Paranoia. 

00029     : isSuccess_( false ) 
00030 {
00031     
00032 }

Dokumentation der Elementfunktionen

void SflexConfig::addCgiValues (  const std::map< std::string, std::string > &    cgiValueList ) 
 

Methode zum Übergeben der CGI-Werte.

Parameter:
cgiValueList  die CGI-Werte 

00127 {
00128     cgiValueList_ = cgiValueList;
00129     return;
00130 }

void SflexConfig::addPathInfo (  std::string    pathInfo ) 
 

Hinzufügen der PATH_INFO-Variable.

Sie wird dann auch direkt geparst.

Parameter:
pathInfo 
Siehe auch:
parsePath 

00117 {
00118     parsePath( pathInfo );
00119     return;
00120 }

void SflexConfig::addValue (  std::string    pool,
std::string    key,
std::string    value
) 
 

Hinzufügen eines Eintrages.

Parameter:
pool  der Pool
key  der Schlüssel
value  der Wert 

00106 {
00107     std::vector< string > v;
00108     v.push_back( value );
00109     configDataList_[ pool + key ] = v;
00110     return;
00111 }

bool SflexConfig::checkChar (  char    c )  [private]
 

Überprüft ein Zeichen auf Zugehörigkeit zu einer Menge.

Die Menge besteht aus a-z, A-Z, 0-9, '/', '.', '-', '_', '#'.

Parameter:
c  Das zu überprüfende Zeichen
Rückgabe:
true wenn c dazugehört, sonst false 

00482 {
00483     using std::isalnum;
00484     
00485     bool r = ( isalnum( c ) || 
00486                c == '/' ||
00487                c == '.' ||
00488                c == '-' ||
00489                c == '_' ||
00490                c == '#' );
00491 
00492     return r;
00493 }

const std::map< std::string, std::string > & SflexConfig::getCgiValues (    )  const
 

Liefert den Container mit den CGI-Werten.

Rückgabe:
die CGI-Werte 

00088 {
00089     return cgiValueList_;
00090 }

SflexConfig * SflexConfig::getConfig (    )  [static]
 

Liefert den Zeiger auf das Konfigurations-Objekt.

Rückgabe:
den Zeiger 

00044 {
00045     if ( !config_ ) {
00046         config_ = new SflexConfig;
00047         return config_;
00048     }
00049     return config_;
00050 }

const std::string SflexConfig::getError (    )  const
 

Liefert im Falle eines Fehlers die Fehlermeldung.

Rückgabe:
die Fehlermeldung(en) 

00064 {
00065     return errorStream_.str();
00066 }

const std::vector< std::string > & SflexConfig::getModuleParameterList (    )  const
 

Liefert die Parameter eines Moduls.

Die Parameter ergeben sich aus dem Inhalt der PATH_INFO Variable. Alles was dort hinter dem Namen des Moduls steht, landet in diesem Container.

Rückgabe:
die Parameter Liste
Siehe auch:
parsePath 

00096 {
00097     return moduleParameterList_;
00098 }

const std::string SflexConfig::getValue (  std::string    pool,
std::string    key
)  const
 

Liefert einen Wert aus der Konfiguration (falls er vorhanden ist).

Parameter:
pool  der Pool aus dem der Wert stammt
key  der Name des Werts
Rückgabe:
den Wert des Keys, wenn nicht vorhanden einen leeren String 

00073 {
00074     using std::string;
00075     
00076     std::map< string, std::vector< string > >::const_iterator i;
00077     i = configDataList_.find( pool + key );
00078     if ( i == configDataList_.end() ) {
00079         return "";
00080     }
00081     return i->second[0];
00082 }

bool SflexConfig::isSuccess (    )  const
 

Liefert den Status.

Er wird dann auf 'false' gesetzt, wenn bei den beiden Parsing-Aktionen (Konfigurationsdatei und PATH_INFO) ein Fehler festgestellt wird.

Rückgabe:
den Status
Siehe auch:
parseConfig , parsePath 

00056 {
00057     return isSuccess_;
00058 }

void SflexConfig::parseConfig (  std::string    configFile ) 
 

Parst die Konfigurations-Datei.

Ich hoffe, daß ich jede gängige Art und Weise der Einrückung und Kommentierung unterstütze.

Parameter:
configFile  den Name der Konfigurations Datei (mit Pfad) 

00136 {
00137     using std::string;
00138     using std::map;
00139     using std::vector;
00140     using std::ifstream;
00141         
00142     enum Zustand { START, COMMENT, POOL, SPACEPOOL, 
00143                    KEY, SPACEKEY, ERW, WERT, FEHLER };
00144 
00145     char zeichen;
00146     string err     = "";
00147     string puffer  = "";
00148     int zeile      = 1;
00149     string pool    = "";
00150     string key     = "";
00151     vector< string > values;
00152     map< string, vector< string > > eintrag;
00153     ifstream datei;
00154 
00155     datei.open( configFile.c_str() );
00156     if ( !datei ) {
00157         errorStream_ << "Config: Fehler, die Datei " << configFile
00158                      << " konnte nicht geöffnet werden!\n";
00159         isSuccess_ = false;
00160         return;
00161     }
00162     
00163     Zustand zustand = START;
00164     
00165     while ( !datei.eof() && zustand != FEHLER ) {
00166         datei.get( zeichen );
00167 
00168         switch( zeichen ) {
00169         case '#' :
00170             switch( zustand ) {
00171             case START :
00172                 zustand = COMMENT;
00173                 break;
00174             case WERT :
00175                 if ( puffer.empty() ) {
00176                     if ( !values.empty() ) {
00177                         eintrag[ pool + key ] = values;
00178                     }
00179                     zustand = COMMENT;
00180                     break;
00181                 }
00182                 values.push_back( puffer );
00183                 eintrag[ pool + key ] = values;
00184                 puffer = "";
00185                 zustand = COMMENT;
00186                 break;
00187             case COMMENT :
00188                 break;
00189             default :
00190                 err = "Fehler: Schlüssel ohne Wert, oder # hier nicht erlaubt";
00191                 zustand = FEHLER;
00192                 break;
00193             }
00194             break;
00195         case '[' :
00196             switch( zustand ) {
00197             case START :
00198                 zustand = POOL;
00199                 break;
00200             case COMMENT :
00201                 break;
00202             default :
00203                 err = "Fehler: [ hier nicht erlaubt";
00204                 zustand = FEHLER;
00205                 break;
00206             }
00207             break;
00208         case ']' :
00209             switch( zustand ) {
00210             case POOL:
00211             case SPACEPOOL:
00212                 pool    = puffer;
00213                 puffer  = "";
00214                 zustand = START;
00215                 break;
00216             case COMMENT :
00217                 break;
00218             default :
00219                 err = "Fehler: ] hier nicht erlaubt, oder [ vergessen";
00220                 zustand = FEHLER;
00221                 break;
00222             }
00223             break;
00224         case '=' :
00225             switch( zustand ) {
00226             case SPACEKEY :
00227             case KEY :
00228                 zustand = ERW;
00229                 key     = puffer;
00230                 puffer  = "";
00231                 break;
00232             case COMMENT :
00233                 break;
00234             default :
00235                 err = "Fehler: = hier nicht erlaubt";
00236                 zustand = FEHLER;
00237                 break;
00238             }
00239             break;
00240         case '\n' :
00241             switch( zustand ) {
00242             case WERT :
00243                 if ( !puffer.empty() ) {
00244                     values.push_back( puffer );
00245                     eintrag[ pool + key ] = values;
00246                     zustand = START;
00247                     puffer = "";
00248                     ++zeile;
00249                     values.clear();
00250                     break;
00251                 }
00252                 else if ( !values.empty() ) {
00253                     eintrag[ pool + key ] = values;
00254                     zustand = START;
00255                     ++zeile;
00256                     values.clear();
00257                     break;
00258                 }
00259                 else {
00260                     err = "Fehler: Schlüssel ohne Wert";
00261                     zustand = FEHLER;
00262                     break;
00263                 }
00264                 break;
00265             case START :
00266             case COMMENT :
00267                 ++zeile;
00268                 zustand = START;
00269                 break;
00270             default :
00271                 err = "Fehler: Schlüssel ohne Wert, oder ] vergessen";
00272                 zustand = FEHLER;
00273                 break;
00274             }
00275             break;
00276         case ' ' :
00277             switch( zustand ) {
00278             case KEY :
00279                 zustand = SPACEKEY;
00280                 break;
00281             case POOL :
00282                 zustand = SPACEPOOL;
00283                 break;
00284             case WERT :
00285                 if ( puffer.empty() ) {
00286                     break;
00287                 }
00288                 values.push_back( puffer );
00289                 puffer = "";
00290                 break;
00291             default :
00292                 break;
00293             }
00294             break;
00295           case '\t' :
00296             switch( zustand ) {
00297             case KEY :
00298                 zustand = SPACEKEY;
00299                 break;
00300             case POOL :
00301                 zustand = SPACEPOOL;
00302                 break;
00303             case WERT:
00304                 if ( puffer.empty() ) {
00305                     break;
00306                 }
00307                 values.push_back( puffer );
00308                 puffer = "";
00309                 break;
00310             default :
00311                 break;
00312             }
00313             break;  
00314         default :
00315             switch( zustand ) {
00316             case COMMENT :
00317                 break;
00318             case START :
00319                 puffer  += zeichen;
00320                 zustand = KEY;
00321                 break;
00322             case ERW :
00323                 puffer += zeichen;
00324                 zustand = WERT;
00325                 break;
00326             case SPACEKEY :
00327                 err = "Fehler: Schlüssel nicht eindeutig";
00328                 zustand = FEHLER;
00329                 break;
00330             case SPACEPOOL :
00331                 if ( puffer.empty() ) {
00332                     puffer  += zeichen;
00333                     zustand = POOL;
00334                     break;
00335                 }
00336                 err = "Fehler: Pool nicht eindeutig";
00337                 zustand = FEHLER;
00338                 break;
00339             default :
00340                 puffer += zeichen;
00341                 break;
00342             }
00343             break;
00344         }
00345     }
00346     datei.close();
00347     
00348     if ( zustand == FEHLER ) {
00349         errorStream_ << "Config: " << err 
00350                      << "in Datei: " << configFile
00351                      <<", in Zeile: " << zeile << "!\n";
00352         isSuccess_ = false;
00353         return;
00354     }
00355 
00356     configDataList_ = eintrag;
00357     isSuccess_      = true;
00358     return;
00359 }

void SflexConfig::parsePath (  std::string    pathInfo )  [private]
 

Parst den PATH_INFO String.

Diese Methode verläßt sich dabei auf pruefeZeichen, um nur die Zeichen zuzulassen, die benötigt werden.

Parameter:
pathInfo  den PATH_INFO String
Siehe auch:
pruefeZeichen 

00363 {
00364     using std::string;
00365     using std::vector;
00366     
00367     enum Zustand { START, MODUL, PARAMETER, STYLE, FORMAT, FEHLER };
00368     string puffer = "";
00369     const unsigned int path_ende = pathInfo.length();
00370     string modul, style, format;
00371     vector< string > para;
00372     Zustand zustand = START;
00373     
00374     for ( unsigned int i = 0; i < path_ende; ++i ) {
00375 
00376         if ( !checkChar( pathInfo.at( i ) ) ) {
00377             continue;
00378         }
00379              
00380         switch( pathInfo.at( i ) ) {
00381         case '/' :
00382             switch( zustand ) {
00383             case START :
00384                 if ( i == 0 ) {
00385                     zustand = MODUL;
00386                 }
00387                 else {
00388                     zustand = FEHLER;
00389                 }
00390                 break;
00391             case MODUL :
00392                 if ( puffer.empty() ) {
00393                     zustand = FEHLER;
00394                     break;
00395                 }
00396                 modul = puffer;
00397                 puffer = "";
00398                 zustand = PARAMETER;
00399                 break;
00400             case FEHLER :
00401                 break;
00402             default :
00403                 if ( puffer.empty() ) {
00404                     zustand = FEHLER;
00405                     break;
00406                 }
00407                 para.push_back( puffer );
00408                 puffer = "";
00409                 break;
00410             }
00411             break;
00412         case '.' :
00413             switch( zustand ) {
00414             case PARAMETER :
00415                 if ( puffer.empty() ) {
00416                     zustand = FEHLER;
00417                     break;
00418                 }
00419                 style = puffer;
00420                 puffer = "";
00421                 zustand = STYLE;
00422                 break;
00423             default :
00424                 zustand = FEHLER;
00425                 break;
00426             }
00427             break;
00428         default :
00429             puffer += pathInfo.at( i );
00430             break;
00431         }
00432     }
00433 
00434     switch( zustand ) {
00435     case STYLE :
00436         if ( puffer.empty() ) {
00437             zustand = FEHLER;
00438             break;
00439         }
00440         format  = puffer;
00441         zustand = FORMAT;
00442         break;
00443     case PARAMETER :
00444         if ( para.empty() ) {
00445             style    = "index";
00446             format   = "html";
00447             zustand  = FORMAT;
00448             break;
00449         }
00450         else if ( !para.empty() ) {
00451             style    = "index";
00452             format   = "html";
00453             zustand  = FORMAT;
00454             break;
00455         }
00456         else {
00457             zustand = FEHLER;
00458             break;
00459         }
00460         break;
00461     default :
00462         zustand = FEHLER;
00463         break;
00464     }
00465     
00466     if ( zustand != FORMAT ) {
00467         errorStream_ << "Config: Path " << pathInfo << " falsch!\n";
00468         isSuccess_ = false;
00469         return;
00470     }
00471     para.push_back( style );
00472     para.push_back( format );
00473 
00474     addValue( "sflex", "module", modul );
00475     moduleParameterList_ = para;
00476     isSuccess_ = true;
00477     return;
00478 }

Dokumentation der Datenelemente

std::map< std::string, std::string > SflexConfig::cgiValueList_ [private]
 

die CGI-Werte.

SflexConfig * SflexConfig::config_ = 0 [static, private]
 

Der Zeiger mit der Adresse des Konfigurations-Objektes.

std::map< std::string, std::vector< std::string > > SflexConfig::configDataList_ [private]
 

die Werte aus der Konfigurations Datei.

std::ostringstream SflexConfig::errorStream_ [private]
 

die Fehlermeldung(en).

bool SflexConfig::isSuccess_ [private]
 

der interne Zustand.

std::vector< std::string > SflexConfig::moduleParameterList_ [private]
 

die Parameter des Moduls.

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien:
Erzeugt am Fri Apr 12 10:56:33 2002 für SfleX von doxygen1.2.14 geschrieben von Dimitri van Heesch, © 1997-2002