use the index for stuff like cpg.method.fullNameExact(a,b,c)

domain-classes-generator/src/main/scala/flatgraph/codegen/CodeSnippets.scala

@@ -126,10 +126,18 @@ object CodeSnippets {
          |/**
          |  * Traverse to nodes where $nameCamelCase matches one of the elements in `values` exactly.
          |  * */
-         |def ${nameCamelCase}Exact(values: $baseType*): Iterator[NodeType] =
-         |  if(values.length == 1) ${nameCamelCase}Exact(values.head) else {
-         |  val valueSet = values.toSet
-         |  traversal.filter{item => valueSet.contains(item.$nameCamelCase)}
+         |def ${nameCamelCase}Exact(values: $baseType*): Iterator[NodeType] = {
+         |  if(values.length == 1) return ${nameCamelCase}Exact(values.head)
+         |  traversal match {
+         |    case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+         |      val someNode = init.next
+         |      values.iterator.flatMap { value =>
+         |        flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind,  $propertyId, value).asInstanceOf[Iterator[NodeType]]
+         |      }
+         |    case _ =>
+         |      val valueSet = values.toSet
+         |      traversal.filter{item => valueSet.contains(item.$nameCamelCase)}
+         |    }
          |  }
          |
          |/**

test-schemas-domain-classes/src/main/scala/testdomains/codepropertygraphminified/traversals/TraversalCallBase.scala

@@ -37,12 +37,19 @@ final class TraversalCallBase[NodeType <: nodes.CallBase](val traversal: Iterato
 
   /** Traverse to nodes where dispatchType matches one of the elements in `values` exactly.
     */
-  def dispatchTypeExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) dispatchTypeExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.dispatchType) }
+  def dispatchTypeExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return dispatchTypeExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.dispatchType) }
     }
+  }
 
   /** Traverse to nodes where dispatchType does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/codepropertygraphminified/traversals/TraversalCallreprBase.scala

@@ -37,12 +37,19 @@ final class TraversalCallreprBase[NodeType <: nodes.CallReprBase](val traversal:
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 1, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/codepropertygraphminified/traversals/TraversalDeclarationBase.scala

@@ -37,12 +37,19 @@ final class TraversalDeclarationBase[NodeType <: nodes.DeclarationBase](val trav
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 1, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/codepropertygraphminified/traversals/TraversalPropertyDispatchType.scala

@@ -39,12 +39,19 @@ final class TraversalPropertyDispatchType[NodeType <: nodes.StoredNode & nodes.S
 
   /** Traverse to nodes where dispatchType matches one of the elements in `values` exactly.
     */
-  def dispatchTypeExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) dispatchTypeExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.dispatchType) }
+  def dispatchTypeExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return dispatchTypeExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.dispatchType) }
     }
+  }
 
   /** Traverse to nodes where dispatchType does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/codepropertygraphminified/traversals/TraversalPropertyName.scala

@@ -38,12 +38,19 @@ final class TraversalPropertyName[NodeType <: nodes.StoredNode & nodes.StaticTyp
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 1, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/TraversalNodeaBase.scala

@@ -157,12 +157,19 @@ final class TraversalNodeaBase[NodeType <: nodes.NodeABase](val traversal: Itera
 
   /** Traverse to nodes where stringMandatory matches one of the elements in `values` exactly.
     */
-  def stringMandatoryExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) stringMandatoryExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.stringMandatory) }
+  def stringMandatoryExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return stringMandatoryExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 4, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.stringMandatory) }
     }
+  }
 
   /** Traverse to nodes where stringMandatory does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/TraversalPropertyStringMandatory.scala

@@ -39,12 +39,19 @@ final class TraversalPropertyStringMandatory[NodeType <: nodes.StoredNode & node
 
   /** Traverse to nodes where stringMandatory matches one of the elements in `values` exactly.
     */
-  def stringMandatoryExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) stringMandatoryExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.stringMandatory) }
+  def stringMandatoryExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return stringMandatoryExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 4, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.stringMandatory) }
     }
+  }
 
   /** Traverse to nodes where stringMandatory does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/TraversalArtistBase.scala

@@ -37,12 +37,19 @@ final class TraversalArtistBase[NodeType <: nodes.ArtistBase](val traversal: Ite
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/TraversalPropertyName.scala

@@ -38,12 +38,19 @@ final class TraversalPropertyName[NodeType <: nodes.StoredNode & nodes.StaticTyp
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/TraversalSongBase.scala

@@ -37,12 +37,19 @@ final class TraversalSongBase[NodeType <: nodes.SongBase](val traversal: Iterato
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/TraversalBasenodeBase.scala

@@ -37,12 +37,19 @@ final class TraversalBasenodeBase[NodeType <: nodes.BaseNodeBase](val traversal:
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/TraversalPropertyName.scala

@@ -38,12 +38,19 @@ final class TraversalPropertyName[NodeType <: nodes.StoredNode & nodes.StaticTyp
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { v =>
+          flatgraph.Accessors.getWithInverseIndex(someNode.graph, someNode.nodeKind, 0, v).asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */