Fix warnings, add sanity check, new default argument to fix warning...

4 files changed, 10 insertions, 8 deletions

diff --git a/libopie2/opiedb/osqlbackend.cpp b/libopie2/opiedb/osqlbackend.cpp
index aede7c1..5c37480 100644
--- a/libopie2/opiedb/osqlbackend.cpp
+++ b/libopie2/opiedb/osqlbackend.cpp
@@ -16,65 +16,65 @@ OSQLBackEnd::OSQLBackEnd( const QString& name,
 }
 OSQLBackEnd::OSQLBackEnd( const OSQLBackEnd& back ) {
     (*this) = back;
 }
 OSQLBackEnd::~OSQLBackEnd() {
 }
 bool OSQLBackEnd::operator==( const OSQLBackEnd& other ) {
     if ( m_pref != other.m_pref ) return false;
     if ( m_default != other.m_default ) return false;
     if ( m_name != other.m_name ) return false;
     if ( m_vendor != other.m_vendor ) return false;
     if ( m_license != other.m_license ) return false;
     if ( m_lib != other.m_lib ) return false;
 
     return true;
 }
 OSQLBackEnd &OSQLBackEnd::operator=(const OSQLBackEnd& back ) {
     m_name = back.m_name;
     m_vendor = back.m_vendor;
     m_license = back.m_license;
     m_lib = back.m_lib;
     m_pref = back.m_pref;
     m_default = back.m_default;
     return *this;
 }
 QString OSQLBackEnd::name() const {
     return m_name;
 }
 QString OSQLBackEnd::vendor() const {
     return m_vendor;
 }
 QString OSQLBackEnd::license() const {
     return m_license;
 }
 QCString OSQLBackEnd::library() const {
     return m_lib;
 }
 bool OSQLBackEnd::isDefault()const {
     return m_default;
 }
 int OSQLBackEnd::preference()const {
     return m_pref;
 }
 void OSQLBackEnd::setName( const QString& name ) {
     m_name = name;
 }
 void OSQLBackEnd::setVendor( const QString& vendor ) {
     m_vendor = vendor;
 }
 void OSQLBackEnd::setLicense( const QString & license ) {
     m_license = license;
 }
 void OSQLBackEnd::setLibrary( const QCString& lib ) {
     m_lib = lib;
 }
 void OSQLBackEnd::setDefault( bool def) {
     m_default = def;
 }
 void OSQLBackEnd::setPreference( int pref ) {
     m_pref = pref;
 }
 
 
 }
-}
\ No newline at end of file
+}
diff --git a/libopie2/opiedb/osqlitedriver.cpp b/libopie2/opiedb/osqlitedriver.cpp
index 92f89cf..c8b560f 100644
--- a/libopie2/opiedb/osqlitedriver.cpp
+++ b/libopie2/opiedb/osqlitedriver.cpp
@@ -1,228 +1,228 @@
 /*
                              This file is part of the Opie Project
 
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "osqlquery.h"
 #include "osqlitedriver.h"
 
 #include <opie2/odebug.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 
-namespace Opie { 
-namespace DB { 
+namespace Opie {
+namespace DB {
 namespace Internal {
 
 namespace {
     struct Query {
         OSQLError::ValueList errors;
         OSQLResultItem::ValueList items;
         OSQLiteDriver *driver;
     };
 }
 
 
 OSQLiteDriver::OSQLiteDriver( QLibrary *lib )
     : OSQLDriver( lib )
 {
     m_sqlite = 0l;
 }
 
 
 OSQLiteDriver::~OSQLiteDriver() {
     close();
 }
 
 
 QString OSQLiteDriver::id()const {
     return QString::fromLatin1("SQLite");
 }
 
 void OSQLiteDriver::setUserName( const QString& ) {}
 
 
 void OSQLiteDriver::setPassword( const QString& ) {}
 
 
 void OSQLiteDriver::setUrl( const QString& url ) {
     m_url = url;
 }
 
 
 void OSQLiteDriver::setOptions( const QStringList& ) {
 }
 
 /*
  * Functions to patch a regex search into sqlite
  */
 int sqliteRlikeCompare(const char *zPattern, const char *zString, sqregex *reg){
     int res;
     if (reg->regex_raw == NULL || (strcmp (zPattern, reg->regex_raw) != 0)){
         if (reg->regex_raw != NULL) {
             free(reg->regex_raw);
             regfree(&reg->regex_c);
         }
         reg->regex_raw = (char *)malloc(strlen(zPattern)+1);
         strncpy(reg->regex_raw, zPattern, strlen(zPattern)+1);
         res = regcomp(&reg->regex_c, zPattern, REG_EXTENDED);
         if ( res != 0 ) {
             printf("Regcomp failed with code %u on string %s\n",res,zPattern);
             free(reg->regex_raw);
             reg->regex_raw=NULL;
         return 0;
         }
     }
     res = (regexec(&reg->regex_c, zString, 0, NULL, 0)==0);
     return res;
 }
 
 void rlikeFunc(sqlite_func *context, int arg, const char **argv){
-    if( argv[0]==0 || argv[1]==0 ){
+    if( arg < 2 || argv[0]==0 || argv[1]==0 ){
         printf("One of arguments Null!!\n");
         return;
     }
         sqlite_set_result_int(context,
         sqliteRlikeCompare((const char*)argv[0],
     (const char*)argv[1], (sqregex *)sqlite_user_data(context) ));
 }
 
 /*
  * try to open a db specified via setUrl
  * and options
  */
 bool OSQLiteDriver::open() {
     char *error;
 
-    odebug << "OSQLiteDriver::open: about to open" << oendl; 
+    odebug << "OSQLiteDriver::open: about to open" << oendl;
     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; 
+        owarn << "OSQLiteDriver::open: " << error << "" << oendl;
         free( error );
         return false;
     }
     if (sqlite_create_function(m_sqlite,"rlike",2,rlikeFunc,&sqreg) != 0)
         odebug << "Unable to create user defined function!" << oendl;
     if (sqlite_function_type(m_sqlite,"rlike",SQLITE_NUMERIC) != 0)
         odebug << "Unable to set rlike function result type!" << oendl;
     sqreg.regex_raw = NULL;
     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;
     if (sqreg.regex_raw != NULL){
         odebug << "Freeing regex on close" << oendl;
         free(sqreg.regex_raw);
         sqreg.regex_raw=NULL;
         regfree(&sqreg.regex_c);
     }
     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().utf8(),&call_back, &query, &err)  > 0 ) {
             owarn << "OSQLiteDriver::query: Error while executing " << err << "" << oendl;
             free( err );
             // FixMe Errors
     }
 
     OSQLResult result(OSQLResult::Success,
                       query.items,
                       query.errors );
     return result;
 }
 
 
 OSQLTable::ValueList OSQLiteDriver::tables() const {
-
+    return OSQLTable::ValueList();
 }
 
 
 OSQLError OSQLiteDriver::lastError() {
     OSQLError error;
     return error;
 };
 
 
 /* handle a callback add the row to the global
  * OSQLResultItem
  */
 int OSQLiteDriver::handleCallBack( int, char**, char** ) {
     return 0;
 }
 
 
 /* callback_handler add the values to the list*/
 int OSQLiteDriver::call_back( void* voi, int argc,
                               char** argv, char** columns) {
     Query* qu = (Query*)voi;
 
     //copy them over to a OSQLResultItem
     QMap<QString, QString> tableString;
     QMap<int, QString> tableInt;
     for (int i = 0; i < argc; i++ ) {
 
         tableInt.insert( i, QString::fromUtf8( argv[i] ) );
         tableString.insert( QString::fromUtf8( columns[i] ),
                             QString::fromUtf8( argv[i] ) );
     }
     OSQLResultItem item( tableString, tableInt );
     qu->items.append( item );
 
     return ((Query*)voi)->driver->handleCallBack( argc,
                                                   argv,
                                                   columns );
 
 
 }
 
 }}} // namespace OPIE::DB::Internal
diff --git a/libopie2/opiedb/osqlresult.cpp b/libopie2/opiedb/osqlresult.cpp
index 268ac8e..a34ab2f 100644
--- a/libopie2/opiedb/osqlresult.cpp
+++ b/libopie2/opiedb/osqlresult.cpp
@@ -10,119 +10,121 @@ OSQLResultItem::OSQLResultItem( const TableString& string,
 
 }
 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;
 }
 OSQLResultItem::TableString OSQLResultItem::tableString()const{
     return m_string;
 }
 OSQLResultItem::TableInt OSQLResultItem::tableInt()const {
     return m_int;
 }
 QString OSQLResultItem::data( const QString& columnName, bool *ok ) const {
     TableString::ConstIterator it = m_string.find( columnName );
 
     /* if found */
     if ( it != m_string.end() ) {
         if ( ok ) *ok = true;
         return it.data();
     }else{
         if ( ok )  *ok = false;
         return QString::null;
     }
 
 }
 QString OSQLResultItem::data( int column, bool *ok ) const {
     TableInt::ConstIterator it = m_int.find( column );
 
     /* if found */
     if ( it != m_int.end() ) {
         if ( ok ) *ok = true;
         return it.data();
     }else{
         if ( ok )  *ok = false;
         return QString::null;
     }
 }
 /*
  * DateFormat is 'YYYY-MM-DD'
  */
 QDate OSQLResultItem::dataToDate( const QString& column, bool *ok ) {
     QDate date = QDate::currentDate();
     QString str = data( column,  ok );
     if (!str.isEmpty() ) {
       ;// convert
     }
     return date;
 }
 QDate OSQLResultItem::dataToDate( int column,  bool *ok ) {
     QDate date = QDate::currentDate();
     QString str = data( column,  ok );
     if (!str.isEmpty() ) {
       ;// convert
     }
     return date;
 
 }
 QDateTime OSQLResultItem::dataToDateTime( const QString& column, bool *ok ) {
+//    #FIXME xxx
     QDateTime time = QDateTime::currentDateTime();
     return time;
 }
 QDateTime OSQLResultItem::dataToDateTime( int column, bool *ok ) {
+//   #FIXME xxx
     QDateTime time = QDateTime::currentDateTime();
     return time;
 }
 
 OSQLResult::OSQLResult( enum State state,
                         const OSQLResultItem::ValueList& list,
                         const OSQLError::ValueList& error )
     : m_state( state ), m_list( list ), m_error( error )
 {
 
 }
 OSQLResult::~OSQLResult() {
 
 }
 OSQLResult::State OSQLResult::state()const {
     return m_state;
 }
 void OSQLResult::setState( OSQLResult::State state ) {
     m_state = state;
 }
 OSQLError::ValueList OSQLResult::errors()const {
     return m_error;
 }
 void OSQLResult::setErrors( const OSQLError::ValueList& err ) {
     m_error = err;
 }
 OSQLResultItem::ValueList OSQLResult::results()const {
     return m_list;
 }
 void OSQLResult::setResults( const OSQLResultItem::ValueList& result ) {
     m_list = result;
 }
 OSQLResultItem OSQLResult::first() {
     it = m_list.begin();
     return (*it);
 }
 OSQLResultItem OSQLResult::next(){
     ++it;
     return (*it);
 }
 bool OSQLResult::atEnd(){
     if ( it == m_list.end() )
         return true;
 
     return false;
 }
 OSQLResultItem::ValueList::ConstIterator OSQLResult::iterator()const {
     OSQLResultItem::ValueList::ConstIterator it;
     it = m_list.begin();
     return it;
 }
diff --git a/libopie2/opiedb/osqltable.h b/libopie2/opiedb/osqltable.h
index 86c30dd..8dd786f 100644
--- a/libopie2/opiedb/osqltable.h
+++ b/libopie2/opiedb/osqltable.h
@@ -9,94 +9,94 @@ 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
      * @param var a Variant
      */
     OSQLTableItem();
     OSQLTableItem( enum Type type,
                    const QString& fieldName,
                    const QVariant& var= QVariant() );
 
     /**
      * copy c'tor
      */
     OSQLTableItem( const OSQLTableItem& );
 
     /**
      * d'tor
      */
     ~OSQLTableItem();
 
     OSQLTableItem& operator=( const OSQLTableItem& );
 
     /**
      * the fieldName
      */
     QString fieldName() const;
 
     /**
      * the field Type
      */
     Type type() const;
     QVariant more() const;
 private:
     class OSQLTableItemPrivate;
     OSQLTableItemPrivate* d;
     Type m_type;
     QString m_field;
     QVariant m_var;
 };
 
 /**
  * A OSQLTable consists of OSQLTableItems
  */
 class OSQLTable  {
 public:
     typedef QValueList<OSQLTable> ValueList;
 
     /**
      * @param tableName the Name of the Table
      */
-    OSQLTable(const QString& tableName);
+    OSQLTable(const QString& tableName = QString::null);
 
     /**
      * d'tor
      */
     ~OSQLTable();
 
     /**
      * 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