SF.net SVN: orm:[1353] trunk

[<mcu...@us...>]

Revision: 1353
          http://orm.svn.sourceforge.net/orm/?rev=1353&view=rev
Author:   mcurland
Date:     2009-01-23 21:57:35 +0000 (Fri, 23 Jan 2009)

Log Message:
-----------
Absorption of a FactType needs to be reconsidered by the absorption gateway when an objectification is added/deleted. Adding and removing roles on objectified FactTypes allowed invalid FactTypes through the gateway. This was manifested by an aborted transaction (null reference exception) or more subtle errors of not readding columns for a reduction from a ternary to a functional binary FactType. refs #327

Also did some minor reorder of debinarization of a unary to avoid creating an implied FactType structure that is destroyed almost immediately. refs #367

Modified Paths:
--------------
    trunk/ORMModel/ObjectModel/Objectification.cs
    trunk/ORMModel/ObjectModel/UnaryBinarization.cs
    trunk/ORMModel/Shell/ORMReadingEditor.cs
    trunk/ORMModel/Shell/ReadingEditor.cs
    trunk/Oial/ORMOialBridge/ORMElementGateway.cs
    trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.cs
    trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.xml

Modified: trunk/ORMModel/ObjectModel/Objectification.cs
===================================================================
--- trunk/ORMModel/ObjectModel/Objectification.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/ORMModel/ObjectModel/Objectification.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -742,14 +742,16 @@
 			ObjectType rolePlayer = link.RolePlayer;
 			FactType factType;
 			Objectification objectification;
-			// Note if the roleplayer is removed, then the links all go away
-			// automatically. There is no additional work to do or checks to make.
-			if (rolePlayer.IsDeleted || rolePlayer.IsDeleting)
+			if (rolePlayer.IsImplicitBooleanValue)
 			{
-				if (rolePlayer.IsImplicitBooleanValue &&
-					null != (factType = role.FactType) &&
+				// The standard code to debinarize a FactType detaches the role first
+				// so that we can distinguish here whether we need to rebuild an implied
+				// FactType for the role. If the role is deleting before the implied value,
+				// then assume the implied value will be deleted right after this call as well.
+				if (null != (factType = role.FactType) &&
 					null != (objectification = factType.Objectification))
 				{
+					bool removeRolePlayer = role.IsDeleting && !(rolePlayer.IsDeleted || rolePlayer.IsDeleting);
 					foreach (RoleBase otherRoleBase in factType.RoleCollection)
 					{
 						// Find the old unary role and modify its implied FactType
@@ -757,7 +759,7 @@
 						FactType impliedFactType;
 						Role otherRole;
 						if (otherRoleBase != role &&
-							!role.IsDeleting &&
+							!otherRoleBase.IsDeleting &&
 							null != (objectifiedUnaryRole = (otherRole = otherRoleBase.Role).ObjectifiedUnaryRole) &&
 							!objectifiedUnaryRole.IsDeleting &&
 							null != (impliedFactType = objectifiedUnaryRole.FactType))
@@ -775,6 +777,8 @@
 							}
 							ObjectType nestingType = objectification.NestingType;
 							CreateImpliedFactTypeForRole(model, nestingType, otherRole, objectification, false);
+							// Note that even if this role is not currently being deleted it will be soon. There
+							// is no reason to keep these. Anything we create here will simply be deleted
 							if (!role.IsDeleting && role.Proxy == null)
 							{
 								CreateImpliedFactTypeForRole(model, nestingType, role, objectification, false);
@@ -782,9 +786,14 @@
 							break;
 						}
 					}
+					if (removeRolePlayer)
+					{
+						rolePlayer.Delete();
+					}
 				}
 			}
-			else if (null != (factType = role.FactType))
+			else if (!(rolePlayer.IsDeleted || rolePlayer.IsDeleting) &&
+				null != (factType = role.FactType))
 			{
 				SubtypeMetaRole subtypeRole;
 				ObjectifiedUnaryRole objectifiedUnaryRole;

Modified: trunk/ORMModel/ObjectModel/UnaryBinarization.cs
===================================================================
--- trunk/ORMModel/ObjectModel/UnaryBinarization.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/ORMModel/ObjectModel/UnaryBinarization.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -237,12 +237,23 @@
 								ruleManager.DisableRule(typeof(ObjectTypePlaysRoleDeletedRuleClass));
 								ruleDisabled = true;
 							}
-							implicitBooleanValueType.Delete();
 							if (deleteImplicitBooleanRole)
 							{
+								// We delete the role first so that rules do not
+								// try to recreate and implied fact type for this rule
+								// if it is part of an objectified FactType.
 								implicitBooleanRole.Delete();
 								--roleCount;
+								if (!implicitBooleanValueType.IsDeleted)
+								{
+									// The Objectification.RolePlayerDeletingRule rule will delet this automatically
+									implicitBooleanValueType.Delete();
+								}
 							}
+							else
+							{
+								implicitBooleanValueType.Delete();
+							}
 						}
 						finally
 						{
@@ -319,7 +330,7 @@
 								contextInfo.Remove(ORMModel.AllowDuplicateNamesKey);
 							}
 						}
-						if (!ValidateConstraints(unaryRole, implicitBooleanRole) || !ValidateImplictBooleanValueType(implicitBooleanRole.RolePlayer))
+						if (!ValidateConstraints(unaryRole, implicitBooleanRole) || !ValidateImplicitBooleanValueType(implicitBooleanRole.RolePlayer))
 						{
 							LinkedElementCollection<RoleBase> roles = factType.RoleCollection;
 							DebinarizeUnary(roles, false, notifyAdded);
@@ -416,7 +427,7 @@
 			/// Checks that only one role is played by the value type, that it has a boolean data type, and that
 			/// if it has a value constraint, that value constraint is alethic and only allows the value 'true'.
 			/// </summary>
-			private static bool ValidateImplictBooleanValueType(ObjectType implicitBooleanValueType)
+			private static bool ValidateImplicitBooleanValueType(ObjectType implicitBooleanValueType)
 			{
 				if (!implicitBooleanValueType.IsValueType || !implicitBooleanValueType.IsImplicitBooleanValue || implicitBooleanValueType.IsIndependent ||
 					implicitBooleanValueType.PlayedRoleCollection.Count != 1 || !(implicitBooleanValueType.DataType is TrueOrFalseLogicalDataType))

Modified: trunk/ORMModel/Shell/ORMReadingEditor.cs
===================================================================
--- trunk/ORMModel/Shell/ORMReadingEditor.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/ORMModel/Shell/ORMReadingEditor.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -193,9 +193,9 @@
 				FactType secondaryFact = null;
 				if (selectedObjects != null)
 				{
-					foreach (object o in selectedObjects)
+					foreach (object element in selectedObjects)
 					{
-						FactType testFact = ORMEditorUtility.ResolveContextFactType(o);
+						FactType testFact = ORMEditorUtility.ResolveContextFactType(element);
 						// Handle selection of multiple elements as long as
 						// they all resolve to the same fact
 						if (theFact == null)
@@ -203,10 +203,17 @@
 							theFact = testFact;
 							Role testImpliedRole;
 							RoleProxy proxy;
-							if (null != (testImpliedRole = o as Role) &&
-								null != (proxy = testImpliedRole.Proxy))
+							ObjectifiedUnaryRole objectifiedUnaryRole;
+							if (null != (testImpliedRole = element as Role))
 							{
-								secondaryFact = proxy.FactType;
+								if (null != (proxy = testImpliedRole.Proxy))
+								{
+									secondaryFact = proxy.FactType;
+								}
+								else if (null != (objectifiedUnaryRole = testImpliedRole.ObjectifiedUnaryRole))
+								{
+									secondaryFact = objectifiedUnaryRole.FactType;
+								}
 							}
 						}
 						else if (testFact != theFact)

Modified: trunk/ORMModel/Shell/ReadingEditor.cs
===================================================================
--- trunk/ORMModel/Shell/ReadingEditor.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/ORMModel/Shell/ReadingEditor.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -1101,13 +1101,16 @@
 				return;
 			}
 			ReadingOrderHasReading link = e.ModelElement as ReadingOrderHasReading;
-			ReadingOrder readingOrder = link.ReadingOrder;
-			FactType fact = readingOrder.FactType;
-			if (fact == myFact || fact == mySecondaryFact)
+			if (!link.IsDeleted)
 			{
-				myMainBranch.ReadingAdded(link.Reading);
+				ReadingOrder readingOrder = link.ReadingOrder;
+				FactType fact = readingOrder.FactType;
+				if (fact == myFact || fact == mySecondaryFact)
+				{
+					myMainBranch.ReadingAdded(link.Reading);
+				}
+				this.UpdateMenuItems();
 			}
-			this.UpdateMenuItems();
 		}
 		private void ReadingLinkRemovedEvent(object sender, ElementDeletedEventArgs e)
 		{
@@ -1403,15 +1406,21 @@
 			/// <param name="reading">the reading to add</param>
 			public void ReadingAdded(Reading reading)
 			{
-				ReadingOrder order = reading.ReadingOrder;
-				if (order.FactType == myFact)
+				ReadingOrder order;
+				FactType orderFactType;
+				if (!reading.IsDeleted &&
+					null != (order = reading.ReadingOrder) &&
+					null != (orderFactType = order.FactType))
 				{
-					this.OrderBranch.ReadingAdded(reading);
+					if (orderFactType == myFact)
+					{
+						this.OrderBranch.ReadingAdded(reading);
+					}
+					else
+					{
+						this.ImpliedBranch.ReadingAdded(reading);
+					}
 				}
-				else
-				{
-					this.ImpliedBranch.ReadingAdded(reading);
-				}
 			}
 			/// <summary>
 			/// Triggers the events notifying the tree that a Reading in the Readingbranch has been updated. 
@@ -1920,36 +1929,38 @@
 			public void ReadingAdded(Reading reading)
 			{
 				ReadingOrder order = reading.ReadingOrder;
-				int location = this.LocateCollectionItem(order);
-
-				if (location < 0)
+				if (order != null)
 				{
-					this.PopulateReadingOrderInfo(order);
-					if (OnBranchModification != null)
-					{
-						int newLoc = this.LocateCollectionItem(order);
-						OnBranchModification(this, BranchModificationEventArgs.InsertItems(this, newLoc - 1, 1));
-						OnBranchModification(this, BranchModificationEventArgs.UpdateCellStyle(this, newLoc, (int)ColumnIndex.ReadingBranch, true)); //may not be needed due to callback on update
-						//redraw off and back on in the branch if it has no more than 1 reading
-					}
-				}
+					int location = this.LocateCollectionItem(order);
 
-				if (location >= 0)
-				{
-					myReadingOrderKeyedCollection[location].EnsureBranch().AddReading(reading);
-					if (OnBranchModification != null)
+					if (location < 0)
 					{
-						OnBranchModification(this, BranchModificationEventArgs.UpdateCellStyle(this, location, (int)ColumnIndex.ReadingBranch, true));
-
-						int actualIndex = myFact.ReadingOrderCollection.IndexOf(order);
-						if (actualIndex != location)
+						this.PopulateReadingOrderInfo(order);
+						if (OnBranchModification != null)
 						{
-							this.ReadingOrderLocationUpdate(order);
+							int newLoc = this.LocateCollectionItem(order);
+							OnBranchModification(this, BranchModificationEventArgs.InsertItems(this, newLoc - 1, 1));
+							OnBranchModification(this, BranchModificationEventArgs.UpdateCellStyle(this, newLoc, (int)ColumnIndex.ReadingBranch, true)); //may not be needed due to callback on update
+							//redraw off and back on in the branch if it has no more than 1 reading
 						}
-						else
+					}
+					else
+					{
+						myReadingOrderKeyedCollection[location].EnsureBranch().AddReading(reading);
+						if (OnBranchModification != null)
 						{
-							OnBranchModification(this, BranchModificationEventArgs.Redraw(false));
-							OnBranchModification(this, BranchModificationEventArgs.Redraw(true));
+							OnBranchModification(this, BranchModificationEventArgs.UpdateCellStyle(this, location, (int)ColumnIndex.ReadingBranch, true));
+
+							int actualIndex = myFact.ReadingOrderCollection.IndexOf(order);
+							if (actualIndex != location)
+							{
+								this.ReadingOrderLocationUpdate(order);
+							}
+							else
+							{
+								OnBranchModification(this, BranchModificationEventArgs.Redraw(false));
+								OnBranchModification(this, BranchModificationEventArgs.Redraw(true));
+							}
 						}
 					}
 				}

Modified: trunk/Oial/ORMOialBridge/ORMElementGateway.cs
===================================================================
--- trunk/Oial/ORMOialBridge/ORMElementGateway.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/Oial/ORMOialBridge/ORMElementGateway.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -379,7 +379,10 @@
 				if (forceCreate ||
 					null == ExcludedORMModelElement.GetAbstractionModel(factType))
 				{
-					new ExcludedORMModelElement(factType, model);
+					if (null == factType.Objectification || factType.UnaryRole != null)
+					{
+						new ExcludedORMModelElement(factType, model);
+					}
 					if (notifyExcluded != null)
 					{
 						notifyExcluded(factType);
@@ -689,6 +692,63 @@
 				});
 			}
 			#endregion // Preferred Identifier Tracking Rules
+			#region Objectification Tracking Rules
+			/// <summary>
+			/// AddRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+			/// Objectification FactTypes are automatically excluded, so changing
+			/// the objectification state is the same as adding/removing a blocking
+			/// error.
+			/// </summary>
+			private static void ObjectificationAddedRule(ElementAddedEventArgs e)
+			{
+				ProcessFactTypeForObjectificationAdded(((Objectification)e.ModelElement).NestedFactType);
+			}
+			private static void ProcessFactTypeForObjectificationAdded(FactType factType)
+			{
+				if (factType.UnaryRole == null)
+				{
+					ExcludedORMModelElement excludedLink = ExcludedORMModelElement.GetLinkToAbstractionModel(factType);
+					if (excludedLink != null)
+					{
+						// We don't keep the exclusion link on objectified FactTypes, but deleting
+						// it does not imply any additional processing because we were already not
+						// considering this FactType
+						excludedLink.Delete();
+					}
+					else
+					{
+						FilterModifiedFactType(factType, false); // false because new implied FactTypes will get notifications on their own
+					}
+				}
+			}
+			private static void ProcessFactTypeForObjectificationDeleted(FactType factType)
+			{
+				if (!factType.IsDeleted && factType.UnaryRole == null)
+				{
+					FilterModifiedFactType(factType, false); // false because there are no implied facttypes without an objectification
+				}
+			}
+			/// <summary>
+			/// DeleteRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+			/// </summary>
+			private static void ObjectificationDeletedRule(ElementDeletedEventArgs e)
+			{
+				ProcessFactTypeForObjectificationDeleted(((Objectification)e.ModelElement).NestedFactType);
+			}
+			/// <summary>
+			/// RolePlayerChangeRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+			/// </summary>
+			private static void ObjectificationRolePlayerChangedRule(RolePlayerChangedEventArgs e)
+			{
+				Objectification link = (Objectification)e.ElementLink;
+				FactType factType;
+				if (e.DomainRole.Id == Objectification.NestedFactTypeDomainRoleId)
+				{
+					ProcessFactTypeForObjectificationDeleted((FactType)e.OldRolePlayer);
+					ProcessFactTypeForObjectificationAdded(link.NestedFactType);
+				}
+			}
+			#endregion // Objectification Tracking Rules
 			#region RolePlayer tracking rules
 			/// <summary>
 			/// AddRule: typeof(Neumont.Tools.ORM.ObjectModel.ObjectTypePlaysRole)

Modified: trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.cs
===================================================================
--- trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.cs	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.cs	2009-01-23 21:57:35 UTC (rev 1353)
@@ -44,6 +44,9 @@
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectTypeAddedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectTypeErrorAddedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectTypeErrorDeletedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
+						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectificationAddedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
+						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectificationDeletedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
+						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("ObjectificationRolePlayerChangedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("PreferredIdentifierAddedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("RolePlayerAddedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
 						typeof(AbstractionModelIsForORMModel).GetNestedType("ORMElementGateway", BindingFlags.Public | BindingFlags.NonPublic).GetNestedType("RolePlayerDeletedRuleClass", BindingFlags.Public | BindingFlags.NonPublic),
@@ -96,7 +99,7 @@
 		{
 			Microsoft.VisualStudio.Modeling.RuleManager ruleManager = store.RuleManager;
 			Type[] disabledRuleTypes = ORMToORMAbstractionBridgeDomainModel.CustomDomainModelTypes;
-			for (int i = 0; i < 29; ++i)
+			for (int i = 0; i < 32; ++i)
 			{
 				ruleManager.EnableRule(disabledRuleTypes[i]);
 			}
@@ -389,6 +392,84 @@
 					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleEnd(e.ModelElement.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectTypeErrorDeletedRule");
 				}
 			}
+			[Microsoft.VisualStudio.Modeling.RuleOn(typeof(Neumont.Tools.ORM.ObjectModel.Objectification), Priority=Neumont.Tools.Modeling.FrameworkDomainModel.InlineRulePriority)]
+			private sealed class ObjectificationAddedRuleClass : Microsoft.VisualStudio.Modeling.AddRule
+			{
+				[System.Diagnostics.DebuggerStepThrough()]
+				public ObjectificationAddedRuleClass()
+				{
+					base.IsEnabled = false;
+				}
+				/// <summary>
+				/// Provide the following method in class: 
+				/// Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway
+				/// /// <summary>
+				/// /// AddRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+				/// /// </summary>
+				/// private static void ObjectificationAddedRule(ElementAddedEventArgs e)
+				/// {
+				/// }
+				/// </summary>
+				[System.Diagnostics.DebuggerStepThrough()]
+				public override void ElementAdded(Microsoft.VisualStudio.Modeling.ElementAddedEventArgs e)
+				{
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleStart(e.ModelElement.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationAddedRule");
+					ORMElementGateway.ObjectificationAddedRule(e);
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleEnd(e.ModelElement.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationAddedRule");
+				}
+			}
+			[Microsoft.VisualStudio.Modeling.RuleOn(typeof(Neumont.Tools.ORM.ObjectModel.Objectification), Priority=Neumont.Tools.Modeling.FrameworkDomainModel.InlineRulePriority)]
+			private sealed class ObjectificationDeletedRuleClass : Microsoft.VisualStudio.Modeling.DeleteRule
+			{
+				[System.Diagnostics.DebuggerStepThrough()]
+				public ObjectificationDeletedRuleClass()
+				{
+					base.IsEnabled = false;
+				}
+				/// <summary>
+				/// Provide the following method in class: 
+				/// Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway
+				/// /// <summary>
+				/// /// DeleteRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+				/// /// </summary>
+				/// private static void ObjectificationDeletedRule(ElementDeletedEventArgs e)
+				/// {
+				/// }
+				/// </summary>
+				[System.Diagnostics.DebuggerStepThrough()]
+				public override void ElementDeleted(Microsoft.VisualStudio.Modeling.ElementDeletedEventArgs e)
+				{
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleStart(e.ModelElement.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationDeletedRule");
+					ORMElementGateway.ObjectificationDeletedRule(e);
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleEnd(e.ModelElement.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationDeletedRule");
+				}
+			}
+			[Microsoft.VisualStudio.Modeling.RuleOn(typeof(Neumont.Tools.ORM.ObjectModel.Objectification), Priority=Neumont.Tools.Modeling.FrameworkDomainModel.InlineRulePriority)]
+			private sealed class ObjectificationRolePlayerChangedRuleClass : Microsoft.VisualStudio.Modeling.RolePlayerChangeRule
+			{
+				[System.Diagnostics.DebuggerStepThrough()]
+				public ObjectificationRolePlayerChangedRuleClass()
+				{
+					base.IsEnabled = false;
+				}
+				/// <summary>
+				/// Provide the following method in class: 
+				/// Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway
+				/// /// <summary>
+				/// /// RolePlayerChangeRule: typeof(Neumont.Tools.ORM.ObjectModel.Objectification)
+				/// /// </summary>
+				/// private static void ObjectificationRolePlayerChangedRule(RolePlayerChangedEventArgs e)
+				/// {
+				/// }
+				/// </summary>
+				[System.Diagnostics.DebuggerStepThrough()]
+				public override void RolePlayerChanged(Microsoft.VisualStudio.Modeling.RolePlayerChangedEventArgs e)
+				{
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleStart(e.ElementLink.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationRolePlayerChangedRule");
+					ORMElementGateway.ObjectificationRolePlayerChangedRule(e);
+					Neumont.Tools.Modeling.Diagnostics.TraceUtility.TraceRuleEnd(e.ElementLink.Store, "Neumont.Tools.ORMToORMAbstractionBridge.AbstractionModelIsForORMModel.ORMElementGateway.ObjectificationRolePlayerChangedRule");
+				}
+			}
 			[Microsoft.VisualStudio.Modeling.RuleOn(typeof(Neumont.Tools.ORM.ObjectModel.EntityTypeHasPreferredIdentifier), Priority=Neumont.Tools.Modeling.FrameworkDomainModel.InlineRulePriority)]
 			private sealed class PreferredIdentifierAddedRuleClass : Microsoft.VisualStudio.Modeling.AddRule
 			{

Modified: trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.xml
===================================================================
--- trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.xml	2009-01-15 21:59:26 UTC (rev 1352)
+++ trunk/Oial/ORMOialBridge/ORMOialBridge.AttachRules.xml	2009-01-23 21:57:35 UTC (rev 1353)
@@ -55,6 +55,15 @@
 				<arg:RuleOn targetType="ObjectTypeHasPreferredIdentifierRequiresMandatoryError" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
 				<arg:RuleOn targetType="ValueTypeHasUnspecifiedDataTypeError" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
 			</arg:DeleteRule>
+			<arg:AddRule methodName="ObjectificationAddedRule">
+				<arg:RuleOn targetType="Objectification" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
+			</arg:AddRule>
+			<arg:DeleteRule methodName="ObjectificationDeletedRule">
+				<arg:RuleOn targetType="Objectification" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
+			</arg:DeleteRule>
+			<arg:RolePlayerChangeRule methodName="ObjectificationRolePlayerChangedRule">
+				<arg:RuleOn targetType="Objectification" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
+			</arg:RolePlayerChangeRule>
 			<arg:AddRule methodName="PreferredIdentifierAddedRule">
 				<arg:RuleOn targetType="EntityTypeHasPreferredIdentifier" targetTypeQualifier="Neumont.Tools.ORM.ObjectModel"/>
 			</arg:AddRule>


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.