it.unibo.alchemist.model.linkingrules.ConnectViaAccessPoint.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of alchemist-implementationbase Show documentation

Abstract, incarnation independent implementations of the Alchemist's interfaces. Provides support for those who want to write incarnations.

There is a newer version: 35.0.1

Show newest version

/*
 * Copyright (C) 2010-2023, Danilo Pianini and contributors
 * listed, for each module, in the respective subproject's build.gradle.kts file.
 *
 * This file is part of Alchemist, and is distributed under the terms of the
 * GNU General Public License, with a linking exception,
 * as described in the file LICENSE in the Alchemist distribution's top directory.
 */

package it.unibo.alchemist.model.linkingrules

import it.unibo.alchemist.model.Environment
import it.unibo.alchemist.model.Molecule
import it.unibo.alchemist.model.Neighborhood
import it.unibo.alchemist.model.Node
import it.unibo.alchemist.model.Position
import it.unibo.alchemist.model.neighborhoods.Neighborhoods

/**
 * @param accessPointId the id of the access point.
 */
class ConnectViaAccessPoint>(
    radius: Double,
    val accessPointId: Molecule,
) : ConnectWithinDistance(radius) {

    private val Node.isAccessPoint
        get() = contains(accessPointId)

    private fun Neighborhood.closestAccessPoint(environment: Environment): Node? =
        asSequence().filter { it.isAccessPoint }.minByOrNull { environment.getDistanceBetweenNodes(center, it) }

    override fun computeNeighborhood(center: Node, environment: Environment): Neighborhood =
        super.computeNeighborhood(center, environment).run {
            if (!center.isAccessPoint) {
                // Connect to closest access point and all nodes connected to the same AP
                closestAccessPoint(environment)?.let { closestAP ->
                    Neighborhoods.make(
                        environment,
                        center,
                        neighbors.filter {
                            it == closestAP || !it.isAccessPoint && environment.getNeighborhood(it).contains(closestAP)
                        },
                    )
                } ?: Neighborhoods.make(environment, center, emptyList())
            } else {
                if (all { it.isAccessPoint }) {
                    this
                } else {
                    // The AP must connect only if it is the closest AP of each node or the node is not connected
                    Neighborhoods.make(
                        environment,
                        center,
                        neighbors
                            .asSequence()
                            .filter { neighbor ->
                                neighbor.isAccessPoint ||
                                    environment.getNeighborhood(neighbor).run {
                                        contains(center) || none { it.isAccessPoint }
                                    }
                            }
                            .asIterable(),
                    )
                }
            }
        }
}