Cursor.cs :  » Persistence-Frameworks » Persist.NET » Persist » C# / CSharp Open Source

// Persist library : Persistence layer
// Copyright (C) 2003 Vincent Daron
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library 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
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

using System;
using System.Data;
using System.Collections;
using System.Reflection;

using Persist.Sql;
using Persist.Maps;

namespace Persist{
   /// <summary>
   /// The Cursor is used to 
   /// </summary>
   public class Cursor : IEnumerable,IDisposable
   {
      #region Cursor Enumerator Class
      /// <summary>
      /// This is the Enumerator used for Cursor objects
      /// </summary>
      internal class CursorEnumerator : IEnumerator
      {
         private Cursor cursor;

         internal CursorEnumerator(Cursor cur)
         {
            cursor = cur;
         }

         public bool MoveNext()
         {
            return cursor.theDataReader.Read();
         }

         public object Current
         {
            get
            {
               return cursor.GetObject();
            }
         }
         public void Reset()
         {
            throw new Exception("Cursors cannot be resested");
         }
      }
      #endregion

      private static readonly log4net.ILog theLogger = log4net.LogManager.GetLogger(typeof(Cursor));

      private static Type[] constructorParameters = new Type[]{};
      private IDbConnection theConnection = null;
      private IDataReader theDataReader = null;
      private ClassMap classMap = null;
      private bool proxy = false;

      private ConstructorInfo constructor = null;

      /// <summary>
      /// Create a new Cursor
      /// </summary>
      /// <param name="dataReader">the DataReader containing the datas</param>
      /// <param name="connection">the Connection associated to the DataReader</param>
      /// <param name="classMap">the ClassMap of the object in the DataReader</param>
      /// <param name="proxy">Indicate if we must return only Proxy objects</param>
      internal Cursor(IDataReader dataReader,IDbConnection connection, ClassMap classMap, bool proxy)
      {
         System.Diagnostics.Debug.WriteLine("Cursor Created");
         this.theConnection = connection;
         this.theDataReader = dataReader;
         this.classMap = classMap;
         this.proxy = proxy;

         constructor = (classMap.MapObjectType).GetConstructor(BindingFlags.NonPublic|BindingFlags.Public|BindingFlags.Instance,null,constructorParameters,null);

         if(constructor == null)
         {
            throw new Exception(classMap.TypeName + " does not have an default constructor");
         }
      }


      #region IDisposable Implementation
      /// <summary>
      /// Cursor Destructor (Should never be called, use Dispose)
      /// </summary>
      ~Cursor()
      {
         System.Diagnostics.Debug.WriteLine("Cursor not Disposed !!");
         Dispose(false);
      }
      /// <summary>
      /// Release Manage resources and cleanup cursor
      /// </summary>
      public void Dispose()
      {
         Dispose(true);
      }
      /// <summary>
      /// Dispose the Cursor
      /// </summary>
      /// <param name="disposing"></param>
      protected void Dispose(bool disposing)
      {
         if(disposing)
         {
            System.Diagnostics.Debug.WriteLine("Cursor Closed");
            // Close the DataReader
            if(theDataReader != null)
            {
               System.Diagnostics.Debug.WriteLine("Closing DataReader");
               theDataReader.Close();
               theDataReader = null;
            }
            // Free Connection
            if(theConnection != null)
            {
               Persist.PersistenceManagerFactory.Instance.ConnectionManager.FreeConnection(classMap.RelationalDatabase,theConnection);
               theConnection = null;
            }
            GC.SuppressFinalize(this);
         }
      }
      #endregion

      /// <summary>
      /// Retreive the Current object
      /// </summary>
      /// <returns>the current object</returns>
      public PersistentObject GetObject()
      {
         PersistentObject obj = (PersistentObject)constructor.Invoke(new object[]{});

         if(proxy)
         {
            classMap.RetrieveProxyObject(obj, theDataReader);
         }
         else
         {
            classMap.RetrieveObject(obj, theDataReader);
         }

         return obj;
      }
      /// <summary>
      /// Return an Cursor Iterator
      /// </summary>
      /// <returns></returns>
      public IEnumerator GetEnumerator()
      {
         return new CursorEnumerator(this);
      }

   }
}