GNOME.org
 

[libgdamm] Statement: Move enums into class.

commit 9c6cbbc2dd9117b5cce1cbfc35edf4d72fe717a3
Author: Murray Cumming <murrayc murrayc com>
Date:   Wed Apr 26 22:39:30 2017 +0200

    Statement: Move enums into class.

 libgda/src/connection.ccg    |   24 ++++++++++++------------
 libgda/src/connection.hg     |   38 +++++++++++++++++++-------------------
 libgda/src/statement.ccg     |    2 +-
 libgda/src/statement.hg      |    8 ++++----
 tools/m4/convert_libgdamm.m4 |    4 ++--
 5 files changed, 38 insertions(+), 38 deletions(-)
---
diff --git a/libgda/src/connection.ccg b/libgda/src/connection.ccg
index ff7f136..2941572 100644
--- a/libgda/src/connection.ccg
+++ b/libgda/src/connection.ccg
@@ -75,7 +75,7 @@ void Connection::close()
     ::Glib::Error::throw_exception(gerror);
 }
 
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& cmd, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_inserted_row)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& cmd, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage, Glib::RefPtr<const Set>& 
last_inserted_row)
 {
   GError* gerror = 0;
   GdaSet* lir = 0;
@@ -91,7 +91,7 @@ Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<cons
   return retval;
 }
 
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& stmt, 
StatementModelUsage model_usage)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& stmt, 
Statement::ModelUsage model_usage)
 {
   GError* gerror = 0;
   Glib::RefPtr<Glib::Object> retval = Glib::wrap(
@@ -103,7 +103,7 @@ Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<cons
   return retval;
 }
 
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::ustring& sql, StatementModelUsage 
model_usage)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::ustring& sql, Statement::ModelUsage 
model_usage)
 {
   Glib::RefPtr<const Statement> stmt;
   Glib::RefPtr<SqlParser> parser = create_parser();
@@ -177,7 +177,7 @@ int Connection::statement_execute_non_select_builder(const Glib::RefPtr<const Sq
   return statement_execute_non_select(stmt, params);
 }
 
-Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const 
Glib::RefPtr<const Set>& params, StatementSqlFlag flags, std::vector< Glib::RefPtr<Holder> >& params_used) 
const
+Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const 
Glib::RefPtr<const Set>& params, Statement::SqlFlag flags, std::vector< Glib::RefPtr<Holder> >& params_used) 
const
 {
   GError* gerror = 0;
   GSList* params_usedc = 0;
@@ -198,7 +198,7 @@ Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>&
 }
 
 
-Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const 
Glib::RefPtr<const Set>& params, StatementSqlFlag flags) const
+Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const 
Glib::RefPtr<const Set>& params, Statement::SqlFlag flags) const
 {
   GError* gerror = 0;
   const Glib::ustring retvalue = 
Glib::convert_return_gchar_ptr_to_ustring(gda_connection_statement_to_sql(const_cast<GdaConnection*>(gobj()), 
const_cast<GdaStatement*>(Glib::unwrap(statement)), const_cast<GdaSet*>(Glib::unwrap(params)), 
((GdaStatementSqlFlag)(flags)), 0, &(gerror)));
@@ -210,7 +210,7 @@ Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>&
 }
   
 
-Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, StatementSqlFlag 
flags) const
+Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, 
Statement::SqlFlag flags) const
 {
   GError* gerror = 0;
   const Glib::ustring retvalue = 
Glib::convert_return_gchar_ptr_to_ustring(gda_connection_statement_to_sql(const_cast<GdaConnection*>(gobj()), 
const_cast<GdaStatement*>(Glib::unwrap(statement)), 0, ((GdaStatementSqlFlag)(flags)), 0, &(gerror)));
@@ -222,7 +222,7 @@ Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>&
 }
   
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
Statement::ModelUsage model_usage)
 {
   GError* gerror = 0;
   Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), 
const_cast<GdaStatement*>(Glib::unwrap(stmt)), 0 /* params */, ((GdaStatementModelUsage)(model_usage)), 0 /* 
col_types */, &(gerror)));
@@ -233,7 +233,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<
   return retvalue;
 }
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
const Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage)
 {
   GError* gerror = 0;
   Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), 
const_cast<GdaStatement*>(Glib::unwrap(stmt)), const_cast<GdaSet*>(Glib::unwrap(params)), 
((GdaStatementModelUsage)(model_usage)), 0 /* col_types */, &(gerror)));
@@ -245,7 +245,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<
 }
 
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& 
builder, StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& 
builder, Statement::ModelUsage model_usage)
 {
   Glib::RefPtr<Gnome::Gda::Statement> stmt = builder->get_statement(); //Allow any exceptions to be thrown 
up to the caller.
 
@@ -256,7 +256,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib:
 }
 
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& 
builder, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& 
builder, const Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage)
 {
   Glib::RefPtr<Gnome::Gda::Statement> stmt = builder->get_statement(); //Allow any exceptions to be thrown 
up to the caller.
 
@@ -266,7 +266,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib:
   return statement_execute_select(stmt, params, model_usage);
 }
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, StatementModelUsage 
model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, Statement::ModelUsage 
model_usage)
 {
   Glib::RefPtr<const Statement> stmt;
   Glib::RefPtr<SqlParser> parser = create_parser();
@@ -287,7 +287,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring
   return retvalue;
 }
 
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage)
 {
   Glib::RefPtr<const Statement> stmt;
   Glib::RefPtr<SqlParser> parser = create_parser();
diff --git a/libgda/src/connection.hg b/libgda/src/connection.hg
index 88c3af8..021938b 100644
--- a/libgda/src/connection.hg
+++ b/libgda/src/connection.hg
@@ -105,40 +105,40 @@ public:
   _IGNORE(gda_connection_point_available_event, gda_connection_add_event, gda_connection_add_event_string, 
gda_connection_clear_events_list)
 
   _WRAP_METHOD_DOCS_ONLY(gda_connection_statement_execute)
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_insert_row);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage, Glib::RefPtr<const Set>& last_insert_row);
 
 //TODO: Documentation:
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, 
StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, 
Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
 
 
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::ustring& sql, StatementModelUsage model_usage = 
StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::ustring& sql, Statement::ModelUsage model_usage = 
Statement::ModelUsage::RANDOM_ACCESS);
 
   //_WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
const Glib::RefPtr<const Set>& params), gda_connection_statement_execute_select, errthrow)
   _IGNORE(gda_connection_statement_execute_select) //We instead create a version that can take an optional 
usage parameter too.
 
 #m4 _CONVERSION(`const std::vector<GType>&', `GType*', 
`const_cast<GType*>(Glib::ArrayHandler<GType>::vector_to_array($3).data())')
-  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, const std::vector<GType>& col_types), 
gda_connection_statement_execute_select_full, errthrow)
+  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
const Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage, const std::vector<GType>& 
col_types), gda_connection_statement_execute_select_full, errthrow)
   _IGNORE(gda_connection_statement_execute_select_fullv)
 
 //This custom-written method has more optional methods than gda_connection_execute_select_command().
 //TODO: Documentation:
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage 
= StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, 
Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, Statement::ModelUsage 
model_usage = Statement::ModelUsage::RANDOM_ACCESS);
 
 //This custom-written method has more optional methods than gda_connection_execute_select_command().
 //TODO: Documentation:
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& 
params, StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& 
params, Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
   _IGNORE(gda_connection_execute_select_command)
 
 
 //TODO: Documentation:
 //Note that we add the prefix _builder() because overloading on different RefPtr<> types seems to be 
ambiguous.
-  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, 
StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, 
Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
 
 //TODO: Documentation:
 //Note that we add the prefix _builder() because overloading on different RefPtr<> types seems to be 
ambiguous.
-  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage = StatementModelUsage::RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage = Statement::ModelUsage::RANDOM_ACCESS);
 
 
   _WRAP_METHOD_DOCS_ONLY(gda_connection_statement_execute_non_select)
@@ -160,14 +160,14 @@ public:
 //TODO: Documentation:
   int statement_execute_non_select_builder(const Glib::RefPtr<const SqlBuilder>& builder, const 
Glib::RefPtr<const Set>& params);
 
-  _WRAP_METHOD(guint async_statement_execute(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, const std::vector<GType>& col_types, bool 
need_last_insert_row = false), gda_connection_async_statement_execute, errthrow)
+  _WRAP_METHOD(guint async_statement_execute(const Glib::RefPtr<const Statement>& stmt, const 
Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage, const std::vector<GType>& col_types, bool 
need_last_insert_row = false), gda_connection_async_statement_execute, errthrow)
 
   //TODO: Wrap the last_insert_row parameter properly and add an overload without it:
   _WRAP_METHOD(Glib::RefPtr<Glib::Object> async_fetch_result(guint task_id, GdaSet **last_insert_row), 
gda_connection_async_fetch_result, errthrow)
   _WRAP_METHOD(bool async_cancel(guint task_id), gda_connection_async_cancel, errthrow)
 
 //TODO: #m4 _CONVERSION(`GSList*',`std::vector<Glib::Object>',`$2(Glib::SListHandler<Glib::RefPtr<const 
Statement> >::slist_to_vector((GSList*)$3, Glib::OWNERSHIP_DEEP))')
-//  _WRAP_METHOD(std::vector<Glib::Object> repetitive_statement_execute(GdaRepetitiveStatement *rstmt, 
StatementModelUsage model_usage, const std::vector<GType>& col_types, gboolean stop_on_error = true), 
gda_connection_repetitive_statement_execute, errthrow)
+//  _WRAP_METHOD(std::vector<Glib::Object> repetitive_statement_execute(GdaRepetitiveStatement *rstmt, 
Statement::ModelUsage model_usage, const std::vector<GType>& col_types, gboolean stop_on_error = true), 
gda_connection_repetitive_statement_execute, errthrow)
 
   //Note that we do not add a non-const version of this because the documentation says that it should not be 
modified:
   _WRAP_METHOD(Glib::RefPtr<const TransactionStatus> get_transaction_status() const, 
gda_connection_get_transaction_status, errthrow, refreturn)
@@ -288,7 +288,7 @@ public:
   _WRAP_METHOD(Glib::RefPtr<const MetaStore> get_meta_store() const, gda_connection_get_meta_store, 
constversion)
 
   #m4 _CONVERSION(`GSList*',`std::vector< Glib::RefPtr<Glib::Object> >',`$2(Glib::SListHandler< 
Glib::RefPtr<Glib::Object > >::slist_to_vector($3, Glib::OWNERSHIP_SHALLOW))')
-  _WRAP_METHOD(std::vector< Glib::RefPtr<Glib::Object> > batch_execute(const Glib::RefPtr<Batch>& batch, 
const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage), gda_connection_batch_execute, 
errthrow)
+  _WRAP_METHOD(std::vector< Glib::RefPtr<Glib::Object> > batch_execute(const Glib::RefPtr<Batch>& batch, 
const Glib::RefPtr<const Set>& params, Statement::ModelUsage model_usage), gda_connection_batch_execute, 
errthrow)
 
   _WRAP_METHOD(Glib::RefPtr<ServerOperation> create_operation(ServerOperation::Type type, const 
Glib::RefPtr<const Set>& options), gda_connection_create_operation, errthrow)
   _WRAP_METHOD(bool perform_operation(const Glib::RefPtr<ServerOperation>& op), 
gda_connection_perform_operation, errthrow)
@@ -306,28 +306,28 @@ public:
    *
    * @param stmt A Statement object.
    * @param A Set object (which can be obtained using Statement::get_parameters()).
-   * @param flags SQL rendering flags, as StatementSqlFlag OR'ed values
+   * @param flags SQL rendering flags, as Statement::SqlFlag OR'ed values
    * @param params_used A place to store the list of individual Holder objects within @a params which have 
been used.
    * @throws ConnectionError
    */
-  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& 
params, StatementSqlFlag flags, std::vector< Glib::RefPtr<Holder> >& params_used) const;
+  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& 
params, Statement::SqlFlag flags, std::vector< Glib::RefPtr<Holder> >& params_used) const;
 
   /** Renders a Statement as a SQL statement string, adapted to the SQL dialect used by the connection.
    *
    * @param stmt A Statement object.
    * @param A Set object (which can be obtained using Statement::get_parameters()).
-   * @param flags SQL rendering flags, as StatementSqlFlag OR'ed values
+   * @param flags SQL rendering flags, as Statement::SqlFlag OR'ed values
    * @throws ConnectionError
    */
-  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& 
params, StatementSqlFlag flags = StatementSqlFlag::PARAMS_AS_VALUES) const;
+  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& 
params, Statement::SqlFlag flags = Statement::SqlFlag::PARAMS_AS_VALUES) const;
   
   /** Renders a Statement as a SQL statement string, adapted to the SQL dialect used by the connection.
    *
    * @param stmt A Statement object..
-   * @param flags SQL rendering flags, as StatementSqlFlag OR'ed values
+   * @param flags SQL rendering flags, as Statement::SqlFlag OR'ed values
    * @throws ConnectionError
    */
-  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, StatementSqlFlag flags = 
StatementSqlFlag::PARAMS_AS_VALUES) const;
+  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, Statement::SqlFlag flags = 
Statement::SqlFlag::PARAMS_AS_VALUES) const;
 
 
   _IGNORE(gda_connection_internal_reset_transaction_status)
diff --git a/libgda/src/statement.ccg b/libgda/src/statement.ccg
index ababd46..5893225 100644
--- a/libgda/src/statement.ccg
+++ b/libgda/src/statement.ccg
@@ -74,7 +74,7 @@ Glib::ustring Statement::to_sql(const Glib::RefPtr<const Set>& params) const
 }
 
 Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params, 
-                              StatementSqlFlag flags, const HolderVector&) const
+                              SqlFlag flags, const HolderVector&) const
 {
   GError* gerror = 0;
   GSList* list = 0;
diff --git a/libgda/src/statement.hg b/libgda/src/statement.hg
index 2539235..36edfaa 100644
--- a/libgda/src/statement.hg
+++ b/libgda/src/statement.hg
@@ -35,9 +35,6 @@ namespace Gda
 
 class Connection;
 
-_WRAP_ENUM(StatementModelUsage, GdaStatementModelUsage, NO_GTYPE)
-_WRAP_ENUM(StatementSqlFlag, GdaStatementSqlFlag, NO_GTYPE)
-
 _WRAP_GERROR(StatementError, GdaStatementError, GDA_STATEMENT_ERROR, NO_GTYPE)
 
 /** Single SQL statement.
@@ -68,6 +65,9 @@ protected:
   _CTOR_DEFAULT()
 
 public:
+  _WRAP_ENUM(ModelUsage, GdaStatementModelUsage, NO_GTYPE)
+  _WRAP_ENUM(SqlFlag, GdaStatementSqlFlag, NO_GTYPE)
+
   _WRAP_CREATE()
   _WRAP_METHOD(Glib::RefPtr<Statement> copy() const, gda_statement_copy)
 
@@ -90,7 +90,7 @@ public:
   //TODO: Add an overload without the params?
   _WRAP_METHOD_DOCS_ONLY(gda_statement_to_sql_extended)
   Glib::ustring to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params,
-                                StatementSqlFlag flags, const HolderVector& params_used) const;
+                                SqlFlag flags, const HolderVector& params_used) const;
 
   _WRAP_METHOD(SqlStatement::Type get_statement_type() const, gda_statement_get_statement_type)
   _WRAP_METHOD(bool is_useless() const, gda_statement_is_useless)
diff --git a/tools/m4/convert_libgdamm.m4 b/tools/m4/convert_libgdamm.m4
index 34d4b1b..e49033b 100644
--- a/tools/m4/convert_libgdamm.m4
+++ b/tools/m4/convert_libgdamm.m4
@@ -129,9 +129,9 @@ _CONV_GNOME_GDA_INCLASS_ENUM(ServerOperation,Type)
 _CONV_GNOME_GDA_INCLASS_ENUM(ServerOperation,NodeType)
 _CONV_GNOME_GDA_INCLASS_ENUM(ServerOperation,NodeStatus)
 _CONV_ENUM(Gda,ValueAttribute)
-_CONV_ENUM(Gda,StatementModelUsage)
 _CONV_GNOME_GDA_INCLASS_ENUM(SqlStatement,Type)
-_CONV_ENUM(Gda,StatementSqlFlag)
+_CONV_GNOME_GDA_INCLASS_ENUM(Statement,SqlFlag)
+_CONV_GNOME_GDA_INCLASS_ENUM(Statement,ModelUsage)
 _CONV_ENUM(Gda,SqlParserMode)
 _CONV_GNOME_GDA_INCLASS_ENUM(MetaStruct,Feature)
 _CONV_ENUM(Gda,MetaDbObjectType)
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]