mono/mcs/class/referencesource/System.Data.Linq/ChangeTracker.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;

namespace System.Data.Linq {
    using System.Data.Linq.Mapping;
    using System.Data.Linq.Provider;

    internal abstract class ChangeTracker {
        /// <summary>
        /// Starts tracking an object as 'unchanged'
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        internal abstract TrackedObject Track(object obj);
        /// <summary>
        /// Starts tracking an object as 'unchanged', and optionally
        /// 'weakly' tracks all other referenced objects recursively.
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="recurse">True if all untracked objects in the graph
        /// should be tracked recursively.</param>
        /// <returns></returns>
        internal abstract TrackedObject Track(object obj, bool recurse);
        /// <summary>
        /// Fast-tracks an object that is already in identity cache
        /// </summary>
        /// <param name="obj"></param>
        internal abstract void FastTrack(object obj);
        internal abstract bool IsTracked(object obj);
        internal abstract TrackedObject GetTrackedObject(object obj);
        internal abstract void StopTracking(object obj);
        internal abstract void AcceptChanges();
        internal abstract IEnumerable<TrackedObject> GetInterestingObjects();

        internal static ChangeTracker CreateChangeTracker(CommonDataServices dataServices, bool asReadOnly) {
            if (asReadOnly) {
                return new ReadOnlyChangeTracker();
            }
            else {
                return new StandardChangeTracker(dataServices);
            }
        }

        class StandardChangeTracker : ChangeTracker {
            Dictionary<object, StandardTrackedObject> items;
            PropertyChangingEventHandler onPropertyChanging;
            CommonDataServices services;

            internal StandardChangeTracker(CommonDataServices services) {
                this.services = services;
                this.items = new Dictionary<object, StandardTrackedObject>();
                this.onPropertyChanging = new PropertyChangingEventHandler(this.OnPropertyChanging);
            }

            /// <summary>
            /// Given a type root and a discriminator, return the type that would be instantiated.
            /// </summary>
            private static MetaType TypeFromDiscriminator(MetaType root, object discriminator) {
                foreach (MetaType type in root.InheritanceTypes) {
                    if (IsSameDiscriminator(discriminator, type.InheritanceCode))
                        return type;
                }
                return root.InheritanceDefault;
            }

            private static bool IsSameDiscriminator(object discriminator1, object discriminator2) {
                if (discriminator1 == discriminator2) {
                    return true;
                }
                if (discriminator1 == null || discriminator2 == null) {
                    return false;
                }
                return discriminator1.Equals(discriminator2);
            }

            internal override TrackedObject Track(object obj) {
                return Track(obj, false);
            }

            internal override TrackedObject Track(object obj, bool recurse) {
                MetaType type = this.services.Model.GetMetaType(obj.GetType());
                Dictionary<object, object> visited = new Dictionary<object, object>();
                return Track(type, obj, visited, recurse, 1);
            }

            private TrackedObject Track(MetaType mt, object obj, Dictionary<object, object> visited, bool recurse, int level) {
                StandardTrackedObject tracked = (StandardTrackedObject)this.GetTrackedObject(obj);
                if (tracked != null || visited.ContainsKey(obj)) {
                    return tracked;
                }

                // The root object tracked is tracked normally - all other objects
                // in the reference graph are weakly tracked.
                bool weaklyTrack = level > 1;
                tracked = new StandardTrackedObject(this, mt, obj, obj, weaklyTrack);
                if (tracked.HasDeferredLoaders) {
                    throw Error.CannotAttachAddNonNewEntities();
                }
                this.items.Add(obj, tracked);
                this.Attach(obj);
                visited.Add(obj, obj);

                if (recurse) {
                    // track parents (objects we are dependent on)
                    foreach (RelatedItem parent in this.services.GetParents(mt, obj)) {
                        this.Track(parent.Type, parent.Item, visited, recurse, level + 1);
                    }

                    // track children (objects that are dependent on us)
                    foreach (RelatedItem child in this.services.GetChildren(mt, obj)) {
                        this.Track(child.Type, child.Item, visited, recurse, level + 1);
                    }
                }

                return tracked;
            }

            internal override void FastTrack(object obj) {
                // assumes object is already in identity cache
                this.Attach(obj);
            }

            internal override void StopTracking(object obj) {
                this.Detach(obj);
                this.items.Remove(obj);
            }

            internal override bool IsTracked(object obj) {
                return this.items.ContainsKey(obj) || this.IsFastTracked(obj);
            }

            private bool IsFastTracked(object obj) {
                MetaType type = this.services.Model.GetTable(obj.GetType()).RowType;
                return this.services.IsCachedObject(type, obj);
            }

            internal override TrackedObject GetTrackedObject(object obj) {
                StandardTrackedObject ti;
                if (!this.items.TryGetValue(obj, out ti)) {
                    if (this.IsFastTracked(obj)) {
                        return this.PromoteFastTrackedObject(obj);
                    }
                }
                return ti;
            }

            private StandardTrackedObject PromoteFastTrackedObject(object obj) {
                Type type = obj.GetType();
                MetaType metaType = this.services.Model.GetTable(type).RowType.GetInheritanceType(type);
                return this.PromoteFastTrackedObject(metaType, obj);
            }

            private StandardTrackedObject PromoteFastTrackedObject(MetaType type, object obj) {
                StandardTrackedObject ti = new StandardTrackedObject(this, type, obj, obj);
                this.items.Add(obj, ti);
                return ti;
            }

            private void Attach(object obj) {
                INotifyPropertyChanging notifier = obj as INotifyPropertyChanging;
                if (notifier != null) {
                    notifier.PropertyChanging += this.onPropertyChanging;
                }
                else {
                    // if has no notifier, consider it modified already
                    this.OnPropertyChanging(obj, null);
                }
            }

            private void Detach(object obj) {
                INotifyPropertyChanging notifier = obj as INotifyPropertyChanging;
                if (notifier != null) {
                    notifier.PropertyChanging -= this.onPropertyChanging;
                }
            }

            private void OnPropertyChanging(object sender, PropertyChangingEventArgs args) {
                StandardTrackedObject ti;
                if (this.items.TryGetValue(sender, out ti)) {
                    ti.StartTracking();
                }
                else if (this.IsFastTracked(sender)) {
                    ti = this.PromoteFastTrackedObject(sender);
                    ti.StartTracking();
                }
            }

            internal override void AcceptChanges() {
                List<StandardTrackedObject> list = new List<StandardTrackedObject>((IEnumerable<StandardTrackedObject>)this.items.Values);
                foreach (TrackedObject item in list) {
                    item.AcceptChanges();
                }
            }

            internal override IEnumerable<TrackedObject> GetInterestingObjects() {
                foreach (StandardTrackedObject ti in this.items.Values) {
                    if (ti.IsInteresting) {
                        yield return ti;
                    }
                }
            }

            class StandardTrackedObject : TrackedObject {
                private StandardChangeTracker tracker;
                private MetaType type;
                private object current;
                private object original;
                private State state;
                private BitArray dirtyMemberCache;
                private bool haveInitializedDeferredLoaders;
                private bool isWeaklyTracked;                

                enum State {
                    New,
                    Deleted,
                    PossiblyModified,
                    Modified,
                    Removed,
                    Dead
                }

                public override string ToString() {
                    return type.Name + ":" + GetState();
                }

                private string GetState() {
                    switch (this.state) {
                        case State.New:
                        case State.Deleted:
                        case State.Dead:
                        case State.Removed:
                            return this.state.ToString();
                        default:
                            if (this.IsModified) {
                                return "Modified";
                            }
                            else {
                                return "Unmodified";
                            }
                    }
                }

                internal StandardTrackedObject(StandardChangeTracker tracker, MetaType type, object current, object original) {
                    if (current == null) {
                        throw Error.ArgumentNull("current");
                    }
                    this.tracker = tracker;
                    this.type = type.GetInheritanceType(current.GetType());
                    this.current = current;
                    this.original = original;
                    this.state = State.PossiblyModified;
                    dirtyMemberCache = new BitArray(this.type.DataMembers.Count);
                }

                internal StandardTrackedObject(StandardChangeTracker tracker, MetaType type, object current, object original, bool isWeaklyTracked)
                    : this(tracker, type, current, original) {
                    this.isWeaklyTracked = isWeaklyTracked;
                }

                internal override bool IsWeaklyTracked {
                    get { return isWeaklyTracked; }
                }

                internal override MetaType Type {
                    get { return this.type; }
                }

                internal override object Current {
                    get { return this.current; }
                }

                internal override object Original {
                    get { return this.original; }
                }

                internal override bool IsNew {
                    get { return this.state == State.New; }
                }

                internal override bool IsDeleted {
                    get { return this.state == State.Deleted; }
                }

                internal override bool IsRemoved {
                    get { return this.state == State.Removed; }
                }

                internal override bool IsDead {
                    get { return this.state == State.Dead; }
                }

                internal override bool IsModified {
                    get { return this.state == State.Modified || (this.state == State.PossiblyModified && this.current != this.original && this.HasChangedValues()); }
                }

                internal override bool IsUnmodified {
                    get { return this.state == State.PossiblyModified && (this.current == this.original || !this.HasChangedValues()); }
                }

                internal override bool IsPossiblyModified {
                    get { return this.state == State.Modified || this.state == State.PossiblyModified; }
                }

                internal override bool CanInferDelete() {
                    // A delete can be inferred iff there is a non-nullable singleton association that has 
                    // been set to null, and the association has DeleteOnNull = true.
                    if (this.state == State.Modified || this.state == State.PossiblyModified) {
                        foreach (MetaAssociation assoc in Type.Associations) {
                            if (assoc.DeleteOnNull && assoc.IsForeignKey && !assoc.IsNullable && !assoc.IsMany &&
                                assoc.ThisMember.StorageAccessor.HasAssignedValue(Current) &&
                                assoc.ThisMember.StorageAccessor.GetBoxedValue(Current) == null) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

                internal override bool IsInteresting {
                    get {
                        return this.state == State.New ||
                               this.state == State.Deleted ||
                               this.state == State.Modified ||
                               (this.state == State.PossiblyModified && this.current != this.original) ||
                               CanInferDelete();
                    }
                }

                internal override void ConvertToNew() {
                    // must be new or unmodified or removed to convert to new
                    System.Diagnostics.Debug.Assert(this.IsNew || this.IsRemoved || this.IsUnmodified);
                    this.original = null;
                    this.state = State.New;
                }

                internal override void ConvertToPossiblyModified() {
                    System.Diagnostics.Debug.Assert(this.IsPossiblyModified || this.IsDeleted);
                    this.state = State.PossiblyModified;
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToModified() {
                    System.Diagnostics.Debug.Assert(this.IsPossiblyModified);
                    System.Diagnostics.Debug.Assert(this.type.VersionMember != null || !this.type.HasUpdateCheck);
                    this.state = State.Modified;
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToPossiblyModified(object originalState) {
                    // must be modified or unmodified to convert to modified
                    System.Diagnostics.Debug.Assert(this.IsNew || this.IsPossiblyModified);
                    System.Diagnostics.Debug.Assert(originalState != null);
                    System.Diagnostics.Debug.Assert(originalState.GetType() == this.type.Type);
                    this.state = State.PossiblyModified;
                    this.original = this.CreateDataCopy(originalState);
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToDeleted() {
                    // must be modified or unmodified to be deleted
                    System.Diagnostics.Debug.Assert(this.IsDeleted || this.IsPossiblyModified);
                    this.state = State.Deleted;
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToDead() {
                    System.Diagnostics.Debug.Assert(this.IsDead || this.IsDeleted);
                    this.state = State.Dead;
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToRemoved() {
                    System.Diagnostics.Debug.Assert(this.IsRemoved || this.IsNew);
                    this.state = State.Removed;
                    this.isWeaklyTracked = false;
                }

                internal override void ConvertToUnmodified() {
                    System.Diagnostics.Debug.Assert(this.IsNew || this.IsPossiblyModified);
                    // reset to unmodified
                    this.state = State.PossiblyModified;
                    if (this.current is INotifyPropertyChanging) {
                        this.original = this.current;
                    }
                    else {
                        this.original = this.CreateDataCopy(this.current);
                    }
                    this.ResetDirtyMemberTracking();
                    this.isWeaklyTracked = false;
                }

                internal override void AcceptChanges() {
                    if (IsWeaklyTracked) {
                        InitializeDeferredLoaders();
                        isWeaklyTracked = false;
                    }
                    if (this.IsDeleted) {
                        this.ConvertToDead();
                    }
                    else if (this.IsNew) {
                        this.InitializeDeferredLoaders();
                        this.ConvertToUnmodified();
                    }
                    else if (this.IsPossiblyModified) {
                        this.ConvertToUnmodified();
                    }
                }

                private void AssignMember(object instance, MetaDataMember mm, object value) {
                    // In the unnotified case, directly use the storage accessor
                    // for everything because there are not events to be fired.
                    if (!(this.current is INotifyPropertyChanging)) {
                        mm.StorageAccessor.SetBoxedValue(ref instance, value);
                    }
                    else {
                        // Go through the member accessor to fire events.
                        mm.MemberAccessor.SetBoxedValue(ref instance, value);
                    }
                }

                /// <summary>
                /// Certain state is saved during change tracking to enable modifications
                /// to be detected taking refresh operations into account.  When changes
                /// are reverted or accepted, this state must be reset.
                /// </summary>
                private void ResetDirtyMemberTracking() {
                    this.dirtyMemberCache.SetAll(false);
                }

                /// <summary>
                /// Refresh internal tracking state using the original value and mode
                /// specified.
                /// </summary>        
                internal override void Refresh(RefreshMode mode, object freshInstance) {
                    this.SynchDependentData();

                    // This must be done prior to updating original values
                    this.UpdateDirtyMemberCache();

                    // Apply the refresh strategy to each data member
                    Type instanceType = freshInstance.GetType();
                    foreach (MetaDataMember mm in type.PersistentDataMembers) {
                        var memberMode = mm.IsDbGenerated ? RefreshMode.OverwriteCurrentValues : mode;
                        if (memberMode != RefreshMode.KeepCurrentValues) {
                            if (!mm.IsAssociation && (this.Type.Type == instanceType || mm.DeclaringType.Type.IsAssignableFrom(instanceType))) {
                                object freshValue = mm.StorageAccessor.GetBoxedValue(freshInstance);
                                this.RefreshMember(mm, memberMode, freshValue);
                            }
                        }
                    }

                    // Make the new data the current original value
                    this.original = this.CreateDataCopy(freshInstance);

                    if (mode == RefreshMode.OverwriteCurrentValues) {
                        this.ResetDirtyMemberTracking();
                    }
                }

                /// <summary>
                /// Using the last saved comparison baseline, figure out which members have
                /// changed since the last refresh, and save that information.  This must be
                /// done BEFORE any merge operations modify the current values.
                /// </summary>
                private void UpdateDirtyMemberCache() {
                    // iterate over all members, and if they differ from 
                    // last read values, mark as dirty           
                    foreach (MetaDataMember mm in type.PersistentDataMembers) {
                        if (mm.IsAssociation && mm.Association.IsMany) {
                            continue;
                        }
                        if (!this.dirtyMemberCache.Get(mm.Ordinal) && this.HasChangedValue(mm)) {
                            this.dirtyMemberCache.Set(mm.Ordinal, true);
                        }
                    }
                }

                internal override void RefreshMember(MetaDataMember mm, RefreshMode mode, object freshValue) {
                    System.Diagnostics.Debug.Assert(!mm.IsAssociation);

                    if (mode == RefreshMode.KeepCurrentValues) {
                        return;
                    }

                    bool hasUserChange = this.HasChangedValue(mm);

                    // we don't want to overwrite any modified values, unless
                    // the mode is original wins                
                    if (hasUserChange && mode != RefreshMode.OverwriteCurrentValues)
                        return;

                    object currentValue = mm.StorageAccessor.GetBoxedValue(this.current);
                    if (!object.Equals(freshValue, currentValue)) {
                        mm.StorageAccessor.SetBoxedValue(ref this.current, freshValue);

                        // update all singleton associations that are affected by a change to this member
                        foreach (MetaDataMember am in this.GetAssociationsForKey(mm)) {
                            if (!am.Association.IsMany) {
                                IEnumerable ds = this.tracker.services.GetDeferredSourceFactory(am).CreateDeferredSource(this.current);
                                if (am.StorageAccessor.HasValue(this.current)) {
                                    this.AssignMember(this.current, am, ds.Cast<Object>().SingleOrDefault());
                                }
                            }
                        }
                    }
                }

                private IEnumerable<MetaDataMember> GetAssociationsForKey(MetaDataMember key) {
                    foreach (MetaDataMember mm in this.type.PersistentDataMembers) {
                        if (mm.IsAssociation && mm.Association.ThisKey.Contains(key)) {
                            yield return mm;
                        }
                    }
                }

                internal override object CreateDataCopy(object instance) {
                    System.Diagnostics.Debug.Assert(instance != null);
                    Type instanceType = instance.GetType();
                    System.Diagnostics.Debug.Assert(instance.GetType() == this.type.Type);

                    object copy = Activator.CreateInstance(this.Type.Type);

                    MetaType rootMetaType = this.tracker.services.Model.GetTable(instanceType).RowType.InheritanceRoot;
                    foreach (MetaDataMember mm in rootMetaType.GetInheritanceType(instanceType).PersistentDataMembers) {
                        if (this.Type.Type != instanceType && !mm.DeclaringType.Type.IsAssignableFrom(instanceType)) {
                            continue;
                        }
                        if (mm.IsDeferred) {
                            // do not copy associations
                            if (!mm.IsAssociation) {
                                if (mm.StorageAccessor.HasValue(instance)) {
                                    object value = mm.DeferredValueAccessor.GetBoxedValue(instance);
                                    mm.DeferredValueAccessor.SetBoxedValue(ref copy, value);
                                }
                                else {
                                    IEnumerable ds = this.tracker.services.GetDeferredSourceFactory(mm).CreateDeferredSource(copy);
                                    mm.DeferredSourceAccessor.SetBoxedValue(ref copy, ds);
                                }
                            }
                        }
                        else {
                            // otherwise assign the value as-is to the backup instance
                            object value = mm.StorageAccessor.GetBoxedValue(instance);
                            // assumes member values are immutable or will communicate changes to entity
                            // note: byte[] and char[] don't do this. 
                            mm.StorageAccessor.SetBoxedValue(ref copy, value);
                        }
                    }
                    return copy;
                }

                internal void StartTracking() {
                    if (this.original == this.current) {
                        this.original = this.CreateDataCopy(this.current);
                    }
                }

                // Return value indicates whether or not any data was actually [....]'d
                internal override bool SynchDependentData() {                    
                    bool valueWasSet = false;

                    // set foreign key fields
                    foreach (MetaAssociation assoc in this.Type.Associations) {
                        MetaDataMember mm = assoc.ThisMember;
                        if (assoc.IsForeignKey) {
                            bool hasAssigned = mm.StorageAccessor.HasAssignedValue(this.current);
                            bool hasLoaded = mm.StorageAccessor.HasLoadedValue(this.current);
                            if (hasAssigned || hasLoaded) {
                                object parent = mm.StorageAccessor.GetBoxedValue(this.current);
                                if (parent != null) {
                                    // copy parent's current primary key into this instance's foreign key fields
                                    for (int i = 0, n = assoc.ThisKey.Count; i < n; i++) {
                                        MetaDataMember accThis = assoc.ThisKey[i];
                                        MetaDataMember accParent = assoc.OtherKey[i];
                                        object parentValue = accParent.StorageAccessor.GetBoxedValue(parent);
                                        accThis.StorageAccessor.SetBoxedValue(ref this.current, parentValue);
                                        valueWasSet = true;
                                    }
                                }
                                else if (assoc.IsNullable) {
                                    if (mm.IsDeferred || (this.original != null && mm.MemberAccessor.GetBoxedValue(this.original) != null)) {
                                        // no known parent? set to null
                                        for (int i = 0, n = assoc.ThisKey.Count; i < n; i++) {
                                            MetaDataMember accThis = assoc.ThisKey[i];
                                            if (accThis.CanBeNull) {
                                                if (this.original != null && this.HasChangedValue(accThis)) {
                                                    if (accThis.StorageAccessor.GetBoxedValue(this.current) != null) {
                                                        throw Error.InconsistentAssociationAndKeyChange(accThis.Member.Name, mm.Member.Name);
                                                    }
                                                }
                                                else {
                                                    accThis.StorageAccessor.SetBoxedValue(ref this.current, null);
                                                    valueWasSet = true;
                                                }
                                            }
                                        }
                                    }
                                }
                                else if (!hasLoaded) {
                                    //Else the parent association has been set to null; but the ID is not nullable so
                                    //the value can not be set
                                    StringBuilder keys = new StringBuilder();
                                    foreach (MetaDataMember key in assoc.ThisKey) {
                                        if (keys.Length > 0) {
                                            keys.Append(", ");
                                        }
                                        keys.AppendFormat("{0}.{1}", this.Type.Name.ToString(), key.Name);
                                    }
                                    throw Error.CouldNotRemoveRelationshipBecauseOneSideCannotBeNull(assoc.OtherType.Name, this.Type.Name, keys);
                                }
                            }
                        }
                    }

                    /// Explicitly set any inheritance discriminator for item.
                    if (this.type.HasInheritance) {
                        if (this.original != null) {
                            object currentDiscriminator = type.Discriminator.MemberAccessor.GetBoxedValue(this.current);
                            MetaType currentTypeFromDiscriminator = TypeFromDiscriminator(this.type, currentDiscriminator);
                            object dbDiscriminator = type.Discriminator.MemberAccessor.GetBoxedValue(this.original);
                            MetaType dbTypeFromDiscriminator = TypeFromDiscriminator(this.type, dbDiscriminator);

                            // Would the discriminator change also change the type? If so, its not allowed.
                            if (currentTypeFromDiscriminator != dbTypeFromDiscriminator) {
                                throw Error.CannotChangeInheritanceType(dbDiscriminator,
                                    currentDiscriminator, original.GetType().Name, currentTypeFromDiscriminator);
                            }
                        }
                        else {
                            // No db value means this is an 'Add'. Set the discriminator.
                            MetaType currentType = type.GetInheritanceType(this.current.GetType());
                            if (currentType.HasInheritanceCode) {
                                object code = currentType.InheritanceCode;
                                this.type.Discriminator.MemberAccessor.SetBoxedValue(ref current, code);
                                valueWasSet = true;
                            }
                        }
                    }
                    return valueWasSet;
                }

                internal override bool HasChangedValue(MetaDataMember mm) {
                    if (this.current == this.original) {
                        return false;
                    }
                    if (mm.IsAssociation && mm.Association.IsMany) {
                        return mm.StorageAccessor.HasAssignedValue(this.original);
                    }
                    if (mm.StorageAccessor.HasValue(this.current)) {
                        if (this.original != null && mm.StorageAccessor.HasValue(this.original)) {
                            // If the member has ever been in a modified state
                            // in the past, it is considered modified
                            if (dirtyMemberCache.Get(mm.Ordinal)) {
                                return true;
                            }
                            object baseline = mm.MemberAccessor.GetBoxedValue(this.original);
                            object currentValue = mm.MemberAccessor.GetBoxedValue(this.current);
                            if (!object.Equals(currentValue, baseline)) {
                                return true;
                            }
                            return false;
                        }
                        else if (mm.IsDeferred && mm.StorageAccessor.HasAssignedValue(this.current)) {
                            return true;
                        }
                    }
                    return false;
                }

                internal override bool HasChangedValues() {
                    if (this.current == this.original) {
                        return false;
                    }
                    if (this.IsNew) {
                        return true;
                    }
                    foreach (MetaDataMember mm in this.type.PersistentDataMembers) {
                        if (!mm.IsAssociation && this.HasChangedValue(mm)) {
                            return true;
                        }
                    }
                    return false;
                }

                internal override IEnumerable<ModifiedMemberInfo> GetModifiedMembers() {
                    foreach (MetaDataMember mm in this.type.PersistentDataMembers) {
                        if (this.IsModifiedMember(mm)) {
                            object currentValue = mm.MemberAccessor.GetBoxedValue(this.current);
                            if (this.original != null && mm.StorageAccessor.HasValue(this.original)) {
                                object originalValue = mm.MemberAccessor.GetBoxedValue(this.original);
                                yield return new ModifiedMemberInfo(mm.Member, currentValue, originalValue);
                            }
                            else if (this.original == null || (mm.IsDeferred && !mm.StorageAccessor.HasLoadedValue(this.current))) {
                                yield return new ModifiedMemberInfo(mm.Member, currentValue, null);
                            }
                        }
                    }
                }

                private bool IsModifiedMember(MetaDataMember member) {
                    return !member.IsAssociation &&
                           !member.IsPrimaryKey &&
                           !member.IsVersion &&
                           !member.IsDbGenerated &&
                            member.StorageAccessor.HasAssignedValue(this.current) &&
                           (this.state == State.Modified ||
                           (this.state == State.PossiblyModified && this.HasChangedValue(member)));
                }

                internal override bool HasDeferredLoaders {
                    get {
                        foreach (MetaAssociation assoc in this.Type.Associations) {
                            if (HasDeferredLoader(assoc.ThisMember)) {
                                return true;
                            }
                        }
                        IEnumerable<MetaDataMember> deferredMembers = this.Type.PersistentDataMembers.Where(p => p.IsDeferred && !p.IsAssociation);
                        foreach (MetaDataMember deferredMember in deferredMembers) {
                            if (HasDeferredLoader(deferredMember)) {
                                return true;
                            }
                        }
                        return false;
                    }
                }

                private bool HasDeferredLoader(MetaDataMember deferredMember) {
                    if (!deferredMember.IsDeferred) {
                        return false;
                    }

                    MetaAccessor acc = deferredMember.StorageAccessor;
                    if (acc.HasAssignedValue(this.current) || acc.HasLoadedValue(this.current)) {
                        return false;
                    }
                    MetaAccessor dsacc = deferredMember.DeferredSourceAccessor;
                    IEnumerable loader = (IEnumerable)dsacc.GetBoxedValue(this.current);

                    return loader != null;
                }

                /// <summary>
                /// Called to initialize deferred loaders for New or Attached entities.
                /// </summary>
                internal override void InitializeDeferredLoaders() {
                    if (this.tracker.services.Context.DeferredLoadingEnabled) {
                        foreach (MetaAssociation assoc in this.Type.Associations) {
                            // don't set loader on association that is dependent on unrealized generated values
                            if (!this.IsPendingGeneration(assoc.ThisKey)) {
                                InitializeDeferredLoader(assoc.ThisMember);
                            }
                        }
                        IEnumerable<MetaDataMember> deferredMembers = this.Type.PersistentDataMembers.Where(p => p.IsDeferred && !p.IsAssociation);
                        foreach (MetaDataMember deferredMember in deferredMembers) {
                            // don't set loader on member that is dependent on unrealized generated values
                            if (!this.IsPendingGeneration(Type.IdentityMembers)) {
                                InitializeDeferredLoader(deferredMember);
                            }
                        }
                        haveInitializedDeferredLoaders = true;
                    }
                }

                private void InitializeDeferredLoader(MetaDataMember deferredMember) {
                    MetaAccessor acc = deferredMember.StorageAccessor;
                    if (!acc.HasAssignedValue(this.current) && !acc.HasLoadedValue(this.current)) {
                        MetaAccessor dsacc = deferredMember.DeferredSourceAccessor;
                        IEnumerable loader = (IEnumerable)dsacc.GetBoxedValue(this.current);
                        // don't reset loader on any deferred member that already has one
                        if (loader == null) {
                            IDeferredSourceFactory factory = this.tracker.services.GetDeferredSourceFactory(deferredMember);
                            loader = factory.CreateDeferredSource(this.current);
                            dsacc.SetBoxedValue(ref this.current, loader);

                        }
                        else if (loader != null && !haveInitializedDeferredLoaders) {
                            // If loader is present but wasn't generated by us, then
                            // an attempt to Attach or Add an entity from another context
                            // has been made, which is not supported.
                            throw Error.CannotAttachAddNonNewEntities();
                        }
                    }
                }

                internal override bool IsPendingGeneration(IEnumerable<MetaDataMember> key) {
                    if (this.IsNew) {
                        foreach (MetaDataMember member in key) {
                            if (IsMemberPendingGeneration(member)) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

                internal override bool IsMemberPendingGeneration(MetaDataMember keyMember) {
                    if (this.IsNew && keyMember.IsDbGenerated) {
                        return true;
                    }
                    // look for any FK association that has this key member (should only be one)
                    foreach (MetaAssociation assoc in type.Associations) {
                        if (assoc.IsForeignKey) {
                            int index = assoc.ThisKey.IndexOf(keyMember);
                            if (index > -1) {
                                // we must have a reference to this other object to know if its side of 
                                // the association is generated or not
                                object otherItem = null;
                                if (assoc.ThisMember.IsDeferred) {
                                    otherItem = assoc.ThisMember.DeferredValueAccessor.GetBoxedValue(this.current);
                                }
                                else {
                                    otherItem = assoc.ThisMember.StorageAccessor.GetBoxedValue(this.current);
                                }
                                if (otherItem != null) {
                                    if (assoc.IsMany) {
                                        // Can't be pending generation for a value that would have to be the same
                                        // across many rows.
                                        continue;
                                    }
                                    else {
                                        StandardTrackedObject trackedOther = (StandardTrackedObject)this.tracker.GetTrackedObject(otherItem);
                                        if (trackedOther != null) {
                                            MetaDataMember otherMember = assoc.OtherKey[index];
                                            return trackedOther.IsMemberPendingGeneration(otherMember);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    return false;
                }
            }
        }

        /// <summary>
        /// This is the implementation used when change tracking is disabled.
        /// </summary>
        class ReadOnlyChangeTracker : ChangeTracker {
            internal override TrackedObject Track(object obj) { return null; }
            internal override TrackedObject Track(object obj, bool recurse) { return null; }
            internal override void FastTrack(object obj) { }
            internal override bool IsTracked(object obj) { return false; }
            internal override TrackedObject GetTrackedObject(object obj) { return null; }
            internal override void StopTracking(object obj) { }
            internal override void AcceptChanges() { }
            internal override IEnumerable<TrackedObject> GetInterestingObjects() { return new TrackedObject[0]; }
        }
    }

    internal abstract class TrackedObject {
        internal abstract MetaType Type { get; }
        /// <summary>
        /// The current client value.
        /// </summary>
        internal abstract object Current { get; }
        /// <summary>
        /// The last read database value.  This is updated whenever the
        /// item is refreshed.
        /// </summary>
        internal abstract object Original { get; }
        internal abstract bool IsInteresting { get; } // new, deleted or possibly changed
        internal abstract bool IsNew { get; }
        internal abstract bool IsDeleted { get; }
        internal abstract bool IsModified { get; }
        internal abstract bool IsUnmodified { get; }
        internal abstract bool IsPossiblyModified { get; }
        internal abstract bool IsRemoved { get; }
        internal abstract bool IsDead { get; }
        /// <summary>
        /// True if the object is being tracked (perhaps during a recursive
        /// attach operation) but can be transitioned to other states.
        /// </summary>
        internal abstract bool IsWeaklyTracked { get; }
        internal abstract bool HasDeferredLoaders { get; }        
        internal abstract bool HasChangedValues();
        internal abstract IEnumerable<ModifiedMemberInfo> GetModifiedMembers();
        internal abstract bool HasChangedValue(MetaDataMember mm);
        internal abstract bool CanInferDelete();
        internal abstract void AcceptChanges();
        internal abstract void ConvertToNew();
        internal abstract void ConvertToPossiblyModified();
        internal abstract void ConvertToPossiblyModified(object original);
        internal abstract void ConvertToUnmodified();
        internal abstract void ConvertToModified();
        internal abstract void ConvertToDeleted();
        internal abstract void ConvertToRemoved();
        internal abstract void ConvertToDead();
        /// <summary>
        /// Refresh the item by making the value passed in the current 
        /// Database value, and refreshing the current values using the
        /// mode specified.
        /// </summary>       
        internal abstract void Refresh(RefreshMode mode, object freshInstance);
        /// <summary>
        /// Does the refresh operation for a single member.  This method does not 
        /// update the baseline 'original' value.  You must call 
        /// Refresh(RefreshMode.KeepCurrentValues, freshInstance) to finish the refresh 
        /// after refreshing individual members.
        /// </summary>
        /// <param name="member"></param>
        /// <param name="mode"></param>
        /// <param name="freshValue"></param>
        internal abstract void RefreshMember(MetaDataMember member, RefreshMode mode, object freshValue);
        /// <summary>
        /// Create a data-member only copy of the instance (no associations)
        /// </summary>
        /// <returns></returns>
        internal abstract object CreateDataCopy(object instance);

        internal abstract bool SynchDependentData();

        internal abstract bool IsPendingGeneration(IEnumerable<MetaDataMember> keyMembers);
        internal abstract bool IsMemberPendingGeneration(MetaDataMember keyMember);

        internal abstract void InitializeDeferredLoaders();
    }
}