/// <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);
}
/// <summary>
/// Derive super types.
/// </summary>
/// <param name="superTypes">The super types.</param>
internal void DeriveSupertypes(HashSet<Interface> superTypes)
{
superTypes.Clear();
this.DeriveSupertypesRecursively(this, superTypes);
this.derivedSupertypes = new LazySet<Interface>(superTypes);
}
/// <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 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 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 sub types.
/// </summary>
/// <param name="subTypes">The super types.</param>
internal void DeriveSubtypes(HashSet<Composite> subTypes)
{
subTypes.Clear();
this.DeriveSubtypesRecursively(this, subTypes);
this.derivedSubtypes = new LazySet<Composite>(subTypes);
}
/// <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);
}