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

EdgeSingletonList

class EdgeSingletonList<NodeType : Node, NullableNodeType : NodeType?, EdgeType : Edge<NodeType>>(var thisRef: Node, var init: (Node, NodeType) -> EdgeType, var onChanged: (old: EdgeType?, new: EdgeType?) -> Unit? = null, var outgoing: Boolean, of: NullableNodeType) : EdgeCollection<NodeType, EdgeType>

This is a MAJOR workaround since Neo4J OGM does not allow to use our (generic) Edge class for our AST edges. See https://github.com/neo4j/neo4j-ogm/issues/1132.

Therefore, we need to wrap the edge in a list with a single element.

Constructors

EdgeSingletonList

constructor(thisRef: Node, init: (Node, NodeType) -> EdgeType, onChanged: (old: EdgeType?, new: EdgeType?) -> Unit? = null, outgoing: Boolean, of: NullableNodeType)

Types

Iterator

inner class Iterator(val element: EdgeType?) : MutableIterator<EdgeType>

UnwrapDelegate

inner class UnwrapDelegate<ThisType : Node>

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: EdgeType?

init

open override var init: (Node, NodeType) -> EdgeType

onAdd

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

onChanged

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

onRemove

open override var onRemove: (EdgeType) -> 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: NodeType, init: (Node, NodeType) -> EdgeType = this.init, builder: EdgeType.() -> 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: EdgeType): Boolean

addAll

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

open override fun addAll(elements: Collection<EdgeType>): 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: NodeType): Boolean

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

containsAll

open override fun containsAll(elements: Collection<EdgeType>): 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, NodeType, NullableNodeType, EdgeType>

forEach

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

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: EdgeType)

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: EdgeType)

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<EdgeType>

parallelStream

open fun parallelStream(): Stream<EdgeType>

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.

open override fun remove(element: EdgeType): Boolean

removeAll

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

removeIf

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

resetTo

open fun resetTo(nodes: Collection<NodeType>)

Clears the collection and adds the nodes.

fun resetTo(node: NodeType)

retainAll

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

spliterator

open override fun spliterator(): Spliterator<EdgeType>

stream

open fun stream(): Stream<EdgeType>

toArray

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

toIdentitySet

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

toNodeCollection

open override fun toNodeCollection(predicate: (EdgeType) -> Boolean?): Collection<NodeType>

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

unwrap

open override fun unwrap(): UnwrappedEdgeCollection<NodeType, EdgeType>

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.