[genmdesc] Fixed generator to allow instructions lengths equal to 0.

[mono.git] / mcs / class / System.Data / System.Data.OleDb / OleDbTransaction.cs

diff --git a/mcs/class/System.Data/System.Data.OleDb/OleDbTransaction.cs b/mcs/class/System.Data/System.Data.OleDb/OleDbTransaction.cs
index c83bec65c28f7dca5f3216c82a6ec08feceeafad..7bd79b17c690d4314acfc169fe941eb07dc9b82c 100644 (file)
--- a/mcs/class/System.Data/System.Data.OleDb/OleDbTransaction.cs
+++ b/mcs/class/System.Data/System.Data.OleDb/OleDbTransaction.cs
@@ -33,13 +33,15 @@ using System.Data.Common;
 
 namespace System.Data.OleDb
 {
-       public sealed class OleDbTransaction : MarshalByRefObject, IDbTransaction, IDisposable
+       public sealed class OleDbTransaction : DbTransaction, IDbTransaction
        {
                #region Fields
 
+               bool disposed;
                OleDbConnection connection;
                IntPtr gdaTransaction;
                int depth;
+               bool isOpen;
 
                #endregion // Fields
 
@@ -81,6 +83,7 @@ namespace System.Data.OleDb
                        }
                        
                        libgda.gda_connection_begin_transaction (connection.GdaConnection, gdaTransaction);
+                       isOpen = true;
                }
 
                internal OleDbTransaction (OleDbConnection connection, IsolationLevel isolevel) 
@@ -93,20 +96,23 @@ namespace System.Data.OleDb
 
                #region Properties
 
-               public OleDbConnection Connection {
+               public new OleDbConnection Connection {
                        get {
                                return connection;
                        }
                }
 
-               IDbConnection IDbTransaction.Connection {
-                       get {
-                               return connection;
-                       }
+               protected override DbConnection DbConnection {
+                       get { return connection; }
                }
                
-               public IsolationLevel IsolationLevel {
+               public
+               override
+               IsolationLevel IsolationLevel {
                        get {
+                               if (!isOpen)
+                                       throw ExceptionHelper.TransactionNotUsable (GetType ());
+
                                switch (libgda.gda_transaction_get_isolation_level (gdaTransaction)) {
                                case GdaTransactionIsolation.ReadCommitted :
                                        return IsolationLevel.ReadCommitted;
@@ -117,7 +123,6 @@ namespace System.Data.OleDb
                                case GdaTransactionIsolation.Serializable :
                                        return IsolationLevel.Serializable;
                                }
-
                                return IsolationLevel.Unspecified;
                        }
                }
@@ -126,42 +131,60 @@ namespace System.Data.OleDb
 
                #region Methods
 
-               public OleDbTransaction Begin () 
+               public OleDbTransaction Begin ()
                {
+                       if (!isOpen)
+                               throw ExceptionHelper.TransactionNotUsable (GetType ());
                        return new OleDbTransaction (connection, depth + 1);
                }
 
                public OleDbTransaction Begin (IsolationLevel isolevel) 
                {
+                       if (!isOpen)
+                               throw ExceptionHelper.TransactionNotUsable (GetType ());
                        return new OleDbTransaction (connection, depth + 1, isolevel);
                }
 
-               public void Commit ()
+               public
+               override
+               void Commit ()
                {
+                       if (!isOpen)
+                               throw ExceptionHelper.TransactionNotUsable (GetType ());
+
                        if (!libgda.gda_connection_commit_transaction (connection.GdaConnection,
-                                                                      gdaTransaction))
+                               gdaTransaction))
                                throw new InvalidOperationException ();
+                       connection = null;
+                       isOpen = false;
                }
 
-               [MonoTODO]
-               ~OleDbTransaction ()
+
+               protected override
+               void Dispose (bool disposing)
                {
-                       libgda.FreeObject (gdaTransaction);
-                       gdaTransaction = IntPtr.Zero;
+                       if (!disposed) {
+                               if (disposing && isOpen)
+                                       Rollback ();
+                               disposed = true;
+                       }
+
+                       base.Dispose (disposing);
                }
 
-               [MonoTODO]
-               void IDisposable.Dispose ()
+
+               public
+               override
+               void Rollback ()
                {
-                       GC.SuppressFinalize (this);
-                       throw new NotImplementedException ();
-               }
+                       if (!isOpen)
+                               throw ExceptionHelper.TransactionNotUsable (GetType ());
 
-               public void Rollback ()
-               {
                        if (!libgda.gda_connection_rollback_transaction (connection.GdaConnection,
-                                                                        gdaTransaction))
+                               gdaTransaction))
                                throw new InvalidOperationException ();
+                       connection = null;
+                       isOpen = false;
                }
 
                #endregion // Methods