but if you have some generated code with a
DataRecord, put it in a gist, I'll have a look at it
let me show you an instance of how it composed the case classes in one instance
reqBetBuild: com.tralala.package.OxiModel = OxiModel(DataRecord(request,Request(ReqClientAuth(DataRecord(ReqClientAuthSequence1(tralala,someval,None,None,None)),Map(@returnToken -> DataRecord(N), @trustedMethod -> DataRecord(accountNo))),DataRecord(reqBetBuild,ReqBetBuild(Some(Token(List(DataRecord(11111111AD)),Map())),Some(CONTINUE),Some(M),None,None,List(DataRecord(outcomeGroup,OutcomeGroup(1,List(49285))), DataRecord(outcomeGroup,OutcomeGroup(2,List(49297))), DataRecord(outcomeGroup,OutcomeGroup(3,List(49291))), DataRecord(outcomeGroup,OutcomeGroup(4,List(49285, 49297, 49291)))),Map(@returnComplexCombinations -> DataRecord(Y), @returnFreebetTokens -> DataRecord(N), @returnOutcomeDetails -> DataRecord(N)))),Map())),Map(@version -> DataRecord(69.0)))
I think it's because the base document schema is very loose as well
and write multi-lines messages by pressing shift+enter to go to the next line
(that's better :-)
new to gitter
case class ReqClientAuth(reqclientauthoption: scalaxb.DataRecord[Any],
attributes: Map[String, scalaxb.DataRecord[Any]] = Map()) {
lazy val returnToken = attributes("@returnToken").as[String]
lazy val trustedMethod = attributes.get("@trustedMethod") map { _.as[TrustedMethod] }
lazy val trustedHost = attributes.get("@trustedHost") map { _.as[String] }
}
then argonaut-shapeless will use it
any example how the codecs are made?
I'll try to convice first the scalaxb guys if they can bundle it as a util
bundling what btw? generation of json instead of xml?
there are two definitons, one a trait
trait DataRecord[+A] {
val namespace: Option[String]
val key: Option[String]
val value: A
def as[B] = value.asInstanceOf[B]
override def toString: String = {
"DataRecord(" +
((namespace, key, value) match {
case (None, Some(k), _) => k + "," + value.toString
case (Some(n), Some(k), _) => "{" + n + "}" + k + "," + value.toString
case _ => value.toString
}) + ")"
}
}
and a singleton
object DataRecord extends XMLStandardTypes {
private case class DataWriter[+A](
namespace: Option[String],
key: Option[String],
xstypeNamespace: Option[String],
xstypeName: Option[String],
value: A,
writer: CanWriteXML[_]) extends DataRecord[A] {
override def equals(o: Any): Boolean =
o match {
case that: DataWriter[_] =>
namespace == that.namespace &&
key == that.key &&
value == that.value
case _ => false
}
override def hashCode: Int = {
var result = 17
result = result + 31 * namespace.hashCode
result = result + 31 * key.hashCode
result = result + 31 * value.hashCode
result
}
}
I get the feeling if this is implemented properly one would have to consider how do two namespaces share the projected names, possibly via a prefix
and omitting prefixes for the default namespace
@alexarchambault / @milessabin For reasons I don't wish to delve too deeply into, I have a 45 field case class that is primarily Strings, Doubles or Options of those. I'm seeing compile times on the order of 250seconds to derive a DecodeJson, using 0.2.0-SNAPSHOT (and therefore shapeless 2.2-M6). Is that to be expected?
@AlecZorab The tests illustrates that a bit, this is how I do it:
- putting the definitions of the types you derive type classes for in a separate file (
Definitions.scala), - deriving the type classes in another file (
JsonCodecs.scala) -Shapeless._is imported only there, - and using the both from other files (
ShapelessTests.scala).
(illustrating files in https://github.com/alexarchambault/argonaut-shapeless/tree/master/src/test/scala/argonaut)
The goal is to have incremental compilation compile once the definitions and derivations, and that's it.
If you don't modify the definitions or derivations, or their dependencies, they shouldn't be recompiled. You can work freely on the other files.
If you don't modify the definitions or derivations, or their dependencies, they shouldn't be recompiled. You can work freely on the other files.
This doesn't speed up compilation per se, this just avoids unnecessary recompilations.
Development will go on towards 0.3.0, with hopefully support for shapeless 2.2 orphan derivation, and more varied / customisable codecs (ability to change the way products are encoded - e.g. to transform the keys' case, or to put the product in a json array rather than an object, or change the way coproducts are encoded - e.g. to encode eithers directly as their right or left values rather than nesting them in
(see the discussion here: alexarchambault/argonaut-shapeless#5)
{ "Left" / "Right": ... }, or to add a custom field for the type, ...)(see the discussion here: alexarchambault/argonaut-shapeless#5)