From 5e4528ca4606d40a30fcc9dd21a632d630b2da53 Mon Sep 17 00:00:00 2001 From: Michael Pollmeier Date: Thu, 4 Jul 2024 11:20:54 +0200 Subject: [PATCH] codegen refactoring: split up massive Traversals.scala, move to correct directory (#219) --- .../codegen/DomainClassesGenerator.scala | 72 +- .../scala/testdomains/generic/Accessors.scala | 3 +- .../testdomains/generic/Traversals.scala | 647 ------------------ .../traversals/Traversal_NodeABase.scala | 256 +++++++ .../traversals/Traversal_NodeBBase.scala | 79 +++ .../Traversal_Property_int_list.scala | 14 + .../Traversal_Property_int_mandatory.scala | 58 ++ .../Traversal_Property_int_optional.scala | 74 ++ .../Traversal_Property_string_list.scala | 14 + .../Traversal_Property_string_mandatory.scala | 67 ++ .../Traversal_Property_string_optional.scala | 81 +++ .../generic/traversals/package.scala | 37 + .../testdomains/gratefuldead/Accessors.scala | 3 +- .../testdomains/gratefuldead/Traversals.scala | 496 -------------- .../traversals/Traversal_ArtistBase.scala | 65 ++ .../traversals/Traversal_Property_name.scala | 66 ++ .../Traversal_Property_performances.scala | 74 ++ .../Traversal_Property_songType.scala | 81 +++ .../traversals/Traversal_SongBase.scala | 200 ++++++ .../gratefuldead/traversals/package.scala | 28 + .../testdomains/hierarchical/Accessors.scala | 4 +- .../testdomains/hierarchical/Traversals.scala | 158 ----- .../traversals/Traversal_BaseNodeBase.scala | 65 ++ .../traversals/Traversal_NodeXBase.scala | 6 + .../traversals/Traversal_NodeYBase.scala | 6 + .../traversals/Traversal_Property_name.scala | 66 ++ .../hierarchical/traversals/package.scala | 28 + 27 files changed, 1413 insertions(+), 1335 deletions(-) delete mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/Traversals.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeABase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeBBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_list.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_mandatory.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_optional.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_list.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_mandatory.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_optional.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/package.scala delete mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Traversals.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_ArtistBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_name.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_performances.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_songType.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_SongBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/package.scala delete mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Traversals.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_BaseNodeBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeXBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeYBase.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_Property_name.scala create mode 100644 test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/package.scala diff --git a/domain-classes-generator/src/main/scala/flatgraph/codegen/DomainClassesGenerator.scala b/domain-classes-generator/src/main/scala/flatgraph/codegen/DomainClassesGenerator.scala index 2a56738f..bcece9eb 100644 --- a/domain-classes-generator/src/main/scala/flatgraph/codegen/DomainClassesGenerator.scala +++ b/domain-classes-generator/src/main/scala/flatgraph/codegen/DomainClassesGenerator.scala @@ -757,9 +757,9 @@ class DomainClassesGenerator(schema: Schema) { val accessorsForBaseNodes = mutable.ArrayBuffer.empty[String] val baseConvert = Seq.fill(prioStages.length + 1)(mutable.ArrayBuffer.empty[String]) - val accessorsForConcreteNodeTraversals = mutable.ArrayBuffer.empty[String] + val accessorsForConcreteNodeTraversals = mutable.ArrayBuffer.empty[ClassnameAndSource] val concreteStoredConvTrav = mutable.ArrayBuffer.empty[String] - val accessorsForBaseNodeTraversals = mutable.ArrayBuffer.empty[String] + val accessorsForBaseNodeTraversals = mutable.ArrayBuffer.empty[ClassnameAndSource] val baseConvertTrav = Seq.fill(prioStages.length + 1)(mutable.ArrayBuffer.empty[String]) for (p <- relevantProperties) { @@ -779,9 +779,14 @@ class DomainClassesGenerator(schema: Schema) { concreteStoredConv.addOne( s"""implicit def accessProperty${p.className}(node: nodes.StoredNode & nodes.StaticType[nodes.Has${p.className}EMT]): Access_Property_${p.name} = new Access_Property_${p.name}(node)""".stripMargin ) + + val concreteNodeTravClassname = s"Traversal_Property_${p.name}" accessorsForConcreteNodeTraversals.addOne( - s"""final class Traversal_Property_${p.name}[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.Has${p.className}EMT]](val traversal: Iterator[NodeType]) extends AnyVal {""".stripMargin + - generatePropertyTraversals(p, propertyKindByProperty(p)) + "}" + ClassnameAndSource( + concreteNodeTravClassname, + s"""final class $concreteNodeTravClassname[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.Has${p.className}EMT]](val traversal: Iterator[NodeType]) extends AnyVal {""".stripMargin + + generatePropertyTraversals(p, propertyKindByProperty(p)) + "}" + ) ) concreteStoredConvTrav.addOne( s"""implicit def accessProperty${p.className}Traversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.Has${p.className}EMT]](traversal: IterableOnce[NodeType]): Traversal_Property_${p.name}[NodeType] = new Traversal_Property_${p.name}(traversal.iterator)""".stripMargin @@ -821,10 +826,13 @@ class DomainClassesGenerator(schema: Schema) { elems.addOne(generatePropertyTraversals(p, propertyKindByProperty(p))) } accessorsForBaseNodeTraversals.addOne( - elems.mkString( - s"final class $extensionClass[NodeType <: nodes.${baseType.className}Base](val traversal: Iterator[NodeType]) extends AnyVal { ", - "\n", - "}" + ClassnameAndSource( + extensionClass, + elems.mkString( + s"final class $extensionClass[NodeType <: nodes.${baseType.className}Base](val traversal: Iterator[NodeType]) extends AnyVal { ", + "\n", + "}" + ) ) ) } @@ -843,11 +851,9 @@ class DomainClassesGenerator(schema: Schema) { (s"AbstractBaseConversions${idx - 2}", if (idx < baseConvert.length) Some(s"AbstractBaseConversions${idx - 1}") else None) } conversionsForProperties.addOne(s"""trait $tname ${tparent.map { p => s" extends $p" }.getOrElse("")} { - |import Accessors.* |${convBuffer(idx).mkString("\n")} |}""".stripMargin) conversionsForTraversals.addOne(s"""trait $tname ${tparent.map { p => s" extends $p" }.getOrElse("")} { - |import Accessors.* |${convBufferTrav(idx).mkString("\n")} |}""".stripMargin) } @@ -870,32 +876,42 @@ class DomainClassesGenerator(schema: Schema) { | /* accessors for base nodes end */ |} | + |import Accessors.* |${conversionsForProperties.mkString("\n\n")} |""".stripMargin os.write(outputDir0 / "Accessors.scala", accessors) - val traversals = - s"""package $basePackage.traversals - |import $basePackage.nodes - | - |/** not supposed to be used directly by users, hence the `bootstrap` in the name */ - |object languagebootstrap extends ConcreteStoredConversions - | - |object Accessors { - | import $basePackage.accessors.languagebootstrap.* + val traversalsOutputDir = outputDir0 / "traversals" + os.makeDir(traversalsOutputDir) + os.write( + traversalsOutputDir / "package.scala", + s"""package $basePackage | - | /* accessors for concrete stored nodes start */ - | ${accessorsForConcreteNodeTraversals.mkString("\n")} - | /* accessors for concrete stored nodes end */ + |import $basePackage.nodes | - | /* accessors for base nodes start */ - | ${accessorsForBaseNodeTraversals.mkString("\n")} - | /* accessors for base nodes end */ + |package object traversals { + | + | /** not supposed to be used directly by users, hence the `bootstrap` in the name */ + | object languagebootstrap extends ConcreteStoredConversions + | + | ${conversionsForTraversals.mkString("\n\n")} |} - |${conversionsForTraversals.mkString("\n\n")} |""".stripMargin - os.write(outputDir0 / "Traversals.scala", traversals) + ) + + (accessorsForConcreteNodeTraversals ++ accessorsForBaseNodeTraversals).foreach { case ClassnameAndSource(classname, source) => + os.write( + traversalsOutputDir / s"$classname.scala", + s"""package $basePackage.traversals + | + |import $basePackage.nodes + |import $basePackage.accessors.languagebootstrap.* + | + |$source + |""".stripMargin + ) + } writeNeighborAccessors(outputDir0, basePackage) // Accessors and traversals: end @@ -1466,6 +1482,8 @@ class DomainClassesGenerator(schema: Schema) { |val ${camelCaseCaps(property.name)} = $propertyKeyImpl""".stripMargin.trim } + private case class ClassnameAndSource(classname: String, source: String) + private case class PropertyContexts(properties: Array[Property[?]], containedNodesByName: Map[String, mutable.HashSet[NodeType]]) private case class KindContexts( diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/Accessors.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/Accessors.scala index 8108ae14..669db68a 100644 --- a/test-schemas-domain-classes/src/main/scala/testdomains/generic/Accessors.scala +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/Accessors.scala @@ -63,8 +63,8 @@ object Accessors { /* accessors for base nodes end */ } +import Accessors.* trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* implicit def accessPropertyIntList(node: nodes.StoredNode & nodes.StaticType[nodes.HasIntListEMT]): Access_Property_int_list = new Access_Property_int_list(node) implicit def accessPropertyIntMandatory( @@ -83,7 +83,6 @@ trait ConcreteStoredConversions extends ConcreteBaseConversions { } trait ConcreteBaseConversions { - import Accessors.* implicit def access_NodeABase(node: nodes.NodeABase): Access_NodeABase = new Access_NodeABase(node) implicit def access_NodeBBase(node: nodes.NodeBBase): Access_NodeBBase = new Access_NodeBBase(node) } diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/Traversals.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/Traversals.scala deleted file mode 100644 index 7ccc4060..00000000 --- a/test-schemas-domain-classes/src/main/scala/testdomains/generic/Traversals.scala +++ /dev/null @@ -1,647 +0,0 @@ -package testdomains.generic.traversals -import testdomains.generic.nodes - -/** not supposed to be used directly by users, hence the `bootstrap` in the name */ -object languagebootstrap extends ConcreteStoredConversions - -object Accessors { - import testdomains.generic.accessors.languagebootstrap.* - - /* accessors for concrete stored nodes start */ - final class Traversal_Property_int_list[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntListEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to intList property */ - def intList: Iterator[Int] = - traversal.flatMap(_.intList) - - } - final class Traversal_Property_int_mandatory[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntMandatoryEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to intMandatory property */ - def intMandatory: Iterator[Int] = - traversal.map(_.intMandatory) - - /** Traverse to nodes where the intMandatory equals the given `value` - */ - def intMandatory(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory == value } - - /** Traverse to nodes where the intMandatory equals at least one of the given `values` - */ - def intMandatory(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => vset.contains(node.intMandatory) } - } - - /** Traverse to nodes where the intMandatory is not equal to the given `value` - */ - def intMandatoryNot(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory != value } - - /** Traverse to nodes where the intMandatory is not equal to any of the given `values` - */ - def intMandatoryNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => !vset.contains(node.intMandatory) } - } - - /** Traverse to nodes where the intMandatory is greater than the given `value` - */ - def intMandatoryGt(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory > value } - - /** Traverse to nodes where the intMandatory is greater than or equal the given `value` - */ - def intMandatoryGte(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory >= value } - - /** Traverse to nodes where the intMandatory is less than the given `value` - */ - def intMandatoryLt(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory < value } - - /** Traverse to nodes where the intMandatory is less than or equal the given `value` - */ - def intMandatoryLte(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory <= value } - - } - final class Traversal_Property_int_optional[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntOptionalEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to intOptional property */ - def intOptional: Iterator[Int] = - traversal.flatMap(_.intOptional) - - /** Traverse to nodes where the intOptional equals the given `value` - */ - def intOptional(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get == value - } - - /** Traverse to nodes where the intOptional equals at least one of the given `values` - */ - def intOptional(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the intOptional is not equal to the given `value` - */ - def intOptionalNot(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isEmpty || tmp.get != value - } - - /** Traverse to nodes where the intOptional does not equal any one of the given `values` - */ - def intOptionalNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.intOptional; tmp.isEmpty || !vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the intOptional is greater than the given `value` - */ - def intOptionalGt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get > value - } - - /** Traverse to nodes where the intOptional is greater than or equal the given `value` - */ - def intOptionalGte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get >= value - } - - /** Traverse to nodes where the intOptional is less than the given `value` - */ - def intOptionalLt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get < value - } - - /** Traverse to nodes where the intOptional is less than or equal the given `value` - */ - def intOptionalLte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get <= value - } - - } - final class Traversal_Property_string_list[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringListEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to stringList property */ - def stringList: Iterator[String] = - traversal.flatMap(_.stringList) - - } - final class Traversal_Property_string_mandatory[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringMandatoryEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to stringMandatory property */ - def stringMandatory: Iterator[String] = - traversal.map(_.stringMandatory) - - /** Traverse to nodes where the stringMandatory matches the regular expression `value` - */ - def stringMandatory(pattern: String): Iterator[NodeType] = - if (!flatgraph.misc.Regex.isRegex(pattern)) { - stringMandatoryExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.stringMandatory).matches } - } - - /** Traverse to nodes where the stringMandatory matches at least one of the regular expressions in `values` - */ - def stringMandatory(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.stringMandatory).matches } } - } - - /** Traverse to nodes where stringMandatory matches `value` exactly. - */ - def stringMandatoryExact(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, 4, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.stringMandatory == value } - } - - /** 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) } - } - - /** Traverse to nodes where stringMandatory does not match the regular expression `value`. - */ - def stringMandatoryNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.stringMandatory != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.stringMandatory).matches } - } - } - - /** Traverse to nodes where stringMandatory does not match any of the regular expressions in `values`. - */ - def stringMandatoryNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.stringMandatory).matches }.isEmpty } - } - - } - final class Traversal_Property_string_optional[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringOptionalEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to stringOptional property */ - def stringOptional: Iterator[String] = - traversal.flatMap(_.stringOptional) - - /** Traverse to nodes where the stringOptional matches the regular expression `value` - */ - def stringOptional(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - stringOptionalExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` - */ - def stringOptional(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - /** Traverse to nodes where stringOptional matches `value` exactly. - */ - def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] - case _ => - traversal.filter { node => - val tmp = node.stringOptional; tmp.isDefined && tmp.get == value - } - } - - /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. - */ - def stringOptionalExact(values: String*): Iterator[NodeType] = - if (values.length == 1) stringOptionalExact(values.head) - else { - val valueSet = values.toSet - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) - } - } - - /** Traverse to nodes where stringOptional does not match the regular expression `value`. - */ - def stringOptionalNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. - */ - def stringOptionalNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - } - /* accessors for concrete stored nodes end */ - - /* accessors for base nodes start */ - final class Traversal_NodeABase[NodeType <: nodes.NodeABase](val traversal: Iterator[NodeType]) extends AnyVal { - - /** Traverse to intList property */ - def intList: Iterator[Int] = - traversal.flatMap(_.intList) - - /** Traverse to intMandatory property */ - def intMandatory: Iterator[Int] = - traversal.map(_.intMandatory) - - /** Traverse to nodes where the intMandatory equals the given `value` - */ - def intMandatory(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory == value } - - /** Traverse to nodes where the intMandatory equals at least one of the given `values` - */ - def intMandatory(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => vset.contains(node.intMandatory) } - } - - /** Traverse to nodes where the intMandatory is not equal to the given `value` - */ - def intMandatoryNot(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory != value } - - /** Traverse to nodes where the intMandatory is not equal to any of the given `values` - */ - def intMandatoryNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => !vset.contains(node.intMandatory) } - } - - /** Traverse to nodes where the intMandatory is greater than the given `value` - */ - def intMandatoryGt(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory > value } - - /** Traverse to nodes where the intMandatory is greater than or equal the given `value` - */ - def intMandatoryGte(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory >= value } - - /** Traverse to nodes where the intMandatory is less than the given `value` - */ - def intMandatoryLt(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory < value } - - /** Traverse to nodes where the intMandatory is less than or equal the given `value` - */ - def intMandatoryLte(value: Int): Iterator[NodeType] = - traversal.filter { _.intMandatory <= value } - - /** Traverse to intOptional property */ - def intOptional: Iterator[Int] = - traversal.flatMap(_.intOptional) - - /** Traverse to nodes where the intOptional equals the given `value` - */ - def intOptional(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get == value - } - - /** Traverse to nodes where the intOptional equals at least one of the given `values` - */ - def intOptional(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the intOptional is not equal to the given `value` - */ - def intOptionalNot(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isEmpty || tmp.get != value - } - - /** Traverse to nodes where the intOptional does not equal any one of the given `values` - */ - def intOptionalNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.intOptional; tmp.isEmpty || !vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the intOptional is greater than the given `value` - */ - def intOptionalGt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get > value - } - - /** Traverse to nodes where the intOptional is greater than or equal the given `value` - */ - def intOptionalGte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get >= value - } - - /** Traverse to nodes where the intOptional is less than the given `value` - */ - def intOptionalLt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get < value - } - - /** Traverse to nodes where the intOptional is less than or equal the given `value` - */ - def intOptionalLte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.intOptional; tmp.isDefined && tmp.get <= value - } - - /** Traverse to stringList property */ - def stringList: Iterator[String] = - traversal.flatMap(_.stringList) - - /** Traverse to stringMandatory property */ - def stringMandatory: Iterator[String] = - traversal.map(_.stringMandatory) - - /** Traverse to nodes where the stringMandatory matches the regular expression `value` - */ - def stringMandatory(pattern: String): Iterator[NodeType] = - if (!flatgraph.misc.Regex.isRegex(pattern)) { - stringMandatoryExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.stringMandatory).matches } - } - - /** Traverse to nodes where the stringMandatory matches at least one of the regular expressions in `values` - */ - def stringMandatory(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.stringMandatory).matches } } - } - - /** Traverse to nodes where stringMandatory matches `value` exactly. - */ - def stringMandatoryExact(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, 4, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.stringMandatory == value } - } - - /** 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) } - } - - /** Traverse to nodes where stringMandatory does not match the regular expression `value`. - */ - def stringMandatoryNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.stringMandatory != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.stringMandatory).matches } - } - } - - /** Traverse to nodes where stringMandatory does not match any of the regular expressions in `values`. - */ - def stringMandatoryNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.stringMandatory).matches }.isEmpty } - } - - /** Traverse to stringOptional property */ - def stringOptional: Iterator[String] = - traversal.flatMap(_.stringOptional) - - /** Traverse to nodes where the stringOptional matches the regular expression `value` - */ - def stringOptional(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - stringOptionalExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` - */ - def stringOptional(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - /** Traverse to nodes where stringOptional matches `value` exactly. - */ - def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] - case _ => - traversal.filter { node => - val tmp = node.stringOptional; tmp.isDefined && tmp.get == value - } - } - - /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. - */ - def stringOptionalExact(values: String*): Iterator[NodeType] = - if (values.length == 1) stringOptionalExact(values.head) - else { - val valueSet = values.toSet - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) - } - } - - /** Traverse to nodes where stringOptional does not match the regular expression `value`. - */ - def stringOptionalNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. - */ - def stringOptionalNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - } - final class Traversal_NodeBBase[NodeType <: nodes.NodeBBase](val traversal: Iterator[NodeType]) extends AnyVal { - - /** Traverse to stringOptional property */ - def stringOptional: Iterator[String] = - traversal.flatMap(_.stringOptional) - - /** Traverse to nodes where the stringOptional matches the regular expression `value` - */ - def stringOptional(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - stringOptionalExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` - */ - def stringOptional(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - /** Traverse to nodes where stringOptional matches `value` exactly. - */ - def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] - case _ => - traversal.filter { node => - val tmp = node.stringOptional; tmp.isDefined && tmp.get == value - } - } - - /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. - */ - def stringOptionalExact(values: String*): Iterator[NodeType] = - if (values.length == 1) stringOptionalExact(values.head) - else { - val valueSet = values.toSet - traversal.filter { item => - val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) - } - } - - /** Traverse to nodes where stringOptional does not match the regular expression `value`. - */ - def stringOptionalNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. - */ - def stringOptionalNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filterNot { item => - val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - } - /* accessors for base nodes end */ -} -trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* - implicit def accessPropertyIntListTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntListEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_int_list[NodeType] = new Traversal_Property_int_list(traversal.iterator) - implicit def accessPropertyIntMandatoryTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntMandatoryEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_int_mandatory[NodeType] = new Traversal_Property_int_mandatory(traversal.iterator) - implicit def accessPropertyIntOptionalTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntOptionalEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_int_optional[NodeType] = new Traversal_Property_int_optional(traversal.iterator) - implicit def accessPropertyStringListTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringListEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_string_list[NodeType] = new Traversal_Property_string_list(traversal.iterator) - implicit def accessPropertyStringMandatoryTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringMandatoryEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_string_mandatory[NodeType] = new Traversal_Property_string_mandatory(traversal.iterator) - implicit def accessPropertyStringOptionalTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringOptionalEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_string_optional[NodeType] = new Traversal_Property_string_optional(traversal.iterator) -} - -trait ConcreteBaseConversions { - import Accessors.* - implicit def traversal_NodeABase[NodeType <: nodes.NodeABase](traversal: IterableOnce[NodeType]): Traversal_NodeABase[NodeType] = - new Traversal_NodeABase(traversal.iterator) - implicit def traversal_NodeBBase[NodeType <: nodes.NodeBBase](traversal: IterableOnce[NodeType]): Traversal_NodeBBase[NodeType] = - new Traversal_NodeBBase(traversal.iterator) -} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeABase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeABase.scala new file mode 100644 index 00000000..0a44c6b3 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeABase.scala @@ -0,0 +1,256 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_NodeABase[NodeType <: nodes.NodeABase](val traversal: Iterator[NodeType]) extends AnyVal { + + /** Traverse to intList property */ + def intList: Iterator[Int] = + traversal.flatMap(_.intList) + + /** Traverse to intMandatory property */ + def intMandatory: Iterator[Int] = + traversal.map(_.intMandatory) + + /** Traverse to nodes where the intMandatory equals the given `value` + */ + def intMandatory(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory == value } + + /** Traverse to nodes where the intMandatory equals at least one of the given `values` + */ + def intMandatory(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => vset.contains(node.intMandatory) } + } + + /** Traverse to nodes where the intMandatory is not equal to the given `value` + */ + def intMandatoryNot(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory != value } + + /** Traverse to nodes where the intMandatory is not equal to any of the given `values` + */ + def intMandatoryNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => !vset.contains(node.intMandatory) } + } + + /** Traverse to nodes where the intMandatory is greater than the given `value` + */ + def intMandatoryGt(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory > value } + + /** Traverse to nodes where the intMandatory is greater than or equal the given `value` + */ + def intMandatoryGte(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory >= value } + + /** Traverse to nodes where the intMandatory is less than the given `value` + */ + def intMandatoryLt(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory < value } + + /** Traverse to nodes where the intMandatory is less than or equal the given `value` + */ + def intMandatoryLte(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory <= value } + + /** Traverse to intOptional property */ + def intOptional: Iterator[Int] = + traversal.flatMap(_.intOptional) + + /** Traverse to nodes where the intOptional equals the given `value` + */ + def intOptional(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get == value + } + + /** Traverse to nodes where the intOptional equals at least one of the given `values` + */ + def intOptional(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the intOptional is not equal to the given `value` + */ + def intOptionalNot(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isEmpty || tmp.get != value + } + + /** Traverse to nodes where the intOptional does not equal any one of the given `values` + */ + def intOptionalNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.intOptional; tmp.isEmpty || !vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the intOptional is greater than the given `value` + */ + def intOptionalGt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get > value + } + + /** Traverse to nodes where the intOptional is greater than or equal the given `value` + */ + def intOptionalGte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get >= value + } + + /** Traverse to nodes where the intOptional is less than the given `value` + */ + def intOptionalLt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get < value + } + + /** Traverse to nodes where the intOptional is less than or equal the given `value` + */ + def intOptionalLte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get <= value + } + + /** Traverse to stringList property */ + def stringList: Iterator[String] = + traversal.flatMap(_.stringList) + + /** Traverse to stringMandatory property */ + def stringMandatory: Iterator[String] = + traversal.map(_.stringMandatory) + + /** Traverse to nodes where the stringMandatory matches the regular expression `value` + */ + def stringMandatory(pattern: String): Iterator[NodeType] = + if (!flatgraph.misc.Regex.isRegex(pattern)) { + stringMandatoryExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.stringMandatory).matches } + } + + /** Traverse to nodes where the stringMandatory matches at least one of the regular expressions in `values` + */ + def stringMandatory(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.stringMandatory).matches } } + } + + /** Traverse to nodes where stringMandatory matches `value` exactly. + */ + def stringMandatoryExact(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, 4, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.stringMandatory == value } + } + + /** 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) } + } + + /** Traverse to nodes where stringMandatory does not match the regular expression `value`. + */ + def stringMandatoryNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.stringMandatory != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.stringMandatory).matches } + } + } + + /** Traverse to nodes where stringMandatory does not match any of the regular expressions in `values`. + */ + def stringMandatoryNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.stringMandatory).matches }.isEmpty } + } + + /** Traverse to stringOptional property */ + def stringOptional: Iterator[String] = + traversal.flatMap(_.stringOptional) + + /** Traverse to nodes where the stringOptional matches the regular expression `value` + */ + def stringOptional(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + stringOptionalExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` + */ + def stringOptional(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + + /** Traverse to nodes where stringOptional matches `value` exactly. + */ + def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] + case _ => + traversal.filter { node => + val tmp = node.stringOptional; tmp.isDefined && tmp.get == value + } + } + + /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. + */ + def stringOptionalExact(values: String*): Iterator[NodeType] = + if (values.length == 1) stringOptionalExact(values.head) + else { + val valueSet = values.toSet + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) + } + } + + /** Traverse to nodes where stringOptional does not match the regular expression `value`. + */ + def stringOptionalNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. + */ + def stringOptionalNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeBBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeBBase.scala new file mode 100644 index 00000000..01e0d16f --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_NodeBBase.scala @@ -0,0 +1,79 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_NodeBBase[NodeType <: nodes.NodeBBase](val traversal: Iterator[NodeType]) extends AnyVal { + + /** Traverse to stringOptional property */ + def stringOptional: Iterator[String] = + traversal.flatMap(_.stringOptional) + + /** Traverse to nodes where the stringOptional matches the regular expression `value` + */ + def stringOptional(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + stringOptionalExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` + */ + def stringOptional(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + + /** Traverse to nodes where stringOptional matches `value` exactly. + */ + def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] + case _ => + traversal.filter { node => + val tmp = node.stringOptional; tmp.isDefined && tmp.get == value + } + } + + /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. + */ + def stringOptionalExact(values: String*): Iterator[NodeType] = + if (values.length == 1) stringOptionalExact(values.head) + else { + val valueSet = values.toSet + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) + } + } + + /** Traverse to nodes where stringOptional does not match the regular expression `value`. + */ + def stringOptionalNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. + */ + def stringOptionalNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_list.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_list.scala new file mode 100644 index 00000000..f742647a --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_list.scala @@ -0,0 +1,14 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_int_list[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntListEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to intList property */ + def intList: Iterator[Int] = + traversal.flatMap(_.intList) + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_mandatory.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_mandatory.scala new file mode 100644 index 00000000..14c9c88d --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_mandatory.scala @@ -0,0 +1,58 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_int_mandatory[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntMandatoryEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to intMandatory property */ + def intMandatory: Iterator[Int] = + traversal.map(_.intMandatory) + + /** Traverse to nodes where the intMandatory equals the given `value` + */ + def intMandatory(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory == value } + + /** Traverse to nodes where the intMandatory equals at least one of the given `values` + */ + def intMandatory(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => vset.contains(node.intMandatory) } + } + + /** Traverse to nodes where the intMandatory is not equal to the given `value` + */ + def intMandatoryNot(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory != value } + + /** Traverse to nodes where the intMandatory is not equal to any of the given `values` + */ + def intMandatoryNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => !vset.contains(node.intMandatory) } + } + + /** Traverse to nodes where the intMandatory is greater than the given `value` + */ + def intMandatoryGt(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory > value } + + /** Traverse to nodes where the intMandatory is greater than or equal the given `value` + */ + def intMandatoryGte(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory >= value } + + /** Traverse to nodes where the intMandatory is less than the given `value` + */ + def intMandatoryLt(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory < value } + + /** Traverse to nodes where the intMandatory is less than or equal the given `value` + */ + def intMandatoryLte(value: Int): Iterator[NodeType] = + traversal.filter { _.intMandatory <= value } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_optional.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_optional.scala new file mode 100644 index 00000000..c761030f --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_int_optional.scala @@ -0,0 +1,74 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_int_optional[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntOptionalEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to intOptional property */ + def intOptional: Iterator[Int] = + traversal.flatMap(_.intOptional) + + /** Traverse to nodes where the intOptional equals the given `value` + */ + def intOptional(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get == value + } + + /** Traverse to nodes where the intOptional equals at least one of the given `values` + */ + def intOptional(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the intOptional is not equal to the given `value` + */ + def intOptionalNot(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isEmpty || tmp.get != value + } + + /** Traverse to nodes where the intOptional does not equal any one of the given `values` + */ + def intOptionalNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.intOptional; tmp.isEmpty || !vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the intOptional is greater than the given `value` + */ + def intOptionalGt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get > value + } + + /** Traverse to nodes where the intOptional is greater than or equal the given `value` + */ + def intOptionalGte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get >= value + } + + /** Traverse to nodes where the intOptional is less than the given `value` + */ + def intOptionalLt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get < value + } + + /** Traverse to nodes where the intOptional is less than or equal the given `value` + */ + def intOptionalLte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.intOptional; tmp.isDefined && tmp.get <= value + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_list.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_list.scala new file mode 100644 index 00000000..052991b1 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_list.scala @@ -0,0 +1,14 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_string_list[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringListEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to stringList property */ + def stringList: Iterator[String] = + traversal.flatMap(_.stringList) + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_mandatory.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_mandatory.scala new file mode 100644 index 00000000..09058c99 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_mandatory.scala @@ -0,0 +1,67 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_string_mandatory[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringMandatoryEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to stringMandatory property */ + def stringMandatory: Iterator[String] = + traversal.map(_.stringMandatory) + + /** Traverse to nodes where the stringMandatory matches the regular expression `value` + */ + def stringMandatory(pattern: String): Iterator[NodeType] = + if (!flatgraph.misc.Regex.isRegex(pattern)) { + stringMandatoryExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.stringMandatory).matches } + } + + /** Traverse to nodes where the stringMandatory matches at least one of the regular expressions in `values` + */ + def stringMandatory(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.stringMandatory).matches } } + } + + /** Traverse to nodes where stringMandatory matches `value` exactly. + */ + def stringMandatoryExact(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, 4, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.stringMandatory == value } + } + + /** 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) } + } + + /** Traverse to nodes where stringMandatory does not match the regular expression `value`. + */ + def stringMandatoryNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.stringMandatory != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.stringMandatory).matches } + } + } + + /** Traverse to nodes where stringMandatory does not match any of the regular expressions in `values`. + */ + def stringMandatoryNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.stringMandatory).matches }.isEmpty } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_optional.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_optional.scala new file mode 100644 index 00000000..2703e67a --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/Traversal_Property_string_optional.scala @@ -0,0 +1,81 @@ +package testdomains.generic.traversals + +import testdomains.generic.nodes +import testdomains.generic.accessors.languagebootstrap.* + +final class Traversal_Property_string_optional[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringOptionalEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to stringOptional property */ + def stringOptional: Iterator[String] = + traversal.flatMap(_.stringOptional) + + /** Traverse to nodes where the stringOptional matches the regular expression `value` + */ + def stringOptional(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + stringOptionalExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where the stringOptional matches at least one of the regular expressions in `values` + */ + def stringOptional(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + + /** Traverse to nodes where stringOptional matches `value` exactly. + */ + def stringOptionalExact(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, 5, value).asInstanceOf[Iterator[NodeType]] + case _ => + traversal.filter { node => + val tmp = node.stringOptional; tmp.isDefined && tmp.get == value + } + } + + /** Traverse to nodes where stringOptional matches one of the elements in `values` exactly. + */ + def stringOptionalExact(values: String*): Iterator[NodeType] = + if (values.length == 1) stringOptionalExact(values.head) + else { + val valueSet = values.toSet + traversal.filter { item => + val tmp = item.stringOptional; tmp.isDefined && valueSet.contains(tmp.get) + } + } + + /** Traverse to nodes where stringOptional does not match the regular expression `value`. + */ + def stringOptionalNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.stringOptional.isEmpty || node.stringOptional.get != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where stringOptional does not match any of the regular expressions in `values`. + */ + def stringOptionalNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filterNot { item => + val tmp = item.stringOptional; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/package.scala b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/package.scala new file mode 100644 index 00000000..9df27318 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/generic/traversals/package.scala @@ -0,0 +1,37 @@ +package testdomains.generic + +import testdomains.generic.nodes + +package object traversals { + + /** not supposed to be used directly by users, hence the `bootstrap` in the name */ + object languagebootstrap extends ConcreteStoredConversions + + trait ConcreteStoredConversions extends ConcreteBaseConversions { + implicit def accessPropertyIntListTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntListEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_int_list[NodeType] = new Traversal_Property_int_list(traversal.iterator) + implicit def accessPropertyIntMandatoryTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntMandatoryEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_int_mandatory[NodeType] = new Traversal_Property_int_mandatory(traversal.iterator) + implicit def accessPropertyIntOptionalTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasIntOptionalEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_int_optional[NodeType] = new Traversal_Property_int_optional(traversal.iterator) + implicit def accessPropertyStringListTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringListEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_string_list[NodeType] = new Traversal_Property_string_list(traversal.iterator) + implicit def accessPropertyStringMandatoryTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringMandatoryEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_string_mandatory[NodeType] = new Traversal_Property_string_mandatory(traversal.iterator) + implicit def accessPropertyStringOptionalTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasStringOptionalEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_string_optional[NodeType] = new Traversal_Property_string_optional(traversal.iterator) + } + + trait ConcreteBaseConversions { + implicit def traversal_NodeABase[NodeType <: nodes.NodeABase](traversal: IterableOnce[NodeType]): Traversal_NodeABase[NodeType] = + new Traversal_NodeABase(traversal.iterator) + implicit def traversal_NodeBBase[NodeType <: nodes.NodeBBase](traversal: IterableOnce[NodeType]): Traversal_NodeBBase[NodeType] = + new Traversal_NodeBBase(traversal.iterator) + } +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Accessors.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Accessors.scala index e71b99df..99fd3bf8 100644 --- a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Accessors.scala +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Accessors.scala @@ -42,8 +42,8 @@ object Accessors { /* accessors for base nodes end */ } +import Accessors.* trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* implicit def accessPropertyName(node: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]): Access_Property_name = new Access_Property_name(node) implicit def accessPropertyPerformances( @@ -54,7 +54,6 @@ trait ConcreteStoredConversions extends ConcreteBaseConversions { } trait ConcreteBaseConversions { - import Accessors.* implicit def access_ArtistBase(node: nodes.ArtistBase): Access_ArtistBase = new Access_ArtistBase(node) implicit def access_SongBase(node: nodes.SongBase): Access_SongBase = new Access_SongBase(node) } diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Traversals.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Traversals.scala deleted file mode 100644 index 4aa19f34..00000000 --- a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/Traversals.scala +++ /dev/null @@ -1,496 +0,0 @@ -package testdomains.gratefuldead.traversals -import testdomains.gratefuldead.nodes - -/** not supposed to be used directly by users, hence the `bootstrap` in the name */ -object languagebootstrap extends ConcreteStoredConversions - -object Accessors { - import testdomains.gratefuldead.accessors.languagebootstrap.* - - /* accessors for concrete stored nodes start */ - final class Traversal_Property_name[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]](val traversal: Iterator[NodeType]) - extends AnyVal { - - /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { - nameExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.name).matches } - } - - /** Traverse to nodes where the name matches at least one of the regular expressions in `values` - */ - def name(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.name).matches } } - } - - /** Traverse to nodes where name matches `value` exactly. - */ - def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.name == value } - } - - /** 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) } - } - - /** Traverse to nodes where name does not match the regular expression `value`. - */ - def nameNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.name != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.name).matches } - } - } - - /** Traverse to nodes where name does not match any of the regular expressions in `values`. - */ - def nameNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } - } - - } - final class Traversal_Property_performances[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasPerformancesEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to performances property */ - def performances: Iterator[Int] = - traversal.flatMap(_.performances) - - /** Traverse to nodes where the performances equals the given `value` - */ - def performances(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get == value - } - - /** Traverse to nodes where the performances equals at least one of the given `values` - */ - def performances(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the performances is not equal to the given `value` - */ - def performancesNot(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isEmpty || tmp.get != value - } - - /** Traverse to nodes where the performances does not equal any one of the given `values` - */ - def performancesNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.performances; tmp.isEmpty || !vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the performances is greater than the given `value` - */ - def performancesGt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get > value - } - - /** Traverse to nodes where the performances is greater than or equal the given `value` - */ - def performancesGte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get >= value - } - - /** Traverse to nodes where the performances is less than the given `value` - */ - def performancesLt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get < value - } - - /** Traverse to nodes where the performances is less than or equal the given `value` - */ - def performancesLte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get <= value - } - - } - final class Traversal_Property_songType[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasSongtypeEMT]]( - val traversal: Iterator[NodeType] - ) extends AnyVal { - - /** Traverse to songtype property */ - def songtype: Iterator[String] = - traversal.flatMap(_.songtype) - - /** Traverse to nodes where the songtype matches the regular expression `value` - */ - def songtype(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - songtypeExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where the songtype matches at least one of the regular expressions in `values` - */ - def songtype(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - /** Traverse to nodes where songtype matches `value` exactly. - */ - def songtypeExact(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, 2, value).asInstanceOf[Iterator[NodeType]] - case _ => - traversal.filter { node => - val tmp = node.songtype; tmp.isDefined && tmp.get == value - } - } - - /** Traverse to nodes where songtype matches one of the elements in `values` exactly. - */ - def songtypeExact(values: String*): Iterator[NodeType] = - if (values.length == 1) songtypeExact(values.head) - else { - val valueSet = values.toSet - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && valueSet.contains(tmp.get) - } - } - - /** Traverse to nodes where songtype does not match the regular expression `value`. - */ - def songtypeNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.songtype.isEmpty || node.songtype.get != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => - val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where songtype does not match any of the regular expressions in `values`. - */ - def songtypeNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filterNot { item => - val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - } - /* accessors for concrete stored nodes end */ - - /* accessors for base nodes start */ - final class Traversal_ArtistBase[NodeType <: nodes.ArtistBase](val traversal: Iterator[NodeType]) extends AnyVal { - - /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { - nameExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.name).matches } - } - - /** Traverse to nodes where the name matches at least one of the regular expressions in `values` - */ - def name(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.name).matches } } - } - - /** Traverse to nodes where name matches `value` exactly. - */ - def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.name == value } - } - - /** 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) } - } - - /** Traverse to nodes where name does not match the regular expression `value`. - */ - def nameNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.name != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.name).matches } - } - } - - /** Traverse to nodes where name does not match any of the regular expressions in `values`. - */ - def nameNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } - } - - } - final class Traversal_SongBase[NodeType <: nodes.SongBase](val traversal: Iterator[NodeType]) extends AnyVal { - - /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { - nameExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.name).matches } - } - - /** Traverse to nodes where the name matches at least one of the regular expressions in `values` - */ - def name(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.name).matches } } - } - - /** Traverse to nodes where name matches `value` exactly. - */ - def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.name == value } - } - - /** 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) } - } - - /** Traverse to nodes where name does not match the regular expression `value`. - */ - def nameNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.name != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.name).matches } - } - } - - /** Traverse to nodes where name does not match any of the regular expressions in `values`. - */ - def nameNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } - } - - /** Traverse to performances property */ - def performances: Iterator[Int] = - traversal.flatMap(_.performances) - - /** Traverse to nodes where the performances equals the given `value` - */ - def performances(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get == value - } - - /** Traverse to nodes where the performances equals at least one of the given `values` - */ - def performances(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the performances is not equal to the given `value` - */ - def performancesNot(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isEmpty || tmp.get != value - } - - /** Traverse to nodes where the performances does not equal any one of the given `values` - */ - def performancesNot(values: Int*): Iterator[NodeType] = { - val vset = values.toSet - traversal.filter { node => - val tmp = node.performances; tmp.isEmpty || !vset.contains(tmp.get) - } - } - - /** Traverse to nodes where the performances is greater than the given `value` - */ - def performancesGt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get > value - } - - /** Traverse to nodes where the performances is greater than or equal the given `value` - */ - def performancesGte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get >= value - } - - /** Traverse to nodes where the performances is less than the given `value` - */ - def performancesLt(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get < value - } - - /** Traverse to nodes where the performances is less than or equal the given `value` - */ - def performancesLte(value: Int): Iterator[NodeType] = - traversal.filter { node => - val tmp = node.performances; tmp.isDefined && tmp.get <= value - } - - /** Traverse to songtype property */ - def songtype: Iterator[String] = - traversal.flatMap(_.songtype) - - /** Traverse to nodes where the songtype matches the regular expression `value` - */ - def songtype(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - songtypeExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where the songtype matches at least one of the regular expressions in `values` - */ - def songtype(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - /** Traverse to nodes where songtype matches `value` exactly. - */ - def songtypeExact(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, 2, value).asInstanceOf[Iterator[NodeType]] - case _ => - traversal.filter { node => - val tmp = node.songtype; tmp.isDefined && tmp.get == value - } - } - - /** Traverse to nodes where songtype matches one of the elements in `values` exactly. - */ - def songtypeExact(values: String*): Iterator[NodeType] = - if (values.length == 1) songtypeExact(values.head) - else { - val valueSet = values.toSet - traversal.filter { item => - val tmp = item.songtype; tmp.isDefined && valueSet.contains(tmp.get) - } - } - - /** Traverse to nodes where songtype does not match the regular expression `value`. - */ - def songtypeNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.songtype.isEmpty || node.songtype.get != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => - val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches - } - } - } - - /** Traverse to nodes where songtype does not match any of the regular expressions in `values`. - */ - def songtypeNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filterNot { item => - val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } - } - } - - } - /* accessors for base nodes end */ -} -trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* - implicit def accessPropertyNameTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_name[NodeType] = new Traversal_Property_name(traversal.iterator) - implicit def accessPropertyPerformancesTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasPerformancesEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_performances[NodeType] = new Traversal_Property_performances(traversal.iterator) - implicit def accessPropertySongtypeTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasSongtypeEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_songType[NodeType] = new Traversal_Property_songType(traversal.iterator) -} - -trait ConcreteBaseConversions { - import Accessors.* - implicit def traversal_ArtistBase[NodeType <: nodes.ArtistBase](traversal: IterableOnce[NodeType]): Traversal_ArtistBase[NodeType] = - new Traversal_ArtistBase(traversal.iterator) - implicit def traversal_SongBase[NodeType <: nodes.SongBase](traversal: IterableOnce[NodeType]): Traversal_SongBase[NodeType] = - new Traversal_SongBase(traversal.iterator) -} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_ArtistBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_ArtistBase.scala new file mode 100644 index 00000000..c4bb6f09 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_ArtistBase.scala @@ -0,0 +1,65 @@ +package testdomains.gratefuldead.traversals + +import testdomains.gratefuldead.nodes +import testdomains.gratefuldead.accessors.languagebootstrap.* + +final class Traversal_ArtistBase[NodeType <: nodes.ArtistBase](val traversal: Iterator[NodeType]) extends AnyVal { + + /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { + nameExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.name).matches } + } + + /** Traverse to nodes where the name matches at least one of the regular expressions in `values` + */ + def name(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.name).matches } } + } + + /** Traverse to nodes where name matches `value` exactly. + */ + def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.name == value } + } + + /** 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) } + } + + /** Traverse to nodes where name does not match the regular expression `value`. + */ + def nameNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.name != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.name).matches } + } + } + + /** Traverse to nodes where name does not match any of the regular expressions in `values`. + */ + def nameNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_name.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_name.scala new file mode 100644 index 00000000..0adb0dca --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_name.scala @@ -0,0 +1,66 @@ +package testdomains.gratefuldead.traversals + +import testdomains.gratefuldead.nodes +import testdomains.gratefuldead.accessors.languagebootstrap.* + +final class Traversal_Property_name[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]](val traversal: Iterator[NodeType]) + extends AnyVal { + + /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { + nameExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.name).matches } + } + + /** Traverse to nodes where the name matches at least one of the regular expressions in `values` + */ + def name(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.name).matches } } + } + + /** Traverse to nodes where name matches `value` exactly. + */ + def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.name == value } + } + + /** 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) } + } + + /** Traverse to nodes where name does not match the regular expression `value`. + */ + def nameNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.name != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.name).matches } + } + } + + /** Traverse to nodes where name does not match any of the regular expressions in `values`. + */ + def nameNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_performances.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_performances.scala new file mode 100644 index 00000000..89820246 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_performances.scala @@ -0,0 +1,74 @@ +package testdomains.gratefuldead.traversals + +import testdomains.gratefuldead.nodes +import testdomains.gratefuldead.accessors.languagebootstrap.* + +final class Traversal_Property_performances[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasPerformancesEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to performances property */ + def performances: Iterator[Int] = + traversal.flatMap(_.performances) + + /** Traverse to nodes where the performances equals the given `value` + */ + def performances(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get == value + } + + /** Traverse to nodes where the performances equals at least one of the given `values` + */ + def performances(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the performances is not equal to the given `value` + */ + def performancesNot(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isEmpty || tmp.get != value + } + + /** Traverse to nodes where the performances does not equal any one of the given `values` + */ + def performancesNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.performances; tmp.isEmpty || !vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the performances is greater than the given `value` + */ + def performancesGt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get > value + } + + /** Traverse to nodes where the performances is greater than or equal the given `value` + */ + def performancesGte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get >= value + } + + /** Traverse to nodes where the performances is less than the given `value` + */ + def performancesLt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get < value + } + + /** Traverse to nodes where the performances is less than or equal the given `value` + */ + def performancesLte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get <= value + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_songType.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_songType.scala new file mode 100644 index 00000000..3dbda966 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_Property_songType.scala @@ -0,0 +1,81 @@ +package testdomains.gratefuldead.traversals + +import testdomains.gratefuldead.nodes +import testdomains.gratefuldead.accessors.languagebootstrap.* + +final class Traversal_Property_songType[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasSongtypeEMT]]( + val traversal: Iterator[NodeType] +) extends AnyVal { + + /** Traverse to songtype property */ + def songtype: Iterator[String] = + traversal.flatMap(_.songtype) + + /** Traverse to nodes where the songtype matches the regular expression `value` + */ + def songtype(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + songtypeExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where the songtype matches at least one of the regular expressions in `values` + */ + def songtype(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + + /** Traverse to nodes where songtype matches `value` exactly. + */ + def songtypeExact(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, 2, value).asInstanceOf[Iterator[NodeType]] + case _ => + traversal.filter { node => + val tmp = node.songtype; tmp.isDefined && tmp.get == value + } + } + + /** Traverse to nodes where songtype matches one of the elements in `values` exactly. + */ + def songtypeExact(values: String*): Iterator[NodeType] = + if (values.length == 1) songtypeExact(values.head) + else { + val valueSet = values.toSet + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && valueSet.contains(tmp.get) + } + } + + /** Traverse to nodes where songtype does not match the regular expression `value`. + */ + def songtypeNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.songtype.isEmpty || node.songtype.get != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => + val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where songtype does not match any of the regular expressions in `values`. + */ + def songtypeNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filterNot { item => + val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_SongBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_SongBase.scala new file mode 100644 index 00000000..83fb7e03 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/Traversal_SongBase.scala @@ -0,0 +1,200 @@ +package testdomains.gratefuldead.traversals + +import testdomains.gratefuldead.nodes +import testdomains.gratefuldead.accessors.languagebootstrap.* + +final class Traversal_SongBase[NodeType <: nodes.SongBase](val traversal: Iterator[NodeType]) extends AnyVal { + + /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { + nameExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.name).matches } + } + + /** Traverse to nodes where the name matches at least one of the regular expressions in `values` + */ + def name(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.name).matches } } + } + + /** Traverse to nodes where name matches `value` exactly. + */ + def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.name == value } + } + + /** 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) } + } + + /** Traverse to nodes where name does not match the regular expression `value`. + */ + def nameNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.name != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.name).matches } + } + } + + /** Traverse to nodes where name does not match any of the regular expressions in `values`. + */ + def nameNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } + } + + /** Traverse to performances property */ + def performances: Iterator[Int] = + traversal.flatMap(_.performances) + + /** Traverse to nodes where the performances equals the given `value` + */ + def performances(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get == value + } + + /** Traverse to nodes where the performances equals at least one of the given `values` + */ + def performances(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the performances is not equal to the given `value` + */ + def performancesNot(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isEmpty || tmp.get != value + } + + /** Traverse to nodes where the performances does not equal any one of the given `values` + */ + def performancesNot(values: Int*): Iterator[NodeType] = { + val vset = values.toSet + traversal.filter { node => + val tmp = node.performances; tmp.isEmpty || !vset.contains(tmp.get) + } + } + + /** Traverse to nodes where the performances is greater than the given `value` + */ + def performancesGt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get > value + } + + /** Traverse to nodes where the performances is greater than or equal the given `value` + */ + def performancesGte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get >= value + } + + /** Traverse to nodes where the performances is less than the given `value` + */ + def performancesLt(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get < value + } + + /** Traverse to nodes where the performances is less than or equal the given `value` + */ + def performancesLte(value: Int): Iterator[NodeType] = + traversal.filter { node => + val tmp = node.performances; tmp.isDefined && tmp.get <= value + } + + /** Traverse to songtype property */ + def songtype: Iterator[String] = + traversal.flatMap(_.songtype) + + /** Traverse to nodes where the songtype matches the regular expression `value` + */ + def songtype(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + songtypeExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where the songtype matches at least one of the regular expressions in `values` + */ + def songtype(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + + /** Traverse to nodes where songtype matches `value` exactly. + */ + def songtypeExact(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, 2, value).asInstanceOf[Iterator[NodeType]] + case _ => + traversal.filter { node => + val tmp = node.songtype; tmp.isDefined && tmp.get == value + } + } + + /** Traverse to nodes where songtype matches one of the elements in `values` exactly. + */ + def songtypeExact(values: String*): Iterator[NodeType] = + if (values.length == 1) songtypeExact(values.head) + else { + val valueSet = values.toSet + traversal.filter { item => + val tmp = item.songtype; tmp.isDefined && valueSet.contains(tmp.get) + } + } + + /** Traverse to nodes where songtype does not match the regular expression `value`. + */ + def songtypeNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.songtype.isEmpty || node.songtype.get != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => + val tmp = item.songtype; tmp.isDefined && matcher.reset(tmp.get).matches + } + } + } + + /** Traverse to nodes where songtype does not match any of the regular expressions in `values`. + */ + def songtypeNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filterNot { item => + val tmp = item.songtype; tmp.isDefined && matchers.exists { _.reset(tmp.get).matches } + } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/package.scala b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/package.scala new file mode 100644 index 00000000..8f5115ec --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/gratefuldead/traversals/package.scala @@ -0,0 +1,28 @@ +package testdomains.gratefuldead + +import testdomains.gratefuldead.nodes + +package object traversals { + + /** not supposed to be used directly by users, hence the `bootstrap` in the name */ + object languagebootstrap extends ConcreteStoredConversions + + trait ConcreteStoredConversions extends ConcreteBaseConversions { + implicit def accessPropertyNameTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_name[NodeType] = new Traversal_Property_name(traversal.iterator) + implicit def accessPropertyPerformancesTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasPerformancesEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_performances[NodeType] = new Traversal_Property_performances(traversal.iterator) + implicit def accessPropertySongtypeTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasSongtypeEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_songType[NodeType] = new Traversal_Property_songType(traversal.iterator) + } + + trait ConcreteBaseConversions { + implicit def traversal_ArtistBase[NodeType <: nodes.ArtistBase](traversal: IterableOnce[NodeType]): Traversal_ArtistBase[NodeType] = + new Traversal_ArtistBase(traversal.iterator) + implicit def traversal_SongBase[NodeType <: nodes.SongBase](traversal: IterableOnce[NodeType]): Traversal_SongBase[NodeType] = + new Traversal_SongBase(traversal.iterator) + } +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Accessors.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Accessors.scala index cf6fbe19..930ac34f 100644 --- a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Accessors.scala +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Accessors.scala @@ -24,19 +24,17 @@ object Accessors { /* accessors for base nodes end */ } +import Accessors.* trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* implicit def accessPropertyName(node: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]): Access_Property_name = new Access_Property_name(node) } trait ConcreteBaseConversions extends AbstractBaseConversions0 { - import Accessors.* implicit def access_NodeXBase(node: nodes.NodeXBase): Access_NodeXBase = new Access_NodeXBase(node) implicit def access_NodeYBase(node: nodes.NodeYBase): Access_NodeYBase = new Access_NodeYBase(node) } trait AbstractBaseConversions0 { - import Accessors.* implicit def access_BaseNodeBase(node: nodes.BaseNodeBase): Access_BaseNodeBase = new Access_BaseNodeBase(node) } diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Traversals.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Traversals.scala deleted file mode 100644 index 82c088ca..00000000 --- a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/Traversals.scala +++ /dev/null @@ -1,158 +0,0 @@ -package testdomains.hierarchical.traversals -import testdomains.hierarchical.nodes - -/** not supposed to be used directly by users, hence the `bootstrap` in the name */ -object languagebootstrap extends ConcreteStoredConversions - -object Accessors { - import testdomains.hierarchical.accessors.languagebootstrap.* - - /* accessors for concrete stored nodes start */ - final class Traversal_Property_name[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]](val traversal: Iterator[NodeType]) - extends AnyVal { - - /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { - nameExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.name).matches } - } - - /** Traverse to nodes where the name matches at least one of the regular expressions in `values` - */ - def name(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.name).matches } } - } - - /** Traverse to nodes where name matches `value` exactly. - */ - def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.name == value } - } - - /** 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) } - } - - /** Traverse to nodes where name does not match the regular expression `value`. - */ - def nameNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.name != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.name).matches } - } - } - - /** Traverse to nodes where name does not match any of the regular expressions in `values`. - */ - def nameNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } - } - - } - /* accessors for concrete stored nodes end */ - - /* accessors for base nodes start */ - final class Traversal_NodeXBase[NodeType <: nodes.NodeXBase](val traversal: Iterator[NodeType]) extends AnyVal {} - final class Traversal_NodeYBase[NodeType <: nodes.NodeYBase](val traversal: Iterator[NodeType]) extends AnyVal {} - final class Traversal_BaseNodeBase[NodeType <: nodes.BaseNodeBase](val traversal: Iterator[NodeType]) extends AnyVal { - - /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { - nameExact(pattern) - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filter { item => matcher.reset(item.name).matches } - } - - /** Traverse to nodes where the name matches at least one of the regular expressions in `values` - */ - def name(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.exists { _.reset(item.name).matches } } - } - - /** Traverse to nodes where name matches `value` exactly. - */ - def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] - case _ => traversal.filter { _.name == value } - } - - /** 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) } - } - - /** Traverse to nodes where name does not match the regular expression `value`. - */ - def nameNot(pattern: String): Iterator[NodeType] = { - if (!flatgraph.misc.Regex.isRegex(pattern)) { - traversal.filter { node => node.name != pattern } - } else { - val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) - traversal.filterNot { item => matcher.reset(item.name).matches } - } - } - - /** Traverse to nodes where name does not match any of the regular expressions in `values`. - */ - def nameNot(patterns: String*): Iterator[NodeType] = { - val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) - traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } - } - - } - /* accessors for base nodes end */ -} -trait ConcreteStoredConversions extends ConcreteBaseConversions { - import Accessors.* - implicit def accessPropertyNameTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]]( - traversal: IterableOnce[NodeType] - ): Traversal_Property_name[NodeType] = new Traversal_Property_name(traversal.iterator) -} - -trait ConcreteBaseConversions extends AbstractBaseConversions0 { - import Accessors.* - implicit def traversal_NodeXBase[NodeType <: nodes.NodeXBase](traversal: IterableOnce[NodeType]): Traversal_NodeXBase[NodeType] = - new Traversal_NodeXBase(traversal.iterator) - implicit def traversal_NodeYBase[NodeType <: nodes.NodeYBase](traversal: IterableOnce[NodeType]): Traversal_NodeYBase[NodeType] = - new Traversal_NodeYBase(traversal.iterator) -} - -trait AbstractBaseConversions0 { - import Accessors.* - implicit def traversal_BaseNodeBase[NodeType <: nodes.BaseNodeBase](traversal: IterableOnce[NodeType]): Traversal_BaseNodeBase[NodeType] = - new Traversal_BaseNodeBase(traversal.iterator) -} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_BaseNodeBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_BaseNodeBase.scala new file mode 100644 index 00000000..46f2272a --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_BaseNodeBase.scala @@ -0,0 +1,65 @@ +package testdomains.hierarchical.traversals + +import testdomains.hierarchical.nodes +import testdomains.hierarchical.accessors.languagebootstrap.* + +final class Traversal_BaseNodeBase[NodeType <: nodes.BaseNodeBase](val traversal: Iterator[NodeType]) extends AnyVal { + + /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { + nameExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.name).matches } + } + + /** Traverse to nodes where the name matches at least one of the regular expressions in `values` + */ + def name(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.name).matches } } + } + + /** Traverse to nodes where name matches `value` exactly. + */ + def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.name == value } + } + + /** 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) } + } + + /** Traverse to nodes where name does not match the regular expression `value`. + */ + def nameNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.name != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.name).matches } + } + } + + /** Traverse to nodes where name does not match any of the regular expressions in `values`. + */ + def nameNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeXBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeXBase.scala new file mode 100644 index 00000000..03802a4c --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeXBase.scala @@ -0,0 +1,6 @@ +package testdomains.hierarchical.traversals + +import testdomains.hierarchical.nodes +import testdomains.hierarchical.accessors.languagebootstrap.* + +final class Traversal_NodeXBase[NodeType <: nodes.NodeXBase](val traversal: Iterator[NodeType]) extends AnyVal {} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeYBase.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeYBase.scala new file mode 100644 index 00000000..aebdc0e2 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_NodeYBase.scala @@ -0,0 +1,6 @@ +package testdomains.hierarchical.traversals + +import testdomains.hierarchical.nodes +import testdomains.hierarchical.accessors.languagebootstrap.* + +final class Traversal_NodeYBase[NodeType <: nodes.NodeYBase](val traversal: Iterator[NodeType]) extends AnyVal {} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_Property_name.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_Property_name.scala new file mode 100644 index 00000000..1e578959 --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/Traversal_Property_name.scala @@ -0,0 +1,66 @@ +package testdomains.hierarchical.traversals + +import testdomains.hierarchical.nodes +import testdomains.hierarchical.accessors.languagebootstrap.* + +final class Traversal_Property_name[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]](val traversal: Iterator[NodeType]) + extends AnyVal { + + /** 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 (!flatgraph.misc.Regex.isRegex(pattern)) { + nameExact(pattern) + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filter { item => matcher.reset(item.name).matches } + } + + /** Traverse to nodes where the name matches at least one of the regular expressions in `values` + */ + def name(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.exists { _.reset(item.name).matches } } + } + + /** Traverse to nodes where name matches `value` exactly. + */ + def nameExact(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, 0, value).asInstanceOf[Iterator[NodeType]] + case _ => traversal.filter { _.name == value } + } + + /** 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) } + } + + /** Traverse to nodes where name does not match the regular expression `value`. + */ + def nameNot(pattern: String): Iterator[NodeType] = { + if (!flatgraph.misc.Regex.isRegex(pattern)) { + traversal.filter { node => node.name != pattern } + } else { + val matcher = flatgraph.misc.Regex.multilineMatcher(pattern) + traversal.filterNot { item => matcher.reset(item.name).matches } + } + } + + /** Traverse to nodes where name does not match any of the regular expressions in `values`. + */ + def nameNot(patterns: String*): Iterator[NodeType] = { + val matchers = patterns.map(flatgraph.misc.Regex.multilineMatcher) + traversal.filter { item => matchers.find { _.reset(item.name).matches }.isEmpty } + } + +} diff --git a/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/package.scala b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/package.scala new file mode 100644 index 00000000..950d728f --- /dev/null +++ b/test-schemas-domain-classes/src/main/scala/testdomains/hierarchical/traversals/package.scala @@ -0,0 +1,28 @@ +package testdomains.hierarchical + +import testdomains.hierarchical.nodes + +package object traversals { + + /** not supposed to be used directly by users, hence the `bootstrap` in the name */ + object languagebootstrap extends ConcreteStoredConversions + + trait ConcreteStoredConversions extends ConcreteBaseConversions { + implicit def accessPropertyNameTraversal[NodeType <: nodes.StoredNode & nodes.StaticType[nodes.HasNameEMT]]( + traversal: IterableOnce[NodeType] + ): Traversal_Property_name[NodeType] = new Traversal_Property_name(traversal.iterator) + } + + trait ConcreteBaseConversions extends AbstractBaseConversions0 { + implicit def traversal_NodeXBase[NodeType <: nodes.NodeXBase](traversal: IterableOnce[NodeType]): Traversal_NodeXBase[NodeType] = + new Traversal_NodeXBase(traversal.iterator) + implicit def traversal_NodeYBase[NodeType <: nodes.NodeYBase](traversal: IterableOnce[NodeType]): Traversal_NodeYBase[NodeType] = + new Traversal_NodeYBase(traversal.iterator) + } + + trait AbstractBaseConversions0 { + implicit def traversal_BaseNodeBase[NodeType <: nodes.BaseNodeBase]( + traversal: IterableOnce[NodeType] + ): Traversal_BaseNodeBase[NodeType] = new Traversal_BaseNodeBase(traversal.iterator) + } +}