/// <summary>
/// DeletingRule: typeof(ORMSolutions.ORMArchitect.ORMAbstraction.UniquenessIncludesConceptTypeChild)
/// Remove a column in a uniqueness constraint when a concept type child is removed from the
/// corresponding abstraction construct
/// </summary>
private static void UniquenessConstraintRoleDeleting(ElementDeletingEventArgs e)
{
UniquenessIncludesConceptTypeChild link = (UniquenessIncludesConceptTypeChild)e.ModelElement;
Uniqueness uniqueness = link.Uniqueness;
LinkedElementCollection <UniquenessConstraint> constraints;
int constraintCount;
if (!uniqueness.IsDeleting &&
!link.ConceptTypeChild.IsDeleting &&
0 != (constraintCount = (constraints = UniquenessConstraintIsForUniqueness.GetUniquenessConstraint(uniqueness)).Count))
{
int removeAtIndex = UniquenessIncludesConceptTypeChild.GetLinksToConceptTypeChildCollection(uniqueness).IndexOf(link);
for (int i = 0; i < constraintCount; ++i)
{
constraints[i].ColumnCollection.RemoveAt(removeAtIndex);
}
}
}
private static Attribute CreateAttributeForInformationType(InformationType informationType, Stack <ConceptTypeChild> conceptTypeChildPath)
{
conceptTypeChildPath.Push(informationType);
Attribute attribute = new Attribute(informationType.Store,
new PropertyAssignment[] {
new PropertyAssignment(Attribute.NameDomainPropertyId, informationType.Name)
});
foreach (Uniqueness u in UniquenessIncludesConceptTypeChild.GetUniquenessCollection(informationType))
{
if (u.IsPreferred)
{
attribute.IsPrimaryIdComponent = true;
break;
}
}
ConceptTypeChild[] conceptTypeChildPathReverse = conceptTypeChildPath.ToArray();
sys.Array.Reverse(conceptTypeChildPathReverse);
AttributeHasConceptTypeChild.GetConceptTypeChildPath(attribute).AddRange(conceptTypeChildPathReverse);
conceptTypeChildPath.Pop();
return(attribute);
}
/// <summary>
/// Generages the <see cref="ConceptType"/> objects along with any relationships that they have and adds them to the
/// model.
/// </summary>
/// <param name="factTypeMappings">A dictionary of all the final decided FactTypeMapping objects.</param>
private void GenerateConceptTypes(FactTypeMappingDictionary factTypeMappings)
{
ORMModel model = this.ORMModel;
LinkedElementCollection<ObjectType> modelObjectTypes = model.ObjectTypeCollection;
AbstractionModel oialModel = this.AbstractionModel;
// For each object type in the model...
foreach (ObjectType objectType in modelObjectTypes)
{
if (ShouldIgnoreObjectType(objectType))
{
continue;
}
// If it should have a conctpt type...
if (ObjectTypeIsConceptType(objectType, factTypeMappings))
{
// Create the ConceptType object.
PropertyAssignment name = new PropertyAssignment(ConceptType.NameDomainPropertyId, objectType.Name);
ConceptType conceptType = new ConceptType(Store, name);
ConceptTypeIsForObjectType conceptTypeIsForObjectType = new ConceptTypeIsForObjectType(conceptType, objectType);
// Add it to the model.
oialModel.ConceptTypeCollection.Add(conceptType);
// If this conceptType is for a ValueType...
if (objectType.IsValueType)
{
InformationTypeFormat valueTypeInformationTypeFormat = InformationTypeFormatIsForValueType.GetInformationTypeFormat(objectType);
RoleAssignment conceptTypeRole = new RoleAssignment(InformationType.ConceptTypeDomainRoleId, conceptType);
RoleAssignment informationTypeFormat = new RoleAssignment(InformationType.InformationTypeFormatDomainRoleId, valueTypeInformationTypeFormat);
RoleAssignment[] roleAssignments = { conceptTypeRole, informationTypeFormat };
PropertyAssignment isMandatory = new PropertyAssignment(InformationType.IsMandatoryDomainPropertyId, true);
PropertyAssignment informationTypeNameProperty = new PropertyAssignment(InformationType.NameDomainPropertyId, String.Concat(objectType.Name, "Value"));
PropertyAssignment[] informationTypePropertyAssignments = { isMandatory, informationTypeNameProperty };
// ConceptType for conceptType gets an InformationType that references InformationTypeFormat for conceptType.
InformationType informationType = new InformationType(Store, roleAssignments, informationTypePropertyAssignments);
PropertyAssignment uniquenessNameProperty = new PropertyAssignment(Uniqueness.NameDomainPropertyId, String.Concat(objectType.Name, "Uniqueness"));
PropertyAssignment isPreferred = new PropertyAssignment(Uniqueness.IsPreferredDomainPropertyId, true);
PropertyAssignment[] uniquenessPropertyAssignments = { uniquenessNameProperty, isPreferred };
// Uniqueness constraint
Uniqueness uniqueness = new Uniqueness(Store, uniquenessPropertyAssignments);
UniquenessIncludesConceptTypeChild uniquenessIncludesConceptTypeChild = new UniquenessIncludesConceptTypeChild(uniqueness, informationType);
conceptType.UniquenessCollection.Add(uniqueness);
}
}
}
}
/// <summary>
/// Generates the <see cref="Uniqueness"/> objects for the <see cref="AbstractionModel"/>.
/// </summary>
/// <param name="factTypeMappings">The decided <see cref="FactTypeMapping"/> objects.</param>
private void GenerateUniqueness(FactTypeMappingDictionary factTypeMappings)
{
// TODO: clean this up.
AbstractionModel oialModel = this.AbstractionModel;
// For each concept type in the model...
foreach (ConceptType conceptType in oialModel.ConceptTypeCollection)
{
ObjectType objectType = ConceptTypeIsForObjectType.GetObjectType(conceptType);
// For each role played by its object type...
foreach (Role role in objectType.PlayedRoleCollection)
{
if (ShouldIgnoreFactType(role.BinarizedFactType))
{
continue;
}
Role oppositeRole = role.OppositeRoleAlwaysResolveProxy.Role;
// For each constraint on the opposite role...
foreach (ConstraintRoleSequence constraintRoleSequence in oppositeRole.ConstraintRoleSequenceCollection)
{
UniquenessConstraint uninquenessConstraint = constraintRoleSequence as UniquenessConstraint;
// If it is a uniqueness constraint...
if (uninquenessConstraint != null && uninquenessConstraint.Modality == ConstraintModality.Alethic)
{
if (UniquenessIsForUniquenessConstraint.GetUniqueness(uninquenessConstraint) != null)
{
continue;
}
bool hasFactTypeThatShouldBeIgnored = false;
bool allChildrenMapTowardObjectType = true;
IList<FactType> factTypes = new List<FactType>();
foreach (Role childRole in uninquenessConstraint.RoleCollection)
{
FactType binarizedFactType = childRole.BinarizedFactType;
if (ShouldIgnoreFactType(binarizedFactType))
{
hasFactTypeThatShouldBeIgnored = true;
break;
}
FactTypeMapping factTypeMapping = factTypeMappings[binarizedFactType];
if (factTypeMapping.TowardsRole != childRole.OppositeRoleAlwaysResolveProxy.Role)
{
allChildrenMapTowardObjectType = false;
break;
}
else
{
factTypes.Add(binarizedFactType);
}
}
if (hasFactTypeThatShouldBeIgnored)
{
continue;
}
if (allChildrenMapTowardObjectType)
{
IList<ConceptTypeChild> conceptTypeChildren = new List<ConceptTypeChild>();
bool skipThisUniquenessConstraint = false;
foreach (FactType factType in factTypes)
{
bool childWasAssimilation = false;
bool missedChild = true;
foreach (ConceptTypeChild conceptTypeChild in ConceptTypeChildHasPathFactType.GetConceptTypeChild(factType))
{
if (conceptTypeChild.Parent != conceptType)
{
// This ConceptTypeChild is of a different ConceptType, so go on to the next ConceptTypeChild.
continue;
}
if (conceptTypeChild is ConceptTypeAssimilatesConceptType)
{
childWasAssimilation = true;
break;
}
missedChild = false;
conceptTypeChildren.Add(conceptTypeChild);
}
if (childWasAssimilation)
{
skipThisUniquenessConstraint = true;
break;
}
if (missedChild)
{
// We couldn't find a ConceptTypeChild for this FactType, so just bail out.
skipThisUniquenessConstraint = true;
break;
}
}
if (!skipThisUniquenessConstraint)
{
PropertyAssignment name = new PropertyAssignment(Uniqueness.NameDomainPropertyId, uninquenessConstraint.Name);
PropertyAssignment isPreferred = new PropertyAssignment(Uniqueness.IsPreferredDomainPropertyId, uninquenessConstraint.IsPreferred);
PropertyAssignment[] propertyAssignments = { name, isPreferred };
// Create uniquenesss
Uniqueness uniqueness = new Uniqueness(Store, propertyAssignments);
uniqueness.ConceptType = conceptType;
new UniquenessIsForUniquenessConstraint(uniqueness, uninquenessConstraint);
foreach (ConceptTypeChild conceptTypeChild in conceptTypeChildren)
{
UniquenessIncludesConceptTypeChild uniquenessIncludesConceptTypeChild = new UniquenessIncludesConceptTypeChild(uniqueness, conceptTypeChild);
}
}
}
}
}
}
}
}
/// <summary>
/// for regular relationships
/// </summary>
/// <param name="relation"></param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="notifyAdded"></param>
/// <param name="associationCounter"></param>
/// <returns></returns>
private static bool CreateBinaryAssociation(ConceptTypeChild relation, ConceptType source, ConceptType target, INotifyElementAdded notifyAdded, ref int associationCounter)
{
if (BinaryAssociationHasConceptTypeChild.GetBinaryAssociation(relation).Count > 0)
{
//it has already been created
return(true);
}
else if (EntityTypeIsPrimarilyForConceptType.GetEntityType(target) != null)
{
#region create association
BinaryAssociation b = new BinaryAssociation(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(BinaryAssociation.NumberDomainPropertyId, associationCounter++) });
//new BinaryAssociationHasConceptTypeChild(b, relation);
BinaryAssociationHasConceptTypeChild.GetConceptTypeChildPath(b).Add(relation);
Role r1 = new Role(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, source.Name) });
Role r2 = new Role(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, target.Name) });
b.RoleCollection.Add(r1);
b.RoleCollection.Add(r2);
EntityType sourceEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(source);
EntityType targetEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(target);
sourceEntity.RoleCollection.Add(r1);
targetEntity.RoleCollection.Add(r2);
sourceEntity.BarkerErModel.BinaryAssociationCollection.Add(b);
#endregion
//determine whether roles are mandatory or optional
List <ConceptTypeChild> links = new List <ConceptTypeChild>(1);
links.Add(relation);
r1.IsMandatory = AllStepsMandatory(targetEntity, links);
if (relation is ConceptTypeAssimilatesConceptType)
{
r2.IsMandatory = AllStepsMandatory(sourceEntity, links);
}
#region determine whether roles are multivalued or not - and possibly rename
ORMCore.ObjectType sourceObjectType = ConceptTypeIsForObjectType.GetObjectType(source);
ORMCore.ObjectType targetObjectType = ConceptTypeIsForObjectType.GetObjectType(target);
ORMCore.UniquenessConstraint uSource = null, uTarget = null;
foreach (ORMCore.FactType factType in ConceptTypeChildHasPathFactType.GetPathFactTypeCollection(relation))
{
Debug.Assert(factType.RoleCollection.Count == 2, "Error when mapping to Barker ER; the fact type is not binary");
foreach (ORMCore.RoleBase r in factType.RoleCollection)
{
//need to use RoleBase because we might run into RoleProxy
ORMCore.Role role = r.Role;
foreach (ORMCore.ConstraintRoleSequence constraintRoleSequence in role.ConstraintRoleSequenceCollection)
{
ORMCore.UniquenessConstraint uninquenessConstraint = constraintRoleSequence as ORMCore.UniquenessConstraint;
if (uninquenessConstraint != null && //check that it's a uniqueness constraint
uninquenessConstraint.Modality == ORMCore.ConstraintModality.Alethic && //check it's alethic
uninquenessConstraint.IsInternal) //check it's internal
{
if (role.RolePlayer == sourceObjectType)
{
uSource = uninquenessConstraint;
}
if (role.RolePlayer == targetObjectType)
{
uTarget = uninquenessConstraint;
}
}
}
}
//name the roles properly
//TODO this is a hack; proper name generation is yet to be implemented
foreach (ORMCore.ReadingOrder order in factType.ReadingOrderCollection)
{
string text = order.ReadingText;
int first = text.IndexOf('}') + 1;
text = text.Substring(first, text.LastIndexOf('{') - first);
text = text.Trim();
if (!string.IsNullOrEmpty(text) &&
order.RoleCollection != null && order.RoleCollection.Count > 0 &&
order.RoleCollection[0].Role != null)
{
ORMCore.ObjectType o = order.RoleCollection[0].Role.RolePlayer;
if (o == sourceObjectType)
{
r1.PredicateText = text;
}
else if (o == targetObjectType)
{
r2.PredicateText = text;
}
}
}
}
if (uSource != null && uSource == uTarget)
{
//it's many-to-many
r1.IsMultiValued = true;
r2.IsMultiValued = true;
}
else if (uSource == null || uTarget == null)
{
//it's one-to-many
r1.IsMultiValued = uSource != null;
r2.IsMultiValued = uTarget != null;
}
else if (uSource != null && uTarget != null)
{
//it's one-to-one
r1.IsMultiValued = false;
r2.IsMultiValued = false;
}
else
{
Debug.Fail("Found a fact type with no uniqueness constraints!");
}
#endregion
#region primary id?
foreach (Uniqueness u in UniquenessIncludesConceptTypeChild.GetUniquenessCollection(relation))
{
if (u.IsPreferred)
{
r1.IsPrimaryIdComponent = true;
break;
}
}
#endregion
//notify elements added
if (notifyAdded != null)
{
notifyAdded.ElementAdded(b, true);
notifyAdded.ElementAdded(r1, true);
notifyAdded.ElementAdded(r2, true);
}
return(true);
}
else
{
//should not create binary association in this case
return(false);
}
}
