io.shiftleft.codepropertygraph.generated.traversal.MethodParameterIn.scala Maven / Gradle / Ivy
package io.shiftleft.codepropertygraph.generated.traversal
import overflowdb.traversal._
import io.shiftleft.codepropertygraph.generated.nodes._
/** Traversal steps for MethodParameterIn */
class MethodParameterInTraversalExtGen[NodeType <: MethodParameterIn](val traversal: Iterator[NodeType])
extends AnyVal {
/** Traverse to method associated with this formal parameter Traverse to METHOD via AST IN edge.
*/
/** Traverse to method associated with this formal parameter */
@overflowdb.traversal.help.Doc(info = """Traverse to method associated with this formal parameter""")
def method: Iterator[Method] =
traversal.map(_.method)
/** Places (identifier) where this parameter is being referenced Traverse to IDENTIFIER via REF IN edge.
*/
/** Places (identifier) where this parameter is being referenced */
@overflowdb.traversal.help.Doc(info = """Places (identifier) where this parameter is being referenced""")
def referencingIdentifiers: Iterator[Identifier] =
traversal.flatMap(_.referencingIdentifiers)
/** Traverse to corresponding formal output parameter Traverse to METHOD_PARAMETER_OUT via PARAMETER_LINK OUT edge.
*/
/** Traverse to corresponding formal output parameter */
@overflowdb.traversal.help.Doc(info = """Traverse to corresponding formal output parameter""")
def asOutput: Iterator[MethodParameterOut] =
traversal.flatMap(_.asOutput)
/** Traverse to parameter type Traverse to TYPE via EVAL_TYPE OUT edge.
*/
/** Traverse to parameter type */
@overflowdb.traversal.help.Doc(info = """Traverse to parameter type""")
def typ: Iterator[Type] =
traversal.map(_.typ)
/** Traverse to closureBindingId property */
def closureBindingId: Iterator[String] =
traversal.flatMap(_.closureBindingId)
/** Traverse to nodes where the closureBindingId matches the regular expression `value`
*/
def closureBindingId(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.closureBindingId.isDefined && node.closureBindingId.get == pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter
.regexp(traversal.filter(_.closureBindingId.isDefined))(_.closureBindingId.get, pattern)
}
}
/** Traverse to nodes where the closureBindingId matches at least one of the regular expressions in `values`
*/
def closureBindingId(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter
.regexpMultiple(traversal.filter(_.closureBindingId.isDefined))(_.closureBindingId.get, patterns)
}
/** Traverse to nodes where closureBindingId matches `value` exactly.
*/
def closureBindingIdExact(value: String): Iterator[NodeType] =
traversal.filter { node => node.closureBindingId.contains(value) }
/** Traverse to nodes where closureBindingId matches one of the elements in `values` exactly.
*/
def closureBindingIdExact(values: String*): Iterator[NodeType] = {
if (values.size == 1)
closureBindingIdExact(values.head)
else
overflowdb.traversal.filter.StringPropertyFilter
.exactMultiple[NodeType, String](traversal, _.closureBindingId, values, "CLOSURE_BINDING_ID")
}
/** Traverse to nodes where closureBindingId does not match the regular expression `value`.
*/
def closureBindingIdNot(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.closureBindingId.isEmpty || node.closureBindingId.get != pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter
.regexpNot(traversal.filter(_.closureBindingId.isDefined))(_.closureBindingId.get, pattern)
}
}
/** Traverse to nodes where closureBindingId does not match any of the regular expressions in `values`.
*/
def closureBindingIdNot(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter
.regexpNotMultiple(traversal.filter(_.closureBindingId.isDefined))(_.closureBindingId.get, patterns)
}
/** Traverse to code property */
def code: Iterator[String] =
traversal.map(_.code)
/** Traverse to nodes where the code matches the regular expression `value`
*/
def code(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
codeExact(pattern)
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexp(traversal)(_.code, pattern)
}
}
/** Traverse to nodes where the code matches at least one of the regular expressions in `values`
*/
def code(patterns: String*): Iterator[NodeType] =
overflowdb.traversal.filter.StringPropertyFilter.regexpMultiple(traversal)(_.code, patterns)
/** Traverse to nodes where code matches `value` exactly.
*/
def codeExact(value: String): Iterator[NodeType] = {
val fastResult = traversal match {
case init: overflowdb.traversal.InitialTraversal[NodeType] => init.getByIndex("CODE", value).getOrElse(null)
case _ => null
}
if (fastResult != null) fastResult
else traversal.filter { node => node.code == value }
}
/** Traverse to nodes where code matches one of the elements in `values` exactly.
*/
def codeExact(values: String*): Iterator[NodeType] = {
if (values.size == 1)
codeExact(values.head)
else
overflowdb.traversal.filter.StringPropertyFilter
.exactMultiple[NodeType, String](traversal, node => Some(node.code), values, "CODE")
}
/** Traverse to nodes where code does not match the regular expression `value`.
*/
def codeNot(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.code != pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexpNot(traversal)(_.code, pattern)
}
}
/** Traverse to nodes where code does not match any of the regular expressions in `values`.
*/
def codeNot(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter.regexpNotMultiple(traversal)(_.code, patterns)
}
/** Traverse to columnNumber property */
def columnNumber: Iterator[scala.Int] =
traversal.flatMap(_.columnNumber)
/** Traverse to nodes where the columnNumber equals the given `value`
*/
def columnNumber(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.columnNumber.isDefined && node.columnNumber.get == value }
/** Traverse to nodes where the columnNumber equals at least one of the given `values`
*/
def columnNumber(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => node.columnNumber.isDefined && vset.contains(node.columnNumber.get) }
}
/** Traverse to nodes where the columnNumber is greater than the given `value`
*/
def columnNumberGt(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.columnNumber.isDefined && node.columnNumber.get > value }
/** Traverse to nodes where the columnNumber is greater than or equal the given `value`
*/
def columnNumberGte(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.columnNumber.isDefined && node.columnNumber.get >= value }
/** Traverse to nodes where the columnNumber is less than the given `value`
*/
def columnNumberLt(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.columnNumber.isDefined && node.columnNumber.get < value }
/** Traverse to nodes where the columnNumber is less than or equal the given `value`
*/
def columnNumberLte(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.columnNumber.isDefined && node.columnNumber.get <= value }
/** Traverse to nodes where columnNumber is not equal to the given `value`.
*/
def columnNumberNot(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => !node.columnNumber.isDefined || node.columnNumber.get != value }
/** Traverse to nodes where columnNumber is not equal to any of the given `values`.
*/
def columnNumberNot(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => !node.columnNumber.isDefined || !vset.contains(node.columnNumber.get) }
}
/** Traverse to dynamicTypeHintFullName property */
def dynamicTypeHintFullName: Iterator[String] =
traversal.flatMap(_.dynamicTypeHintFullName)
/** Traverse to evaluationStrategy property */
def evaluationStrategy: Iterator[String] =
traversal.map(_.evaluationStrategy)
/** Traverse to nodes where the evaluationStrategy matches the regular expression `value`
*/
def evaluationStrategy(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
evaluationStrategyExact(pattern)
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexp(traversal)(_.evaluationStrategy, pattern)
}
}
/** Traverse to nodes where the evaluationStrategy matches at least one of the regular expressions in `values`
*/
def evaluationStrategy(patterns: String*): Iterator[NodeType] =
overflowdb.traversal.filter.StringPropertyFilter.regexpMultiple(traversal)(_.evaluationStrategy, patterns)
/** Traverse to nodes where evaluationStrategy matches `value` exactly.
*/
def evaluationStrategyExact(value: String): Iterator[NodeType] = {
val fastResult = traversal match {
case init: overflowdb.traversal.InitialTraversal[NodeType] =>
init.getByIndex("EVALUATION_STRATEGY", value).getOrElse(null)
case _ => null
}
if (fastResult != null) fastResult
else traversal.filter { node => node.evaluationStrategy == value }
}
/** Traverse to nodes where evaluationStrategy matches one of the elements in `values` exactly.
*/
def evaluationStrategyExact(values: String*): Iterator[NodeType] = {
if (values.size == 1)
evaluationStrategyExact(values.head)
else
overflowdb.traversal.filter.StringPropertyFilter.exactMultiple[NodeType, String](
traversal,
node => Some(node.evaluationStrategy),
values,
"EVALUATION_STRATEGY"
)
}
/** Traverse to nodes where evaluationStrategy does not match the regular expression `value`.
*/
def evaluationStrategyNot(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.evaluationStrategy != pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexpNot(traversal)(_.evaluationStrategy, pattern)
}
}
/** Traverse to nodes where evaluationStrategy does not match any of the regular expressions in `values`.
*/
def evaluationStrategyNot(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter.regexpNotMultiple(traversal)(_.evaluationStrategy, patterns)
}
/** Traverse to index property */
def index: Iterator[scala.Int] =
traversal.map(_.index)
/** Traverse to nodes where the index equals the given `value`
*/
def index(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index == value }
/** Traverse to nodes where the index equals at least one of the given `values`
*/
def index(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => vset.contains(node.index) }
}
/** Traverse to nodes where the index is greater than the given `value`
*/
def indexGt(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index > value }
/** Traverse to nodes where the index is greater than or equal the given `value`
*/
def indexGte(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index >= value }
/** Traverse to nodes where the index is less than the given `value`
*/
def indexLt(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index < value }
/** Traverse to nodes where the index is less than or equal the given `value`
*/
def indexLte(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index <= value }
/** Traverse to nodes where index is not equal to the given `value`.
*/
def indexNot(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.index != value }
/** Traverse to nodes where index is not equal to any of the given `values`.
*/
def indexNot(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => !vset.contains(node.index) }
}
/** Traverse to isVariadic property */
def isVariadic: Iterator[Boolean] =
traversal.map(_.isVariadic)
/** Traverse to nodes where the isVariadic equals the given `value`
*/
def isVariadic(value: Boolean): Iterator[NodeType] =
traversal.filter { _.isVariadic == value }
/** Traverse to nodes where isVariadic is not equal to the given `value`.
*/
def isVariadicNot(value: Boolean): Iterator[NodeType] =
traversal.filter { _.isVariadic != value }
/** Traverse to lineNumber property */
def lineNumber: Iterator[scala.Int] =
traversal.flatMap(_.lineNumber)
/** Traverse to nodes where the lineNumber equals the given `value`
*/
def lineNumber(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.lineNumber.isDefined && node.lineNumber.get == value }
/** Traverse to nodes where the lineNumber equals at least one of the given `values`
*/
def lineNumber(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => node.lineNumber.isDefined && vset.contains(node.lineNumber.get) }
}
/** Traverse to nodes where the lineNumber is greater than the given `value`
*/
def lineNumberGt(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.lineNumber.isDefined && node.lineNumber.get > value }
/** Traverse to nodes where the lineNumber is greater than or equal the given `value`
*/
def lineNumberGte(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.lineNumber.isDefined && node.lineNumber.get >= value }
/** Traverse to nodes where the lineNumber is less than the given `value`
*/
def lineNumberLt(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.lineNumber.isDefined && node.lineNumber.get < value }
/** Traverse to nodes where the lineNumber is less than or equal the given `value`
*/
def lineNumberLte(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => node.lineNumber.isDefined && node.lineNumber.get <= value }
/** Traverse to nodes where lineNumber is not equal to the given `value`.
*/
def lineNumberNot(value: scala.Int): Iterator[NodeType] =
traversal.filter { node => !node.lineNumber.isDefined || node.lineNumber.get != value }
/** Traverse to nodes where lineNumber is not equal to any of the given `values`.
*/
def lineNumberNot(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => !node.lineNumber.isDefined || !vset.contains(node.lineNumber.get) }
}
/** Traverse to name property */
def name: Iterator[String] =
traversal.map(_.name)
/** Traverse to nodes where the name matches the regular expression `value`
*/
def name(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
nameExact(pattern)
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexp(traversal)(_.name, pattern)
}
}
/** Traverse to nodes where the name matches at least one of the regular expressions in `values`
*/
def name(patterns: String*): Iterator[NodeType] =
overflowdb.traversal.filter.StringPropertyFilter.regexpMultiple(traversal)(_.name, patterns)
/** Traverse to nodes where name matches `value` exactly.
*/
def nameExact(value: String): Iterator[NodeType] = {
val fastResult = traversal match {
case init: overflowdb.traversal.InitialTraversal[NodeType] => init.getByIndex("NAME", value).getOrElse(null)
case _ => null
}
if (fastResult != null) fastResult
else traversal.filter { node => node.name == value }
}
/** Traverse to nodes where name matches one of the elements in `values` exactly.
*/
def nameExact(values: String*): Iterator[NodeType] = {
if (values.size == 1)
nameExact(values.head)
else
overflowdb.traversal.filter.StringPropertyFilter
.exactMultiple[NodeType, String](traversal, node => Some(node.name), values, "NAME")
}
/** Traverse to nodes where name does not match the regular expression `value`.
*/
def nameNot(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.name != pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexpNot(traversal)(_.name, pattern)
}
}
/** Traverse to nodes where name does not match any of the regular expressions in `values`.
*/
def nameNot(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter.regexpNotMultiple(traversal)(_.name, patterns)
}
/** Traverse to order property */
def order: Iterator[scala.Int] =
traversal.map(_.order)
/** Traverse to nodes where the order equals the given `value`
*/
def order(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order == value }
/** Traverse to nodes where the order equals at least one of the given `values`
*/
def order(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => vset.contains(node.order) }
}
/** Traverse to nodes where the order is greater than the given `value`
*/
def orderGt(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order > value }
/** Traverse to nodes where the order is greater than or equal the given `value`
*/
def orderGte(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order >= value }
/** Traverse to nodes where the order is less than the given `value`
*/
def orderLt(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order < value }
/** Traverse to nodes where the order is less than or equal the given `value`
*/
def orderLte(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order <= value }
/** Traverse to nodes where order is not equal to the given `value`.
*/
def orderNot(value: scala.Int): Iterator[NodeType] =
traversal.filter { _.order != value }
/** Traverse to nodes where order is not equal to any of the given `values`.
*/
def orderNot(values: scala.Int*): Iterator[NodeType] = {
val vset = values.toSet
traversal.filter { node => !vset.contains(node.order) }
}
/** Traverse to possibleTypes property */
def possibleTypes: Iterator[String] =
traversal.flatMap(_.possibleTypes)
/** Traverse to typeFullName property */
def typeFullName: Iterator[String] =
traversal.map(_.typeFullName)
/** Traverse to nodes where the typeFullName matches the regular expression `value`
*/
def typeFullName(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
typeFullNameExact(pattern)
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexp(traversal)(_.typeFullName, pattern)
}
}
/** Traverse to nodes where the typeFullName matches at least one of the regular expressions in `values`
*/
def typeFullName(patterns: String*): Iterator[NodeType] =
overflowdb.traversal.filter.StringPropertyFilter.regexpMultiple(traversal)(_.typeFullName, patterns)
/** Traverse to nodes where typeFullName matches `value` exactly.
*/
def typeFullNameExact(value: String): Iterator[NodeType] = {
val fastResult = traversal match {
case init: overflowdb.traversal.InitialTraversal[NodeType] =>
init.getByIndex("TYPE_FULL_NAME", value).getOrElse(null)
case _ => null
}
if (fastResult != null) fastResult
else traversal.filter { node => node.typeFullName == value }
}
/** Traverse to nodes where typeFullName matches one of the elements in `values` exactly.
*/
def typeFullNameExact(values: String*): Iterator[NodeType] = {
if (values.size == 1)
typeFullNameExact(values.head)
else
overflowdb.traversal.filter.StringPropertyFilter
.exactMultiple[NodeType, String](traversal, node => Some(node.typeFullName), values, "TYPE_FULL_NAME")
}
/** Traverse to nodes where typeFullName does not match the regular expression `value`.
*/
def typeFullNameNot(pattern: String): Iterator[NodeType] = {
if (!Misc.isRegex(pattern)) {
traversal.filter { node => node.typeFullName != pattern }
} else {
overflowdb.traversal.filter.StringPropertyFilter.regexpNot(traversal)(_.typeFullName, pattern)
}
}
/** Traverse to nodes where typeFullName does not match any of the regular expressions in `values`.
*/
def typeFullNameNot(patterns: String*): Iterator[NodeType] = {
overflowdb.traversal.filter.StringPropertyFilter.regexpNotMultiple(traversal)(_.typeFullName, patterns)
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy