io.shiftleft.codepropertygraph.generated.traversals.TraversalMetadataBase.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of codepropertygraph-domain-classes_3 Show documentation
Show all versions of codepropertygraph-domain-classes_3 Show documentation
codepropertygraph-domain-classes
package io.shiftleft.codepropertygraph.generated.traversals
import io.shiftleft.codepropertygraph.generated.nodes
import io.shiftleft.codepropertygraph.generated.accessors.languagebootstrap.*
final class TraversalMetadataBase[NodeType <: nodes.MetaDataBase](val traversal: Iterator[NodeType]) extends AnyVal {
/** Traverse to hash property */
def hash: Iterator[String] =
traversal.flatMap(_.hash)
/** Traverse to nodes where the hash matches the regular expression `value`
*/
def hash(pattern: String): Iterator[NodeType] = {
if (!flatgraph.misc.Regex.isRegex(pattern)) {
hashExact(pattern)
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filter { item =>
val tmp = item.hash; tmp.isDefined && matcher.reset(tmp.get).matches
}
}
}
/** Traverse to nodes where the hash matches at least one of the regular expressions in `values`
*/
def hash(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item =>
val tmp = item.hash; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches }
}
}
/** Traverse to nodes where hash matches `value` exactly.
*/
def hashExact(value: String): Iterator[NodeType] = traversal match {
case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
val someNode = init.next
flatgraph.Accessors
.getWithInverseIndex(someNode.graph, someNode.nodeKind, 23, value)
.asInstanceOf[Iterator[NodeType]]
case _ =>
traversal.filter { node =>
val tmp = node.hash; tmp.isDefined && tmp.get == value
}
}
/** Traverse to nodes where hash matches one of the elements in `values` exactly.
*/
def hashExact(values: String*): Iterator[NodeType] =
if (values.length == 1) hashExact(values.head)
else {
val valueSet = values.toSet
traversal.filter { item =>
val tmp = item.hash; tmp.isDefined && valueSet.contains(tmp.get)
}
}
/** Traverse to nodes where hash does not match the regular expression `value`.
*/
def hashNot(pattern: String): Iterator[NodeType] = {
if (!flatgraph.misc.Regex.isRegex(pattern)) {
traversal.filter { node => node.hash.isEmpty || node.hash.get != pattern }
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filterNot { item =>
val tmp = item.hash; tmp.isDefined && matcher.reset(tmp.get).matches
}
}
}
/** Traverse to nodes where hash does not match any of the regular expressions in `values`.
*/
def hashNot(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filterNot { item =>
val tmp = item.hash; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches }
}
}
/** Traverse to language property */
def language: Iterator[String] =
traversal.map(_.language)
/** Traverse to nodes where the language matches the regular expression `value`
*/
def language(pattern: String): Iterator[NodeType] =
if (!flatgraph.misc.Regex.isRegex(pattern)) {
languageExact(pattern)
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filter { item => matcher.reset(item.language).matches }
}
/** Traverse to nodes where the language matches at least one of the regular expressions in `values`
*/
def language(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.exists { _.reset(item.language).matches } }
}
/** Traverse to nodes where language matches `value` exactly.
*/
def languageExact(value: String): Iterator[NodeType] = traversal match {
case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
val someNode = init.next
flatgraph.Accessors
.getWithInverseIndex(someNode.graph, someNode.nodeKind, 33, value)
.asInstanceOf[Iterator[NodeType]]
case _ => traversal.filter { _.language == value }
}
/** Traverse to nodes where language matches one of the elements in `values` exactly.
*/
def languageExact(values: String*): Iterator[NodeType] =
if (values.length == 1) languageExact(values.head)
else {
val valueSet = values.toSet
traversal.filter { item => valueSet.contains(item.language) }
}
/** Traverse to nodes where language does not match the regular expression `value`.
*/
def languageNot(pattern: String): Iterator[NodeType] = {
if (!flatgraph.misc.Regex.isRegex(pattern)) {
traversal.filter { node => node.language != pattern }
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filterNot { item => matcher.reset(item.language).matches }
}
}
/** Traverse to nodes where language does not match any of the regular expressions in `values`.
*/
def languageNot(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.find { _.reset(item.language).matches }.isEmpty }
}
/** Traverse to overlays property */
def overlays: Iterator[String] =
traversal.flatMap(_.overlays)
/** Traverse to root property */
def root: Iterator[String] =
traversal.map(_.root)
/** Traverse to nodes where the root matches the regular expression `value`
*/
def root(pattern: String): Iterator[NodeType] =
if (!flatgraph.misc.Regex.isRegex(pattern)) {
rootExact(pattern)
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filter { item => matcher.reset(item.root).matches }
}
/** Traverse to nodes where the root matches at least one of the regular expressions in `values`
*/
def root(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.exists { _.reset(item.root).matches } }
}
/** Traverse to nodes where root matches `value` exactly.
*/
def rootExact(value: String): Iterator[NodeType] = traversal match {
case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
val someNode = init.next
flatgraph.Accessors
.getWithInverseIndex(someNode.graph, someNode.nodeKind, 48, value)
.asInstanceOf[Iterator[NodeType]]
case _ => traversal.filter { _.root == value }
}
/** Traverse to nodes where root matches one of the elements in `values` exactly.
*/
def rootExact(values: String*): Iterator[NodeType] =
if (values.length == 1) rootExact(values.head)
else {
val valueSet = values.toSet
traversal.filter { item => valueSet.contains(item.root) }
}
/** Traverse to nodes where root does not match the regular expression `value`.
*/
def rootNot(pattern: String): Iterator[NodeType] = {
if (!flatgraph.misc.Regex.isRegex(pattern)) {
traversal.filter { node => node.root != pattern }
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filterNot { item => matcher.reset(item.root).matches }
}
}
/** Traverse to nodes where root does not match any of the regular expressions in `values`.
*/
def rootNot(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.find { _.reset(item.root).matches }.isEmpty }
}
/** Traverse to version property */
def version: Iterator[String] =
traversal.map(_.version)
/** Traverse to nodes where the version matches the regular expression `value`
*/
def version(pattern: String): Iterator[NodeType] =
if (!flatgraph.misc.Regex.isRegex(pattern)) {
versionExact(pattern)
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filter { item => matcher.reset(item.version).matches }
}
/** Traverse to nodes where the version matches at least one of the regular expressions in `values`
*/
def version(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.exists { _.reset(item.version).matches } }
}
/** Traverse to nodes where version matches `value` exactly.
*/
def versionExact(value: String): Iterator[NodeType] = traversal match {
case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
val someNode = init.next
flatgraph.Accessors
.getWithInverseIndex(someNode.graph, someNode.nodeKind, 54, value)
.asInstanceOf[Iterator[NodeType]]
case _ => traversal.filter { _.version == value }
}
/** Traverse to nodes where version matches one of the elements in `values` exactly.
*/
def versionExact(values: String*): Iterator[NodeType] =
if (values.length == 1) versionExact(values.head)
else {
val valueSet = values.toSet
traversal.filter { item => valueSet.contains(item.version) }
}
/** Traverse to nodes where version does not match the regular expression `value`.
*/
def versionNot(pattern: String): Iterator[NodeType] = {
if (!flatgraph.misc.Regex.isRegex(pattern)) {
traversal.filter { node => node.version != pattern }
} else {
val matcher = flatgraph.misc.Regex.multilineMatcher(pattern)
traversal.filterNot { item => matcher.reset(item.version).matches }
}
}
/** Traverse to nodes where version does not match any of the regular expressions in `values`.
*/
def versionNot(patterns: String*): Iterator[NodeType] = {
val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher)
traversal.filter { item => matchers.find { _.reset(item.version).matches }.isEmpty }
}
}