/// <summary>
/// Derive direct super type derivations.
/// </summary>
/// <param name="directSupertypes">The direct super types.</param>
internal void DeriveDirectSupertypes(HashSet <Interface> directSupertypes)
{
directSupertypes.Clear();
foreach (var inheritance in this.MetaPopulation.Inheritances.Where(inheritance => this.Equals(inheritance.Subtype)))
{
directSupertypes.Add(inheritance.Supertype);
}
this.derivedDirectSupertypes = new LazySet <Interface>(directSupertypes);
}
/// <summary>
/// Derive subclasses.
/// </summary>
/// <param name="subClasses">The sub classes.</param>
internal void DeriveSubclasses(HashSet <Class> subClasses)
{
subClasses.Clear();
foreach (var subType in this.derivedSubtypes)
{
if (subType is IClass)
{
subClasses.Add((Class)subType);
}
}
this.derivedSubclasses = new LazySet <Class>(subClasses);
}
/// <summary>
/// Derive method types.
/// </summary>
/// <param name="methodTypes">
/// The method types.
/// </param>
internal void DeriveMethodTypes(HashSet <MethodType> methodTypes)
{
methodTypes.Clear();
foreach (var methodType in this.MetaPopulation.MethodTypes.Where(m => this.Equals(m.ObjectType)))
{
methodTypes.Add(methodType);
}
foreach (var superType in this.Supertypes)
{
var type = superType;
foreach (var methodType in this.MetaPopulation.MethodTypes.Where(m => type.Equals(m.ObjectType)))
{
methodTypes.Add(methodType);
}
}
this.derivedMethodTypes = new LazySet <MethodType>(methodTypes);
}
/// <summary>
/// Derive association types.
/// </summary>
/// <param name="associations">The associations.</param>
/// <param name="relationTypesByRoleObjectType">AssociationTypes grouped by the ObjectType of the Role</param>
internal void DeriveAssociationTypes(HashSet <AssociationType> associations, Dictionary <ObjectType, HashSet <AssociationType> > relationTypesByRoleObjectType)
{
associations.Clear();
HashSet <AssociationType> classAssociationTypes;
if (relationTypesByRoleObjectType.TryGetValue(this, out classAssociationTypes))
{
associations.UnionWith(classAssociationTypes);
}
foreach (var superType in this.Supertypes)
{
HashSet <AssociationType> interfaceAssociationTypes;
if (relationTypesByRoleObjectType.TryGetValue(superType, out interfaceAssociationTypes))
{
associations.UnionWith(interfaceAssociationTypes);
}
}
this.derivedAssociationTypes = new LazySet <AssociationType>(associations);
}
/// <summary>
/// Derive role types.
/// </summary>
/// <param name="roleTypes">The role types.</param>
/// <param name="roleTypesByAssociationObjectType">RoleTypes grouped by the ObjectType of the Association</param>
internal void DeriveRoleTypes(HashSet <RoleType> roleTypes, Dictionary <ObjectType, HashSet <RoleType> > roleTypesByAssociationObjectType)
{
roleTypes.Clear();
HashSet <RoleType> classRoleTypes;
if (roleTypesByAssociationObjectType.TryGetValue(this, out classRoleTypes))
{
roleTypes.UnionWith(classRoleTypes);
}
foreach (var superType in this.Supertypes)
{
HashSet <RoleType> superTypeRoleTypes;
if (roleTypesByAssociationObjectType.TryGetValue(superType, out superTypeRoleTypes))
{
roleTypes.UnionWith(superTypeRoleTypes);
}
}
this.derivedRoleTypes = new LazySet <RoleType>(roleTypes);
}
