Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# XFuConfiguration.cpp

Go to the documentation of this file.

    00001 /*! \file
    00002  * X-Forge Util <br>
    00003  * Copyright 2000-2003 Fathammer Ltd
    00004  *
    00005  * \brief XFuConfiguration.cpp is the implementation file for the XFuConfiguration
    00006  * class. For more information, see XFuConfiguration.h
    00007  *
    00008  * $Id: XFuConfiguration.cpp,v 1.19 2003/09/23 13:33:42 toni Exp $
    00009  * $Date: 2003/09/23 13:33:42 $
    00010  * $Revision: 1.19 $
    00011  */
    00012
    00013 #include <xfcore/XFcCore.h>
    00014 #include <xfutil/XFuConfiguration.h>
    00015
    00016
    00017 XFuConfiguration * XFuConfiguration::create()
    00018 {
    00019     return new XFuConfiguration;
    00020 }
    00021
    00022
    00023 XFuConfiguration * XFuConfiguration::create(const CHAR *aFilename)
    00024 {
    00025     XFuConfiguration *config = new XFuConfiguration;
    00026     if (config != NULL)
    00027     {
    00028         if (!config->load(aFilename))
    00029         {
    00030             delete config;
    00031             return NULL;
    00032         }
    00033     }
    00034     return config;
    00035 }
    00036
    00037
    00038 XFuConfiguration * XFuConfiguration::create(XFcFile *aFile)
    00039 {
    00040     XFuConfiguration *config = new XFuConfiguration;
    00041     if (config != NULL)
    00042     {
    00043         if (!config->load(aFile))
    00044         {
    00045             delete config;
    00046             return NULL;
    00047         }
    00048     }
    00049     return config;
    00050 }
    00051
    00052
    00053 XFuConfiguration::XFuConfiguration() : mProperties(NULL)
    00054 {
    00055 }
    00056
    00057
    00058 XFuConfiguration::~XFuConfiguration()
    00059 {
    00060     clear();
    00061 }
    00062
    00063
    00064 CHAR * XFuConfiguration::get(const CHAR *aKey)
    00065 {
    00066     if (mProperties == NULL) return NULL;
    00067     XFcHashtableIterator<XFuStringKey, void *> it = mProperties->find(XFuStringKey(aKey));
    00068     return (it.isValid() ? (CHAR *)it.getValue() : NULL);
    00069 }
    00070
    00071
    00072 INT32 XFuConfiguration::getINT32(const CHAR *aKey)
    00073 {
    00074     CHAR *value = get(aKey);
    00075     if (value == NULL)
    00076         return 0;
    00077     else
    00078         return XFcStringToolkit::toINT32(value);
    00079 }
    00080
    00081
    00082 FLOAT32 XFuConfiguration::getFLOAT32(const CHAR *aKey)
    00083 {
    00084     CHAR *value = get(aKey);
    00085     if (value == NULL)
    00086         return 0;
    00087     else
    00088         return XFcStringToolkit::toFLOAT32(value);
    00089 }
    00090
    00091
    00092 void XFuConfiguration::put(const CHAR *aKey, const CHAR *aValue)
    00093 {
    00094     if (mProperties == NULL || aKey == NULL || aValue == NULL) return;
    00095     CHAR *oldVal = get(aKey);
    00096     if (oldVal != NULL)
    00097     {
    00098         delete[] get(aKey);
    00099         mProperties->remove(XFuStringKey(aKey));
    00100     }
    00101     CHAR *val = XFcStringToolkit::copy(aValue);
    00102     mProperties->put(XFuStringKey(aKey), (void *)val);
    00103 }
    00104
    00105
    00106 void XFuConfiguration::clear()
    00107 {
    00108     if (mProperties != NULL)
    00109     {
    00110         XFcHashtableIterator<XFuStringKey, void *> it;
    00111         for (it = mProperties->begin(); it != mProperties->end(); ++it)
    00112             delete[] (CHAR *)it.getValue();
    00113         delete mProperties;
    00114         mProperties = NULL;
    00115     }
    00116 }
    00117
    00118
    00119 INT XFuConfiguration::load(XFcFile *aFile)
    00120 {
    00121     if (aFile == NULL)
    00122         return 0;
    00123
    00124     if (mProperties == NULL)
    00125         mProperties = new XFcHashtable<XFuStringKey, void *>;
    00126     if (mProperties == NULL)
    00127         return 0;
    00128
    00129     // check length of rest of the file
    00130     INT32 orgFilePos = aFile->tell();
    00131     aFile->seek(0, SEEK_END);
    00132     INT32 fileLen = aFile->tell();
    00133     aFile->seek(orgFilePos, SEEK_SET);
    00134
    00135     // read until end of file
    00136     while (aFile->tell() < fileLen)
    00137     {
    00138         // read a line, covert it to 16 bit and remove leading and trailing white spaces
    00139         CHAR8 *buffer8 = buffer8 = readLine(aFile);
    00140         CHAR *buffer = XFcStringToolkit::copy(buffer8);
    00141         CHAR *trimmedBuffer = strDupTrim(buffer);
    00142
    00143         // parse the line and add the property key and value to the property hashtable
    00144         processLine(trimmedBuffer);
    00145
    00146         delete[] trimmedBuffer;
    00147         delete[] buffer;
    00148         delete[] buffer8;
    00149     }
    00150
    00151     return 1;
    00152 }
    00153
    00154
    00155 INT XFuConfiguration::load(const CHAR *aFilename)
    00156 {
    00157     XFcFile *file = XFcFile::open(aFilename, XFCSTR("rb"));
    00158     if (file == NULL)
    00159         return 0;
    00160
    00161     INT result = load(file);
    00162
    00163     file->close();
    00164
    00165     return result;
    00166 }
    00167
    00168
    00169 void XFuConfiguration::processLine(const CHAR *aStr)
    00170 {
    00171     // valid property definition?
    00172     INT32 len = XFcStringToolkit::getLength(aStr);
    00173     if (len > 0 && aStr[0] != '#')
    00174     {
    00175
    00176         // find the first = char
    00177         INT32 valStart = 0;
    00178         while (valStart < len && aStr[valStart] != '=') valStart++;
    00179
    00180         if (valStart != len && valStart != 0)
    00181         {
    00182
    00183             INT32 i, p;
    00184
    00185             CHAR * key = new CHAR[valStart + 1];
    00186
    00187             p = 0;
    00188             for (i = 0; i < valStart; i++) key[p++] = aStr[i];
    00189             // find last non white space char of the key
    00190             do --p; while (key[p] == ' ' || key[p] == '\t');
    00191             key[p + 1] = '\0';
    00192
    00193             // find first non white space char of the value
    00194             do valStart++; while (aStr[valStart] == ' ' || aStr[valStart] == '\t');
    00195
    00196             CHAR * val = new CHAR[len - valStart + 1];
    00197
    00198             p = 0;
    00199             for (i = valStart; i < len; i++) val[p++] = aStr[i];
    00200             val[p] = '\0';
    00201
    00202             put(key, val);
    00203
    00204             delete[] key;
    00205             delete[] val;
    00206
    00207         }
    00208
    00209     }
    00210 }
    00211
    00212
    00213 CHAR * XFuConfiguration::strDupTrim(const CHAR *aStr)
    00214 {
    00215     INT32 len = XFcStringToolkit::getLength(aStr);
    00216
    00217     // find first non white space char
    00218     INT32 start = 0;
    00219     while (start < len && (aStr[start] == ' ' || aStr[start] == '\t'))
    00220         start++;
    00221
    00222     // find last non white space char
    00223     INT32 end = len - 1;
    00224     while (end >= 0 && (aStr[end] == ' ' || aStr[end] == '\t'))
    00225         end--;
    00226
    00227     CHAR *buf;
    00228     INT32 p = 0;
    00229     if (end == -1)
    00230     {
    00231         // only spaces so the result is an empty string
    00232         buf = new CHAR[1];
    00233     }
    00234     else
    00235     {
    00236         // copy the chars between the first and the last white space
    00237         buf = new CHAR[end - start + 2];
    00238         INT32 i;
    00239         for (i = start; i <= end; i++) buf[p++] = aStr[i];
    00240     }
    00241
    00242     buf[p] = '\0';
    00243     return buf;
    00244 }
    00245
    00246
    00247 CHAR8 * XFuConfiguration::readLine(XFcFile *aFile)
    00248 {
    00249     INT32 currentPos = aFile->tell();
    00250
    00251     INT32 count = 0;
    00252     CHAR8 c = 0;
    00253
    00254     // find end of line
    00255     while (c != 10)
    00256     {
    00257         if (aFile->read(&c, sizeof(CHAR8), 1) == 0) break;
    00258         count++;
    00259     }
    00260
    00261     aFile->seek(currentPos, SEEK_SET);
    00262
    00263     // read until end of line
    00264     CHAR8 *buffer = new CHAR8[count + 1];
    00265     if (count > 0) aFile->read(buffer, sizeof(CHAR8), count);
    00266
    00267     buffer[count] = '\0';
    00268
    00269     // remove trailing CR and LF
    00270     if (count >= 1 && buffer[count - 1] == 10) buffer[count - 1] = '\0';
    00271     if (count >= 2 && buffer[count - 2] == 13) buffer[count - 2] = '\0';
    00272
    00273     return buffer;
    00274 }
    00275

|  | X-Forge Documentation Confidential Copyright © 2002-2003 Fathammer |  | Documentation generated with doxygen by Dimitri van Heesch