Remove the debug output of the ConfigCache

1 files changed, 0 insertions, 1 deletions

diff --git a/library/config.cpp b/library/config.cpp
index e9cae4c..72bd4d2 100644
--- a/library/config.cpp
+++ b/library/config.cpp
@@ -1,342 +1,341 @@
 /**********************************************************************
 ** Copyright (C) 2000,2004 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qdir.h>
 #include <qmessagebox.h>
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include <qtextcodec.h>
 #endif
 #include <qtextstream.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <time.h>
 #include <unistd.h>
 
 #define QTOPIA_INTERNAL_LANGLIST
 #include "config.h"
 #include "global.h"
 #include "qpeapplication.h"
 
 
 /*
  * Internal Class
  */
 class ConfigPrivate {
 public:
     ConfigPrivate() : multilang(FALSE) {}
     ConfigPrivate(const ConfigPrivate& o) :
         trfile(o.trfile),
         trcontext(o.trcontext),
         multilang(o.multilang)
     {}
     ConfigPrivate& operator=(const ConfigPrivate& o)
     {
         trfile = o.trfile;
         trcontext = o.trcontext;
         multilang = o.multilang;
         return *this;
     }
 
     QString trfile;
     QCString trcontext;
     bool multilang;
 };
 
 /////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////
 
 #ifndef Q_OS_WIN32
 
 //#define DEBUG_CONFIG_CACHE
 class ConfigData
 {
 public:
     ConfigData() {}
     ConfigData( const ConfigGroupMap& cf, const ConfigPrivate& pri,
                 struct stat sbuf )
         : cfg( cf ), priv( pri ), mtime( sbuf.st_mtime ),
           size( sbuf.st_size )
         {
             gettimeofday(&used, 0 );
         }
 
     ConfigGroupMap cfg;
     ConfigPrivate priv; // Owned by this object
     time_t mtime;
     unsigned int size;
     struct timeval used;
 };
 
 
 class ConfigCache : public QObject {
 public:
     static ConfigCache* instance();
 
     void insert( const QString& fileName, const ConfigGroupMap& cfg,
                  const ConfigPrivate *priv );
     bool find(const QString& fileName, ConfigGroupMap& cfg,
               ConfigPrivate** priv );
 protected:
     void timerEvent( QTimerEvent* );
 
 private:
     ConfigCache();
     void remove( const QString& fileName );
     void removeLru();
 
 private:
     QMap<QString, ConfigData> m_cached;
     unsigned int m_totalSize;
     int m_tid;
 private:
     static ConfigCache* m_inst;
     static const unsigned int CONFIG_CACHE_SIZE = 8192;
     static const unsigned int CONFIG_CACHE_TIMEOUT = 1000;
 };
 
 ConfigCache* ConfigCache::m_inst = 0;
 /*
  * get destroyed when qApp gets destroyed
  */
 ConfigCache::ConfigCache() : QObject( qApp ), m_totalSize( 0 ), m_tid( 0 ) {}
 ConfigCache* ConfigCache::instance() {
     if ( !m_inst )
         m_inst = new ConfigCache();
 
     return m_inst;
 }
 
 void ConfigCache::remove( const QString& fileName ) {
     QMap<QString, ConfigData>::Iterator it = m_cached.find( fileName );
 
     if ( it == m_cached.end() )
         return;
 
     m_totalSize -= (*it).size;
     m_cached.remove( it );
 }
 
 void ConfigCache::removeLru() {
     QMap<QString, ConfigData>::Iterator it  = m_cached.begin();
     QMap<QString, ConfigData>::Iterator lru = it;
     ++it;
     for (; it != m_cached.end(); ++it)
         if ((*it).used.tv_sec < (*lru).used.tv_sec ||
             ((*it).used.tv_sec == (*lru).used.tv_sec &&
              (*it).used.tv_usec < (*lru).used.tv_usec))
             lru = it;
 
-    qWarning( "Removing item" );
     m_totalSize -= (*lru).size;
     m_cached.remove(lru);
 }
 
 void ConfigCache::timerEvent( QTimerEvent* ) {
     while ( m_totalSize > CONFIG_CACHE_SIZE )
         removeLru();
 
     killTimer(m_tid);
     m_tid = 0;
 }
 
 void ConfigCache::insert( const QString& fileName, const ConfigGroupMap& cfg,
                           const ConfigPrivate* _priv ) {
 
 
     struct stat sbuf;
     ::stat( QFile::encodeName(fileName), &sbuf );
     if ( static_cast<unsigned int>(sbuf.st_size) >= CONFIG_CACHE_SIZE>>1)
         return;
 
     /*
      * remove the old version and use the new one
      */
     ConfigPrivate priv = _priv ? *_priv : ConfigPrivate();
     ConfigData data( cfg, priv, sbuf );
     m_totalSize += data.size;
 
     remove( fileName );
     m_cached.insert( fileName, data );
 
     /*
      * we've overcommited allocation, let us clean up
      * soon
      */
     if ( m_totalSize >= CONFIG_CACHE_SIZE )
         if ( !m_tid )
             m_tid = startTimer(CONFIG_CACHE_TIMEOUT);
 }
 
 bool ConfigCache::find( const QString& fileName, ConfigGroupMap& cfg,
                         ConfigPrivate **ppriv ) {
     QMap<QString, ConfigData>::Iterator it = m_cached.find(fileName);
     if (it != m_cached.end()) {
         ConfigData &data = *it;
         struct stat sbuf;
         ::stat(QFile::encodeName( fileName ), &sbuf);
 
         if (data.mtime == sbuf.st_mtime && (int)data.size == sbuf.st_size) {
             cfg = data.cfg;
 
             /*
              * null pointer
              */
             if ( *ppriv == 0 )
                 *ppriv = new ConfigPrivate( data.priv );
             **ppriv = data.priv;
             gettimeofday(&data.used, 0);
 
             return true;
         }
     }
 
     return false;
 }
 
 #endif
 
 
 /*!
   \internal
 */
 QString Config::configFilename(const QString& name, Domain d)
 {
     switch (d) {
     case File:
         return name;
     case User: {
         QDir dir = (QString(getenv("HOME")) + "/Settings");
         if ( !dir.exists() )
             mkdir(dir.path().local8Bit(),0700);
         return dir.path() + "/" + name + ".conf";
     }
     }
     return name;
 }
 
 /* This cannot be made public because of binary compat issues */
 void Config::read( QTextStream &s )
 {
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
     // The below should work, but doesn't in Qt 2.3.0
     s.setCodec( QTextCodec::codecForMib( 106 ) );
 #else
     s.setEncoding( QTextStream::UnicodeUTF8 );
 #endif
 
     QStringList list = QStringList::split('\n', s.read() );
 
     for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
         if ( !parse( *it ) ) {
             git = groups.end();
             return;
         }
     }
 }
 
 /*!
   \class Config config.h
   \brief The Config class provides for saving application cofniguration state.
 
   You should keep a Config in existence only while you do not want others
   to be able to change the state. There is no locking currently, but there
   may be in the future.
 */
 
 /*!
   \enum Config::ConfigGroup
   \internal
 */
 
 /*!
   \enum Config::Domain
 
   \value File
   \value User
 
   See Config for details.
 */
 
 /*!
   Constructs a config that will load or create a configuration with the
   given \a name in the given \a domain.
 
   You must call setGroup() before doing much else with the Config.
 
   In the default Domain, \e User,
   the configuration is user-specific. \a name should not contain "/" in
   this case, and in general should be the name of the C++ class that is
   primarily responsible for maintaining the configuration.
 
   In the File Domain, \a name is an absolute filename.
 */
 Config::Config( const QString &name, Domain domain )
     : filename( configFilename(name,domain) )
 {
     git = groups.end();
     d = 0;
     read();
 }
 
 
 // Sharp ROM compatibility
 Config::Config ( const QString &name, bool what )
 	: filename( configFilename(name,what ? User : File) )
 {
     git = groups.end();
     d = 0;
     read();
 }
 
 /*!
   Writes any changes to disk and destroys the in-memory object.
 */
 Config::~Config()
 {
     if ( changed )
         write();
 
     delete d;
 }
 
 /*!
   Returns whether the current group has an entry called \a key.
 */
 bool Config::hasKey( const QString &key ) const
 {
     if ( groups.end() == git )
 	return FALSE;
     ConfigGroup::ConstIterator it = ( *git ).find( key );
     if ( it == ( *git ).end() ) {
         if ( d && !d->trcontext.isNull() ) {
             it = ( *git ).find( key + "[]" );
         } else if ( d && d->multilang ) {
             it = ( *git ).find( key + "["+lang+"]" );
             if ( it == ( *git ).end() && !glang.isEmpty() )
                 it = ( *git ).find( key + "["+glang+"]" );
         }
     }
     return it != ( *git ).end();
 }