cpg-core/de.fraunhofer.aisec.cpg.graph.edges.overlay/OverlaySingleEdge

OverlaySingleEdge

class OverlaySingleEdge(thisRef: Node, of: Node?, var mirrorProperty: KProperty<MutableCollection<OverlayEdge>>, outgoing: Boolean = true) : EdgeSingletonList<Node, Node?, OverlayEdge> , MirroredEdgeCollection<Node, OverlayEdge>

Represents a single edge in an overlay graph structure, linking nodes with specific properties.

Parameters

thisRef

The current node that the edge originates from or is associated with.

The optional target node of the edge.

mirrorProperty

The property representing a mutable collection of mirrored overlay edges.

outgoing

A flag indicating whether the edge is outgoing (default is true).

Constructors

OverlaySingleEdge

constructor(thisRef: Node, of: Node?, mirrorProperty: KProperty<MutableCollection<OverlayEdge>>, outgoing: Boolean = true)

Initializes the OverlaySingleEdge instance with the provided parameters.

Properties

commonType

val Collection<Type>.commonType: Type?

This computed property returns the common type in a Collection of Type objects. For example, if two types A and B both derive from the interface C`` then C` would be returned.

element

var element: OverlayEdge?

init

open override var init: (Node, Node) -> OverlayEdge

mirrorProperty

open override var mirrorProperty: KProperty<MutableCollection<OverlayEdge>>

onAdd

open override var onAdd: (OverlayEdge) -> Unit?

onChanged

var onChanged: (old: OverlayEdge?, new: OverlayEdge?) -> Unit?

onRemove

open override var onRemove: (OverlayEdge) -> Unit?

outgoing

open override var outgoing: Boolean

size

open override val size: Int

thisRef

open override var thisRef: Node

Functions

add

open fun add(target: Node, init: (Node, Node) -> OverlayEdge = this.init, builder: OverlayEdge.() -> Unit? = null): Boolean

Creates a new edge with the target node and an optional builder to include edge properties. If outgoing is true, the edge is created from thisRef ->target, otherwise from target to thisRef.

open override fun add(element: OverlayEdge): Boolean

addAll

open fun addAll(targets: Collection<Node>, builder: OverlayEdge.() -> Unit? = null): Boolean

open override fun addAll(elements: Collection<OverlayEdge>): Boolean

byNameOrNull

fun <T : Node> Collection<T>?.byNameOrNull(lookup: String, modifier: SearchModifier): T?

This function returns the first node that matches the name on the supplied list of nodes.

clear

open override fun clear()

contains

open fun contains(target: Node): Boolean

open operator override fun contains(element: OverlayEdge): Boolean

containsAll

open override fun containsAll(elements: Collection<OverlayEdge>): Boolean

createEdge

open fun <NodeType : Node, PropertyEdgeType : Edge<NodeType>> createEdge(target: NodeType, init: (Node, NodeType) -> PropertyEdgeType, outgoing: Boolean = true, builder: PropertyEdgeType.() -> Unit? = null): PropertyEdgeType

delegate

fun <ThisType : Node> delegate(): EdgeSingletonList.UnwrapDelegate<ThisType, Node, Node?, OverlayEdge>

get

operator fun <T : Node> Collection<T>?.get(predicate: (T) -> Boolean, modifier: SearchModifier = SearchModifier.NONE): T?

A shortcut to call firstOrNull using the [] syntax.

operator fun <T : Node> Collection<T>?.get(lookup: String, modifier: SearchModifier = SearchModifier.NONE): T?

A shortcut to call byNameOrNull using the [] syntax.

handleOnAdd

open fun handleOnAdd(edge: OverlayEdge)

This function will be executed after the edge was added to the container. This can be used to propagate the edge to other properties or register additional handlers, e.g. a TypeObserver.

handleOnRemove

open fun handleOnRemove(edge: OverlayEdge)

This function will be executed after an edge was removed from the container. This can be used to unregister additional handlers, e.g. a TypeObserver.

invoke

operator fun <T : Node> Collection<T>.invoke(predicate: (T) -> Boolean): List<T>

A shortcut invoke filter on a list of nodes.

operator fun <T : Node> Collection<T>.invoke(lookup: String): List<T>

A shortcut to filter a list of nodes by their name.

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<OverlayEdge>

plusAssign

open operator fun plusAssign(end: Node)

remove

open fun remove(target: Node): Boolean

Removes all edges with the target node. The target is considered to be either the Edge.end or Edge.start depending on outgoing.

open override fun remove(element: OverlayEdge): Boolean

removeAll

open override fun removeAll(elements: Collection<OverlayEdge>): Boolean

resetTo

open fun resetTo(nodes: Collection<Node>)

Clears the collection and adds the nodes.

fun resetTo(node: Node)

retainAll

open override fun retainAll(elements: Collection<OverlayEdge>): Boolean

toIdentitySet

fun <T> Collection<T>.toIdentitySet(): IdentitySet<T>

toNodeCollection

open override fun toNodeCollection(predicate: (OverlayEdge) -> Boolean?): Collection<Node>

Converts this collection of edges into a collection of nodes for easier access to the "target" nodes.

unwrap

open override fun unwrap(): UnwrappedEdgeCollection<Node, OverlayEdge>

Returns an UnwrappedEdgeCollection magic container which holds a structure that provides easy access to the "target" nodes without edge information, but is mutable and in-sync with this collection.