Example #1
0
        /// <summary>
        /// Initial the role pattern and constraints for a standard
        /// subtype. This should be called after the subtype is parented
        /// by either the model or an alternate owner so that the created
        /// elements can also be properly parented.
        /// </summary>
        protected void InitializeIdentityFactType()
        {
            Store store;

            if (CopyMergeUtility.GetIntegrationPhase(store = this.Store) == CopyClosureIntegrationPhase.None)
            {
                IDictionary <object, object> contextInfo = store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo;
                try
                {
                    // Establish role collecton
                    contextInfo[InitializingIdentityFactTypeKey] = null;
                    LinkedElementCollection <RoleBase> roles = this.RoleCollection;
                    Partition         partition         = this.Partition;
                    SubtypeMetaRole   subTypeMetaRole   = new SubtypeMetaRole(partition);
                    SupertypeMetaRole superTypeMetaRole = new SupertypeMetaRole(partition);
                    roles.Add(subTypeMetaRole);
                    roles.Add(superTypeMetaRole);

                    // Add injection constraints
                    superTypeMetaRole.Multiplicity = RoleMultiplicity.ExactlyOne;
                    subTypeMetaRole.Multiplicity   = RoleMultiplicity.ZeroToOne;
                }
                finally
                {
                    contextInfo.Remove(InitializingIdentityFactTypeKey);
                }
            }
        }
Example #2
0
        /// <summary>
        /// AddRule: typeof(ConstraintRoleSequenceHasRole)
        /// Block internal constraints from being modified on a subtype, block
        /// external constraints from being added to the subtype role, and
        /// limit external constraints being added to the supertype role
        /// </summary>
        private static void LimitSubtypeConstraintRolesAddRule(ElementAddedEventArgs e)
        {
            ConstraintRoleSequenceHasRole link = e.ModelElement as ConstraintRoleSequenceHasRole;
            Role untypedRole = link.Role;
            SupertypeMetaRole      supertypeRole = untypedRole as SupertypeMetaRole;
            SubtypeMetaRole        subtypeRole   = (supertypeRole == null) ? untypedRole as SubtypeMetaRole : null;
            ConstraintRoleSequence sequence      = link.ConstraintRoleSequence;
            IConstraint            constraint;

            if (supertypeRole != null || subtypeRole != null)
            {
                SetConstraint ic;
                SetComparisonConstraintRoleSequence externalSequence;
                bool invalidConstraintOnSubtypeRole   = false;
                bool invalidConstraintOnSupertypeRole = false;
                if (null != (ic = sequence as SetConstraint))
                {
                    constraint = ic.Constraint;
                    if (constraint.ConstraintIsInternal)
                    {
                        SubtypeFact subtypeFact;
                        Store       store;
                        if (null != (subtypeFact = untypedRole.FactType as SubtypeFact) &&
                            subtypeFact.ResolvedModel != null &&
                            CopyMergeUtility.GetIntegrationPhase(store = subtypeFact.Store) == CopyClosureIntegrationPhase.None)
                        {
                            // Allow before adding to model, not afterwards
                            ThrowPatternModifiedException(store);
                        }
                    }
                    else if (constraint.ConstraintType == ConstraintType.ImpliedMandatory)
                    {
                        // Nothing to do
                    }
                    else if (subtypeRole != null)
                    {
                        invalidConstraintOnSubtypeRole = true;
                    }
                    else if (constraint.ConstraintType != ConstraintType.DisjunctiveMandatory)
                    {
                        invalidConstraintOnSupertypeRole = true;
                    }
                }
                else if (subtypeRole != null)
                {
                    invalidConstraintOnSubtypeRole = true;
                }
                else if (null != (externalSequence = sequence as SetComparisonConstraintRoleSequence))
                {
                    constraint = externalSequence.Constraint;
                    if (constraint != null)
                    {
                        switch (constraint.ConstraintType)
                        {
                        case ConstraintType.Exclusion:
                            FrameworkDomainModel.DelayValidateElement((ModelElement)constraint, DelayValidateSupertypeExclusionSingleColumnOnly);
                            break;

                        case ConstraintType.Subset:
                            FrameworkDomainModel.DelayValidateElement((ModelElement)constraint, DelayValidateSupertypeSubsetPattern);
                            break;

                        default:
                            invalidConstraintOnSupertypeRole = true;
                            break;
                        }
                    }
                }
                if (invalidConstraintOnSupertypeRole)
                {
                    ThrowInvalidSupertypeMetaRoleConstraint();
                }
                else if (invalidConstraintOnSubtypeRole)
                {
                    ThrowInvalidSubtypeMetaRoleConstraint();
                }
            }
            else if (null != (constraint = sequence.Constraint))
            {
                switch (constraint.ConstraintType)
                {
                case ConstraintType.Exclusion:
                    FrameworkDomainModel.DelayValidateElement((ModelElement)constraint, DelayValidateSupertypeExclusionSingleColumnOnly);
                    break;

                case ConstraintType.Subset:
                    FrameworkDomainModel.DelayValidateElement((ModelElement)constraint, DelayValidateSupertypeSubsetPattern);
                    break;
                }
            }
        }