/// <summary>
        /// Cascade to the collection elements
        /// </summary>
        /// <param name="action"></param>
        /// <param name="style"></param>
        /// <param name="collectionType"></param>
        /// <param name="elemType"></param>
        /// <param name="child"></param>
        /// <param name="cascadeVia"></param>
        /// <param name="session"></param>
        /// <param name="anything"></param>
        private static void CascadeCollection(
            CascadingAction action,
            CascadeStyle style,
            PersistentCollectionType collectionType,
            IType elemType,
            object child,
            CascadePoint cascadeVia,
            ISessionImplementor session,
            object anything)
        {
            // cascade to current collection elements
            if (log.IsDebugEnabled)
            {
                log.Debug("cascading to collection: " + collectionType.Role);
            }
            ICollection iter = action.CascadableChildrenCollection(collectionType, child);

            foreach (object obj in iter)
            {
                Cascade(session, obj, elemType, action, style, cascadeVia, anything);
            }

            // handle oprhaned entities!!
            if (style.HasOrphanDelete && action.DeleteOrphans() && child is PersistentCollection)
            {
                // We can do the cast since orphan-delete does not apply to:
                // 1. newly instatiated collections
                // 2. arrays ( we can't track orphans for detached arrays)
                DeleteOrphans(child as PersistentCollection, session);
            }
        }
        /// <summary>
        /// Cascade an action to the child or children
        /// </summary>
        /// <param name="session"></param>
        /// <param name="child"></param>
        /// <param name="type"></param>
        /// <param name="action"></param>
        /// <param name="style"></param>
        /// <param name="cascadeTo"></param>
        /// <param name="anything"></param>
        private static void Cascade(
            ISessionImplementor session,
            object child,
            IType type,
            CascadingAction action,
            CascadeStyle style,
            CascadePoint cascadeTo,
            object anything)
        {
            if (child != null)
            {
                if (type.IsAssociationType)
                {
                    if ((( IAssociationType )type).ForeignKeyType.CascadeNow(cascadeTo))
                    {
                        if (type.IsEntityType || type.IsObjectType)
                        {
                            action.Cascade(session, child, anything);
                        }
                        else if (type.IsPersistentCollectionType)
                        {
                            CascadePoint cascadeVia;
                            if (cascadeTo == CascadePoint.CascadeAfterInsertBeforeDelete)
                            {
                                cascadeVia = CascadePoint.CascadeAfterInsertBeforeDeleteViaCollection;
                            }
                            else
                            {
                                cascadeVia = cascadeTo;
                            }
                            PersistentCollectionType pctype    = ( PersistentCollectionType )type;
                            ICollectionPersister     persister = session.Factory.GetCollectionPersister(pctype.Role);
                            IType elemType = persister.ElementType;

                            // cascade to current collection elements
                            if (elemType.IsEntityType || elemType.IsObjectType || elemType.IsComponentType)
                            {
                                CascadeCollection(action, style, pctype, elemType, child, cascadeVia, session, anything);
                            }
                        }
                    }
                }
                else if (type.IsComponentType)
                {
                    IAbstractComponentType ctype = (( IAbstractComponentType )type);
                    object[] children            = ctype.GetPropertyValues(child, session);
                    IType[]  types = ctype.Subtypes;
                    for (int i = 0; i < types.Length; i++)
                    {
                        CascadeStyle componentPropertyStyle = ctype.Cascade(i);
                        if (componentPropertyStyle.DoCascade(action))
                        {
                            Cascade(session, children[i], types[i], action, componentPropertyStyle, cascadeTo, anything);
                        }
                    }
                }
            }
        }
Exemple #3
0
        /// <summary> Cascade an action to a collection</summary>
        private void CascadeCollection(object parent, object child, CascadeStyle style, object anything, CollectionType type)
        {
            ICollectionPersister persister = eventSource.Factory.GetCollectionPersister(type.Role);
            IType elemType = persister.ElementType;

            CascadePoint oldCascadeTo = point;

            if (point == CascadePoint.AfterInsertBeforeDelete)
            {
                point = CascadePoint.AfterInsertBeforeDeleteViaCollection;
            }

            //cascade to current collection elements
            if (elemType.IsEntityType || elemType.IsAnyType || elemType.IsComponentType)
            {
                CascadeCollectionElements(parent, child, type, style, elemType, anything, persister.CascadeDeleteEnabled);
            }

            point = oldCascadeTo;
        }
Exemple #4
0
        /// <summary> Cascade an action to a collection</summary>
        private async Task CascadeCollectionAsync(object parent, object child, CascadeStyle style, object anything, CollectionType type, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            ICollectionPersister persister = eventSource.Factory.GetCollectionPersister(type.Role);
            IType elemType = persister.ElementType;

            CascadePoint oldCascadeTo = point;

            if (point == CascadePoint.AfterInsertBeforeDelete)
            {
                point = CascadePoint.AfterInsertBeforeDeleteViaCollection;
            }

            //cascade to current collection elements
            if (elemType.IsEntityType || elemType.IsAnyType || elemType.IsComponentType)
            {
                await(CascadeCollectionElementsAsync(parent, child, type, style, elemType, anything, persister.CascadeDeleteEnabled, cancellationToken)).ConfigureAwait(false);
            }

            point = oldCascadeTo;
        }
			public override bool CascadeNow(CascadePoint cascadePoint)
			{
				return cascadePoint != CascadePoint.BeforeInsertAfterDelete;
			}
		/// <summary>
		/// Cascade an action to the child or children
		/// </summary>
		/// <param name="session"></param>
		/// <param name="child"></param>
		/// <param name="type"></param>
		/// <param name="action"></param>
		/// <param name="style"></param>
		/// <param name="cascadeTo"></param>
		/// <param name="anything"></param>
		private static void Cascade(
			ISessionImplementor session,
			object child,
			IType type,
			CascadingAction action,
			CascadeStyle style,
			CascadePoint cascadeTo,
			object anything)
		{
			if (child != null)
			{
				if (type.IsAssociationType)
				{
					if (((IAssociationType) type).ForeignKeyDirection.CascadeNow(cascadeTo))
					{
						if (type.IsEntityType || type.IsAnyType)
						{
							action.Cascade(session, child, anything);
						}
						else if (type.IsCollectionType)
						{
							CascadePoint cascadeVia;
							if (cascadeTo == CascadePoint.CascadeAfterInsertBeforeDelete)
							{
								cascadeVia = CascadePoint.CascadeAfterInsertBeforeDeleteViaCollection;
							}
							else
							{
								cascadeVia = cascadeTo;
							}
							CollectionType pctype = (CollectionType) type;
							ICollectionPersister persister = session.Factory.GetCollectionPersister(pctype.Role);
							IType elemType = persister.ElementType;

							// cascade to current collection elements
							if (elemType.IsEntityType || elemType.IsAnyType || elemType.IsComponentType)
							{
								CascadeCollection(action, style, pctype, elemType, child, cascadeVia, session, anything);
							}
						}
					}
				}
				else if (type.IsComponentType)
				{
					IAbstractComponentType ctype = ((IAbstractComponentType) type);
					object[] children = ctype.GetPropertyValues(child, session);
					IType[] types = ctype.Subtypes;
					for (int i = 0; i < types.Length; i++)
					{
						CascadeStyle componentPropertyStyle = ctype.GetCascadeStyle(i);
						if (componentPropertyStyle.DoCascade(action))
						{
							Cascade(session, children[i], types[i], action, componentPropertyStyle, cascadeTo, anything);
						}
					}
				}
			}
		}
Exemple #7
0
 public Cascade(CascadingAction action, CascadePoint point, IEventSource eventSource)
 {
     this.point       = point;
     this.eventSource = eventSource;
     this.action      = action;
 }
		/// <summary>
		/// Should we cascade at this cascade point?
		/// </summary>
		public abstract bool CascadeNow(CascadePoint cascadePoint);
			public override bool CascadeNow( CascadePoint cascadePoint )
			{
				return cascadePoint != CascadePoint.CascadeAfterInsertBeforeDelete;
			}
 /// <summary>
 /// Cascade an action from the parent object to all its children.
 /// </summary>
 /// <param name="session"></param>
 /// <param name="persister"></param>
 /// <param name="parent"></param>
 /// <param name="action"></param>
 /// <param name="cascadeTo"></param>
 /// <param name="anything"></param>
 public static void Cascade(ISessionImplementor session, IClassPersister persister, object parent, CascadingAction action, CascadePoint cascadeTo, object anything)
 {
     if (persister.HasCascades)
     {
         if (log.IsDebugEnabled)
         {
             log.Debug("processing cascades for: " + persister.ClassName);
         }
         IType[]        types         = persister.PropertyTypes;
         CascadeStyle[] cascadeStyles = persister.PropertyCascadeStyles;
         for (int i = 0; i < types.Length; i++)
         {
             CascadeStyle style = cascadeStyles[i];
             if (style.DoCascade(action))
             {
                 Cascade(session, persister.GetPropertyValue(parent, i), types[i], action, style, cascadeTo, anything);
             }
         }
         if (log.IsDebugEnabled)
         {
             log.Debug("done processing cascades for: " + persister.ClassName);
         }
     }
 }
		/// <summary>
		/// Cascade an action from the parent object to all its children.
		/// </summary>
		/// <param name="session"></param>
		/// <param name="persister"></param>
		/// <param name="parent"></param>
		/// <param name="action"></param>
		/// <param name="cascadeTo"></param>
		/// <param name="anything"></param>
		public static void Cascade(ISessionImplementor session, IEntityPersister persister, object parent,
		                           CascadingAction action, CascadePoint cascadeTo, object anything)
		{
			if (persister.HasCascades)
			{
				if (log.IsDebugEnabled)
				{
					log.Debug("processing cascades for: " + persister.ClassName);
				}
				IType[] types = persister.PropertyTypes;
				CascadeStyle[] cascadeStyles = persister.PropertyCascadeStyles;
				for (int i = 0; i < types.Length; i++)
				{
					CascadeStyle style = cascadeStyles[i];
					if (style.DoCascade(action))
					{
						Cascade(session, persister.GetPropertyValue(parent, i), types[i], action, style, cascadeTo, anything);
					}
				}
				if (log.IsDebugEnabled)
				{
					log.Debug("done processing cascades for: " + persister.ClassName);
				}
			}
		}
		/// <summary>
		/// Cascade to the collection elements
		/// </summary>
		/// <param name="action"></param>
		/// <param name="style"></param>
		/// <param name="collectionType"></param>
		/// <param name="elemType"></param>
		/// <param name="child"></param>
		/// <param name="cascadeVia"></param>
		/// <param name="session"></param>
		/// <param name="anything"></param>
		private static void CascadeCollection(
			CascadingAction action,
			CascadeStyle style,
			CollectionType collectionType,
			IType elemType,
			object child,
			CascadePoint cascadeVia,
			ISessionImplementor session,
			object anything)
		{
			// cascade to current collection elements
			if (log.IsDebugEnabled)
			{
				log.Debug("cascading to collection: " + collectionType.Role);
			}
			ICollection iter = action.CascadableChildrenCollection(collectionType, child);
			foreach (object obj in iter)
			{
				Cascade(session, obj, elemType, action, style, cascadeVia, anything);
			}

			// handle oprhaned entities!!
			if (style.HasOrphanDelete && action.DeleteOrphans() && child is IPersistentCollection)
			{
				// We can do the cast since orphan-delete does not apply to:
				// 1. newly instatiated collections
				// 2. arrays ( we can't track orphans for detached arrays)
				System.Type entityName = collectionType.GetAssociatedClass(session.Factory);
				DeleteOrphans(entityName, child as IPersistentCollection, session);
			}
		}
 /// <summary>
 ///
 /// </summary>
 /// <param name="session"></param>
 /// <param name="persister"></param>
 /// <param name="parent"></param>
 /// <param name="action"></param>
 /// <param name="cascadeTo"></param>
 public static void Cascade(ISessionImplementor session, IClassPersister persister, object parent, CascadingAction action, CascadePoint cascadeTo)
 {
     Cascade(session, persister, parent, action, cascadeTo, null);
 }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="session"></param>
		/// <param name="persister"></param>
		/// <param name="parent"></param>
		/// <param name="action"></param>
		/// <param name="cascadeTo"></param>
		public static void Cascade(ISessionImplementor session, IEntityPersister persister, object parent,
		                           CascadingAction action, CascadePoint cascadeTo)
		{
			Cascade(session, persister, parent, action, cascadeTo, null);
		}
Exemple #15
0
		public Cascade(CascadingAction action, CascadePoint point, IEventSource eventSource)
		{
			this.point = point;
			this.eventSource = eventSource;
			this.action = action;
		}
Exemple #16
0
		/// <summary> Cascade an action to a collection</summary>
		private void CascadeCollection(object child, CascadeStyle style, object anything, CollectionType type)
		{
			ICollectionPersister persister = eventSource.Factory.GetCollectionPersister(type.Role);
			IType elemType = persister.ElementType;

			CascadePoint oldCascadeTo = point;
			if (point == CascadePoint.AfterInsertBeforeDelete)
				point = CascadePoint.AfterInsertBeforeDeleteViaCollection;

			//cascade to current collection elements
			if (elemType.IsEntityType || elemType.IsAnyType || elemType.IsComponentType)
				CascadeCollectionElements(child, type, style, elemType, anything, persister.CascadeDeleteEnabled);

			point = oldCascadeTo;
		}
 public override bool CascadeNow(CascadePoint cascadePoint)
 {
     return(cascadePoint != CascadePoint.BeforeInsertAfterDelete);
 }
 /// <summary>
 /// Should we cascade at this cascade point?
 /// </summary>
 public abstract bool CascadeNow(CascadePoint cascadePoint);
 public override bool CascadeNow(CascadePoint cascadePoint)
 {
     return(cascadePoint != CascadePoint.CascadeAfterInsertBeforeDelete);
 }