/// <summary>
/// AddRule: typeof(ObjectTypePlaysRole)
/// </summary>
private static void ObjectTypePlaysRoleAddedRule(ElementAddedEventArgs e)
{
ObjectTypePlaysRole link = e.ModelElement as ObjectTypePlaysRole;
FactType factType;
if (null != (factType = link.PlayedRole.FactType))
{
FrameworkDomainModel.DelayValidateElement(factType, DelayValidateUnaryBinarization);
}
}
/// <summary>
/// DeleteRule: typeof(ObjectTypePlaysRole), FireTime=LocalCommit, Priority=ORMCoreDomainModel.BeforeDelayValidateRulePriority;
/// Ensure that a role player deletion on a subtype results in a deletion
/// of the subtype itself.
/// </summary>
private static void DeleteSubtypeWhenRolePlayerDeletedRule(ElementDeletedEventArgs e)
{
ObjectTypePlaysRole link = e.ModelElement as ObjectTypePlaysRole;
Role role = link.PlayedRole;
if (role != null && !role.IsDeleted)
{
SubtypeFact subtypeFact = role.FactType as SubtypeFact;
if (subtypeFact != null && !subtypeFact.IsDeleted)
{
subtypeFact.Delete();
}
}
}
/// <summary>
/// AddRule: typeof(ObjectTypePlaysRole), FireTime=LocalCommit, Priority=ORMCoreDomainModel.BeforeDelayValidateRulePriority;
/// Ensure consistent types (EntityType or ValueType) for role
/// players in a subtyping relationship
/// </summary>
private static void EnsureConsistentRolePlayerTypesAddRule(ElementAddedEventArgs e)
{
ObjectTypePlaysRole link = e.ModelElement as ObjectTypePlaysRole;
SubtypeMetaRole subtypeRole;
SubtypeFact subtypeFact;
if (null != (subtypeRole = link.PlayedRole as SubtypeMetaRole) &&
null != (subtypeFact = subtypeRole.FactType as SubtypeFact))
{
ObjectType superType = subtypeFact.Supertype;
if (null == superType ||
((superType.DataType == null) != (link.RolePlayer.DataType == null)))
{
ThrowMixedRolePlayerTypesException();
}
}
}
/// <summary>
/// RolePlayerChangeRule: typeof(ORMSolutions.ORMArchitect.Core.ObjectModel.ObjectTypePlaysRole)
/// Revalidate the model when the <see cref="ObjectType">role player</see> of a <see cref="Role"/>
/// is changed.
/// </summary>
private static void RolePlayerRolePlayerChangedRule(RolePlayerChangedEventArgs e)
{
// UNDONE: Incremental changes will not be as severe here. Note that adding
// and deleting role players already triggers the correct actions in the
// gateway rules. However, a change where none of the parties are excluded
// simply needs to regenerate for now.
ObjectTypePlaysRole link = (ObjectTypePlaysRole)e.ElementLink;
if (e.DomainRole.Id == ObjectTypePlaysRole.PlayedRoleDomainRoleId)
{
SignificantFactTypeChange(((Role)e.OldRolePlayer).BinarizedFactType);
}
else
{
SignificantObjectTypeChange((ObjectType)e.OldRolePlayer);
}
SignificantObjectTypeChange(link.RolePlayer);
SignificantFactTypeChange(link.PlayedRole.BinarizedFactType);
}
/// <summary>
/// DeleteRule: typeof(ObjectTypePlaysRole)
/// </summary>
private static void ObjectTypePlaysRoleDeletedRule(ElementDeletedEventArgs e)
{
// After this point, it is unknown whether the FactType was a unary, so we just delete it for now
ObjectTypePlaysRole link = e.ModelElement as ObjectTypePlaysRole;
ObjectType objectType = link.RolePlayer;
Role role;
FactType factType;
if (objectType.IsImplicitBooleanValue)
{
if (!(role = link.PlayedRole).IsDeleted &&
null != (factType = role.FactType) &&
!factType.IsDeleted)
{
factType.Delete();
}
if (!objectType.IsDeleted)
{
objectType.Delete();
}
}
}
/// <summary>
/// Implements <see cref="IModelErrorActivation.ActivateModelError"/> for
/// the <see cref="ValueComparisonConstraintOperatorNotSpecifiedError"/>
/// </summary>
protected new bool ActivateModelError(ModelError error)
{
ValueComparisonConstraintOperatorNotSpecifiedError operatorError;
ValueComparisonRolesNotComparableError comparabilityError;
ValueComparisonConstraint constraint;
Store store;
bool retVal = true;
if (null != (operatorError = error as ValueComparisonConstraintOperatorNotSpecifiedError))
{
store = Store;
constraint = operatorError.ValueComparisonConstraint;
EditorUtility.ActivatePropertyEditor(
(store as IORMToolServices).ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(constraint, ValueComparisonConstraint.OperatorDomainPropertyId),
true);
}
else if (null != (comparabilityError = error as ValueComparisonRolesNotComparableError))
{
constraint = comparabilityError.ValueComparisonConstraint;
LinkedElementCollection <Role> constraintRoles = constraint.RoleCollection;
Role role1;
Role role2;
ObjectTypePlaysRole rolePlayerLink1;
ObjectTypePlaysRole rolePlayerLink2;
ObjectType rolePlayer1 = null;
ObjectType rolePlayer2 = null;
Role[] valueRoles1 = null;
Role[] valueRoles2 = null;
// The default behavior is to activate the role sequence
// for editing. However, if the problem is with a single
// resolved value type, and the units are correct, then
// we need to select the first directly detached object.
if (constraintRoles.Count == 2 &&
null != (rolePlayerLink1 = ObjectTypePlaysRole.GetLinkToRolePlayer(role1 = constraintRoles[0])) &&
null != (rolePlayerLink2 = ObjectTypePlaysRole.GetLinkToRolePlayer(role2 = constraintRoles[1])) &&
(rolePlayerLink1.RolePlayer == rolePlayerLink2.RolePlayer ||
(null != (valueRoles1 = role1.GetValueRoles()) &&
null != (valueRoles2 = role2.GetValueRoles()) &&
DataType.IsComparableValueType(rolePlayer1 = valueRoles1[0].RolePlayer, rolePlayer2 = valueRoles2[0].RolePlayer, !constraint.IsDirectional))))
{
bool verifiedReferenceMode = true;
if (valueRoles1 != null)
{
ORMModel model = null;
ReferenceMode referenceMode1 = (valueRoles1.Length > 1) ?
ReferenceMode.FindReferenceModeFromEntityNameAndValueName(rolePlayer1.Name, valueRoles1[1].RolePlayer.Name, model = constraint.ResolvedModel) :
null;
ReferenceMode referenceMode2 = (valueRoles2.Length > 1) ?
ReferenceMode.FindReferenceModeFromEntityNameAndValueName(rolePlayer2.Name, valueRoles2[1].RolePlayer.Name, model ?? constraint.ResolvedModel) :
null;
bool referenceMode1IsUnit = referenceMode1 != null && referenceMode1.Kind.ReferenceModeType == ReferenceModeType.UnitBased;
bool referenceMode2IsUnit = referenceMode2 != null && referenceMode2.Kind.ReferenceModeType == ReferenceModeType.UnitBased;
verifiedReferenceMode = referenceMode1IsUnit ? (referenceMode2IsUnit && referenceMode1 == referenceMode2) : !referenceMode2IsUnit;
}
if (verifiedReferenceMode)
{
// Find a connected role player
foreach (ExternalConstraintLink constraintLink in MultiShapeUtility.GetEffectiveAttachedLinkShapes <ExternalConstraintLink>(this))
{
FactTypeShape factTypeShape;
if (constraintLink.AssociatedConstraintRole.Role == role1 &&
null != (factTypeShape = constraintLink.FromShape as FactTypeShape))
{
foreach (RolePlayerLink rolePlayerLinkShape in MultiShapeUtility.GetEffectiveAttachedLinkShapes <RolePlayerLink>(factTypeShape))
{
if (rolePlayerLinkShape.AssociatedRolePlayerLink == rolePlayerLink1)
{
Diagram.ActiveDiagramView.Selection.Set(new DiagramItem(rolePlayerLinkShape.ToShape));
return(true);
}
}
}
}
}
}
ActivateNewRoleSequenceConnectAction(null);
}
else
{
retVal = base.ActivateModelError(error);
}
return(retVal);
}
private static void ProcessRolePlayerDeleted(ObjectTypePlaysRole link, ObjectType rolePlayer, Role role)
{
if (role == null)
{
role = link.PlayedRole;
}
if (rolePlayer == null)
{
rolePlayer = link.RolePlayer;
}
FilterModifiedFactType(role.FactType, false);
RoleProxy proxy = role.Proxy;
if (proxy != null)
{
FilterModifiedFactType(proxy.FactType, false);
}
FilterModifiedObjectType(rolePlayer);
}
private static void ProcessRolePlayerAdded(ObjectTypePlaysRole link)
{
Role role = link.PlayedRole;
FilterModifiedFactType(role.FactType, false);
RoleProxy proxy = role.Proxy;
if (proxy != null)
{
FilterModifiedFactType(proxy.FactType, false);
}
FilterModifiedObjectType(link.RolePlayer);
}
