cpg-core/de.fraunhofer.aisec.cpg.graph.edges.collections/MirroredEdgeCollection

MirroredEdgeCollection

interface MirroredEdgeCollection<NodeType : Node, PropertyEdgeType : Edge<NodeType>> : EdgeCollection<NodeType, PropertyEdgeType>

This interface can be used for edge collections, which "mirror" its content to another property. This can be used to automatically populate next/prev flow edges.

Inheritors

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.

init

abstract var init: (start: Node, end: NodeType) -> PropertyEdgeType

mirrorProperty

abstract var mirrorProperty: KProperty<MutableCollection<PropertyEdgeType>>

onAdd

abstract var onAdd: (PropertyEdgeType) -> Unit?

onRemove

abstract var onRemove: (PropertyEdgeType) -> Unit?

outgoing

abstract var outgoing: Boolean

size

abstract val size: Int

thisRef

abstract var thisRef: Node

Functions

add

open fun add(target: NodeType, init: (Node, NodeType) -> PropertyEdgeType = this.init, builder: PropertyEdgeType.() -> 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.

abstract fun add(element: PropertyEdgeType): Boolean

addAll

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

abstract fun addAll(elements: Collection<PropertyEdgeType>): 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

abstract fun clear()

contains

open fun contains(target: NodeType): Boolean

abstract operator fun contains(element: PropertyEdgeType): Boolean

containsAll

abstract fun containsAll(elements: Collection<PropertyEdgeType>): Boolean

createEdge

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

forEach

open fun forEach(p0: Consumer<in PropertyEdgeType>)

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 override fun handleOnAdd(edge: PropertyEdgeType)

Adds this particular edge to its mirrorProperty. We need the information if this is an outgoing or incoming edge collection.

handleOnRemove

open override fun handleOnRemove(edge: PropertyEdgeType)

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

abstract fun isEmpty(): Boolean

iterator

abstract operator override fun iterator(): MutableIterator<PropertyEdgeType>

parallelStream

open fun parallelStream(): Stream<PropertyEdgeType>

plusAssign

open operator fun plusAssign(end: NodeType)

remove

open fun remove(target: NodeType): Boolean

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

abstract fun remove(element: PropertyEdgeType): Boolean

removeAll

abstract fun removeAll(elements: Collection<PropertyEdgeType>): Boolean

removeIf

open fun removeIf(p0: Predicate<in PropertyEdgeType>): Boolean

resetTo

open fun resetTo(nodes: Collection<NodeType>)

Clears the collection and adds the nodes.

retainAll

abstract fun retainAll(elements: Collection<PropertyEdgeType>): Boolean

spliterator

open override fun spliterator(): Spliterator<PropertyEdgeType>

stream

open fun stream(): Stream<PropertyEdgeType>

toArray

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

toIdentitySet

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

toNodeCollection

abstract fun toNodeCollection(predicate: (PropertyEdgeType) -> Boolean? = null): Collection<NodeType>

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

unwrap

abstract fun unwrap(): UnwrappedEdgeCollection<NodeType, PropertyEdgeType>

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.