in.specmatic.core.pattern.LookupRowPattern.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of specmatic-core Show documentation
Show all versions of specmatic-core Show documentation
Turn your contracts into executable specifications. Contract Driven Development - Collaboratively Design & Independently Deploy MicroServices & MicroFrontends.
Deprecation Notice for group ID "in.specmatic"
******************************************************************************************************
Updates for "specmatic-core" will no longer be available under the deprecated group ID "in.specmatic".
Please update your dependencies to use the new group ID "io.specmatic".
******************************************************************************************************
package `in`.specmatic.core.pattern
import `in`.specmatic.core.Resolver
import `in`.specmatic.core.Result
import `in`.specmatic.core.value.EmptyString
import `in`.specmatic.core.value.Value
data class LookupRowPattern(override val pattern: Pattern, override val key: String? = null) : Pattern, Keyed {
override fun equals(other: Any?): Boolean = other is LookupRowPattern && resolvedHop(other.pattern, Resolver()) == resolvedHop(pattern, Resolver())
override fun hashCode(): Int = pattern.hashCode()
override fun matches(sampleData: Value?, resolver: Resolver): Result =
resolver.matchesPattern(key, pattern, sampleData ?: EmptyString)
override fun generate(resolver: Resolver): Value {
return resolver.withCyclePrevention(pattern) { cyclePreventedResolver ->
when (key) {
null -> pattern.generate(cyclePreventedResolver)
else -> cyclePreventedResolver.generate(key, pattern)
}
}
}
override fun newBasedOn(row: Row, resolver: Resolver): Sequence {
return when(key) {
null -> resolver.withCyclePrevention(pattern) { cyclePreventedResolver ->
pattern.newBasedOn(row, cyclePreventedResolver)
}
// Cycle prevention handled in helper method
else -> newBasedOn(row, key, pattern, resolver)
}
}
override fun newBasedOn(resolver: Resolver): Sequence {
return when(key) {
null -> resolver.withCyclePrevention(pattern) { cyclePreventedResolver ->
pattern.newBasedOn(cyclePreventedResolver)
}
// Cycle prevention handled in helper method
else -> newBasedOn(key, pattern, resolver)
}
}
override fun negativeBasedOn(row: Row, resolver: Resolver): Sequence> {
return sequenceOf(HasValue(this))
}
override fun parse(value: String, resolver: Resolver): Value = pattern.parse(value, resolver)
override fun encompasses(otherPattern: Pattern, thisResolver: Resolver, otherResolver: Resolver, typeStack: TypeStack): Result {
return pattern.encompasses(resolvedHop(otherPattern, otherResolver), thisResolver, otherResolver, typeStack)
}
override fun listOf(valueList: List, resolver: Resolver): Value {
return pattern.listOf(valueList, resolver)
}
override val typeAlias: String? = pattern.typeAlias
override fun patternSet(resolver: Resolver): List = pattern.patternSet(resolver)
override val typeName: String = pattern.typeName
}