-
-
Notifications
You must be signed in to change notification settings - Fork 84
/
EvalCacheBsonHandlers.scala
92 lines (82 loc) · 3.29 KB
/
EvalCacheBsonHandlers.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package lila.ws
package evalCache
import reactivemongo.api.bson.*
import reactivemongo.api.bson.exceptions.TypeDoesNotMatchException
import scala.util.{ Failure, Success, Try }
import cats.data.NonEmptyList
import cats.syntax.all.*
import chess.format.Uci
object EvalCacheBsonHandlers:
import Mongo.given
import Eval.*
import EvalCacheEntry.*
given BSONHandler[NonEmptyList[Pv]] = new:
private def scoreWrite(s: Score): String = s.value.fold(_.value.toString, m => s"#${m.value}")
private def scoreRead(str: String): Option[Score] =
if (str startsWith "#") str.drop(1).toIntOption map { m =>
Score mate Mate(m)
}
else
str.toIntOption map { c =>
Score cp Cp(c)
}
private def movesWrite(moves: Moves): String = Uci writeListChars moves.value.toList
private def movesRead(str: String): Option[Moves] = Moves from:
Uci.readListChars(str).flatMap(_.toNel)
private val scoreSeparator = ':'
private val pvSeparator = '/'
private val pvSeparatorStr = pvSeparator.toString
def readTry(bs: BSONValue) =
bs match
case BSONString(value) =>
Try {
value.split(pvSeparator).toList.map { pvStr =>
pvStr.split(scoreSeparator) match
case Array(score, moves) =>
Pv(
scoreRead(score) getOrElse sys.error(s"Invalid score $score"),
movesRead(moves) getOrElse sys.error(s"Invalid moves $moves")
)
case x => sys error s"Invalid PV $pvStr: ${x.toList} (in $value)"
}
}.flatMap:
_.toNel.toRight(new Exception(s"Empty PVs $value")).toTry
case b => handlerBadType[NonEmptyList[Pv]](b)
def writeTry(x: NonEmptyList[Pv]) =
Success(BSONString {
x.toList.map { pv =>
s"${scoreWrite(pv.score)}$scoreSeparator${movesWrite(pv.moves)}"
} mkString pvSeparatorStr
})
private def handlerBadType[T](b: BSONValue): Try[T] =
Failure(TypeDoesNotMatchException("BSONValue", b.getClass.getSimpleName))
private def handlerBadValue[T](msg: String): Try[T] = Failure(new IllegalArgumentException(msg))
private def tryHandler[T](read: PartialFunction[BSONValue, Try[T]], write: T => BSONValue): BSONHandler[T] =
new:
def readTry(bson: BSONValue) = read.applyOrElse(bson, (b: BSONValue) => handlerBadType(b))
def writeTry(t: T) = Success(write(t))
given BSONHandler[Id] = tryHandler[Id](
{ case BSONString(value) =>
value split ':' match {
case Array(fen) => Success(Id(chess.variant.Standard, SmallFen(fen)))
case Array(variantId, fen) =>
import chess.variant.Variant
Success(
Id(
Variant.Id.from(variantId.toIntOption) flatMap {
Variant(_)
} getOrElse sys.error(s"Invalid evalcache variant $variantId"),
SmallFen(fen)
)
)
case _ => handlerBadValue(s"Invalid evalcache id $value")
}
},
x =>
BSONString {
if (x.variant.standard || x.variant.fromPosition) x.smallFen.value
else s"${x.variant.id}:${x.smallFen.value}"
}
)
given BSONDocumentHandler[Eval] = Macros.handler
given BSONDocumentHandler[EvalCacheEntry] = Macros.handler