Created
June 20, 2012 22:08
-
-
Save rajish/2962518 to your computer and use it in GitHub Desktop.
Generated Scala with problems
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by <a href="http://scalaxb.org/">scalaxb</a>. | |
| package models | |
| case class ZpBaseType(zpbasetypeoption: scalaxb.DataRecord[Any]*) | |
| trait ZpBaseTypeOption |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by <a href="http://scalaxb.org/">scalaxb</a>. | |
| package models | |
| case class CzType(wykonawcy: models.WykonawcyType, | |
| nazwa: Option[String] = None, | |
| nr_czesci_1: Option[String] = None, | |
| data_zam: Option[String] = None, | |
| liczba_ofert: Option[Byte] = None, | |
| liczba_odrzuconych_ofert: Option[Byte] = None, | |
| wartosc: Option[String] = None, | |
| cena: Option[String] = None, | |
| cena_min: Option[String] = None, | |
| cena_max: Option[String] = None, | |
| kod_wal: Option[models.Kod_walType] = None, | |
| walutaType: Option[scalaxb.DataRecord[Any]] = None) | |
| case class CzesciType(czescitypesequence1: models.CzesciTypeSequence1, | |
| czescitypesequence2: models.CzesciTypeSequence2, | |
| czescitypesequence3: models.CzesciTypeSequence3, | |
| czescitypesequence4: models.CzesciTypeSequence4, | |
| czescitypesequence5: models.CzesciTypeSequence5, | |
| czescitypesequence6: models.CzesciTypeSequence6, | |
| czescitypesequence7: models.CzesciTypeSequence7, | |
| czescitypesequence8: models.CzesciTypeSequence8) { | |
| lazy val cz_0 = czescitypesequence1.cz_0 | |
| lazy val cz_1 = czescitypesequence1.cz_1 | |
| lazy val cz_2 = czescitypesequence1.cz_2 | |
| lazy val cz_3 = czescitypesequence1.cz_3 | |
| lazy val cz_4 = czescitypesequence1.cz_4 | |
| lazy val cz_5 = czescitypesequence1.cz_5 | |
| lazy val cz_6 = czescitypesequence1.cz_6 | |
| lazy val cz_7 = czescitypesequence1.cz_7 | |
| lazy val cz_8 = czescitypesequence1.cz_8 | |
| lazy val cz_9 = czescitypesequence1.cz_9 | |
| lazy val cz_10 = czescitypesequence2.cz_10 | |
| lazy val cz_11 = czescitypesequence2.cz_11 | |
| lazy val cz_12 = czescitypesequence2.cz_12 | |
| lazy val cz_13 = czescitypesequence2.cz_13 | |
| lazy val cz_14 = czescitypesequence2.cz_14 | |
| lazy val cz_15 = czescitypesequence2.cz_15 | |
| lazy val cz_16 = czescitypesequence2.cz_16 | |
| lazy val cz_17 = czescitypesequence2.cz_17 | |
| lazy val cz_18 = czescitypesequence2.cz_18 | |
| lazy val cz_19 = czescitypesequence2.cz_19 | |
| lazy val cz_20 = czescitypesequence3.cz_20 | |
| lazy val cz_21 = czescitypesequence3.cz_21 | |
| lazy val cz_22 = czescitypesequence3.cz_22 | |
| lazy val cz_23 = czescitypesequence3.cz_23 | |
| lazy val cz_24 = czescitypesequence3.cz_24 | |
| lazy val cz_25 = czescitypesequence3.cz_25 | |
| lazy val cz_26 = czescitypesequence3.cz_26 | |
| lazy val cz_27 = czescitypesequence3.cz_27 | |
| lazy val cz_28 = czescitypesequence3.cz_28 | |
| lazy val cz_29 = czescitypesequence3.cz_29 | |
| lazy val cz_30 = czescitypesequence4.cz_30 | |
| lazy val cz_31 = czescitypesequence4.cz_31 | |
| lazy val cz_32 = czescitypesequence4.cz_32 | |
| lazy val cz_33 = czescitypesequence4.cz_33 | |
| lazy val cz_34 = czescitypesequence4.cz_34 | |
| lazy val cz_35 = czescitypesequence4.cz_35 | |
| lazy val cz_36 = czescitypesequence4.cz_36 | |
| lazy val cz_37 = czescitypesequence4.cz_37 | |
| lazy val cz_38 = czescitypesequence4.cz_38 | |
| lazy val cz_39 = czescitypesequence4.cz_39 | |
| lazy val cz_40 = czescitypesequence5.cz_40 | |
| lazy val cz_41 = czescitypesequence5.cz_41 | |
| lazy val cz_42 = czescitypesequence5.cz_42 | |
| lazy val cz_43 = czescitypesequence5.cz_43 | |
| lazy val cz_44 = czescitypesequence5.cz_44 | |
| lazy val cz_45 = czescitypesequence5.cz_45 | |
| lazy val cz_46 = czescitypesequence5.cz_46 | |
| lazy val cz_47 = czescitypesequence5.cz_47 | |
| lazy val cz_48 = czescitypesequence5.cz_48 | |
| lazy val cz_49 = czescitypesequence5.cz_49 | |
| lazy val cz_50 = czescitypesequence6.cz_50 | |
| lazy val cz_51 = czescitypesequence6.cz_51 | |
| lazy val cz_52 = czescitypesequence6.cz_52 | |
| lazy val cz_53 = czescitypesequence6.cz_53 | |
| lazy val cz_54 = czescitypesequence6.cz_54 | |
| lazy val cz_55 = czescitypesequence6.cz_55 | |
| lazy val cz_56 = czescitypesequence6.cz_56 | |
| lazy val cz_57 = czescitypesequence6.cz_57 | |
| lazy val cz_58 = czescitypesequence6.cz_58 | |
| lazy val cz_59 = czescitypesequence6.cz_59 | |
| lazy val cz_60 = czescitypesequence7.cz_60 | |
| lazy val cz_61 = czescitypesequence7.cz_61 | |
| lazy val cz_62 = czescitypesequence7.cz_62 | |
| lazy val cz_63 = czescitypesequence7.cz_63 | |
| lazy val cz_64 = czescitypesequence7.cz_64 | |
| lazy val cz_65 = czescitypesequence7.cz_65 | |
| lazy val cz_66 = czescitypesequence7.cz_66 | |
| lazy val cz_67 = czescitypesequence7.cz_67 | |
| lazy val cz_68 = czescitypesequence7.cz_68 | |
| lazy val cz_69 = czescitypesequence7.cz_69 | |
| lazy val cz_70 = czescitypesequence8.cz_70 | |
| lazy val cz_71 = czescitypesequence8.cz_71 | |
| lazy val cz_72 = czescitypesequence8.cz_72 | |
| lazy val cz_73 = czescitypesequence8.cz_73 | |
| lazy val cz_74 = czescitypesequence8.cz_74 | |
| lazy val cz_75 = czescitypesequence8.cz_75 | |
| lazy val cz_76 = czescitypesequence8.cz_76 | |
| lazy val cz_77 = czescitypesequence8.cz_77 | |
| lazy val cz_78 = czescitypesequence8.cz_78 | |
| } | |
| case class CzesciTypeSequence1(cz_0: models.CzType, | |
| cz_1: Option[models.CzType] = None, | |
| cz_2: Option[models.CzType] = None, | |
| cz_3: Option[models.CzType] = None, | |
| cz_4: Option[models.CzType] = None, | |
| cz_5: Option[models.CzType] = None, | |
| cz_6: Option[models.CzType] = None, | |
| cz_7: Option[models.CzType] = None, | |
| cz_8: Option[models.CzType] = None, | |
| cz_9: Option[models.CzType] = None) | |
| case class CzesciTypeSequence2(cz_10: Option[models.CzType] = None, | |
| cz_11: Option[models.CzType] = None, | |
| cz_12: Option[models.CzType] = None, | |
| cz_13: Option[models.CzType] = None, | |
| cz_14: Option[models.CzType] = None, | |
| cz_15: Option[models.CzType] = None, | |
| cz_16: Option[models.CzType] = None, | |
| cz_17: Option[models.CzType] = None, | |
| cz_18: Option[models.CzType] = None, | |
| cz_19: Option[models.CzType] = None) | |
| case class CzesciTypeSequence3(cz_20: Option[models.CzType] = None, | |
| cz_21: Option[models.CzType] = None, | |
| cz_22: Option[models.CzType] = None, | |
| cz_23: Option[models.CzType] = None, | |
| cz_24: Option[models.CzType] = None, | |
| cz_25: Option[models.CzType] = None, | |
| cz_26: Option[models.CzType] = None, | |
| cz_27: Option[models.CzType] = None, | |
| cz_28: Option[models.CzType] = None, | |
| cz_29: Option[models.CzType] = None) | |
| case class CzesciTypeSequence4(cz_30: Option[models.CzType] = None, | |
| cz_31: Option[models.CzType] = None, | |
| cz_32: Option[models.CzType] = None, | |
| cz_33: Option[models.CzType] = None, | |
| cz_34: Option[models.CzType] = None, | |
| cz_35: Option[models.CzType] = None, | |
| cz_36: Option[models.CzType] = None, | |
| cz_37: Option[models.CzType] = None, | |
| cz_38: Option[models.CzType] = None, | |
| cz_39: Option[models.CzType] = None) | |
| case class CzesciTypeSequence5(cz_40: Option[models.CzType] = None, | |
| cz_41: Option[models.CzType] = None, | |
| cz_42: Option[models.CzType] = None, | |
| cz_43: Option[models.CzType] = None, | |
| cz_44: Option[models.CzType] = None, | |
| cz_45: Option[models.CzType] = None, | |
| cz_46: Option[models.CzType] = None, | |
| cz_47: Option[models.CzType] = None, | |
| cz_48: Option[models.CzType] = None, | |
| cz_49: Option[models.CzType] = None) | |
| case class CzesciTypeSequence6(cz_50: Option[models.CzType] = None, | |
| cz_51: Option[models.CzType] = None, | |
| cz_52: Option[models.CzType] = None, | |
| cz_53: Option[models.CzType] = None, | |
| cz_54: Option[models.CzType] = None, | |
| cz_55: Option[models.CzType] = None, | |
| cz_56: Option[models.CzType] = None, | |
| cz_57: Option[models.CzType] = None, | |
| cz_58: Option[models.CzType] = None, | |
| cz_59: Option[models.CzType] = None) | |
| case class CzesciTypeSequence7(cz_60: Option[models.CzType] = None, | |
| cz_61: Option[models.CzType] = None, | |
| cz_62: Option[models.CzType] = None, | |
| cz_63: Option[models.CzType] = None, | |
| cz_64: Option[models.CzType] = None, | |
| cz_65: Option[models.CzType] = None, | |
| cz_66: Option[models.CzType] = None, | |
| cz_67: Option[models.CzType] = None, | |
| cz_68: Option[models.CzType] = None, | |
| cz_69: Option[models.CzType] = None) | |
| case class CzesciTypeSequence8(cz_70: Option[models.CzType] = None, | |
| cz_71: Option[models.CzType] = None, | |
| cz_72: Option[models.CzType] = None, | |
| cz_73: Option[models.CzType] = None, | |
| cz_74: Option[models.CzType] = None, | |
| cz_75: Option[models.CzType] = None, | |
| cz_76: Option[models.CzType] = None, | |
| cz_77: Option[models.CzType] = None, | |
| cz_78: Option[models.CzType] = None) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| package scalaxb | |
| import scala.xml.{Node, NodeSeq, NamespaceBinding, Elem, UnprefixedAttribute, PrefixedAttribute} | |
| import javax.xml.datatype.{XMLGregorianCalendar} | |
| import javax.xml.namespace.QName | |
| object `package` extends XMLStandardTypes { | |
| import annotation.implicitNotFound | |
| @implicitNotFound(msg = "Cannot find XMLFormat type class for ${A}") | |
| def fromXML[A](seq: NodeSeq, stack: List[ElemName] = Nil) | |
| (implicit format: XMLFormat[A]): A = format.reads(seq, stack) match { | |
| case Right(a) => a | |
| case Left(a) => throw new ParserFailure(a) | |
| } | |
| @implicitNotFound(msg = "Cannot find XMLFormat type class for ${A}") | |
| def fromXMLEither[A](seq: NodeSeq, stack: List[ElemName] = Nil) | |
| (implicit format: XMLFormat[A]): Either[String, A] = format.reads(seq, stack) | |
| @implicitNotFound(msg = "Cannot find CanWriteXML type class for ${A}") | |
| def toXML[A](obj: A, namespace: Option[String], elementLabel: Option[String], | |
| scope: NamespaceBinding, typeAttribute: Boolean = false)(implicit format: CanWriteXML[A]): NodeSeq = | |
| format.writes(obj, namespace, elementLabel, scope, typeAttribute) | |
| @implicitNotFound(msg = "Cannot find CanWriteXML type class for ${A}") | |
| def toXML[A](obj: A, namespace: Option[String], elementLabel: String, scope: NamespaceBinding) | |
| (implicit format: CanWriteXML[A]): NodeSeq = | |
| toXML(obj, namespace, Some(elementLabel), scope, false) | |
| @implicitNotFound(msg = "Cannot find CanWriteXML type class for ${A}") | |
| def toXML[A](obj: A, elementLabel: String, scope: NamespaceBinding)(implicit format: CanWriteXML[A]): NodeSeq = | |
| toXML(obj, None, Some(elementLabel), scope, false) | |
| /** @returns - maps from prefix to namespace URI. | |
| */ | |
| def fromScope(scope: NamespaceBinding): List[(Option[String], String)] = { | |
| def doFromScope(s: NamespaceBinding): List[(Option[String], String)] = { | |
| lazy val parentMap: List[(Option[String], String)] = Option[NamespaceBinding](s.parent) map { doFromScope | |
| } getOrElse { Nil } | |
| scalaxb.Helper.nullOrEmpty(s.uri) map { uri => (scalaxb.Helper.nullOrEmpty(s.prefix) -> uri) :: parentMap } getOrElse {parentMap} | |
| } | |
| doFromScope(scope).reverse | |
| } | |
| /** @param pairs - pairs of (prefix, namespace URI) | |
| */ | |
| def toScope(pairs: (Option[String], String)*): NamespaceBinding = | |
| pairs.reverse.foldLeft[NamespaceBinding](scala.xml.TopScope) { (scope, pair) => | |
| scala.xml.NamespaceBinding(pair._1.getOrElse{null}, pair._2, scope) } | |
| } | |
| trait XMLFormat[A] extends CanWriteXML[A] with CanReadXML[A] | |
| trait CanReadXML[A] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, A] | |
| } | |
| trait CanWriteXML[A] { | |
| def writes(obj: A, namespace: Option[String], elementLabel: Option[String], | |
| scope: NamespaceBinding, typeAttribute: Boolean): NodeSeq | |
| } | |
| trait XMLStandardTypes { | |
| implicit lazy val __NodeXMLFormat: XMLFormat[Node] = new XMLFormat[Node] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Node] = seq match { | |
| case node: Node => Right(node) | |
| case _ => Left("scala.xml.Node is required.") | |
| } | |
| def writes(obj: Node, namespace: Option[String], elementLabel: Option[String], | |
| scope: NamespaceBinding, typeAttribute: Boolean): NodeSeq = Helper.mergeNodeScope(obj, scope) | |
| } | |
| implicit lazy val __NodeSeqXMLFormat: XMLFormat[NodeSeq] = new XMLFormat[NodeSeq] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, NodeSeq] = Right(seq) | |
| def writes(obj: NodeSeq, namespace: Option[String], elementLabel: Option[String], | |
| scope: NamespaceBinding, typeAttribute: Boolean): NodeSeq = Helper.mergeNodeSeqScope(obj, scope) | |
| } | |
| implicit lazy val __ElemXMLFormat: XMLFormat[Elem] = new XMLFormat[Elem] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Elem] = seq match { | |
| case elem: Elem => Right(elem) | |
| case _ => Left("scala.xml.Elem is required.") | |
| } | |
| def writes(obj: Elem, namespace: Option[String], elementLabel: Option[String], | |
| scope: NamespaceBinding, typeAttribute: Boolean): NodeSeq = Helper.mergeNodeScope(obj, scope) | |
| } | |
| implicit lazy val __StringXMLFormat: XMLFormat[String] = new XMLFormat[String] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, String] = Right(seq.text) | |
| def writes(obj: String, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __IntXMLFormat: XMLFormat[Int] = new XMLFormat[Int] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Int] = try { | |
| Right(seq.text.toInt) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Int, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __ByteXMLFormat: XMLFormat[Byte] = new XMLFormat[Byte] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Byte] = try { | |
| Right(seq.text.toByte) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Byte, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __ShortXMLFormat: XMLFormat[Short] = new XMLFormat[Short] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Short] = try { | |
| Right(seq.text.toShort) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Short, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __LongXMLFormat: XMLFormat[Long] = new XMLFormat[Long] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Long] = try { | |
| Right(seq.text.toLong) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Long, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __BigDecimalXMLFormat: XMLFormat[BigDecimal] = new XMLFormat[BigDecimal] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, BigDecimal] = try { | |
| Right(BigDecimal(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: BigDecimal, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __BigIntXMLFormat: XMLFormat[BigInt] = new XMLFormat[BigInt] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, BigInt] = try { | |
| Right(BigInt(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: BigInt, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __FloatXMLFormat: XMLFormat[Float] = new XMLFormat[Float] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Float] = try { | |
| Right(seq.text.toFloat) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Float, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __DoubleXMLFormat: XMLFormat[Double] = new XMLFormat[Double] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Double] = try { | |
| Right(seq.text.toDouble) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Double, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __BooleanXMLFormat: XMLFormat[Boolean] = new XMLFormat[Boolean] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Boolean] = try { | |
| Right(seq.text.toBoolean) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Boolean, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __DurationXMLFormat: XMLFormat[javax.xml.datatype.Duration] = new XMLFormat[javax.xml.datatype.Duration] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, javax.xml.datatype.Duration] = | |
| try { Right(Helper.toDuration(seq.text)) } | |
| catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: javax.xml.datatype.Duration, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __CalendarXMLFormat: XMLFormat[XMLGregorianCalendar] = new XMLFormat[XMLGregorianCalendar] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, XMLGregorianCalendar] = try { | |
| Right(XMLCalendar(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: XMLGregorianCalendar, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toXMLFormat, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __GregorianCalendarXMLWriter: CanWriteXML[java.util.GregorianCalendar] = new CanWriteXML[java.util.GregorianCalendar] { | |
| def writes(obj: java.util.GregorianCalendar, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(Helper.toCalendar(obj).toXMLFormat, namespace, elementLabel, scope) | |
| } | |
| def qnameXMLFormat(scope: scala.xml.NamespaceBinding) = new XMLFormat[javax.xml.namespace.QName] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, javax.xml.namespace.QName] = | |
| seq match { | |
| case node: scala.xml.Node => | |
| val (namespace, localPart) = Helper.splitQName(node.text, scope) | |
| Right(new QName(namespace orNull, localPart)) | |
| case _ => Left("scala.xml.Node is required") | |
| } | |
| def writes(obj: javax.xml.namespace.QName, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __QNameXMLFormat: XMLFormat[javax.xml.namespace.QName] = new XMLFormat[javax.xml.namespace.QName] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, javax.xml.namespace.QName] = | |
| seq match { | |
| case node: scala.xml.Node => qnameXMLFormat(node.scope).reads(node, stack) | |
| case _ => Left("scala.xml.Node is required") | |
| } | |
| def writes(obj: javax.xml.namespace.QName, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __Base64BinaryXMLFormat: XMLFormat[Base64Binary] = new XMLFormat[Base64Binary] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Base64Binary] = try { | |
| Right(Base64Binary(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Base64Binary, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __HexBinaryXMLFormat: XMLFormat[HexBinary] = new XMLFormat[HexBinary] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, HexBinary] = try { | |
| Right(HexBinary(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: HexBinary, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit lazy val __URIXMLFormat: XMLFormat[java.net.URI] = new XMLFormat[java.net.URI] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, java.net.URI] = try { | |
| Right(Helper.toURI(seq.text)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: java.net.URI, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML(obj.toString, namespace, elementLabel, scope) | |
| } | |
| implicit def seqXMLFormat[A: XMLFormat]: XMLFormat[Seq[A]] = new XMLFormat[Seq[A]] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, Seq[A]] = try { | |
| val xs = Helper.splitBySpace(seq.text).toSeq | |
| Right(xs map { x => fromXML[A](scala.xml.Text(x), stack) }) | |
| } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: Seq[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.stringToXML((obj map { x => scalaxb.toXML(x, namespace, elementLabel, scope, typeAttribute).text }).mkString(" "), | |
| namespace, elementLabel, scope) | |
| } | |
| implicit def dataRecordFormat[A: XMLFormat]: XMLFormat[DataRecord[A]] = new XMLFormat[DataRecord[A]] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, DataRecord[A]] = seq match { | |
| case node: Node => | |
| try { | |
| Right(DataRecord(Some(node.namespace), Some(node.label), scalaxb.fromXML[A](node))) | |
| } catch { case e: Exception => Left(e.toString) } | |
| case _ => Left("scala.xml.Node is required.") | |
| } | |
| def writes(obj: DataRecord[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| DataRecord.toXML(obj, namespace, elementLabel, scope, typeAttribute) | |
| } | |
| implicit def dataRecordXMLWriter[A]: CanWriteXML[DataRecord[A]] = new CanWriteXML[DataRecord[A]] { | |
| def writes(obj: DataRecord[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| DataRecord.toXML(obj, namespace, elementLabel, scope, typeAttribute) | |
| } | |
| implicit def someXMLWriter[A: CanWriteXML]: CanWriteXML[Some[A]] = new CanWriteXML[Some[A]] { | |
| def writes(obj: Some[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scalaxb.toXML[A](obj.get, namespace, elementLabel, scope, typeAttribute) | |
| } | |
| implicit def optionXMLWriter[A: CanWriteXML]: CanWriteXML[Option[A]] = new CanWriteXML[Option[A]] { | |
| def writes(obj: Option[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = obj match { | |
| case Some(x) => scalaxb.toXML[A](x, namespace, elementLabel, scope, typeAttribute) | |
| case None => Helper.nilElem(namespace, elementLabel.get, scope) | |
| } | |
| } | |
| implicit lazy val __NoneXMLWriter: CanWriteXML[None.type] = new CanWriteXML[None.type] { | |
| def writes(obj: None.type, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Helper.nilElem(namespace, elementLabel.get, scope) | |
| } | |
| implicit lazy val __DataRecordAnyXMLFormat: XMLFormat[DataRecord[Any]] = new XMLFormat[DataRecord[Any]] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, DataRecord[Any]] = try { | |
| Right(DataRecord.fromAny(seq)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: DataRecord[Any], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| DataRecord.toXML(obj, namespace, elementLabel, scope, typeAttribute) | |
| } | |
| implicit lazy val __DataRecordOptionAnyXMLFormat: XMLFormat[DataRecord[Option[Any]]] = | |
| new XMLFormat[DataRecord[Option[Any]]] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, DataRecord[Option[Any]]] = try { | |
| Right(DataRecord.fromNillableAny(seq)) } catch { case e: Exception => Left(e.toString) } | |
| def writes(obj: DataRecord[Option[Any]], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| DataRecord.toXML(obj, namespace, elementLabel, scope, typeAttribute) | |
| } | |
| implicit lazy val __DataRecordMapWriter: CanWriteXML[Map[String, scalaxb.DataRecord[Any]]] = | |
| new CanWriteXML[Map[String, scalaxb.DataRecord[Any]]] { | |
| def writes(obj: Map[String, scalaxb.DataRecord[Any]], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| obj.valuesIterator.toList flatMap { x => | |
| scalaxb.toXML[DataRecord[Any]](x, x.namespace, x.key, scope, typeAttribute) | |
| } | |
| } | |
| } | |
| 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 | |
| }) + ")" | |
| } | |
| } | |
| 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 | |
| } | |
| } | |
| import Helper._ | |
| // this is for nil element. | |
| def apply(namespace: Option[String], key: Option[String], value: None.type): DataRecord[Option[Nothing]] = | |
| DataWriter(namespace, key, None, None, value, __NoneXMLWriter) | |
| // this is for choice option: DataRecord(x.namespace, Some(x.name), fromXML[Address](x)) | |
| def apply[A:CanWriteXML](namespace: Option[String], key: Option[String], value: A): DataRecord[A] = | |
| DataWriter(namespace, key, None, None, value, implicitly[CanWriteXML[A]]) | |
| def apply[A:CanWriteXML](node: Node, value: A): DataRecord[A] = node match { | |
| case elem: Elem => | |
| val ns = scalaxb.Helper.nullOrEmpty(elem.scope.getURI(elem.prefix)) | |
| val key = Some(elem.label) | |
| DataRecord(ns, key, value) | |
| case _ => DataRecord(value) | |
| } | |
| def apply[A:CanWriteXML](node: Node, parent: Node, value: A): DataRecord[A] = node match { | |
| case elem: Elem => DataRecord(node, value) | |
| case attr: UnprefixedAttribute => | |
| val key = Some(attr.key) | |
| DataRecord(None, key, value) | |
| case attr: PrefixedAttribute => | |
| val ns = scalaxb.Helper.nullOrEmpty(attr.getNamespace(node)) | |
| val key = Some(attr.key) | |
| DataRecord(ns, key, value) | |
| case _ => DataRecord(value) | |
| } | |
| def apply[A:CanWriteXML](value: A): DataRecord[A] = | |
| apply(None, None, value) | |
| def apply[A:CanWriteXML](namespace: Option[String], key: Option[String], | |
| xstypeNamespace: Option[String], xstypeName: Option[String], value: A): DataRecord[A] = | |
| DataWriter(namespace, key, xstypeNamespace, xstypeName, value, implicitly[CanWriteXML[A]]) | |
| // this is for any. | |
| def apply(elemName: ElemName): DataRecord[Any] = fromAny(elemName.node) | |
| def fromAny(seq: NodeSeq): DataRecord[Any] = { | |
| seq match { | |
| case elem: Elem => fromAny(elem) | |
| case _ => DataRecord(None, None, None, None, seq.text) | |
| } | |
| } | |
| def fromAny(elem: Elem): DataRecord[Any] = { | |
| val ns = scalaxb.Helper.nullOrEmpty(elem.scope.getURI(elem.prefix)) | |
| val key = Some(elem.label) | |
| val XS = Some(XML_SCHEMA_URI) | |
| instanceType(elem) match { | |
| case (XS, xstype) => | |
| xstype match { | |
| case Some("int") => DataRecord(ns, key, XS, xstype, fromXML[Int](elem, Nil)) | |
| case Some("byte") => DataRecord(ns, key, XS, xstype, fromXML[Byte](elem, Nil)) | |
| case Some("short") => DataRecord(ns, key, XS, xstype, fromXML[Short](elem, Nil)) | |
| case Some("long") => DataRecord(ns, key, XS, xstype, fromXML[Long](elem, Nil)) | |
| case Some("float") => DataRecord(ns, key, XS, xstype, fromXML[Float](elem, Nil)) | |
| case Some("double") => DataRecord(ns, key, XS, xstype, fromXML[Double](elem, Nil)) | |
| case Some("integer") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("nonPositiveInteger") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("negativeInteger") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("nonNegativeInteger") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("positiveInteger") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("unsignedLong") => DataRecord(ns, key, XS, xstype, fromXML[BigInt](elem, Nil)) | |
| case Some("unsignedInt") => DataRecord(ns, key, XS, xstype, fromXML[Long](elem, Nil)) | |
| case Some("unsignedShort") => DataRecord(ns, key, XS, xstype, fromXML[Int](elem, Nil)) | |
| case Some("unsignedByte") => DataRecord(ns, key, XS, xstype, fromXML[Int](elem, Nil)) | |
| case Some("decimal") => DataRecord(ns, key, XS, xstype, fromXML[BigDecimal](elem, Nil)) | |
| case Some("boolean") => DataRecord(ns, key, XS, xstype, fromXML[Boolean](elem, Nil)) | |
| case Some("string") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("normalizedString") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("token") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("language") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("Name") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("NCName") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("NMTOKEN") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("NMTOKENS") => DataRecord(ns, key, XS, xstype, fromXML[Seq[String]](elem, Nil)) | |
| case Some("ID") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("IDREF") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("IDREFS") => DataRecord(ns, key, XS, xstype, fromXML[Seq[String]](elem, Nil)) | |
| case Some("ENTITY") => DataRecord(ns, key, XS, xstype, fromXML[String](elem, Nil)) | |
| case Some("ENTITIES") => DataRecord(ns, key, XS, xstype, fromXML[Seq[String]](elem, Nil)) | |
| case Some("hexBinary") => DataRecord(ns, key, XS, xstype, fromXML[HexBinary](elem, Nil)) | |
| case Some("base64Binary") => DataRecord(ns, key, XS, xstype, fromXML[Base64Binary](elem, Nil)) | |
| case Some("anyURI") => DataRecord(ns, key, XS, xstype, fromXML[java.net.URI](elem, Nil)) | |
| case Some("QName") => DataRecord(ns, key, XS, xstype, fromXML[javax.xml.namespace.QName](elem, Nil)) | |
| case Some("NOTATION") => DataRecord(ns, key, XS, xstype, fromXML[javax.xml.namespace.QName](elem, Nil)) | |
| case Some("duration") => DataRecord(ns, key, XS, xstype, fromXML[javax.xml.datatype.Duration](elem, Nil)) | |
| case Some("dateTime") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("time") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("gYearMonth") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("gYear") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("gMonthDay") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("gDay") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case Some("gMonth") => DataRecord(ns, key, XS, xstype, fromXML[XMLGregorianCalendar](elem, Nil)) | |
| case _ => DataRecord(ns, key, XS, xstype, elem) | |
| } | |
| case _ => | |
| val (xsns, xstype) = instanceType(elem) | |
| DataRecord(ns, key, xsns, xstype, elem) | |
| } | |
| } | |
| // this is for any. | |
| def fromNillableAny(seq: NodeSeq): DataRecord[Option[Any]] = { | |
| seq match { | |
| case elem: Elem => fromNillableAny(elem) | |
| case _ => DataRecord(None, None, None, None, Some(seq.text)) | |
| } | |
| } | |
| // this is for any. | |
| def fromNillableAny(elem: Elem): DataRecord[Option[Any]] = { | |
| val ns = scalaxb.Helper.nullOrEmpty(elem.scope.getURI(elem.prefix)) | |
| val key = Some(elem.label) | |
| val XS = Some(XML_SCHEMA_URI) | |
| if (isNil(elem)) DataRecord(ns, key, None) | |
| else instanceType(elem) match { | |
| case (XS, xstype) => | |
| xstype match { | |
| case Some("int") => DataRecord(ns, key, XS, xstype, Some(fromXML[Int](elem, Nil))) | |
| case Some("byte") => DataRecord(ns, key, XS, xstype, Some(fromXML[Byte](elem, Nil))) | |
| case Some("short") => DataRecord(ns, key, XS, xstype, Some(fromXML[Short](elem, Nil))) | |
| case Some("long") => DataRecord(ns, key, XS, xstype, Some(fromXML[Long](elem, Nil))) | |
| case Some("float") => DataRecord(ns, key, XS, xstype, Some(fromXML[Float](elem, Nil))) | |
| case Some("double") => DataRecord(ns, key, XS, xstype, Some(fromXML[Double](elem, Nil))) | |
| case Some("integer") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("nonPositiveInteger") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("negativeInteger") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("nonNegativeInteger") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("positiveInteger") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("unsignedLong") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigInt](elem, Nil))) | |
| case Some("unsignedInt") => DataRecord(ns, key, XS, xstype, Some(fromXML[Long](elem, Nil))) | |
| case Some("unsignedShort") => DataRecord(ns, key, XS, xstype, Some(fromXML[Int](elem, Nil))) | |
| case Some("unsignedByte") => DataRecord(ns, key, XS, xstype, Some(fromXML[Int](elem, Nil))) | |
| case Some("decimal") => DataRecord(ns, key, XS, xstype, Some(fromXML[BigDecimal](elem, Nil))) | |
| case Some("boolean") => DataRecord(ns, key, XS, xstype, Some(fromXML[Boolean](elem, Nil))) | |
| case Some("string") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("normalizedString") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("token") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("language") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("Name") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("NCName") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("NMTOKEN") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("NMTOKENS") => DataRecord(ns, key, XS, xstype, Some(fromXML[Seq[String]](elem, Nil))) | |
| case Some("ID") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("IDREF") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("IDREFS") => DataRecord(ns, key, XS, xstype, Some(fromXML[Seq[String]](elem, Nil))) | |
| case Some("ENTITY") => DataRecord(ns, key, XS, xstype, Some(fromXML[String](elem, Nil))) | |
| case Some("ENTITIES") => DataRecord(ns, key, XS, xstype, Some(fromXML[Seq[String]](elem, Nil))) | |
| case Some("hexBinary") => DataRecord(ns, key, XS, xstype, Some(fromXML[HexBinary](elem, Nil))) | |
| case Some("base64Binary") => DataRecord(ns, key, XS, xstype, Some(fromXML[Base64Binary](elem, Nil))) | |
| case Some("anyURI") => DataRecord(ns, key, XS, xstype, Some(fromXML[java.net.URI](elem, Nil))) | |
| case Some("QName") => DataRecord(ns, key, XS, xstype, Some(fromXML[javax.xml.namespace.QName](elem, Nil))) | |
| case Some("NOTATION") => DataRecord(ns, key, XS, xstype, Some(fromXML[javax.xml.namespace.QName](elem, Nil))) | |
| case Some("duration") => DataRecord(ns, key, XS, xstype, Some(fromXML[javax.xml.datatype.Duration](elem, Nil))) | |
| case Some("dateTime") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("time") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("gYearMonth") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("gYear") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("gMonthDay") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("gDay") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case Some("gMonth") => DataRecord(ns, key, XS, xstype, Some(fromXML[XMLGregorianCalendar](elem, Nil))) | |
| case _ => DataRecord(ns, key, XS, xstype, Some(elem)) | |
| } | |
| case _ => | |
| val (xsns, xstype) = instanceType(elem) | |
| DataRecord(ns, key, xsns, xstype, Some(elem)) | |
| } | |
| } | |
| def unapply[A](record: DataRecord[A]): Option[(Option[String], Option[String], A)] = | |
| Some(record.namespace, record.key, record.value) | |
| def toXML[A](obj: DataRecord[A], namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = obj match { | |
| case w: DataWriter[_] => | |
| obj.value match { | |
| case seq: NodeSeq => | |
| w.writer.asInstanceOf[CanWriteXML[A]].writes(obj.value, namespace, elementLabel, scope, typeAttribute) | |
| case _ => | |
| w.writer.asInstanceOf[CanWriteXML[A]].writes(obj.value, namespace, elementLabel, scope, false) match { | |
| case elem: Elem if (w.xstypeName.isDefined && scope.getPrefix(XSI_URL) != null) => | |
| elem % scala.xml.Attribute(scope.getPrefix(Helper.XSI_URL), "type", | |
| Helper.prefixedName(w.xstypeNamespace, w.xstypeName.get, scope), scala.xml.Null) | |
| case x => x | |
| } | |
| } | |
| case _ => error("unknown DataRecord.") | |
| } | |
| } | |
| case class ElemName(namespace: Option[String], name: String) { | |
| var node: scala.xml.Node = _ | |
| def text = node.text | |
| def nil = Helper.isNil(node) | |
| def nilOption: Option[ElemName] = if (nil) None else Some(this) | |
| def splitBySpace = Helper.splitBySpace(text) | |
| override def toString = namespace match { | |
| case Some(x) => "{%s}%s".format(x, name) | |
| case _ => name | |
| } | |
| } | |
| object ElemName { | |
| implicit def apply(node: scala.xml.Node): ElemName = node match { | |
| case x: scala.xml.Elem => | |
| val elemName = ElemName(scalaxb.Helper.nullOrEmpty(x.scope.getURI(x.prefix)), x.label) | |
| elemName.node = x | |
| elemName | |
| case _ => | |
| val elemName = ElemName(None, "") | |
| elemName.node = node | |
| elemName | |
| } | |
| } | |
| trait AnyElemNameParser extends scala.util.parsing.combinator.Parsers { | |
| type Elem = ElemName | |
| // we need this so treat ElemName as NodeSeq for fromXML etc. | |
| implicit def toNodeSeq(elem: Elem): scala.xml.NodeSeq = elem.node | |
| def any(f: ElemName => Boolean): Parser[ElemName] = | |
| accept("any", { case x: ElemName if x.name != "" && f(x) => x }) | |
| def optTextRecord(implicit format: XMLFormat[String]): Parser[Option[DataRecord[Any]]] = | |
| opt(text ^^ (x => DataRecord(x.node.text)(format))) | |
| def text: Parser[ElemName] = | |
| accept("text", { case x: ElemName if x.name == "" => x }) | |
| } | |
| trait CanWriteChildNodes[A] extends CanWriteXML[A] { | |
| def targetNamespace: Option[String] | |
| def typeName: Option[String] = None | |
| def writesAttribute(obj: A, scope: scala.xml.NamespaceBinding): scala.xml.MetaData = scala.xml.Null | |
| def writesChildNodes(obj: A, scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] | |
| def writes(obj: A, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scala.xml.Elem(Helper.getPrefix(namespace, scope).orNull, | |
| elementLabel getOrElse { error("missing element label.") }, | |
| if (typeAttribute && typeName.isDefined && | |
| scope.getPrefix(Helper.XSI_URL) != null) { | |
| val attrs = writesAttribute(obj, scope) | |
| val mod = attrs remove (Helper.XSI_URL, scope, "type") | |
| scala.xml.Attribute(scope.getPrefix(Helper.XSI_URL), "type", | |
| Helper.prefixedName(targetNamespace, typeName.get, scope), mod) | |
| } | |
| else writesAttribute(obj, scope), | |
| scope, | |
| writesChildNodes(obj, scope): _*) | |
| } | |
| trait AttributeGroupFormat[A] extends scalaxb.XMLFormat[A] { | |
| def writes(__obj: A, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = error("don't call me.") | |
| def toAttribute(__obj: A, __attr: scala.xml.MetaData, __scope: scala.xml.NamespaceBinding): scala.xml.MetaData | |
| } | |
| trait ElemNameParser[A] extends AnyElemNameParser with XMLFormat[A] with CanWriteChildNodes[A] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, A] = seq match { | |
| case node: scala.xml.Node => | |
| parse(parser(node, stack), node.child) match { | |
| case x: Success[_] => Right(x.get) | |
| case x: Failure => Left(parserErrorMsg(x.msg, x.next, ElemName(node) :: stack)) | |
| case x: Error => Left(parserErrorMsg(x.msg, node)) | |
| } | |
| case _ => Left("seq must be scala.xml.Node") | |
| } | |
| private def parserErrorMsg(msg: String, next: scala.util.parsing.input.Reader[Elem], stack: List[ElemName]): String = | |
| if (msg contains "paser error ") msg | |
| else "parser error \"" + msg + "\" while parsing " + stack.reverse.mkString("/", "/", "/") + next.pos.longString | |
| private def parserErrorMsg(msg: String, node: scala.xml.Node): String = | |
| if (msg contains "paser error ") msg | |
| else "parser error \"" + msg + "\" while parsing " + node.toString | |
| def parser(node: scala.xml.Node, stack: List[ElemName]): Parser[A] | |
| def isMixed: Boolean = false | |
| def parse[A](p: Parser[A], in: Seq[scala.xml.Node]): ParseResult[A] = | |
| p(new ElemNameSeqReader(elementNames(in))) | |
| def elementNames(in: Seq[scala.xml.Node]): Seq[ElemName] = | |
| if (isMixed) in map { x => ElemName(x) } | |
| else in collect { case x: scala.xml.Elem => ElemName(x) } | |
| } | |
| class ElemNameSeqReader(seq: Seq[ElemName], | |
| override val offset: Int) extends scala.util.parsing.input.Reader[ElemName] { | |
| import scala.util.parsing.input._ | |
| def this(seq: Seq[ElemName]) = this(seq, 0) | |
| override def first: ElemName = | |
| if (seq.isDefinedAt(offset)) seq(offset) | |
| else null | |
| def rest: ElemNameSeqReader = | |
| if (seq.isDefinedAt(offset)) new ElemNameSeqReader(seq, offset + 1) | |
| else this | |
| def pos: Position = new ElemNameSeqPosition(seq, offset) | |
| def atEnd = !seq.isDefinedAt(offset) | |
| override def drop(n: Int): ElemNameSeqReader = | |
| new ElemNameSeqReader(seq, offset + n) | |
| } | |
| class ElemNameSeqPosition(val source: Seq[ElemName], val offset: Int) extends | |
| scala.util.parsing.input.Position { | |
| protected def lineContents = | |
| source.mkString | |
| override def line = 1 | |
| override def column = offset + 1 | |
| } | |
| class HexBinary(_vector: Vector[Byte]) extends scala.collection.IndexedSeq[Byte] { | |
| private val vector = _vector | |
| def length = vector.length | |
| def apply(idx: Int): Byte = vector(idx) | |
| override def toString: String = | |
| (vector map { x => ("0" + Integer.toHexString(x.toInt)).takeRight(2) }).mkString.toUpperCase | |
| def toIndexedSeq: IndexedSeq[Byte] = vector | |
| } | |
| object HexBinary { | |
| def apply(xs: Byte*): HexBinary = { | |
| import scala.collection.breakOut | |
| val vector: Vector[Byte] = (xs.toIndexedSeq map {x: Byte => x})(breakOut) | |
| new HexBinary(vector) | |
| } | |
| def apply(value: String): HexBinary = { | |
| val array = new Array[Byte](value.length / 2) | |
| for (i <- 0 to array.length - 1) { | |
| array(i) = Integer.parseInt(value.drop(i * 2).take(2), 16).toByte | |
| } | |
| apply(array: _*) | |
| } | |
| def unapplySeq[Byte](x: HexBinary) = Some(x.toIndexedSeq) | |
| } | |
| class Base64Binary(_vector: Vector[Byte]) extends scala.collection.IndexedSeq[Byte] { | |
| private val vector = _vector | |
| def length = vector.length | |
| def apply(idx: Int): Byte = vector(idx) | |
| override def toString: String = (new sun.misc.BASE64Encoder()).encodeBuffer(vector.toArray).stripLineEnd | |
| def toIndexedSeq: IndexedSeq[Byte] = vector | |
| } | |
| object Base64Binary { | |
| def apply(xs: Byte*): Base64Binary = { | |
| import scala.collection.breakOut | |
| val vector: Vector[Byte] = (xs.toIndexedSeq map {x: Byte => x})(breakOut) | |
| new Base64Binary(vector) | |
| } | |
| def apply(value: String): Base64Binary = { | |
| val array = (new sun.misc.BASE64Decoder()).decodeBuffer(value) | |
| apply(array: _*) | |
| } | |
| def unapplySeq[Byte](x: Base64Binary) = Some(x.toIndexedSeq) | |
| } | |
| object XMLCalendar { | |
| def apply(value: String): XMLGregorianCalendar = Helper.toCalendar(value) | |
| def unapply(value: XMLGregorianCalendar): Option[String] = Some(value.toXMLFormat) | |
| } | |
| object Helper { | |
| val XML_SCHEMA_URI = "http://www.w3.org/2001/XMLSchema" | |
| val XSI_URL = "http://www.w3.org/2001/XMLSchema-instance" | |
| val XSI_PREFIX = "xsi" | |
| def toString(value: QName, scope: NamespaceBinding): String = | |
| Option[String](scope.getPrefix(value.getNamespaceURI)) map { | |
| "%s:%s" format (_, value.getLocalPart)} getOrElse {value.getLocalPart} | |
| def toCalendar(value: String): XMLGregorianCalendar = { | |
| import javax.xml.datatype._ | |
| val typeFactory = javax.xml.datatype.DatatypeFactory.newInstance() | |
| typeFactory.newXMLGregorianCalendar(value) | |
| } | |
| def toCalendar(value: java.util.GregorianCalendar): XMLGregorianCalendar = { | |
| import javax.xml.datatype._ | |
| import java.util.{GregorianCalendar, Calendar => JCalendar} | |
| val typeFactory = javax.xml.datatype.DatatypeFactory.newInstance() | |
| val xmlGregorian = typeFactory.newXMLGregorianCalendar() | |
| if (value.getTimeZone != null) { | |
| xmlGregorian.setTimezone(value.getTimeZone.getRawOffset / 60000) | |
| } | |
| if (value.isSet(JCalendar.YEAR)) xmlGregorian.setYear(if (value.get(JCalendar.ERA) == GregorianCalendar.AD) value.get(JCalendar.YEAR) else -value.get(JCalendar.YEAR)) | |
| if (value.isSet(JCalendar.MONTH)) xmlGregorian.setMonth(value.get(JCalendar.MONTH) - JCalendar.JANUARY + DatatypeConstants.JANUARY) | |
| if (value.isSet(JCalendar.DAY_OF_MONTH)) xmlGregorian.setDay(value.get(JCalendar.DAY_OF_MONTH)) | |
| if (value.isSet(JCalendar.HOUR_OF_DAY)) xmlGregorian.setHour(value.get(JCalendar.HOUR_OF_DAY)) | |
| if (value.isSet(JCalendar.MINUTE)) xmlGregorian.setMinute(value.get(JCalendar.MINUTE)) | |
| if (value.isSet(JCalendar.SECOND)) xmlGregorian.setSecond(value.get(JCalendar.SECOND)) | |
| if (value.isSet(JCalendar.MILLISECOND) && value.get(JCalendar.MILLISECOND) > 0) xmlGregorian.setFractionalSecond(new java.math.BigDecimal(value.get(JCalendar.MILLISECOND))) | |
| xmlGregorian | |
| } | |
| def toDuration(value: String) = { | |
| val typeFactory = javax.xml.datatype.DatatypeFactory.newInstance() | |
| typeFactory.newDuration(value) | |
| } | |
| def toURI(value: String) = | |
| java.net.URI.create(value) | |
| def isNil(node: scala.xml.Node) = | |
| (node \ ("@{" + XSI_URL + "}nil")).headOption map { _.text == "true" } getOrElse { | |
| false | |
| } | |
| def nilElem(namespace: Option[String], elementLabel: String, | |
| scope: scala.xml.NamespaceBinding) = | |
| scala.xml.Elem(getPrefix(namespace, scope).orNull, elementLabel, | |
| scala.xml.Attribute(scope.getPrefix(XSI_URL), "nil", "true", scala.xml.Null), | |
| scope, Nil: _*) | |
| def splitBySpace(text: String) = text.split(' ').filter("" !=) | |
| def instanceType(node: scala.xml.Node): (Option[String], Option[String]) = { | |
| val typeName = (node \ ("@{" + XSI_URL + "}type")).text | |
| val prefix = if (typeName.contains(':')) Some(typeName.dropRight(typeName.length - typeName.indexOf(':'))) | |
| else None | |
| val namespace = scalaxb.Helper.nullOrEmpty(node.scope.getURI(prefix.orNull)) | |
| val value = if (typeName.contains(':')) typeName.drop(typeName.indexOf(':') + 1) | |
| else typeName | |
| (namespace, if (value == "") None else Some(value)) | |
| } | |
| def splitQName(value: String, scope: scala.xml.NamespaceBinding): (Option[String], String) = | |
| if (value startsWith "{") { | |
| val qname = javax.xml.namespace.QName.valueOf(value) | |
| (nullOrEmpty(qname.getNamespaceURI), qname.getLocalPart) | |
| } | |
| else if (value contains ':') { | |
| val prefix = value.dropRight(value.length - value.indexOf(':')) | |
| val localPart = value.drop(value.indexOf(':') + 1) | |
| (nullOrEmpty(scope.getURI(prefix)), localPart) | |
| } | |
| else (nullOrEmpty(scope.getURI(null)), value) | |
| def nullOrEmpty(value: String): Option[String] = | |
| value match { | |
| case null | "" => None | |
| case x => Some(x) | |
| } | |
| def getPrefix(namespace: Option[String], scope: scala.xml.NamespaceBinding) = | |
| if (nullOrEmpty(scope.getURI(null)) == namespace) None | |
| else nullOrEmpty(scope.getPrefix(namespace.orNull)) | |
| def prefixedName(namespace: Option[String], name: String, scope: scala.xml.NamespaceBinding) = | |
| getPrefix(namespace, scope) map { """%s:%s""" format(_, name) | |
| } getOrElse {name} | |
| def stringToXML(obj: String, namespace: Option[String], elementLabel: Option[String], | |
| scope: scala.xml.NamespaceBinding): scala.xml.NodeSeq = { | |
| elementLabel map { label => | |
| scala.xml.Elem(getPrefix(namespace, scope).orNull, label, | |
| scala.xml.Null, | |
| scope, scala.xml.Text(obj.toString)) | |
| } getOrElse { scala.xml.Text(obj) } | |
| } | |
| // assume outer scope | |
| def mergeNodeSeqScope(nodeseq: NodeSeq, outer: NamespaceBinding): NodeSeq = | |
| nodeseq.toSeq flatMap { mergeNodeScope(_, outer) } | |
| // assume outer scope | |
| def mergeNodeScope(node: Node, outer: NamespaceBinding): Node = | |
| node match { | |
| case elem: Elem => | |
| withInnerScope(elem.scope, outer) { (innerScope, mapping) => | |
| val newPrefix: String = mapping.get(scalaxb.Helper.nullOrEmpty(elem.prefix)) map {_.orNull} getOrElse {elem.prefix} | |
| val newChild = mergeNodeSeqScope(mergeNodeSeqScope(elem.child, outer), innerScope) | |
| elem.copy(scope = innerScope, prefix = newPrefix, child = newChild) | |
| } | |
| case _ => node | |
| } | |
| def withInnerScope[A](scope: NamespaceBinding, outer: NamespaceBinding) | |
| (f: (NamespaceBinding, Map[Option[String], Option[String]]) => A): A = { | |
| val outerList = fromScope(outer) | |
| def renamePrefix(prefix: Option[String], n: Int): Option[String] = | |
| if (outerList exists { case (p, n) => p == Some((prefix getOrElse {"ns"}) + n.toString)}) renamePrefix(prefix, n + 1) | |
| else Some((prefix getOrElse {"ns"}) + n.toString) | |
| val xs: List[((Option[String], String), (Option[String], Option[String]))] = fromScope(scope) flatMap { | |
| case (prefix, ns) if outerList contains (prefix -> ns) => None | |
| case (prefix, ns) if outerList exists { case (p, n) => p == prefix && p.isDefined } => | |
| val renamed = renamePrefix(prefix, 2) | |
| Some((renamed -> ns, prefix -> renamed)) | |
| case (prefix, ns) => Some((prefix -> ns, prefix -> prefix)) | |
| } | |
| f(toScope(xs map {_._1}: _*), Map(xs map {_._2}: _*)) | |
| } | |
| } | |
| class ParserFailure(message: String) extends RuntimeException(message) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by <a href="http://scalaxb.org/">scalaxb</a>. | |
| package models | |
| trait YesNoType | |
| object YesNoType { | |
| def fromString(value: String): YesNoType = value match { | |
| case "T" => T | |
| case "N" => N | |
| } | |
| } | |
| case object T extends YesNoType { override def toString = "T" } | |
| case object N extends YesNoType { override def toString = "N" } | |
| trait Kod_walType | |
| object Kod_walType { | |
| def fromString(value: String): Kod_walType = value match { | |
| case "0" => Number0 | |
| case "1" => Number1 | |
| } | |
| } | |
| case object Number0 extends Kod_walType { override def toString = "0" } | |
| case object Number1 extends Kod_walType { override def toString = "1" } | |
| trait WalutaType | |
| object WalutaType { | |
| def fromString(value: String): WalutaType = value match { | |
| case "PLN" => PLN | |
| case "EUR" => EUR | |
| } | |
| } | |
| case object PLN extends WalutaType { override def toString = "PLN" } | |
| case object EUR extends WalutaType { override def toString = "EUR" } | |
| trait Rodz_zamType | |
| object Rodz_zamType { | |
| def fromString(value: String): Rodz_zamType = value match { | |
| case "D" => D | |
| case "U" => U | |
| case "B" => B | |
| } | |
| } | |
| case object D extends Rodz_zamType { override def toString = "D" } | |
| case object U extends Rodz_zamType { override def toString = "U" } | |
| case object B extends Rodz_zamType { override def toString = "B" } | |
| case class CzZmianyType(miejsce: String, | |
| jest: Option[String] = None, | |
| ma: Option[String] = None) | |
| case class ZmianyType(cz_0: models.CzZmianyType, | |
| cz_1: Option[models.CzZmianyType] = None, | |
| cz_2: Option[models.CzZmianyType] = None, | |
| cz_3: Option[models.CzZmianyType] = None, | |
| cz_4: Option[models.CzZmianyType] = None, | |
| cz_5: Option[models.CzZmianyType] = None, | |
| cz_6: Option[models.CzZmianyType] = None, | |
| cz_7: Option[models.CzZmianyType] = None, | |
| cz_8: Option[models.CzZmianyType] = None, | |
| cz_9: Option[models.CzZmianyType] = None) | |
| case class CzDodaneType(miejsce: String, | |
| dodac: String) | |
| case class DodaneType(cz_0: models.CzDodaneType, | |
| cz_1: Option[models.CzDodaneType] = None, | |
| cz_2: Option[models.CzDodaneType] = None, | |
| cz_3: Option[models.CzDodaneType] = None, | |
| cz_4: Option[models.CzDodaneType] = None) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by <a href="http://scalaxb.org/">scalaxb</a>. | |
| package models | |
| case class WykonawcaType(nazwa_wyk: String, | |
| adres: String, | |
| miejsc: String, | |
| kod: Option[String] = None, | |
| wojew: Byte, | |
| wojewodztwo: String, | |
| cena: Option[String] = None, | |
| cena_min: Option[String] = None, | |
| cena_max: Option[String] = None, | |
| kod_wal: Option[Byte] = None, | |
| waluta: Option[String] = None) | |
| case class WykonawcyType(wykonawca_0: models.WykonawcaType, | |
| wykonawca_1: Option[models.WykonawcaType] = None, | |
| wykonawca_2: Option[models.WykonawcaType] = None, | |
| wykonawca_3: Option[models.WykonawcaType] = None, | |
| wykonawca_4: Option[models.WykonawcaType] = None, | |
| wykonawca_5: Option[models.WykonawcaType] = None) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by <a href="http://scalaxb.org/">scalaxb</a>. | |
| package zpProtocol | |
| /** | |
| usage: | |
| val obj = scalaxb.fromXML[zpProtocol.Foo](node) | |
| val document = scalaxb.toXML[zpProtocol.Foo](obj, "foo", zpProtocol.defaultScope) | |
| **/ | |
| object `package` extends XMLProtocol { } | |
| trait XMLProtocol extends scalaxb.XMLStandardTypes { | |
| val defaultScope = scalaxb.toScope(Some("xs") -> "http://www.w3.org/2001/XMLSchema", | |
| Some("xsi") -> "http://www.w3.org/2001/XMLSchema-instance") | |
| implicit lazy val ModelsCzTypeFormat: scalaxb.XMLFormat[models.CzType] = new DefaultModelsCzTypeFormat {} | |
| implicit lazy val ModelsCzesciTypeFormat: scalaxb.XMLFormat[models.CzesciType] = new DefaultModelsCzesciTypeFormat {} | |
| implicit lazy val ModelsCzesciTypeSequence1Format: scalaxb.XMLFormat[models.CzesciTypeSequence1] = new DefaultModelsCzesciTypeSequence1Format {} | |
| implicit lazy val ModelsCzesciTypeSequence2Format: scalaxb.XMLFormat[models.CzesciTypeSequence2] = new DefaultModelsCzesciTypeSequence2Format {} | |
| implicit lazy val ModelsCzesciTypeSequence3Format: scalaxb.XMLFormat[models.CzesciTypeSequence3] = new DefaultModelsCzesciTypeSequence3Format {} | |
| implicit lazy val ModelsCzesciTypeSequence4Format: scalaxb.XMLFormat[models.CzesciTypeSequence4] = new DefaultModelsCzesciTypeSequence4Format {} | |
| implicit lazy val ModelsCzesciTypeSequence5Format: scalaxb.XMLFormat[models.CzesciTypeSequence5] = new DefaultModelsCzesciTypeSequence5Format {} | |
| implicit lazy val ModelsCzesciTypeSequence6Format: scalaxb.XMLFormat[models.CzesciTypeSequence6] = new DefaultModelsCzesciTypeSequence6Format {} | |
| implicit lazy val ModelsCzesciTypeSequence7Format: scalaxb.XMLFormat[models.CzesciTypeSequence7] = new DefaultModelsCzesciTypeSequence7Format {} | |
| implicit lazy val ModelsCzesciTypeSequence8Format: scalaxb.XMLFormat[models.CzesciTypeSequence8] = new DefaultModelsCzesciTypeSequence8Format {} | |
| implicit lazy val ModelsWykonawcaTypeFormat: scalaxb.XMLFormat[models.WykonawcaType] = new DefaultModelsWykonawcaTypeFormat {} | |
| implicit lazy val ModelsWykonawcyTypeFormat: scalaxb.XMLFormat[models.WykonawcyType] = new DefaultModelsWykonawcyTypeFormat {} | |
| implicit lazy val ModelsZpBaseTypeFormat: scalaxb.XMLFormat[models.ZpBaseType] = new DefaultModelsZpBaseTypeFormat {} | |
| implicit lazy val ModelsYesNoTypeFormat: scalaxb.XMLFormat[models.YesNoType] = new DefaultModelsYesNoTypeFormat {} | |
| implicit lazy val ModelsKod_walTypeFormat: scalaxb.XMLFormat[models.Kod_walType] = new DefaultModelsKod_walTypeFormat {} | |
| implicit lazy val ModelsWalutaTypeFormat: scalaxb.XMLFormat[models.WalutaType] = new DefaultModelsWalutaTypeFormat {} | |
| implicit lazy val ModelsRodz_zamTypeFormat: scalaxb.XMLFormat[models.Rodz_zamType] = new DefaultModelsRodz_zamTypeFormat {} | |
| implicit lazy val ModelsCzZmianyTypeFormat: scalaxb.XMLFormat[models.CzZmianyType] = new DefaultModelsCzZmianyTypeFormat {} | |
| implicit lazy val ModelsZmianyTypeFormat: scalaxb.XMLFormat[models.ZmianyType] = new DefaultModelsZmianyTypeFormat {} | |
| implicit lazy val ModelsCzDodaneTypeFormat: scalaxb.XMLFormat[models.CzDodaneType] = new DefaultModelsCzDodaneTypeFormat {} | |
| implicit lazy val ModelsDodaneTypeFormat: scalaxb.XMLFormat[models.DodaneType] = new DefaultModelsDodaneTypeFormat {} | |
| trait DefaultModelsCzTypeFormat extends scalaxb.ElemNameParser[models.CzType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("czType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.CzType] = | |
| phrase((scalaxb.ElemName(None, "wykonawcy")) ~ | |
| opt(scalaxb.ElemName(None, "nazwa")) ~ | |
| opt(scalaxb.ElemName(None, "nr_czesci_1")) ~ | |
| opt(scalaxb.ElemName(None, "data_zam")) ~ | |
| opt(scalaxb.ElemName(None, "liczba_ofert")) ~ | |
| opt(scalaxb.ElemName(None, "liczba_odrzuconych_ofert")) ~ | |
| opt(scalaxb.ElemName(None, "wartosc")) ~ | |
| opt(scalaxb.ElemName(None, "cena")) ~ | |
| opt(scalaxb.ElemName(None, "cena_min")) ~ | |
| opt(scalaxb.ElemName(None, "cena_max")) ~ | |
| opt(scalaxb.ElemName(None, "kod_wal")) ~ | |
| opt(any(_ => true)) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 ~ p11 ~ p12 => | |
| models.CzType(scalaxb.fromXML[models.WykonawcyType](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[Byte](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[Byte](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p11.headOption map { scalaxb.fromXML[models.Kod_walType](_, scalaxb.ElemName(node) :: stack) }, | |
| p12.headOption map { scalaxb.fromXML[scalaxb.DataRecord[Any]](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.CzType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[models.WykonawcyType](__obj.wykonawcy, None, Some("wykonawcy"), __scope, false), | |
| __obj.nazwa map { scalaxb.toXML[String](_, None, Some("nazwa"), __scope, false) } getOrElse {Nil}, | |
| __obj.nr_czesci_1 map { scalaxb.toXML[String](_, None, Some("nr_czesci_1"), __scope, false) } getOrElse {Nil}, | |
| __obj.data_zam map { scalaxb.toXML[String](_, None, Some("data_zam"), __scope, false) } getOrElse {Nil}, | |
| __obj.liczba_ofert map { scalaxb.toXML[Byte](_, None, Some("liczba_ofert"), __scope, false) } getOrElse {Nil}, | |
| __obj.liczba_odrzuconych_ofert map { scalaxb.toXML[Byte](_, None, Some("liczba_odrzuconych_ofert"), __scope, false) } getOrElse {Nil}, | |
| __obj.wartosc map { scalaxb.toXML[String](_, None, Some("wartosc"), __scope, false) } getOrElse {Nil}, | |
| __obj.cena map { scalaxb.toXML[String](_, None, Some("cena"), __scope, false) } getOrElse {Nil}, | |
| __obj.cena_min map { scalaxb.toXML[String](_, None, Some("cena_min"), __scope, false) } getOrElse {Nil}, | |
| __obj.cena_max map { scalaxb.toXML[String](_, None, Some("cena_max"), __scope, false) } getOrElse {Nil}, | |
| __obj.kod_wal map { scalaxb.toXML[models.Kod_walType](_, None, Some("kod_wal"), __scope, false) } getOrElse {Nil}, | |
| __obj.walutaType map { x => scalaxb.toXML[scalaxb.DataRecord[Any]](x, x.namespace, x.key, __scope, true) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeFormat extends scalaxb.ElemNameParser[models.CzesciType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("czesciType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.CzesciType] = | |
| phrase((((scalaxb.ElemName(None, "cz_0")) ~ | |
| opt(scalaxb.ElemName(None, "cz_1")) ~ | |
| opt(scalaxb.ElemName(None, "cz_2")) ~ | |
| opt(scalaxb.ElemName(None, "cz_3")) ~ | |
| opt(scalaxb.ElemName(None, "cz_4")) ~ | |
| opt(scalaxb.ElemName(None, "cz_5")) ~ | |
| opt(scalaxb.ElemName(None, "cz_6")) ~ | |
| opt(scalaxb.ElemName(None, "cz_7")) ~ | |
| opt(scalaxb.ElemName(None, "cz_8")) ~ | |
| opt(scalaxb.ElemName(None, "cz_9"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence1(scalaxb.fromXML[models.CzType](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_10")) ~ | |
| opt(scalaxb.ElemName(None, "cz_11")) ~ | |
| opt(scalaxb.ElemName(None, "cz_12")) ~ | |
| opt(scalaxb.ElemName(None, "cz_13")) ~ | |
| opt(scalaxb.ElemName(None, "cz_14")) ~ | |
| opt(scalaxb.ElemName(None, "cz_15")) ~ | |
| opt(scalaxb.ElemName(None, "cz_16")) ~ | |
| opt(scalaxb.ElemName(None, "cz_17")) ~ | |
| opt(scalaxb.ElemName(None, "cz_18")) ~ | |
| opt(scalaxb.ElemName(None, "cz_19"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence2(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_20")) ~ | |
| opt(scalaxb.ElemName(None, "cz_21")) ~ | |
| opt(scalaxb.ElemName(None, "cz_22")) ~ | |
| opt(scalaxb.ElemName(None, "cz_23")) ~ | |
| opt(scalaxb.ElemName(None, "cz_24")) ~ | |
| opt(scalaxb.ElemName(None, "cz_25")) ~ | |
| opt(scalaxb.ElemName(None, "cz_26")) ~ | |
| opt(scalaxb.ElemName(None, "cz_27")) ~ | |
| opt(scalaxb.ElemName(None, "cz_28")) ~ | |
| opt(scalaxb.ElemName(None, "cz_29"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence3(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_30")) ~ | |
| opt(scalaxb.ElemName(None, "cz_31")) ~ | |
| opt(scalaxb.ElemName(None, "cz_32")) ~ | |
| opt(scalaxb.ElemName(None, "cz_33")) ~ | |
| opt(scalaxb.ElemName(None, "cz_34")) ~ | |
| opt(scalaxb.ElemName(None, "cz_35")) ~ | |
| opt(scalaxb.ElemName(None, "cz_36")) ~ | |
| opt(scalaxb.ElemName(None, "cz_37")) ~ | |
| opt(scalaxb.ElemName(None, "cz_38")) ~ | |
| opt(scalaxb.ElemName(None, "cz_39"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence4(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_40")) ~ | |
| opt(scalaxb.ElemName(None, "cz_41")) ~ | |
| opt(scalaxb.ElemName(None, "cz_42")) ~ | |
| opt(scalaxb.ElemName(None, "cz_43")) ~ | |
| opt(scalaxb.ElemName(None, "cz_44")) ~ | |
| opt(scalaxb.ElemName(None, "cz_45")) ~ | |
| opt(scalaxb.ElemName(None, "cz_46")) ~ | |
| opt(scalaxb.ElemName(None, "cz_47")) ~ | |
| opt(scalaxb.ElemName(None, "cz_48")) ~ | |
| opt(scalaxb.ElemName(None, "cz_49"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence5(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_50")) ~ | |
| opt(scalaxb.ElemName(None, "cz_51")) ~ | |
| opt(scalaxb.ElemName(None, "cz_52")) ~ | |
| opt(scalaxb.ElemName(None, "cz_53")) ~ | |
| opt(scalaxb.ElemName(None, "cz_54")) ~ | |
| opt(scalaxb.ElemName(None, "cz_55")) ~ | |
| opt(scalaxb.ElemName(None, "cz_56")) ~ | |
| opt(scalaxb.ElemName(None, "cz_57")) ~ | |
| opt(scalaxb.ElemName(None, "cz_58")) ~ | |
| opt(scalaxb.ElemName(None, "cz_59"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence6(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_60")) ~ | |
| opt(scalaxb.ElemName(None, "cz_61")) ~ | |
| opt(scalaxb.ElemName(None, "cz_62")) ~ | |
| opt(scalaxb.ElemName(None, "cz_63")) ~ | |
| opt(scalaxb.ElemName(None, "cz_64")) ~ | |
| opt(scalaxb.ElemName(None, "cz_65")) ~ | |
| opt(scalaxb.ElemName(None, "cz_66")) ~ | |
| opt(scalaxb.ElemName(None, "cz_67")) ~ | |
| opt(scalaxb.ElemName(None, "cz_68")) ~ | |
| opt(scalaxb.ElemName(None, "cz_69"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => models.CzesciTypeSequence7(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ~ | |
| ((opt(scalaxb.ElemName(None, "cz_70")) ~ | |
| opt(scalaxb.ElemName(None, "cz_71")) ~ | |
| opt(scalaxb.ElemName(None, "cz_72")) ~ | |
| opt(scalaxb.ElemName(None, "cz_73")) ~ | |
| opt(scalaxb.ElemName(None, "cz_74")) ~ | |
| opt(scalaxb.ElemName(None, "cz_75")) ~ | |
| opt(scalaxb.ElemName(None, "cz_76")) ~ | |
| opt(scalaxb.ElemName(None, "cz_77")) ~ | |
| opt(scalaxb.ElemName(None, "cz_78"))) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 => models.CzesciTypeSequence8(p1.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p2.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzType](_, scalaxb.ElemName(node) :: stack) }) }) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 => | |
| models.CzesciType(p1, | |
| p2, | |
| p3, | |
| p4, | |
| p5, | |
| p6, | |
| p7, | |
| p8) }) | |
| def writesChildNodes(__obj: models.CzesciType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[models.CzesciTypeSequence1](__obj.czescitypesequence1, None, Some("czescitypesequence1"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence2](__obj.czescitypesequence2, None, Some("czescitypesequence2"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence3](__obj.czescitypesequence3, None, Some("czescitypesequence3"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence4](__obj.czescitypesequence4, None, Some("czescitypesequence4"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence5](__obj.czescitypesequence5, None, Some("czescitypesequence5"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence6](__obj.czescitypesequence6, None, Some("czescitypesequence6"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence7](__obj.czescitypesequence7, None, Some("czescitypesequence7"), __scope, false), | |
| scalaxb.toXML[models.CzesciTypeSequence8](__obj.czescitypesequence8, None, Some("czescitypesequence8"), __scope, false)) | |
| } | |
| trait DefaultModelsCzesciTypeSequence1Format extends scalaxb.XMLFormat[models.CzesciTypeSequence1] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence1] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence1, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(scalaxb.toXML[models.CzType](__obj.cz_0, None, Some("cz_0"), __scope, false), | |
| __obj.cz_1 map { scalaxb.toXML[models.CzType](_, None, Some("cz_1"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_2 map { scalaxb.toXML[models.CzType](_, None, Some("cz_2"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_3 map { scalaxb.toXML[models.CzType](_, None, Some("cz_3"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_4 map { scalaxb.toXML[models.CzType](_, None, Some("cz_4"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_5 map { scalaxb.toXML[models.CzType](_, None, Some("cz_5"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_6 map { scalaxb.toXML[models.CzType](_, None, Some("cz_6"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_7 map { scalaxb.toXML[models.CzType](_, None, Some("cz_7"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_8 map { scalaxb.toXML[models.CzType](_, None, Some("cz_8"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_9 map { scalaxb.toXML[models.CzType](_, None, Some("cz_9"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence2Format extends scalaxb.XMLFormat[models.CzesciTypeSequence2] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence2] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence2, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_10 map { scalaxb.toXML[models.CzType](_, None, Some("cz_10"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_11 map { scalaxb.toXML[models.CzType](_, None, Some("cz_11"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_12 map { scalaxb.toXML[models.CzType](_, None, Some("cz_12"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_13 map { scalaxb.toXML[models.CzType](_, None, Some("cz_13"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_14 map { scalaxb.toXML[models.CzType](_, None, Some("cz_14"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_15 map { scalaxb.toXML[models.CzType](_, None, Some("cz_15"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_16 map { scalaxb.toXML[models.CzType](_, None, Some("cz_16"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_17 map { scalaxb.toXML[models.CzType](_, None, Some("cz_17"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_18 map { scalaxb.toXML[models.CzType](_, None, Some("cz_18"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_19 map { scalaxb.toXML[models.CzType](_, None, Some("cz_19"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence3Format extends scalaxb.XMLFormat[models.CzesciTypeSequence3] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence3] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence3, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_20 map { scalaxb.toXML[models.CzType](_, None, Some("cz_20"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_21 map { scalaxb.toXML[models.CzType](_, None, Some("cz_21"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_22 map { scalaxb.toXML[models.CzType](_, None, Some("cz_22"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_23 map { scalaxb.toXML[models.CzType](_, None, Some("cz_23"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_24 map { scalaxb.toXML[models.CzType](_, None, Some("cz_24"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_25 map { scalaxb.toXML[models.CzType](_, None, Some("cz_25"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_26 map { scalaxb.toXML[models.CzType](_, None, Some("cz_26"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_27 map { scalaxb.toXML[models.CzType](_, None, Some("cz_27"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_28 map { scalaxb.toXML[models.CzType](_, None, Some("cz_28"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_29 map { scalaxb.toXML[models.CzType](_, None, Some("cz_29"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence4Format extends scalaxb.XMLFormat[models.CzesciTypeSequence4] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence4] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence4, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_30 map { scalaxb.toXML[models.CzType](_, None, Some("cz_30"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_31 map { scalaxb.toXML[models.CzType](_, None, Some("cz_31"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_32 map { scalaxb.toXML[models.CzType](_, None, Some("cz_32"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_33 map { scalaxb.toXML[models.CzType](_, None, Some("cz_33"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_34 map { scalaxb.toXML[models.CzType](_, None, Some("cz_34"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_35 map { scalaxb.toXML[models.CzType](_, None, Some("cz_35"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_36 map { scalaxb.toXML[models.CzType](_, None, Some("cz_36"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_37 map { scalaxb.toXML[models.CzType](_, None, Some("cz_37"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_38 map { scalaxb.toXML[models.CzType](_, None, Some("cz_38"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_39 map { scalaxb.toXML[models.CzType](_, None, Some("cz_39"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence5Format extends scalaxb.XMLFormat[models.CzesciTypeSequence5] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence5] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence5, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_40 map { scalaxb.toXML[models.CzType](_, None, Some("cz_40"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_41 map { scalaxb.toXML[models.CzType](_, None, Some("cz_41"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_42 map { scalaxb.toXML[models.CzType](_, None, Some("cz_42"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_43 map { scalaxb.toXML[models.CzType](_, None, Some("cz_43"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_44 map { scalaxb.toXML[models.CzType](_, None, Some("cz_44"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_45 map { scalaxb.toXML[models.CzType](_, None, Some("cz_45"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_46 map { scalaxb.toXML[models.CzType](_, None, Some("cz_46"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_47 map { scalaxb.toXML[models.CzType](_, None, Some("cz_47"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_48 map { scalaxb.toXML[models.CzType](_, None, Some("cz_48"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_49 map { scalaxb.toXML[models.CzType](_, None, Some("cz_49"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence6Format extends scalaxb.XMLFormat[models.CzesciTypeSequence6] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence6] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence6, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_50 map { scalaxb.toXML[models.CzType](_, None, Some("cz_50"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_51 map { scalaxb.toXML[models.CzType](_, None, Some("cz_51"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_52 map { scalaxb.toXML[models.CzType](_, None, Some("cz_52"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_53 map { scalaxb.toXML[models.CzType](_, None, Some("cz_53"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_54 map { scalaxb.toXML[models.CzType](_, None, Some("cz_54"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_55 map { scalaxb.toXML[models.CzType](_, None, Some("cz_55"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_56 map { scalaxb.toXML[models.CzType](_, None, Some("cz_56"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_57 map { scalaxb.toXML[models.CzType](_, None, Some("cz_57"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_58 map { scalaxb.toXML[models.CzType](_, None, Some("cz_58"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_59 map { scalaxb.toXML[models.CzType](_, None, Some("cz_59"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence7Format extends scalaxb.XMLFormat[models.CzesciTypeSequence7] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence7] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence7, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_60 map { scalaxb.toXML[models.CzType](_, None, Some("cz_60"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_61 map { scalaxb.toXML[models.CzType](_, None, Some("cz_61"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_62 map { scalaxb.toXML[models.CzType](_, None, Some("cz_62"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_63 map { scalaxb.toXML[models.CzType](_, None, Some("cz_63"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_64 map { scalaxb.toXML[models.CzType](_, None, Some("cz_64"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_65 map { scalaxb.toXML[models.CzType](_, None, Some("cz_65"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_66 map { scalaxb.toXML[models.CzType](_, None, Some("cz_66"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_67 map { scalaxb.toXML[models.CzType](_, None, Some("cz_67"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_68 map { scalaxb.toXML[models.CzType](_, None, Some("cz_68"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_69 map { scalaxb.toXML[models.CzType](_, None, Some("cz_69"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzesciTypeSequence8Format extends scalaxb.XMLFormat[models.CzesciTypeSequence8] { | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.CzesciTypeSequence8] = Left("don't call me.") | |
| def writes(__obj: models.CzesciTypeSequence8, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| Seq.concat(__obj.cz_70 map { scalaxb.toXML[models.CzType](_, None, Some("cz_70"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_71 map { scalaxb.toXML[models.CzType](_, None, Some("cz_71"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_72 map { scalaxb.toXML[models.CzType](_, None, Some("cz_72"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_73 map { scalaxb.toXML[models.CzType](_, None, Some("cz_73"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_74 map { scalaxb.toXML[models.CzType](_, None, Some("cz_74"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_75 map { scalaxb.toXML[models.CzType](_, None, Some("cz_75"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_76 map { scalaxb.toXML[models.CzType](_, None, Some("cz_76"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_77 map { scalaxb.toXML[models.CzType](_, None, Some("cz_77"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_78 map { scalaxb.toXML[models.CzType](_, None, Some("cz_78"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsWykonawcaTypeFormat extends scalaxb.ElemNameParser[models.WykonawcaType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("wykonawcaType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.WykonawcaType] = | |
| phrase((scalaxb.ElemName(None, "nazwa_wyk")) ~ | |
| (scalaxb.ElemName(None, "adres")) ~ | |
| (scalaxb.ElemName(None, "miejsc")) ~ | |
| opt(scalaxb.ElemName(None, "kod")) ~ | |
| (scalaxb.ElemName(None, "wojew")) ~ | |
| (scalaxb.ElemName(None, "wojewodztwo")) ~ | |
| opt(scalaxb.ElemName(None, "cena")) ~ | |
| opt(scalaxb.ElemName(None, "cena_min")) ~ | |
| opt(scalaxb.ElemName(None, "cena_max")) ~ | |
| opt(scalaxb.ElemName(None, "kod_wal")) ~ | |
| opt(scalaxb.ElemName(None, "waluta")) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 ~ p11 => | |
| models.WykonawcaType(scalaxb.fromXML[String](p1, scalaxb.ElemName(node) :: stack), | |
| scalaxb.fromXML[String](p2, scalaxb.ElemName(node) :: stack), | |
| scalaxb.fromXML[String](p3, scalaxb.ElemName(node) :: stack), | |
| p4.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| scalaxb.fromXML[Byte](p5, scalaxb.ElemName(node) :: stack), | |
| scalaxb.fromXML[String](p6, scalaxb.ElemName(node) :: stack), | |
| p7.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[Byte](_, scalaxb.ElemName(node) :: stack) }, | |
| p11.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.WykonawcaType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[String](__obj.nazwa_wyk, None, Some("nazwa_wyk"), __scope, false), | |
| scalaxb.toXML[String](__obj.adres, None, Some("adres"), __scope, false), | |
| scalaxb.toXML[String](__obj.miejsc, None, Some("miejsc"), __scope, false), | |
| __obj.kod map { scalaxb.toXML[String](_, None, Some("kod"), __scope, false) } getOrElse {Nil}, | |
| scalaxb.toXML[Byte](__obj.wojew, None, Some("wojew"), __scope, false), | |
| scalaxb.toXML[String](__obj.wojewodztwo, None, Some("wojewodztwo"), __scope, false), | |
| __obj.cena map { scalaxb.toXML[String](_, None, Some("cena"), __scope, false) } getOrElse {Nil}, | |
| __obj.cena_min map { scalaxb.toXML[String](_, None, Some("cena_min"), __scope, false) } getOrElse {Nil}, | |
| __obj.cena_max map { scalaxb.toXML[String](_, None, Some("cena_max"), __scope, false) } getOrElse {Nil}, | |
| __obj.kod_wal map { scalaxb.toXML[Byte](_, None, Some("kod_wal"), __scope, false) } getOrElse {Nil}, | |
| __obj.waluta map { scalaxb.toXML[String](_, None, Some("waluta"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsWykonawcyTypeFormat extends scalaxb.ElemNameParser[models.WykonawcyType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("wykonawcyType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.WykonawcyType] = | |
| phrase((scalaxb.ElemName(None, "wykonawca_0")) ~ | |
| opt(scalaxb.ElemName(None, "wykonawca_1")) ~ | |
| opt(scalaxb.ElemName(None, "wykonawca_2")) ~ | |
| opt(scalaxb.ElemName(None, "wykonawca_3")) ~ | |
| opt(scalaxb.ElemName(None, "wykonawca_4")) ~ | |
| opt(scalaxb.ElemName(None, "wykonawca_5")) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 => | |
| models.WykonawcyType(scalaxb.fromXML[models.WykonawcaType](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[models.WykonawcaType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.WykonawcaType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.WykonawcaType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.WykonawcaType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.WykonawcaType](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.WykonawcyType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[models.WykonawcaType](__obj.wykonawca_0, None, Some("wykonawca_0"), __scope, false), | |
| __obj.wykonawca_1 map { scalaxb.toXML[models.WykonawcaType](_, None, Some("wykonawca_1"), __scope, false) } getOrElse {Nil}, | |
| __obj.wykonawca_2 map { scalaxb.toXML[models.WykonawcaType](_, None, Some("wykonawca_2"), __scope, false) } getOrElse {Nil}, | |
| __obj.wykonawca_3 map { scalaxb.toXML[models.WykonawcaType](_, None, Some("wykonawca_3"), __scope, false) } getOrElse {Nil}, | |
| __obj.wykonawca_4 map { scalaxb.toXML[models.WykonawcaType](_, None, Some("wykonawca_4"), __scope, false) } getOrElse {Nil}, | |
| __obj.wykonawca_5 map { scalaxb.toXML[models.WykonawcaType](_, None, Some("wykonawca_5"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsZpBaseTypeFormat extends scalaxb.ElemNameParser[models.ZpBaseType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("zpBaseType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.ZpBaseType] = | |
| phrase(rep(((scalaxb.ElemName(None, "biuletyn")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "pozycja")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "data_publikacji")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[javax.xml.datatype.XMLGregorianCalendar](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nazwa")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "ulica")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nr_domu")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nr_miesz")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "miejscowosc")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kod_poczt")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wojewodztwo")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "tel")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "fax")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "internet")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "regon")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "e_mail")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "ogloszenie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_obowiazkowa")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dotyczy")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "rodzaj_zam")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nazwa_zamowienia")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "rodz_zam")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "przedmiot_zam")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv1c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv2c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv3c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv4c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv5c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv6c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv7c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv8c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv9c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv10c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv11c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv12c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv13c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv14c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv15c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv16c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv17c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv18c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv19c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv20c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "cpv21c")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_czesci")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_wariant")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_uzup")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czas")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czas_mies")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zaliczka")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "uprawnienie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wiedza")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "potencjal")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zdolne")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "sytuacja")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_1")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_2")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_3")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_4")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_5")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_6")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_7")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_8")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_9")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_potwierdzenia_10")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_1")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_2")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_3")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_4")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_5")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_6")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenia_wykluczenia_7")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_podm_zag_1")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_podm_zag_2")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_podm_zag_3")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_podm_zag_4")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "inne_dokumenty")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "niepelnosprawne")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kod_trybu")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_zmiana_umowy")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zmiana_umowy")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_cena")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_aukcja")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "spec_www")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "spec_war")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "data_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "godz_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "miejsce")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "termin")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "okres_liczba_dni")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_uniewaznienie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "data_zak")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wadium")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "inf_dodat")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "rodzaj_zam_inny")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "captcha_sec_code")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "ilosc_czesci")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Short](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "adres_dyn_zak")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czesci")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[models.CzesciType](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zam_uzupelniajace")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czas_dni")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Short](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "data_roz")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "okres_data_do")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_1")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_1p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Float](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_2")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_2p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Float](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_3")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_3p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_4")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_4p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_5")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_5p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_6")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_6p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_7")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_7p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_8")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_8p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_9")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "kryt_9p")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "sprawozdanie_calosc")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "lata_obrotowe")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_1")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_2")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_3")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_4")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_5")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dok_potw_6")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "inne_dok_potw")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "aukcja_dod_info")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "liczba_wyk")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wybor_wyk")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "licytacja_etapy")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czas_trwania")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_adres_aukcja")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[java.net.URI](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_adres_opis")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[java.net.URI](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_wymagania")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_postapien")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_data_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_godz_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_miejsce_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_term_otw")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "le_term_war_zam")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wym_zab_umowy")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "istotne_post")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "oswiadczenie_przedlozyc")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zamowienie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "bzp_rok")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "bzp_poz")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nrbiuletynu")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nrpozycji")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "datawydaniabiuletynu")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[javax.xml.datatype.XMLGregorianCalendar](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_biul_pub")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "biul_pub_rok")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[javax.xml.datatype.XMLGregorianCalendar](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "biul_pub_poz")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Int](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "czy_zmiana_ogl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zamowienie_ue")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "projekt")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zal_pprawna_hid")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zal_pprawna")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zal_uzasadnienie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "wymagania")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "data_odb")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "godz_odb")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "miejsce_odb")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "miejsce_skl")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "termin_konk")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "miejsce_konk")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nagrody")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "nazwa_konkursu")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "uczest")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[Byte](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zmiany")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[models.ZmianyType](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "dodane")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[models.DodaneType](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "szacunkowa_wart_zam")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zamowienie_pprawna_hid")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zamowienie_pprawna")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack)))) | | |
| ((scalaxb.ElemName(None, "zamowienie_uzasadnienie")) ^^ | |
| (x => scalaxb.DataRecord(x.namespace, Some(x.name), scalaxb.fromXML[String](x, scalaxb.ElemName(node) :: stack))))) ^^ | |
| { case p1 => | |
| models.ZpBaseType(p1.toSeq: _*) }) | |
| def writesChildNodes(__obj: models.ZpBaseType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| (__obj.zpbasetypeoption flatMap { x => scalaxb.toXML[scalaxb.DataRecord[Any]](x, x.namespace, x.key, __scope, false) }) | |
| } | |
| def buildModelsYesNoTypeFormat = new DefaultModelsYesNoTypeFormat {} | |
| trait DefaultModelsYesNoTypeFormat extends scalaxb.XMLFormat[models.YesNoType] { | |
| val targetNamespace: Option[String] = None | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.YesNoType] = | |
| Right(models.YesNoType.fromString(seq.text)) | |
| def writes(__obj: models.YesNoType, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scala.xml.Elem(scalaxb.Helper.getPrefix(__namespace, __scope).orNull, | |
| __elementLabel getOrElse { sys.error("missing element label.") }, | |
| scala.xml.Null, __scope, scala.xml.Text(__obj.toString)) | |
| } | |
| def buildModelsKod_walTypeFormat = new DefaultModelsKod_walTypeFormat {} | |
| trait DefaultModelsKod_walTypeFormat extends scalaxb.XMLFormat[models.Kod_walType] { | |
| val targetNamespace: Option[String] = None | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.Kod_walType] = | |
| Right(models.Kod_walType.fromString(seq.text)) | |
| def writes(__obj: models.Kod_walType, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scala.xml.Elem(scalaxb.Helper.getPrefix(__namespace, __scope).orNull, | |
| __elementLabel getOrElse { sys.error("missing element label.") }, | |
| scala.xml.Null, __scope, scala.xml.Text(__obj.toString)) | |
| } | |
| def buildModelsWalutaTypeFormat = new DefaultModelsWalutaTypeFormat {} | |
| trait DefaultModelsWalutaTypeFormat extends scalaxb.XMLFormat[models.WalutaType] { | |
| val targetNamespace: Option[String] = None | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.WalutaType] = | |
| Right(models.WalutaType.fromString(seq.text)) | |
| def writes(__obj: models.WalutaType, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scala.xml.Elem(scalaxb.Helper.getPrefix(__namespace, __scope).orNull, | |
| __elementLabel getOrElse { sys.error("missing element label.") }, | |
| scala.xml.Null, __scope, scala.xml.Text(__obj.toString)) | |
| } | |
| def buildModelsRodz_zamTypeFormat = new DefaultModelsRodz_zamTypeFormat {} | |
| trait DefaultModelsRodz_zamTypeFormat extends scalaxb.XMLFormat[models.Rodz_zamType] { | |
| val targetNamespace: Option[String] = None | |
| def reads(seq: scala.xml.NodeSeq, stack: List[scalaxb.ElemName]): Either[String, models.Rodz_zamType] = | |
| Right(models.Rodz_zamType.fromString(seq.text)) | |
| def writes(__obj: models.Rodz_zamType, __namespace: Option[String], __elementLabel: Option[String], | |
| __scope: scala.xml.NamespaceBinding, __typeAttribute: Boolean): scala.xml.NodeSeq = | |
| scala.xml.Elem(scalaxb.Helper.getPrefix(__namespace, __scope).orNull, | |
| __elementLabel getOrElse { sys.error("missing element label.") }, | |
| scala.xml.Null, __scope, scala.xml.Text(__obj.toString)) | |
| } | |
| trait DefaultModelsCzZmianyTypeFormat extends scalaxb.ElemNameParser[models.CzZmianyType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("czZmianyType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.CzZmianyType] = | |
| phrase((scalaxb.ElemName(None, "miejsce")) ~ | |
| opt(scalaxb.ElemName(None, "jest")) ~ | |
| opt(scalaxb.ElemName(None, "ma")) ^^ | |
| { case p1 ~ p2 ~ p3 => | |
| models.CzZmianyType(scalaxb.fromXML[String](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[String](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.CzZmianyType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[String](__obj.miejsce, None, Some("miejsce"), __scope, false), | |
| __obj.jest map { scalaxb.toXML[String](_, None, Some("jest"), __scope, false) } getOrElse {Nil}, | |
| __obj.ma map { scalaxb.toXML[String](_, None, Some("ma"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsZmianyTypeFormat extends scalaxb.ElemNameParser[models.ZmianyType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("zmianyType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.ZmianyType] = | |
| phrase((scalaxb.ElemName(None, "cz_0")) ~ | |
| opt(scalaxb.ElemName(None, "cz_1")) ~ | |
| opt(scalaxb.ElemName(None, "cz_2")) ~ | |
| opt(scalaxb.ElemName(None, "cz_3")) ~ | |
| opt(scalaxb.ElemName(None, "cz_4")) ~ | |
| opt(scalaxb.ElemName(None, "cz_5")) ~ | |
| opt(scalaxb.ElemName(None, "cz_6")) ~ | |
| opt(scalaxb.ElemName(None, "cz_7")) ~ | |
| opt(scalaxb.ElemName(None, "cz_8")) ~ | |
| opt(scalaxb.ElemName(None, "cz_9")) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 ~ p6 ~ p7 ~ p8 ~ p9 ~ p10 => | |
| models.ZmianyType(scalaxb.fromXML[models.CzZmianyType](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p6.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p7.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p8.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p9.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }, | |
| p10.headOption map { scalaxb.fromXML[models.CzZmianyType](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.ZmianyType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[models.CzZmianyType](__obj.cz_0, None, Some("cz_0"), __scope, false), | |
| __obj.cz_1 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_1"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_2 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_2"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_3 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_3"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_4 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_4"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_5 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_5"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_6 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_6"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_7 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_7"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_8 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_8"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_9 map { scalaxb.toXML[models.CzZmianyType](_, None, Some("cz_9"), __scope, false) } getOrElse {Nil}) | |
| } | |
| trait DefaultModelsCzDodaneTypeFormat extends scalaxb.ElemNameParser[models.CzDodaneType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("czDodaneType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.CzDodaneType] = | |
| phrase((scalaxb.ElemName(None, "miejsce")) ~ | |
| (scalaxb.ElemName(None, "dodac")) ^^ | |
| { case p1 ~ p2 => | |
| models.CzDodaneType(scalaxb.fromXML[String](p1, scalaxb.ElemName(node) :: stack), | |
| scalaxb.fromXML[String](p2, scalaxb.ElemName(node) :: stack)) }) | |
| def writesChildNodes(__obj: models.CzDodaneType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[String](__obj.miejsce, None, Some("miejsce"), __scope, false), | |
| scalaxb.toXML[String](__obj.dodac, None, Some("dodac"), __scope, false)) | |
| } | |
| trait DefaultModelsDodaneTypeFormat extends scalaxb.ElemNameParser[models.DodaneType] { | |
| val targetNamespace: Option[String] = None | |
| override def typeName: Option[String] = Some("dodaneType") | |
| def parser(node: scala.xml.Node, stack: List[scalaxb.ElemName]): Parser[models.DodaneType] = | |
| phrase((scalaxb.ElemName(None, "cz_0")) ~ | |
| opt(scalaxb.ElemName(None, "cz_1")) ~ | |
| opt(scalaxb.ElemName(None, "cz_2")) ~ | |
| opt(scalaxb.ElemName(None, "cz_3")) ~ | |
| opt(scalaxb.ElemName(None, "cz_4")) ^^ | |
| { case p1 ~ p2 ~ p3 ~ p4 ~ p5 => | |
| models.DodaneType(scalaxb.fromXML[models.CzDodaneType](p1, scalaxb.ElemName(node) :: stack), | |
| p2.headOption map { scalaxb.fromXML[models.CzDodaneType](_, scalaxb.ElemName(node) :: stack) }, | |
| p3.headOption map { scalaxb.fromXML[models.CzDodaneType](_, scalaxb.ElemName(node) :: stack) }, | |
| p4.headOption map { scalaxb.fromXML[models.CzDodaneType](_, scalaxb.ElemName(node) :: stack) }, | |
| p5.headOption map { scalaxb.fromXML[models.CzDodaneType](_, scalaxb.ElemName(node) :: stack) }) }) | |
| def writesChildNodes(__obj: models.DodaneType, __scope: scala.xml.NamespaceBinding): Seq[scala.xml.Node] = | |
| Seq.concat(scalaxb.toXML[models.CzDodaneType](__obj.cz_0, None, Some("cz_0"), __scope, false), | |
| __obj.cz_1 map { scalaxb.toXML[models.CzDodaneType](_, None, Some("cz_1"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_2 map { scalaxb.toXML[models.CzDodaneType](_, None, Some("cz_2"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_3 map { scalaxb.toXML[models.CzDodaneType](_, None, Some("cz_3"), __scope, false) } getOrElse {Nil}, | |
| __obj.cz_4 map { scalaxb.toXML[models.CzDodaneType](_, None, Some("cz_4"), __scope, false) } getOrElse {Nil}) | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment