예제 #1
0
        public bool CompareLists(IList newList, IList oldList)
        {
            bool stackNewMute           = false;
            bool stackOldMute           = false;
            IInterceptableList iNewList = newList as IInterceptableList;

            if (iNewList != null)
            {
                stackNewMute        = iNewList.MuteNotify;
                iNewList.MuteNotify = true;
            }
            IInterceptableList iOldList = newList as IInterceptableList;

            if (iOldList != null)
            {
                stackOldMute        = iOldList.MuteNotify;
                iOldList.MuteNotify = true;
            }

            bool result = DoCompareLists(newList, oldList);

            if (iNewList != null)
            {
                iNewList.MuteNotify = stackNewMute;
            }
            if (iOldList != null)
            {
                iOldList.MuteNotify = stackOldMute;
            }

            return(result);
        }
예제 #2
0
        protected void OverwriteOriginalList()
        {
            bool  stackMute = false;
            IList orgList   = this.cachedOriginalValue as IList;
            IList freshList = this.freshValue as IList;

            IInterceptableList mList = orgList as IInterceptableList;

            if (mList != null)
            {
                stackMute        = mList.MuteNotify;
                mList.MuteNotify = true;
            }
            orgList.Clear();

            foreach (object value in freshList)
            {
                orgList.Add(value);
            }

            if (mList != null)
            {
                mList.MuteNotify = stackMute;
            }
        }
        public void CheckPartiallyLoadedList(string propertyName, ITransaction transaction)
        {
            IList partialList = GetPartiallyLoadedList(propertyName, transaction);
            int   count       = GetCount(propertyName, transaction);

            if (count == partialList.Count)
            {
                IContext       context = ((IInterceptable)this.target).GetInterceptor().Context;
                IObjectManager om      = context.ObjectManager;

                IInterceptableList iList = om.GetPropertyValue(target, propertyName) as IInterceptableList;
                if (iList == null)
                {
                    throw new NPersistException(string.Format("Object of type {0} and identity {1} does not have an interceptable list injected in property {2}", target.GetType(), om.GetObjectIdentity(target), propertyName));
                }

                bool stackMute = iList.MuteNotify;
                iList.MuteNotify = true;

                if (iList.Count < 1)
                {
                    IList orgList = new ArrayList();
                    foreach (object refObj in partialList)
                    {
                        iList.Add(refObj);
                        orgList.Add(refObj);
                    }
                    iList.MuteNotify = stackMute;
                    om.SetPropertyValue(target, propertyName, iList);
                    om.SetOriginalPropertyValue(target, propertyName, orgList);
                    om.SetNullValueStatus(target, propertyName, false);
                    om.SetUpdatedStatus(target, propertyName, false);

                    context.InverseManager.NotifyPropertyGet(target, propertyName);
                }
                else
                {
                    iList.MuteNotify = stackMute;
                }
            }
        }
예제 #4
0
        public static IInterceptableList CreateProxy(Type baseType, IObjectFactory objectFactory, params object[] ctorArgs)
        {
            if (objectFactory == null)
            {
                throw new Exception("apa");
            }

            Type proxyType = GetProxyType(baseType);

            IInterceptableList result = (IInterceptableList)objectFactory.CreateInstance(proxyType, ctorArgs);

            if (result == null)
            {
                result = (IInterceptableList)Activator.CreateInstance(proxyType, ctorArgs);
            }

            //attach the an interceptor to the list
            //result.SetInterceptor(new ListInterceptor());


            return(result);
        }
예제 #5
0
        //[DebuggerStepThrough()]
        protected virtual void DoNotifyPropertySet(object obj, string propertyName, ref object value, object oldValue, bool hasOldValue, ref bool cancel)
        {
            IContext                ctx = this.Context;
            IObjectManager          om  = ctx.ObjectManager;
            IPersistenceEngine      pe  = ctx.PersistenceEngine;
            PropertyCancelEventArgs e;

            if (hasOldValue)
            {
                e = new PropertyCancelEventArgs(obj, propertyName, value, oldValue, this.Context.ObjectManager.GetNullValueStatus(obj, propertyName));
            }
            else
            {
                e = new PropertyCancelEventArgs(obj, propertyName, value, this.Context.ObjectManager.GetPropertyValue(obj, propertyName), this.Context.ObjectManager.GetNullValueStatus(obj, propertyName));
            }
            this.Context.EventManager.OnWritingProperty(this, e);
            if (e.Cancel)
            {
                cancel = true;
                return;
            }
            value = e.NewValue;
            IClassMap    classMap = ctx.DomainMap.MustGetClassMap(obj.GetType());
            IPropertyMap propertyMap;
            string       prevId;
            string       newId;

            propertyMap = classMap.MustGetPropertyMap(propertyName);

            if (propertyMap.ReferenceType != ReferenceType.None && value != null)
            {
                if (propertyMap.ReferenceType == ReferenceType.OneToMany || propertyMap.ReferenceType == ReferenceType.OneToOne)
                {
                    //parent object
                    IInterceptable ivalue = value as IInterceptable;
                    if (ivalue == null)
                    {
                        throw new NPersistException(string.Format("Object is not a NPersist managed object, do not use 'new' on Entities. (Property='{0}', Owner={1})", propertyName, obj));
                    }
                    else
                    {
                        if (ivalue.GetInterceptor().Context != this.Context)
                        {
                            throw new NPersistException(string.Format("Object does not belong to the same context object as the property owner. (Property='{0}', Owner={1})", propertyName, obj));
                        }
                        ObjectStatus valueObjectStatus = om.GetObjectStatus(value);
                        if (valueObjectStatus == ObjectStatus.UpForDeletion || valueObjectStatus == ObjectStatus.Deleted)
                        {
                            throw new DeletedObjectException(string.Format("Object has been deleted. (Object={0})", value), value);
                        }
                    }
                }
                else if (propertyMap.ReferenceType == ReferenceType.ManyToOne || propertyMap.ReferenceType == ReferenceType.ManyToMany)
                {
                    IInterceptableList ivalue = value as IInterceptableList;
                    if (ivalue == null)
                    {
                        throw new NPersistException(string.Format("List is not a NPersist managed list, do not use 'new' to initialize lists, NPersist does this for you. (Property='{0}', Owner={1})", propertyName, obj));
                    }
                    else if (ivalue.Interceptable.GetInterceptor().Context != this.Context)
                    {
                        throw new NPersistException(string.Format("List does not belong to the same context object as the property owner. (Property='{0}', Owner={1})", propertyName, obj));
                    }
                }
            }

            if (propertyMap.IsReadOnly)
            {
                //Let read-only inverse properties through
                if (!(propertyMap.ReferenceType != ReferenceType.None && propertyMap.Inverse.Length > 0 && propertyMap.NoInverseManagement == false))
                {
                    //Special - if someone forgot to make their ManyOne read-only,
                    //why bug them about it? (so don't add an "else" with an exception...)
                    if (propertyMap.ReferenceType != ReferenceType.ManyToOne)
                    {
                        throw new ReadOnlyException("Property '" + classMap.Name + "." + propertyName + "' is read-only!");                         // do not localize
                    }
                }
            }
            PropertyStatus propStatus        = PropertyStatus.Clean;
            ObjectStatus   objStatus         = om.GetObjectStatus(obj);
            bool           hasPropertyStatus = false;

            if (objStatus == ObjectStatus.Deleted)
            {
                throw new DeletedObjectException("The object has been deleted!", obj, propertyName);                 // do not localize
            }
            else if (objStatus == ObjectStatus.UpForDeletion)
            {
                throw new DeletedObjectException("The object has been registered as up for deletion!", obj, propertyName);                 // do not localize
            }

            this.Context.ObjectCloner.EnsureIsClonedIfEditing(obj);

            if (objStatus == ObjectStatus.UpForCreation)
            {
            }
            else if (objStatus == ObjectStatus.Clean)
            {
                propStatus = om.GetPropertyStatus(obj, propertyName);
                if (propStatus == PropertyStatus.NotLoaded)
                {
                    pe.LoadProperty(obj, propertyName);
                }
                if (!(hasOldValue))
                {
                    if (!(om.ComparePropertyValues(obj, propertyName, value, om.GetPropertyValue(obj, propertyName))))
                    {
                        this.Context.UnitOfWork.RegisterDirty(obj);
                    }
                }
            }
            else if (objStatus == ObjectStatus.NotLoaded)
            {
                propertyMap = this.Context.DomainMap.MustGetClassMap(obj.GetType()).MustGetPropertyMap(propertyName);
                if (!(propertyMap.IsIdentity))
                {
                    propStatus        = this.Context.ObjectManager.GetPropertyStatus(obj, propertyName);
                    hasPropertyStatus = true;
                    //it would be sweet to be able to determine beforehand if this property would be part of the span
                    //that is loaded with LoadObject and only call LoadObject if that is the case....
                    if (propStatus == PropertyStatus.NotLoaded)
                    {
                        hasPropertyStatus = false;
                        //this.Context.PersistenceEngine.LoadObject(ref obj);
                        this.Context.IdentityMap.LoadObject(ref obj, true);
                        if (obj == null)
                        {
                            throw new ObjectNotFoundException("Object not found!");                             // do not localize
                        }
                    }
                    if (!hasPropertyStatus)
                    {
                        propStatus = om.GetPropertyStatus(obj, propertyName);
                    }

                    if (propStatus == PropertyStatus.NotLoaded)
                    {
                        pe.LoadProperty(obj, propertyName);
                    }
                }

                if (!(hasOldValue))
                {
                    if (!(om.ComparePropertyValues(obj, propertyName, value, om.GetPropertyValue(obj, propertyName))))
                    {
                        this.Context.UnitOfWork.RegisterDirty(obj);
                    }
                }
            }
            else if (objStatus == ObjectStatus.Dirty)
            {
                propStatus = om.GetPropertyStatus(obj, propertyName);
                if (propStatus == PropertyStatus.NotLoaded)
                {
                    pe.LoadProperty(obj, propertyName);
                }
            }
            if (propertyMap.IsIdentity)
            {
                prevId = om.GetObjectIdentity(obj);
                newId  = om.GetObjectIdentity(obj, propertyMap, value);
                if (prevId != newId)
                {
                    ctx.IdentityMap.UpdateIdentity(obj, prevId, newId);
                }
            }
            om.SetNullValueStatus(obj, propertyName, false);
            om.SetUpdatedStatus(obj, propertyName, true);
            if (hasOldValue)
            {
                ctx.InverseManager.NotifyPropertySet(obj, propertyName, value, oldValue);
                ctx.UnitOfWork.RegisterDirty(obj);
            }
            else
            {
                ctx.InverseManager.NotifyPropertySet(obj, propertyName, value);
            }
        }
        protected virtual void DeserializeClone(object obj, ReadOnlyClone clone)
        {
            IObjectManager   om       = this.Context.ObjectManager;
            IDomainMap       dm       = this.Context.DomainMap;
            IAssemblyManager am       = this.Context.AssemblyManager;
            IClassMap        classMap = dm.MustGetClassMap(obj.GetType());
            IListManager     lm       = this.Context.ListManager;

            foreach (IPropertyMap propertyMap in classMap.GetAllPropertyMaps())
            {
                if (propertyMap.ReferenceType == ReferenceType.None)
                {
                    if (propertyMap.IsCollection)
                    {
                        IList values = (IList)clone.PropertyValues[propertyMap.Name];
                        IList list   = (IList)om.GetPropertyValue(obj, propertyMap.Name);

                        bool stackMute           = false;
                        IInterceptableList mList = list as IInterceptableList;
                        if (mList != null)
                        {
                            stackMute        = mList.MuteNotify;
                            mList.MuteNotify = true;
                        }
                        list.Clear();

                        foreach (object value in values)
                        {
                            list.Add(value);
                        }

                        IList cloneList = new ArrayList(list);

                        if (mList != null)
                        {
                            mList.MuteNotify = stackMute;
                        }

                        om.SetOriginalPropertyValue(obj, propertyMap.Name, cloneList);
                        om.SetNullValueStatus(obj, propertyMap.Name, false);
                    }
                    else
                    {
                        object value = clone.PropertyValues[propertyMap.Name];
                        om.SetPropertyValue(obj, propertyMap.Name, value);
                        om.SetOriginalPropertyValue(obj, propertyMap.Name, value);
                        om.SetNullValueStatus(obj, propertyMap.Name, (bool)clone.NullValueStatuses[propertyMap.Name]);
                    }
                }
                else
                {
                    IClassMap refClassMap = propertyMap.MustGetReferencedClassMap();
                    if (refClassMap.IsReadOnly)
                    {
                        if (propertyMap.IsCollection)
                        {
                            IList values = (IList)clone.PropertyValues[propertyMap.Name];
                            IList list   = (IList)om.GetPropertyValue(obj, propertyMap.Name);

                            bool stackMute           = false;
                            IInterceptableList mList = list as IInterceptableList;
                            if (mList != null)
                            {
                                stackMute        = mList.MuteNotify;
                                mList.MuteNotify = true;
                            }
                            list.Clear();

                            foreach (SerializedReference refId in values)
                            {
                                object value = null;
                                if (refId != null)
                                {
                                    refClassMap = dm.MustGetClassMap(refId.Type);
                                    Type refType = am.GetTypeFromClassMap(refClassMap);
                                    value = this.Context.GetObjectById(refId.Identity, refType, true);
                                    list.Add(value);
                                }
                            }

                            IList cloneList = new ArrayList(list);

                            if (mList != null)
                            {
                                mList.MuteNotify = stackMute;
                            }

                            om.SetOriginalPropertyValue(obj, propertyMap.Name, cloneList);
                            om.SetNullValueStatus(obj, propertyMap.Name, false);
                        }
                        else
                        {
                            object value = null;
                            SerializedReference refId = (SerializedReference)clone.PropertyValues[propertyMap.Name];
                            if (refId != null)
                            {
                                refClassMap = dm.MustGetClassMap(refId.Type);
                                Type refType = am.GetTypeFromClassMap(refClassMap);
                                value = this.Context.GetObjectById(refId.Identity, refType, true);
                            }
                            om.SetPropertyValue(obj, propertyMap.Name, value);
                            om.SetOriginalPropertyValue(obj, propertyMap.Name, value);
                            om.SetNullValueStatus(obj, propertyMap.Name, (bool)clone.NullValueStatuses[propertyMap.Name]);
                        }
                    }
                }
            }
        }
        private void LoadReferenceList(IList list, IList orgList, IObjectManager om, object obj, IPropertyMap propertyMap)
        {
            IList objectsToRemove = new ArrayList();
            IList objectsToAdd    = new ArrayList();

            foreach (object itemOrgObj in orgList)
            {
                string itemOrgObjId = om.GetObjectIdentity(itemOrgObj);
                bool   found        = false;
                foreach (object itemObj in list)
                {
                    string itemObjId = om.GetObjectIdentity(itemObj);
                    if (itemObjId == itemOrgObjId)
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    objectsToRemove.Add(itemOrgObj);
                }
            }
            foreach (object itemObj in list)
            {
                string itemObjId = om.GetObjectIdentity(itemObj);
                bool   found     = false;
                foreach (object itemOrgObj in orgList)
                {
                    string itemOrgObjId = om.GetObjectIdentity(itemOrgObj);
                    if (itemObjId == itemOrgObjId)
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    object itemOrgObj = this.Context.GetObjectById(itemObjId, itemObj.GetType(), true);
                    objectsToAdd.Add(itemOrgObj);
                }
            }

            if (objectsToRemove.Count > 0 || objectsToAdd.Count > 0)
            {
                bool stackMute           = false;
                IInterceptableList mList = orgList as IInterceptableList;
                if (mList != null)
                {
                    stackMute        = mList.MuteNotify;
                    mList.MuteNotify = true;
                }
                foreach (object itemOrgObj in objectsToRemove)
                {
                    orgList.Remove(itemOrgObj);
                }
                foreach (object itemOrgObj in objectsToAdd)
                {
                    orgList.Add(itemOrgObj);
                }

                if (mList != null)
                {
                    mList.MuteNotify = stackMute;
                }
            }

            bool iStackMute          = false;
            IInterceptableList iList = orgList as IInterceptableList;

            if (iList != null)
            {
                iStackMute       = iList.MuteNotify;
                iList.MuteNotify = true;
            }

            IList listClone = new ArrayList(orgList);

            if (iList != null)
            {
                iList.MuteNotify = iStackMute;
            }

            om.SetOriginalPropertyValue(obj, propertyMap.Name, listClone);
        }