root/lang/csharp/iTunesCOMWrap/trunk/iTunesCOMWrap/Base.cs @ 11205

// $Id$
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Clovery.iTunesHelper.COMWrap.Interfaces;

namespace Clovery.iTunesHelper.COMWrap
{
    /// <summary>
    /// base class of some factorizable classes to represent iTunes object.
    /// </summary>
    internal class ITFactory : IITFactory
    {
        /// <summary>
        /// Points to this sessions' iTunes application object.
        /// </summary>
        protected internal readonly ITunesApp _app;

        /// <summary>
        /// Points to internal iTunes object.
        /// </summary>
        protected internal object _internal;

        /// <summary>
        /// Base Initializer.
        /// </summary>
        /// <param name="_internal">iTunes internal object</param>
        /// <param name="app">iTunes application object</param>
        protected internal ITFactory(object _internal, ITunesApp app)
        {
            this._app = app;
            this._internal = _internal;
        }

        /// <summary>
        /// Base initializer.
        /// </summary>
        /// <param name="app">iTunes application object</param>
        public ITFactory(ITunesApp app)
        {
            this._app = app;
            this._internal = null;
        }

        /// <summary>
        /// Returns self-wrapped iTunes object factory.
        /// </summary>
        public IITunesWrappedObjectFactory factory
        {
            get { return this._app.factory; }
        }
        
        public object __internalObject
        {
            get { return this._internal; }
        }

        public bool Attached
        {
            get { return this._internal != null; }
        }
    }

    internal class ITObject : ITFactory, IITObject
    {
        protected internal readonly int _playlistID;
        protected internal readonly int _sourceID;
        protected internal readonly int _TrackDatabaseID;
        protected internal readonly int _trackID;
        protected internal string _name;

        protected internal ITObject(iTunesLib.IITObject _internal, ITunesApp app) : base(_internal, app)
        {
            _internal.GetITObjectIDs(out this._sourceID, out this._playlistID, out this._trackID,
                                     out this._TrackDatabaseID);
            this._name = _internal.Name;
        }

        protected internal ITObject(int sourceID, int playlistID, int trackID, int TrackDatabaseID, ITunesApp app) : base(app)
        {
            this._sourceID = sourceID;
            this._playlistID = playlistID;
            this._trackID = trackID;
            this._TrackDatabaseID = TrackDatabaseID;
        }

        ~ITObject ()
        {
            this._internal = null;
        }

        protected iTunesLib.IITObject _asIITObject
        {
            get
            {
                if (this._internal == null)
                {
                    throw new InvalidCastException("this object cannot be called with abstract ITObject");
                }
                return (iTunesLib.IITObject) this._internal;
            }
        }

        public void GetITObjectIDs(out int sourceID, out int playlistID, out int trackID, out int databaseID)
        {
            //this._asIITObject.GetITObjectIDs(out sourceID, out playlistID, out trackID, out databaseID);
            sourceID = this.sourceID;
            playlistID = this.playlistID;
            trackID = this.trackID;
            databaseID = this.TrackDatabaseID;
        }

        public string Name
        {
            get
            {
                try
                {
                    string name = this._asIITObject.Name;
                    this._name = name;
                    return name;
                }
                catch (InvalidCastException)
                {
                    return this._name;
                }
            }

            set
            {
                this._asIITObject.Name = value;
                this._name = value;
            }
        }

        public int Index
        {
            get { return this._asIITObject.Index; }
        }

        public int sourceID
        {
            get { return this._sourceID; }
        }

        public int playlistID
        {
            get { return this._playlistID; }
        }

        public int trackID
        {
            get { return this._trackID; }
        }

        public int TrackDatabaseID
        {
            get { return this._TrackDatabaseID; }
        }

        ///<summary>
        ///Indicates whether the current object is equal to another object of the same type.
        ///</summary>
        ///
        ///<returns>
        ///true if the current object is equal to the other parameter; otherwise, false.
        ///</returns>
        ///
        ///<param name="other">An object to compare with this object.</param>
        public bool Equals(IITObject other)
        {
            if (other == null) return false;
            if (this._sourceID != other.sourceID) return false;
            if (this._playlistID != other.playlistID) return false;
            if (this._trackID != other.trackID) return false;
            if (this._TrackDatabaseID != other.TrackDatabaseID) return false;
            return true;
        }

        ///<summary>
        ///Indicates whether the current object is equal to another object of the same type.
        ///</summary>
        ///
        ///<returns>
        ///true if the current object is equal to the other parameter; otherwise, false.
        ///</returns>
        ///
        ///<param name="other">An object to compare with this object.</param>
        public override bool Equals(object other)
        {
            if (ReferenceEquals(this, other)) return true;
            if (other == null) return false;
            return Equals(other as IITObject);
        }

        public static bool operator ==(ITObject a, ITObject b)
        {
            if (ReferenceEquals(a, b)) return true;
            if (((object) a == null) || ((object) b == null))
            {
                return false;
            }

            return a.Equals(b);
        }

        public static bool operator !=(ITObject a, ITObject b)
        {
            return !(a == b);
        }

        public override int GetHashCode()
        {
            int result = this._sourceID;
            result = 29*result + this._playlistID;
            result = 29*result + this._trackID;
            result = 29*result + this._TrackDatabaseID;
            return result;
        }

        public IITObject Retrive()
        {
            return this._app.GetITObjectByID(this.sourceID, this.playlistID, this.trackID, this.TrackDatabaseID);
        }

        public void Invalidate()
        {
            this._name = this._asIITObject.Name;
        }
    }

    internal class ParentStringIndexerReferrer<TCollection, TItem> : IIndexedCollection<string, TItem>
        where TCollection : IIndexedCollection<string, TItem>
    {
        protected internal readonly TCollection _parent;

        internal ParentStringIndexerReferrer(TCollection _parent)
        {
            this._parent = _parent;
        }

        public TItem this[string Name]
        {
            get { return this._parent[Name]; }
        }
    }

    internal abstract class ITBaseCollection<TItem> : ITFactory, IITBaseCollection<TItem>
        where TItem : class
    {
        protected ITBaseCollection(object _internal, ITunesApp app) : base(_internal, app)
        {
        }

        public abstract int Count { get; }

        ///<summary>
        ///Returns an enumerator that iterates through the collection.
        ///</summary>
        ///
        ///<returns>
        ///A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public IEnumerator<TItem> GetEnumerator()
        {
            return this._GetEnumerator();
        }

        ///<summary>
        ///Returns an enumerator that iterates through a collection.
        ///</summary>
        ///
        ///<returns>
        ///An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.
        ///</returns>
        ///<filterpriority>2</filterpriority>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this._GetEnumerator();
        }

        protected internal abstract IEnumerator<TItem> _GetEnumerator();
    }

    internal class ITBaseEnumerator<TITunesItem, TItem, TBaseCollection> : IEnumerator<TItem>
        where TBaseCollection : IITBaseCollection<TItem>, ItemCreatableCollection<TITunesItem, TItem>
        where TItem : class
    {
        protected internal readonly TBaseCollection _collection;
        protected internal readonly IEnumerator _internal;
        protected TItem _current;

        internal ITBaseEnumerator(IEnumerator internalEnumerator, TBaseCollection baseCollection)
        {
            this._internal = internalEnumerator;
            this._collection = baseCollection;
        }

        ///<summary>
        ///Advances the enumerator to the next element of the collection.
        ///</summary>
        ///
        ///<returns>
        ///true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
        ///</returns>
        ///
        ///<exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception><filterpriority>2</filterpriority>
        public bool MoveNext()
        {
            this._current = null;
            return this._internal.MoveNext();
        }

        ///<summary>
        ///Sets the enumerator to its initial position, which is before the first element in the collection.
        ///</summary>
        ///
        ///<exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception><filterpriority>2</filterpriority>
        public void Reset()
        {
            this._internal.Reset();
        }

        ///<summary>
        ///Gets the current element in the collection.
        ///</summary>
        ///
        ///<returns>
        ///The current element in the collection.
        ///</returns>
        ///
        ///<exception cref="T:System.InvalidOperationException">The enumerator is positioned before the first element of the collection or after the last element. </exception><filterpriority>2</filterpriority>
        object IEnumerator.Current
        {
            get { return this.GetCurrent(); }
        }

        ///<summary>
        ///Gets the element in the collection at the current position of the enumerator.
        ///</summary>
        ///
        ///<returns>
        ///The element in the collection at the current position of the enumerator.
        ///</returns>
        ///
        TItem IEnumerator<TItem>.Current
        {
            get { return this.GetCurrent(); }
        }

        ///<summary>
        ///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        ///</summary>
        ///<filterpriority>2</filterpriority>
        public void Dispose()
        {
        }

        protected TItem GetCurrent()
        {
            if (this._current == null)
            {
                this._current = this._GetCurrent();
            }

            return this._current;
        }

        protected TItem _GetCurrent()
        {
            return this._collection.CreateItem((TITunesItem) this._internal.Current);
        }
    }

    public class EventAttachStatusChangedEventArgs : EventArgs
    {
        private readonly bool newState;


        public EventAttachStatusChangedEventArgs(bool newState)
        {
            this.newState = newState;
        }

        public bool NewState
        {
            get { return this.newState; }
        }

        public override string ToString()
        {
            return String.Format("{0}({1})", this.GetType(), this.NewState);
        }
    }
}