/// <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); }