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

UnwrappedEdgeList

class UnwrappedEdgeList<NodeType : Node, EdgeType : Edge<NodeType>>(var list: EdgeList<NodeType, EdgeType>) : UnwrappedEdgeCollection<NodeType, EdgeType> , MutableList<NodeType>

An intelligent MutableList wrapper around an EdgeList which supports iterating, adding and removing Node elements.

Constructors

UnwrappedEdgeList

constructor(list: EdgeList<NodeType, EdgeType>)

Types

inner class Delegate<ThisType : Node>

This class can be used to implement delegated properties in Node classes. The most common use case is to have a property that is a list of Edge objects (for persistence) and a second (delegated) property that allows easy access just to the connected nodes of the individual edges for in-memory access. It should not be used directly, but rather by using unwrapping.

inner class ListIterator(var edgeIterator: MutableListIterator<EdgeType>) : MutableListIterator<NodeType>

Properties

var collection: EdgeCollection<NodeType, EdgeType>

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.

var list: EdgeList<NodeType, EdgeType>

open override val size: Int

Functions

open override fun add(element: NodeType): Boolean

fun add(element: NodeType, builder: EdgeType.() -> Unit? = null): Boolean

open override fun add(index: Int, element: NodeType)

fun <EdgeType : Edge<Node>> MutableList<Node>.add(target: Node, builder: EdgeType.() -> Unit): Boolean

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

open override fun addAll(index: Int, elements: Collection<NodeType>): Boolean

fun TypeOperations.apply(root: Type): Type

Wraps the given Type into a chain of PointerTypes and ReferenceTypes, given the operations in TypeOperations.

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.

open override fun clear()

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

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

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

open operator override fun get(index: Int): NodeType

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.

open override fun indexOf(element: NodeType): Int

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.

inline operator fun <T> List<Node>.invoke(i: Int = 0): T?

Returns the i-th item in this list (or null) and casts it to T.

open override fun isEmpty(): Boolean

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

open override fun lastIndexOf(element: NodeType): Int

open override fun listIterator(): MutableListIterator<NodeType>

open override fun listIterator(index: Int): MutableListIterator<NodeType>

open fun parallelStream(): Stream<NodeType>

provideDelegate

operator fun <ThisType : Node> provideDelegate(thisRef: ThisType, prop: KProperty<*>): UnwrappedEdgeList.Delegate<ThisType, NodeType, EdgeType>

open override fun remove(element: NodeType): Boolean

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

open override fun removeAt(index: Int): NodeType

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

open fun replaceAll(p0: UnaryOperator<NodeType>)

fun resetTo(c: Collection<NodeType>)

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

open operator override fun set(index: Int, element: NodeType): NodeType

open fun sort(p0: Comparator<in NodeType>)

open override fun spliterator(): Spliterator<NodeType>

open fun stream(): Stream<NodeType>

open override fun subList(fromIndex: Int, toIndex: Int): MutableList<NodeType>

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

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