Move XML class to internal PIM

Add namespaces!!!

Opie::Core and Opie::Core::Private
Opie::Net  and Opie::Net::Private
Opie::Ui   and Opie::Ui::Private
Opie::MM   and Opie::MM::Private
Opie::DB   and Opie::DB::Private

PIM classes are not yet converted because we will do other work
on it as well

20 files changed, 95 insertions, 6 deletions

diff --git a/libopie2/opiedb/TODO b/libopie2/opiedb/TODO
index ca04ac6..8b86187 100644
--- a/libopie2/opiedb/TODO
+++ b/libopie2/opiedb/TODO
@@ -1,9 +1,10 @@
 * something like Capabilities of a Driver
   - ROWID
   - How to declare INTEGER PRIMARY KEY
   - Abstract from implementation of some dbs
   - provides( Type::What )
+  - emit signals directly on arriving of data
   
  * OSQLDriver DriverVersion - DatabaseVersion
  * Better OSQLQueries
    - more than OSQLRawQuery
\ No newline at end of file
diff --git a/libopie2/opiedb/opiedb.pro b/libopie2/opiedb/opiedb.pro
index c773d6c..147435a 100644
--- a/libopie2/opiedb/opiedb.pro
+++ b/libopie2/opiedb/opiedb.pro
@@ -8,29 +8,29 @@ HEADERS     = osqlbackend.h    \
               osqlquery.h      \
               osqlresult.h     \
               osqltable.h      \
               osqlbackendmanager.h \
               osqlitedriver.h
 SOURCES     = osqlbackend.cpp   \
               osqldriver.cpp   \
               osqlerror.cpp    \
               osqlmanager.cpp  \
               osqlquery.cpp    \
               osqlresult.cpp   \
               osqltable.cpp    \
               osqlbackendmanager.cpp \
               osqlitedriver.cpp
 INTERFACES  =
 TARGET      = opiedb2
-VERSION     = 1.8.2
+VERSION     = 1.9.0
 INCLUDEPATH = $(OPIEDIR)/include
 DEPENDPATH  = $(OPIEDIR)/include
 LIBS       += -lopiecore2 -lqpe -lsqlite
 
 !contains( platform, x11 ) {
   include ( $(OPIEDIR)/include.pro )
 }
 
 contains( platform, x11 ) {
   LIBS        += -L$(OPIEDIR)/lib -Wl,-rpath,$(OPIEDIR)/lib
 }
 
diff --git a/libopie2/opiedb/osqlbackend.cpp b/libopie2/opiedb/osqlbackend.cpp
index d6c39a9..6e5159f 100644
--- a/libopie2/opiedb/osqlbackend.cpp
+++ b/libopie2/opiedb/osqlbackend.cpp
@@ -1,19 +1,21 @@
 
 #include "osqlbackend.h"
 
+using namespace Opie::DB;
+
 
 OSQLBackEnd::OSQLBackEnd( const QString& name,
                           const QString& vendor,
                           const QString& license,
                           const QCString& lib )
     : m_name( name), m_vendor( vendor),  m_license( license ), m_lib( lib )
 {
     m_default = false;
     m_pref = -1;
 }
 OSQLBackEnd::OSQLBackEnd( const OSQLBackEnd& back ) {
     (*this) = back;
 }
 OSQLBackEnd::~OSQLBackEnd() {
 }
 bool OSQLBackEnd::operator==( const OSQLBackEnd& other ) {
diff --git a/libopie2/opiedb/osqlbackend.h b/libopie2/opiedb/osqlbackend.h
index ad879a4..28451b6 100644
--- a/libopie2/opiedb/osqlbackend.h
+++ b/libopie2/opiedb/osqlbackend.h
@@ -1,24 +1,27 @@
 
 #ifndef OSQL_BACKEND_H
 #define OSQL_BACKEND_H
 
 #include <qcstring.h>
 #include <qstring.h>
 #include <qvaluelist.h>
 
+
+namespace Opie {
+namespace DB {
 /**
  * OSQLBackEnd represents an available backend
  * to the Opie Database Service
  * It's used to easily extend OSQL services by
  * 3rd party plugins.
  * It's used to show
  */
 class OSQLBackEnd  /*: public QShared */ {
 public:
     typedef QValueList<OSQLBackEnd> ValueList;
     /**
      * A basic c'tor
      * @param name the user visible name of the service
      * @param vendor the vendor of the service
      * @param license the license of the service
      * @param library what is the name of lib if builtin it's builtin
@@ -57,19 +60,24 @@ public:
     /** @param license the license applied */
     void setLicense( const QString& license );
 
     /** @param the lib to set */
     void setLibrary( const QCString& lib );
 
     void setDefault( bool );
     void setPreference( int );
 
 private:
     QString m_name;
     QString m_vendor;
     QString m_license;
     QCString m_lib;
     bool m_default :1;
     int m_pref;
+    class Private;
+    Private *d;
 };
 
+}
+}
+
 #endif
diff --git a/libopie2/opiedb/osqlbackendmanager.cpp b/libopie2/opiedb/osqlbackendmanager.cpp
index 95ed77b..fc18e07 100644
--- a/libopie2/opiedb/osqlbackendmanager.cpp
+++ b/libopie2/opiedb/osqlbackendmanager.cpp
@@ -1,21 +1,25 @@
 #include <qdir.h>
 #include <qmap.h>
 
 #include "osqlbackendmanager.h"
 
+/**
+ * \todo FIXME CONFIG!!!
+ */
+
 namespace {
     class Config {
         typedef QMap<QString, QString> List;
     public:
         Config( const QString& fileName );
         /**
          * Quite simple layout in nature
          * BeginFile
          * Key = Value
          */
         bool load();
         QString value( const QString& key );
     private:
         List m_list;
         QString m_fileName;
     };
@@ -31,32 +35,36 @@ namespace {
             return false;
         QStringList list = QStringList::split( '\n', file.readAll() );
         QStringList::Iterator it;
         QString line;
         for (it =  list.begin(); it != list.end(); ++it ) {
             line = (*it).stripWhiteSpace();
             qWarning("Anonymous::Config:" + line );
             QStringList test = QStringList::split(' ', line );
             m_list.insert( test[0], test[2] );
         }
         return true;
     }
     QString Config::value( const QString& key ) {
         return m_list[key];
     }
 };
+
+
+using namespace Opie::DB;
+
 OSQLBackEndManager::OSQLBackEndManager( const QStringList& path )
     :m_path( path )
 {
 }
 OSQLBackEndManager::~OSQLBackEndManager() {
 }
 /**
  * scan dirs
  */
 OSQLBackEnd::ValueList OSQLBackEndManager::scan() {
     OSQLBackEnd::ValueList list;
     if (!m_path.isEmpty() ) {
         QStringList::Iterator it;
         for ( it = m_path.begin(); it != m_path.end(); ++it ) {
             list += scanDir( (*it) );
         }
diff --git a/libopie2/opiedb/osqlbackendmanager.h b/libopie2/opiedb/osqlbackendmanager.h
index bc357a9..00e81fc 100644
--- a/libopie2/opiedb/osqlbackendmanager.h
+++ b/libopie2/opiedb/osqlbackendmanager.h
@@ -1,20 +1,26 @@
 #ifndef OSQL_BACKEND_MANAGER_H
 #define OSQL_BACKEND_MANAGER_H
 
 #include <qstringlist.h>
 
 #include "osqlbackend.h"
 
+namespace Opie {
+namespace DB {
+
 class OSQLBackEndManager {
 public:
     OSQLBackEndManager(const QStringList& path );
     ~OSQLBackEndManager();
     OSQLBackEnd::ValueList scan();
 private:
     OSQLBackEnd::ValueList scanDir( const QString& dir );
     OSQLBackEnd file2backend( const QString& file );
     class OSQLBackEndManagerPrivate;
     OSQLBackEndManagerPrivate* d;
     QStringList m_path;
 };
+}
+}
+
 #endif
diff --git a/libopie2/opiedb/osqldriver.cpp b/libopie2/opiedb/osqldriver.cpp
index 258c116..a6dae77 100644
--- a/libopie2/opiedb/osqldriver.cpp
+++ b/libopie2/opiedb/osqldriver.cpp
@@ -1,13 +1,15 @@
 #include <qpe/qlibrary.h>
 
 #include "osqldriver.h"
 
+using namespace Opie::DB;
+
 OSQLDriver::OSQLDriver( QLibrary* lib )
 : QObject(), m_lib(lib) {
 }
 OSQLDriver::~OSQLDriver() {
     delete m_lib;
 }
 bool OSQLDriver::sync() {
     return true;
 }
diff --git a/libopie2/opiedb/osqldriver.h b/libopie2/opiedb/osqldriver.h
index 68d8ee6..492b8dd 100644
--- a/libopie2/opiedb/osqldriver.h
+++ b/libopie2/opiedb/osqldriver.h
@@ -1,25 +1,29 @@
 #ifndef OSQL_DRIVER_H
 #define OSQL_DRIVER_H
 
 #include <qobject.h>
 #include <qstring.h>
 
 #include "osqltable.h"
 
 class QLibrary;
+
+namespace Opie {
+namespace DB {
+
 class OSQLResult;
 class OSQLQuery;
 class OSQLError;
 
 /**
  * A OSQLDriver implements the communication with
  * a database.
  * After you queried and loaded a driver you can
  * set some informations and finally try to open
  * the database
  *
  */
 class OSQLDriver : public QObject{
     Q_OBJECT
 public:
     enum Capabilities { RowID=0 };
@@ -71,17 +75,20 @@ public:
     virtual OSQLResult query( OSQLQuery* ) = 0;
 
     /**
      * Get a list of tables
      */
     virtual OSQLTable::ValueList tables() const = 0l;
     virtual bool sync();
 
 
 private:
     QLibrary* m_lib;
     class OSQLDriverPrivate;
     OSQLDriverPrivate *d;
 
 };
 
+}
+}
+
 #endif
diff --git a/libopie2/opiedb/osqlerror.cpp b/libopie2/opiedb/osqlerror.cpp
index 3890a50..165ba65 100644
--- a/libopie2/opiedb/osqlerror.cpp
+++ b/libopie2/opiedb/osqlerror.cpp
@@ -1,18 +1,20 @@
 #include "osqlerror.h"
 
+using namespace Opie::DB;
+
 OSQLError::OSQLError( const QString& driverText,
                       const QString& driverDatabaseText,
                       int type, int subType )
     : m_drvText( driverText ), m_drvDBText( driverDatabaseText ),
       m_type( type ), m_number( subType )
 {
 }
 OSQLError::~OSQLError() {
 }
 QString OSQLError::driverText()const {
     return m_drvText;
 }
 QString OSQLError::databaseText()const {
     return m_drvDBText;
 }
 int OSQLError::type()const {
diff --git a/libopie2/opiedb/osqlerror.h b/libopie2/opiedb/osqlerror.h
index 35a4368..8fa973d 100644
--- a/libopie2/opiedb/osqlerror.h
+++ b/libopie2/opiedb/osqlerror.h
@@ -1,22 +1,25 @@
 #ifndef OSQL_ERROR_H
 #define OSQL_ERROR_H
 
 #include <qstring.h>
 #include <qvaluelist.h>
 
+
+namespace Opie {
+namespace DB {
 /**
  * OSQLError is the base class of all errors
  */
 class OSQLError {
 public:
     typedef QValueList<OSQLError> ValueList;
     enum Type { None = 0, // NoError
                 Internal, // Internal Error in OSQL
                 Unknown, // Unknown Error
                 Transaction, // Transaction Error
                 Statement, // Wrong Statement
                 Connection, // Connection Error( lost )
                 Driver // Driver Specefic error
     };
     enum DriverError {
         DriverInternal=0, // internal DriverError
@@ -43,17 +46,19 @@ public:
                int type = None, int subNumber = -1 );
     ~OSQLError();
 
     QString driverText()const;
     QString databaseText()const;
     int type()const;
     int subNumber()const;
 private:
     QString m_drvText;
     QString m_drvDBText;
     int m_type;
     int m_number;
     class OSQLErrorPrivate;
     OSQLErrorPrivate* d;
 };
 
+}
+}
 #endif
diff --git a/libopie2/opiedb/osqlitedriver.cpp b/libopie2/opiedb/osqlitedriver.cpp
index 6141504..47bc250 100644
--- a/libopie2/opiedb/osqlitedriver.cpp
+++ b/libopie2/opiedb/osqlitedriver.cpp
@@ -27,32 +27,35 @@
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "osqlquery.h"
 #include "osqlitedriver.h"
 
 #include <opie2/odebug.h>
 
 #include <stdlib.h>
 
 // fromLocal8Bit() does not work as expected. Thus it
 // is replaced by fromLatin1() (eilers)
 #define __BUGGY_LOCAL8BIT_
 
 
+using namespace Opie::DB;
+using namespace Opie::DB::Private;
+
 namespace {
     struct Query {
         OSQLError::ValueList errors;
         OSQLResultItem::ValueList items;
         OSQLiteDriver *driver;
     };
 }
 
 
 OSQLiteDriver::OSQLiteDriver( QLibrary *lib )
     : OSQLDriver( lib )
 {
     m_sqlite = 0l;
 }
 
 
@@ -73,73 +76,73 @@ void OSQLiteDriver::setPassword( const QString& ) {}
 
 void OSQLiteDriver::setUrl( const QString& url ) {
     m_url = url;
 }
 
 
 void OSQLiteDriver::setOptions( const QStringList& ) {
 }
 
 
 /*
  * try to open a db specified via setUrl
  * and options
  */
 bool OSQLiteDriver::open() {
     char *error;
-    odebug << "OSQLiteDriver::open: about to open" << oendl;
+    qDebug("OSQLiteDriver::open: about to open");
     m_sqlite = sqlite_open(m_url.local8Bit(),
                            0,
                            &error );
 
     /* failed to open */
     if (m_sqlite == 0l ) {
         // FIXME set the last error
-        owarn << "OSQLiteDriver::open: " << error << oendl;
+        qWarning("OSQLiteDriver::open: %s", error );
         free( error );
         return false;
     }
     return true;
 }
 
 
 /* close the db
  * sqlite closes them without
  * telling failure or success
  */
 bool OSQLiteDriver::close() {
     if (m_sqlite )
         sqlite_close( m_sqlite ), m_sqlite=0l;
 
     return true;
 }
 
 
 /* Query */
 OSQLResult OSQLiteDriver::query( OSQLQuery* qu) {
     if ( !m_sqlite ) {
         // FIXME set error code
         OSQLResult result( OSQLResult::Failure );
         return result;
     }
     Query query;
     query.driver = this;
     char *err;
     /* SQLITE_OK 0 if return code > 0 == failure */
     if ( sqlite_exec(m_sqlite, qu->query(),&call_back, &query, &err)  > 0 ) {
-        owarn << "OSQLiteDriver::query: Error while executing" << oendl;
+        qWarning("OSQLiteDriver::query: Error while executing");
         free(err );
         // FixMe Errors
     }
 
     OSQLResult result(OSQLResult::Success,
                       query.items,
                       query.errors );
     return result;
 }
 
 
 OSQLTable::ValueList OSQLiteDriver::tables() const {
 
 }
 
 
diff --git a/libopie2/opiedb/osqlitedriver.h b/libopie2/opiedb/osqlitedriver.h
index 6984539..3e1325b 100644
--- a/libopie2/opiedb/osqlitedriver.h
+++ b/libopie2/opiedb/osqlitedriver.h
@@ -1,34 +1,42 @@
 #ifndef OSQL_LITE_DRIVER_H
 #define OSQL_LITE_DRIVER_H
 
 #include <sqlite.h>
 
 #include "osqldriver.h"
 #include "osqlerror.h"
 #include "osqlresult.h"
 
+namespace Opie {
+namespace DB {
+namespace Private {
+
 class OSQLiteDriver : public OSQLDriver {
     Q_OBJECT
 public:
     OSQLiteDriver( QLibrary *lib = 0l );
     ~OSQLiteDriver();
     QString id()const;
     void setUserName( const QString& );
     void setPassword( const QString& );
     void setUrl( const QString& url );
     void setOptions( const QStringList& );
     bool open();
     bool close();
     OSQLError lastError();
     OSQLResult query( OSQLQuery* );
     OSQLTable::ValueList tables()const;
 private:
     OSQLError m_lastE;
     OSQLResult m_result;
     OSQLResultItem m_items;
     int handleCallBack( int, char**, char** );
     static int call_back( void*, int, char**, char** );
     QString m_url;
     sqlite *m_sqlite;
 };
+}
+}
+}
+
 #endif
diff --git a/libopie2/opiedb/osqlmanager.cpp b/libopie2/opiedb/osqlmanager.cpp
index 766ebe1..990d258 100644
--- a/libopie2/opiedb/osqlmanager.cpp
+++ b/libopie2/opiedb/osqlmanager.cpp
@@ -1,61 +1,63 @@
 
 #include <stdlib.h>
 
 #include "osqlmanager.h"
 #include "osqlbackendmanager.h"
 #include "osqlitedriver.h"
 
+using namespace Opie::DB;
+
 OSQLManager::OSQLManager() {
 }
 OSQLBackEnd::ValueList OSQLManager::queryBackEnd() {
     m_list.clear();
     QString opie = QString::fromLatin1( getenv("OPIEDIR") );
     QString qpe = QString::fromLatin1( getenv("QPEDIR") );
 
     if ( !m_path.contains(opie) && !opie.isEmpty() )
         m_path << opie;
     if ( !m_path.contains(qpe) && !qpe.isEmpty() )
         m_path << qpe;
 
     OSQLBackEndManager mng( m_path );
     m_list = mng.scan();
     m_list += builtIn();
 
     return m_list;
 }
 /*
  * loading dso's is currently not enabled due problems with QLibrary
  * beeing in libqpe and not libqte
  */
 OSQLDriver* OSQLManager::load( const QString& name ) {
     OSQLDriver* driver = 0l;
 
     if ( name == "SQLite" ) {
-        driver = new OSQLiteDriver();
+        driver = new Opie::DB::Private::OSQLiteDriver;
     }
     return driver;
 }
 /*
  * same as above
  */
 OSQLDriver* OSQLManager::load( const OSQLBackEnd& end) {
     OSQLDriver *driver = 0l;
     if ( end.library() == "builtin" &&
          end.name() == "SQLite" )
-        driver = new OSQLiteDriver();
+        driver = new Opie::DB::Private::OSQLiteDriver;
 
     return driver;
 }
 /*
  * let's find the a default with the highes preference
  */
 OSQLDriver* OSQLManager::standard() {
     OSQLDriver* driver =0l;
     if ( m_list.isEmpty() ) queryBackEnd();
     OSQLBackEnd::ValueList::Iterator it;
     OSQLBackEnd back;
     for ( it = m_list.begin(); it != m_list.end(); ++it ) {
         if ( (*it).isDefault() &&
              back.preference() < (*it).preference() ) {
             back = (*it);
         }
diff --git a/libopie2/opiedb/osqlmanager.h b/libopie2/opiedb/osqlmanager.h
index 5323b14..ca73c64 100644
--- a/libopie2/opiedb/osqlmanager.h
+++ b/libopie2/opiedb/osqlmanager.h
@@ -1,26 +1,28 @@
 
 #ifndef OSQL_MANAGER_H
 #define OSQL_MANAGER_H
 
 #include <qobject.h>
 #include <qstringlist.h>
 
 #include "osqlbackend.h"
 
 
+namespace Opie {
+namespace DB {
 /**
  * OSQLManager is responsible for loading
  * and unloading, querying different OSQL
  * services
  * Load a OSQLDriver and delete it yourself
  *
  */
 class OSQLDriver;
 class OSQLManager : public QObject {
     Q_OBJECT
 public:
     /**
      * Empty c'tor
      */
     OSQLManager();
 
@@ -46,19 +48,23 @@ public:
 
     /**
      * register path to the search path list
      * When querying for services we scan all the
      * registered path for backends
      */
     void registerPath( const QString& path );
 
     /**
      * unregisterPath from the search path list
      */
     bool unregisterPath( const QString& path );
 private:
     OSQLBackEnd::ValueList builtIn()const;
     OSQLBackEnd::ValueList m_list;
     QStringList m_path;
+    class Private;
+    Private *d;
 };
+}
+}
 
 #endif
diff --git a/libopie2/opiedb/osqlquery.cpp b/libopie2/opiedb/osqlquery.cpp
index ecd53f2..8270c4c 100644
--- a/libopie2/opiedb/osqlquery.cpp
+++ b/libopie2/opiedb/osqlquery.cpp
@@ -1,17 +1,19 @@
 
 #include "osqlquery.h"
 
+using namespace Opie::DB;
+
 OSQLQuery::OSQLQuery() {
 }
 OSQLQuery::~OSQLQuery() {
 }
 
 OSQLRawQuery::OSQLRawQuery(const QString& query)
     : OSQLQuery(), m_query( query ) {
 
 }
 OSQLRawQuery::~OSQLRawQuery() {
 }
 QString OSQLRawQuery::query()const {
     return m_query;
 }
diff --git a/libopie2/opiedb/osqlquery.h b/libopie2/opiedb/osqlquery.h
index 63c26b0..0265d2b 100644
--- a/libopie2/opiedb/osqlquery.h
+++ b/libopie2/opiedb/osqlquery.h
@@ -1,25 +1,28 @@
 
 #ifndef OSQL_QUERY_H
 #define OSQL_QUERY_H
 
 #include <qmap.h>
 #include <qvaluelist.h>
 #include <qstring.h>
 
 
+namespace Opie {
+namespace DB {
+
 /** I'm not happy with them
 class OSQLQueryOrder {
 public:
     typedef QValueList<OSQLQueryOrder> ValueList;
     OSQLQueryOrder(const QString& table = QString::null );
     OSQLQueryOrder( const OSQLQueryOrder& );
     ~OSQLQueryOrder();
     void setOrderFields( const QStringList& list );
     void setValue( const QString& fieldName, const QString& Value );
     void setValues( const QMap<QString, QString>& );
     QMap<QString, QString> orders() const;
     QString orderStatement()const;
     OSQLQueryOrder &operator=(const OSQLQueryOrder& );
 private:
     QMap<QString, QString> m_fields;
     class OSQLQueryOrderPrivate;
@@ -34,32 +37,35 @@ public:
     ~OSQLWhere();
     void setExpression(const QString& key, enum Vergleiche, const QString& );
     QString statement()const;
 private:
     int m_vergleich;
     const QString& m_left;
     const QString& m_right;
 
 };
 */
 class OSQLQuery {
 public:
     OSQLQuery();
     virtual ~OSQLQuery();
 
     virtual QString query()const = 0;
+private:
+    class Private;
+    Private *d;    
 };
 
 class OSQLRawQuery : public OSQLQuery {
 public:
     OSQLRawQuery( const QString& query );
     ~OSQLRawQuery();
     QString query() const;
 private:
     class OSQLRawQueryPrivate;
     OSQLRawQueryPrivate* d;
     QString m_query;
 
 };
 /* I'm not happy with them again
 class OSQLSelectQuery : public OSQLQuery {
 public:
@@ -106,17 +112,19 @@ private:
 
 };
 class OSQLUpdateQuery : public OSQLQuery {
 public:
     OSQLUpdateQuery( const QString& table );
     ~OSQLUpdateQuery();
     void setWhere( const OSQLWhere& );
     void setWheres( const OSQLWhere::ValueList& );
     */
     /* replaces all previous set Values */
     /*
     void setValue( const QString& field, const QString& value );
     void setValue( const QMap<QString, QString> &fields );
     QString query() const;
 };
 */
+}
+}
 #endif
diff --git a/libopie2/opiedb/osqlresult.cpp b/libopie2/opiedb/osqlresult.cpp
index 42da356..bad7d8b 100644
--- a/libopie2/opiedb/osqlresult.cpp
+++ b/libopie2/opiedb/osqlresult.cpp
@@ -1,19 +1,21 @@
 
 #include "osqlresult.h"
 
+using namespace Opie::DB;
+
 OSQLResultItem::OSQLResultItem( const TableString& string,
                                 const TableInt& Int)
     : m_string( string ), m_int( Int )
 {
 
 }
 OSQLResultItem::~OSQLResultItem() {
 }
 OSQLResultItem::OSQLResultItem( const OSQLResultItem& item) {
     *this = item;
 }
 OSQLResultItem &OSQLResultItem::operator=( const OSQLResultItem& other) {
     m_string = other.m_string;
     m_int = other.m_int;
     return *this;
 }
diff --git a/libopie2/opiedb/osqlresult.h b/libopie2/opiedb/osqlresult.h
index 9c9efa2..fc6f01a 100644
--- a/libopie2/opiedb/osqlresult.h
+++ b/libopie2/opiedb/osqlresult.h
@@ -1,25 +1,29 @@
 #ifndef OSQL_RESULT_H
 #define OSQL_RESULT_H
 
 #include <qdatetime.h>
 #include <qmap.h>
 #include <qvaluelist.h>
 
 
 #include "osqlerror.h"
+
+namespace Opie {
+namespace DB {
+
 /**
  * ResultItem  represents one row of the resulting answer
  */
 class OSQLResultItem {
 public:
     typedef QValueList<OSQLResultItem> ValueList;
     /**
      * TableString is used to establish the relations
      * between the column name and the real item
      */
     typedef QMap<QString, QString> TableString;
 
     /**
      * TableInt is used to establish a relation between a
      * position of a column and the row value
      */
@@ -94,19 +98,23 @@ public:
     OSQLError::ValueList errors()const;
     OSQLResultItem::ValueList results()const;
 
     void setState( enum State state );
     void setErrors( const OSQLError::ValueList& error );
     void setResults( const OSQLResultItem::ValueList& result );
 
     OSQLResultItem first();
     OSQLResultItem next();
     bool atEnd();
     OSQLResultItem::ValueList::ConstIterator iterator()const;
 private:
     enum State m_state;
     OSQLResultItem::ValueList m_list;
     OSQLError::ValueList m_error;
     OSQLResultItem::ValueList::Iterator it;
+    class Private;
+    Private *d;
 };
 
+}
+}
 #endif
diff --git a/libopie2/opiedb/osqltable.cpp b/libopie2/opiedb/osqltable.cpp
index cde40f4..117cf21 100644
--- a/libopie2/opiedb/osqltable.cpp
+++ b/libopie2/opiedb/osqltable.cpp
@@ -1,18 +1,20 @@
 #include "osqltable.h"
 
+using namespace Opie::DB;
+
 OSQLTableItem::OSQLTableItem() {}
 OSQLTableItem::OSQLTableItem( enum Type type,
                               const QString& field,
                               const QVariant& var)
     : m_type( type ), m_field( field ), m_var( var )
 {
 
 }
 OSQLTableItem::~OSQLTableItem() {}
 OSQLTableItem::OSQLTableItem( const OSQLTableItem& item) {
     *this = item;
 }
 OSQLTableItem &OSQLTableItem::operator=(const OSQLTableItem& other) {
     m_var = other.m_var;
     m_field = other.m_field;
     m_type = other.m_type;
diff --git a/libopie2/opiedb/osqltable.h b/libopie2/opiedb/osqltable.h
index 87f7e74..86c30dd 100644
--- a/libopie2/opiedb/osqltable.h
+++ b/libopie2/opiedb/osqltable.h
@@ -1,23 +1,25 @@
 #ifndef OSQL_TABLE_H
 #define OSQL_TABLE_H
 
 #include <qstring.h>
 #include <qvaluelist.h>
 #include <qvariant.h>
 
+namespace Opie {
+namespace DB {
 /**
  * OSQLTableItem saves one column of a complete
  * table
  */
 class OSQLTableItem {
 public:
     typedef QValueList<OSQLTableItem> ValueList;
     /**
      * Type kinds ( to be extended )
      */
     enum Type { Undefined=-1, Integer=0, BigInteger =1,
                 Float = 2, VarChar = 4 };
     /**
      * A constructor
      * @param type the Type of the Column
      * @param fieldName the Name of the Column
@@ -77,19 +79,24 @@ public:
 
     /**
      * setColumns sets the Columns of the Table
      */
     void setColumns( const OSQLTableItem::ValueList& );
 
     /**
      * returns all columns of the table
      */
     OSQLTableItem::ValueList columns() const;
 
     QString tableName()const;
 
 private:
     QString m_table;
     OSQLTableItem::ValueList m_list;
+    class Private;
+    Private *d;
 };
 
+}
+}
+
 #endif