if ('org' == id.group) {
                           belongsTo("\${id.group}:platform:\${id.version}")
                           belongsTo("\${id.group}:platform2:\${id.version}")
                        }
                    }
                }
            }
        """
    }

				"Country": {
					Name: "Country", Type: schema.BelongsTo, Schema: "Org", FieldSchema: "Country",
					References: []Reference{
						{PrimaryKey: "ID", PrimarySchema: "Country", ForeignKey: "CountryID", ForeignSchema: "Org"},
					},
				},
			},
		},
		"VisitingAddress": {
			Relations: map[string]Relation{
				"Country": {
					Name: "Country", Type: schema.BelongsTo, Schema: "Org", FieldSchema: "Country",

        ctx.details.with {
            if (id.group.startsWith("com.fasterxml.jackson")) {
                // declare that Jackson modules belong to the platform defined by the Jackson BOM
                belongsTo("com.fasterxml.jackson:jackson-bom:${id.version}", false)
            }
        }
    }
}
// end::bom-alignment-rule[]

// tag::alignment-rule[]

	HasMany   RelationshipType = "has_many"     // HasManyRel has many relationship
	BelongsTo RelationshipType = "belongs_to"   // BelongsToRel belongs to relationship
	Many2Many RelationshipType = "many_to_many" // Many2ManyRel many to many relationship
	has       RelationshipType = "has"
)

type Relationships struct {
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship

    }

    @Override
    public void belongsTo(Object notation) {
        belongsTo(notation, true);
    }

    @Override
    public void belongsTo(Object notation, boolean virtual) {
        ComponentIdentifier id = componentIdentifierParser.parseNotation(notation);
        if (virtual) {
            metadata.belongsTo(VirtualComponentHelper.makeVirtual(id));

        ctx.details.run {
            if (id.group.startsWith("com.fasterxml.jackson")) {
                // declare that Jackson modules belong to the platform defined by the Jackson BOM
                belongsTo("com.fasterxml.jackson:jackson-bom:${id.version}", false)
            }
        }
    }
}
// end::bom-alignment-rule[]

// tag::alignment-rule[]
abstract class JacksonAlignmentRule: ComponentMetadataRule {

    /**
     * Declares that this component belongs to a virtual platform, which should be
     * considered during dependency resolution.
     * @param notation the coordinates of the owner
     *
     * @since 4.10
     */
    void belongsTo(Object notation);

    /**
     * Declares that this component belongs to a platform, which should be
     * considered during dependency resolution.

		reflectValue := association.DB.Statement.ReflectValue
		rel := association.Relationship

		var oldBelongsToExpr clause.Expression
		// we have to record the old BelongsTo value
		if association.Unscope && rel.Type == schema.BelongsTo {
			var foreignFields []*schema.Field
			for _, ref := range rel.References {
				if !ref.OwnPrimaryKey {
					foreignFields = append(foreignFields, ref.ForeignKey)
				}
			}

include::sample[dir="snippets/dependencyManagement/managingTransitiveDependencies-dependencyAlignment/groovy",files="build.gradle[tags=bom-alignment-rule]"]
====

By using the `belongsTo` with `false` (**not** virtual), we declare that all modules belong to the same _published platform_.

     */
    VariantMetadataRules getVariantMetadataRules();

    /**
     * Declares that this component belongs to a virtual platform.
     * @param platform the identifier of the virtual platform
     */
    void belongsTo(VirtualComponentIdentifier platform);

    @Nullable
    Set<? extends VirtualComponentIdentifier> getPlatformOwners();