com.scalakml.io.KmlToXml.scala Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2013, Ringo Wathelet
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* - Neither the name of "scalakml" nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.scalakml.io
import com.scalakml.kml._
import scala.collection.mutable.MutableList
import xml._
import com.scalakml.gx._
import com.scalakml.atom.Author
import com.scalaxal.xAL.AddressDetails
import com.scalaxal.io.XalToXml
import com.scalakml.kml.Document
import scala.language.implicitConversions
import scala.language.postfixOps
/**
* @author Ringo Wathelet
* Date: 12/12/12
* Version: 1
*/
/**
* represents the extraction of an xml node sequence from a kml element
*/
trait XmlExtractor {
def getXmlFrom[A: KmlToXml](kml: A): NodeSeq
}
trait KmlToXml[A] {
def toXml(value: A): NodeSeq
}
trait KmlToXmlSeq[A] {
def toXml(value: A): Seq[NodeSeq]
}
/** Factory to convert kml objects instances to scala xml NodeSeq */
object KmlToXml extends XmlExtractor {
// ------------------------------------------------------------
// -----------------------implicits----------------------------
// ------------------------------------------------------------
implicit def StringToXmlText(valueOption: Option[String]): Option[xml.Text] = {
valueOption match {
case Some(value) => Some(Text(value.trim))
case None => None
}
}
/** this is the crux of getting xml from the kml objects */
def getXmlFrom[A: KmlToXml](kml: A) = implicitly[KmlToXml[A]].toXml(kml)
def getXmlSeqFrom[A: KmlToXmlSeq](kml: A) = implicitly[KmlToXmlSeq[A]].toXml(kml)
def getNodeFromFieldName(name: String, objOption: Option[Any]): NodeSeq = {
val baseName = if (name.startsWith("gx:")) name.substring(3) else name
objOption match {
case Some(obj) =>
if (!obj.getClass.getDeclaredFields.exists(field => field.getName.equals(baseName)))
NodeSeq.Empty
else {
Some(obj.getClass.getDeclaredField(baseName)) match {
case Some(field) => {
field.setAccessible(true)
val fieldValue = field.get(obj)
if (fieldValue == null || !fieldValue.isInstanceOf[Option[_]]) NodeSeq.Empty
else makeXmlNode(name, fieldValue.asInstanceOf[Option[_]])
}
case _ => NodeSeq.Empty
}
}
case None => NodeSeq.Empty
}
}
def makeXmlNode[_](name: String, valueOption: Option[_]): NodeSeq = {
valueOption match {
case Some(value) => value match {
case bool: Boolean =>
{if (bool) "1" else "0"}
.copy(label = name)
case vec2: Vec2 =>
val theNode = % Attribute(None, "x", Text(vec2.x.toString), Null) % Attribute(None, "y", Text(vec2.y.toString), Null) % Attribute(None, "xunits", Text(vec2.xunits.toString), Null) % Attribute(None, "yunits", Text(vec2.yunits.toString), Null)
theNode.copy(label = name)
case hColor: HexColor =>
{hColor.hexString}
.copy(label = name)
case _ =>
{value}
.copy(label = name)
}
case None => NodeSeq.Empty
}
}
implicit object AddressDetailsToXml extends KmlToXml[Option[AddressDetails]] {
def toXml(addressDetailsOption: Option[AddressDetails]): NodeSeq = {
addressDetailsOption match {
case Some(addressDetails) => XalToXml(addressDetails)
case None => NodeSeq.Empty
}
}
}
implicit object UpdateToXml extends KmlToXml[Option[Update]] {
def toXml(updateOption: Option[Update]): NodeSeq = {
updateOption match {
case Some(update) =>
{getNodeFromFieldName("targetHref", updateOption)}
{getXmlSeqFrom(Option(update.updateOption))}
case None => NodeSeq.Empty
}
}
}
implicit object UpdateOptionToXml extends KmlToXml[Option[UpdateOption]] {
def toXml(updateOptionOption: Option[UpdateOption]): NodeSeq = {
updateOptionOption match {
case Some(updateOption) => updateOption match {
case delete: Delete => getXmlFrom(Option(delete))
case create: Create => getXmlFrom(Option(create))
case change: Change => getXmlFrom(Option(change))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object DeleteToXml extends KmlToXml[Option[Delete]] {
def toXml(deleteOption: Option[Delete]): NodeSeq = {
deleteOption match {
case Some(delete) =>
if (delete.featureSet == Nil) NodeSeq.Empty
else
{for (f <- delete.featureSet) yield getXmlFrom(Option(f))}
case None => NodeSeq.Empty
}
}
}
implicit object CreateToXml extends KmlToXml[Option[Create]] {
def toXml(createOption: Option[Create]): NodeSeq = {
createOption match {
case Some(create) =>
if (create.containerSet == Nil) NodeSeq.Empty
else
{for (f <- create.containerSet) yield getXmlFrom(Option(f))}
case None => NodeSeq.Empty
}
}
}
implicit object KmlObjectToXml extends KmlToXml[Option[KmlObject]] {
def toXml(kmlObjectOption: Option[KmlObject]): NodeSeq = {
kmlObjectOption match {
case Some(kmlObject) => kmlObject match {
case resourceMap: ResourceMap => getXmlFrom(Option(resourceMap))
case alias: Alias => getXmlFrom(Option(alias))
case viewVolume: ViewVolume => getXmlFrom(Option(viewVolume))
case imagePyramid: ImagePyramid => getXmlFrom(Option(imagePyramid))
case pair: Pair => getXmlFrom(Option(pair))
case data: Data => getXmlFrom(Option(data))
case schemaData: SchemaData => getXmlFrom(Option(schemaData))
case timePrimitive: TimePrimitive => getXmlFrom(Option(timePrimitive))
case region: Region => getXmlFrom(Option(region))
case latLonAltBox: LatLonAltBox => getXmlFrom(Option(latLonAltBox))
case latLonBox: LatLonBox => getXmlFrom(Option(latLonBox))
case lod: Lod => getXmlFrom(Option(lod))
case icon: Icon => getXmlFrom(Option(icon))
case link: Link => getXmlFrom(Option(link))
case location: Location => getXmlFrom(Option(location))
case orientation: Orientation => getXmlFrom(Option(orientation))
case scale: Scale => getXmlFrom(Option(scale))
case geometry: Geometry => getXmlFrom(Option(geometry))
case iconStyle: IconStyle => getXmlFrom(Option(iconStyle))
case labelStyle: LabelStyle => getXmlFrom(Option(labelStyle))
case lineStyle: LineStyle => getXmlFrom(Option(lineStyle))
case polyStyle: PolyStyle => getXmlFrom(Option(polyStyle))
case balloonStyle: BalloonStyle => getXmlFrom(Option(balloonStyle))
case listStyle: ListStyle => getXmlFrom(Option(listStyle))
case style: Style => getXmlFrom(Option(style))
case styleMap: StyleMap => getXmlFrom(Option(styleMap))
case itemIcon: ItemIcon => getXmlFrom(Option(itemIcon))
case placemark: Placemark => getXmlFrom(Option(placemark))
case document: Document => getXmlFrom(Option(document))
case folder: Folder => getXmlFrom(Option(folder))
case networkLink: NetworkLink => getXmlFrom(Option(networkLink))
case photoOverlay: PhotoOverlay => getXmlFrom(Option(photoOverlay))
case screenOverlay: ScreenOverlay => getXmlFrom(Option(screenOverlay))
case groundOverlay: GroundOverlay => getXmlFrom(Option(groundOverlay))
case abstractView: AbstractView => getXmlFrom(Option(abstractView))
case feature: Feature => getXmlFrom(Option(feature))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object ChangeToXml extends KmlToXml[Option[Change]] {
def toXml(changeOption: Option[Change]): NodeSeq = {
changeOption match {
case Some(change) =>
if (change.objectChangeSet == Nil) NodeSeq.Empty
else
{for (kmlObject <- change.objectChangeSet) yield getXmlFrom(Option(kmlObject.asInstanceOf[KmlObject]))}
case None => NodeSeq.Empty
}
}
}
implicit object networkLinkControlToXml extends KmlToXml[Option[NetworkLinkControl]] {
def toXml(networkLinkControlOption: Option[NetworkLinkControl]): NodeSeq = {
networkLinkControlOption match {
case Some(networkLinkControl) =>
{getNodeFromFieldName("minRefreshPeriod", networkLinkControlOption)}
{getNodeFromFieldName("maxSessionLength", networkLinkControlOption)}
{getNodeFromFieldName("cookie", networkLinkControlOption)}
{getNodeFromFieldName("message", networkLinkControlOption)}
{getNodeFromFieldName("linkName", networkLinkControlOption)}
{getNodeFromFieldName("linkDescription", networkLinkControlOption)}
{getNodeFromFieldName("expires", networkLinkControlOption)}
{if (networkLinkControl.linkSnippet.isDefined)
0) networkLinkControl.linkSnippet.get.maxLines.toString else null}>
{if ((networkLinkControl.linkSnippet.get.value != null) && (!networkLinkControl.linkSnippet.get.value.isEmpty)) networkLinkControl.linkSnippet.get.value else null}
else null}
{getXmlFrom(networkLinkControl.update)}
{getXmlFrom(networkLinkControl.abstractView)}
case None => NodeSeq.Empty
}
}
}
implicit object placemarkToXml extends KmlToXml[Option[Placemark]] {
def toXml(placemarkOption: Option[Placemark]): NodeSeq = {
placemarkOption match {
case Some(placemark) =>
{getXmlSeqFrom(Option(placemark.featurePart))}{getXmlFrom(placemark.geometry)}
case None => NodeSeq.Empty
}
}
}
implicit object documentToXml extends KmlToXml[Option[Document]] {
def toXml(documentOption: Option[Document]): NodeSeq = {
documentOption match {
case Some(document) =>
{getXmlSeqFrom(Option(document.featurePart))}{for (s <- document.schemas) yield getXmlFrom(Option(s))}{for (f <- document.features) yield getXmlFrom(Option(f))}
case None => NodeSeq.Empty
}
}
}
implicit object SchemaToXml extends KmlToXml[Option[Schema]] {
def toXml(schemaOption: Option[Schema]): NodeSeq = {
schemaOption match {
case Some(schema) =>
{for (x <- schema.simpleField) yield getXmlFrom(Option(x))}
case None => NodeSeq.Empty
}
}
}
implicit object SimpleFieldToXml extends KmlToXml[Option[SimpleField]] {
def toXml(simpleFieldOption: Option[SimpleField]): NodeSeq = {
simpleFieldOption match {
case Some(simpleField) =>
{getNodeFromFieldName("displayName", simpleFieldOption)}
case None => NodeSeq.Empty
}
}
}
// TODO ability to make different namespaces
implicit object kmlToXml extends KmlToXml[Option[Kml]] {
def toXml(kmlOption: Option[Kml]): NodeSeq = {
kmlOption match {
case Some(kml) =>
{getXmlFrom(kml.networkLinkControl)}{getXmlFrom(kml.feature)}
case None => NodeSeq.Empty
}
}
}
implicit object BalloonStyleToXml extends KmlToXml[Option[BalloonStyle]] {
def toXml(balloonStyleOption: Option[BalloonStyle]): NodeSeq = {
balloonStyleOption match {
case Some(balloonStyle) =>
{makeXmlNode("bgColor", balloonStyle.bgColor)}
{makeXmlNode("textColor", balloonStyle.textColor)}
{getNodeFromFieldName("displayMode", balloonStyleOption)}
{getNodeFromFieldName("text", balloonStyleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object IconStyleToXml extends KmlToXml[Option[IconStyle]] {
def toXml(iconStyleOption: Option[IconStyle]): NodeSeq = {
iconStyleOption match {
case Some(iconStyle) =>
{getNodeFromFieldName("scale", iconStyleOption)}
{getNodeFromFieldName("heading", iconStyleOption)}
{getXmlFrom(iconStyle.color)}
{getNodeFromFieldName("colorMode", iconStyleOption)}
{getXmlFrom(iconStyle.icon)}
{makeXmlNode("hotSpot", iconStyle.hotSpot)}
case None => NodeSeq.Empty
}
}
}
implicit object LabelStyleToXml extends KmlToXml[Option[LabelStyle]] {
def toXml(labelStyleOption: Option[LabelStyle]): NodeSeq = {
labelStyleOption match {
case Some(labelStyle) =>
{getNodeFromFieldName("scale", labelStyleOption)}
{getXmlFrom(labelStyle.color)}
{getNodeFromFieldName("colorMode", labelStyleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object LineStyleToXml extends KmlToXml[Option[LineStyle]] {
def toXml(lineStyleOption: Option[LineStyle]): NodeSeq = {
lineStyleOption match {
case Some(lineStyle) =>
{getNodeFromFieldName("width", lineStyleOption)}
{getXmlFrom(lineStyle.color)}
{getNodeFromFieldName("colorMode", lineStyleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object ListStyleToXml extends KmlToXml[Option[ListStyle]] {
def toXml(listStyleOption: Option[ListStyle]): NodeSeq = {
listStyleOption match {
case Some(listStyle) =>
{getNodeFromFieldName("listItemType", listStyleOption)}
{getXmlSeqFrom(Option(listStyle.itemIcon))}
{makeXmlNode("bgColor", listStyle.bgColor)}
{getNodeFromFieldName("maxSnippetLines", listStyleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object IconStateToXml extends KmlToXml[Option[ItemIconState]] {
def toXml(iconStateOption: Option[ItemIconState]): NodeSeq = {
iconStateOption match {
case Some(iconState) => {iconState}
case None => NodeSeq.Empty
}
}
}
implicit object ItemIconToXml extends KmlToXml[Option[ItemIcon]] {
def toXml(itemIconOption: Option[ItemIcon]): NodeSeq = {
itemIconOption match {
case Some(itemIcon) =>
{getNodeFromFieldName("href", itemIconOption)}
{if (itemIcon.state != Nil) { {for (x <- itemIcon.state) yield x.toString + " "} }}
case None => NodeSeq.Empty
}
}
}
implicit object PolyStyleToXml extends KmlToXml[Option[PolyStyle]] {
def toXml(polyStyleOption: Option[PolyStyle]): NodeSeq = {
polyStyleOption match {
case Some(polyStyle) =>
{getNodeFromFieldName("fill", polyStyleOption)}
{getNodeFromFieldName("outline", polyStyleOption)}
{getXmlFrom(polyStyle.color)}
{getNodeFromFieldName("colorMode", polyStyleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object StyleToXml extends KmlToXml[Option[Style]] {
def toXml(styleOption: Option[Style]): NodeSeq = {
styleOption match {
case Some(style) =>
case None => NodeSeq.Empty
}
}
}
implicit object StyleSelectorToXml extends KmlToXml[Option[StyleSelector]] {
def toXml(styleSelectorOption: Option[StyleSelector]): NodeSeq = {
styleSelectorOption match {
case Some(styleSelector) => styleSelector match {
case style: Style => getXmlFrom(Option(style))
case styleMap: StyleMap => getXmlFrom(Option(styleMap))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object PairToXml extends KmlToXml[Option[Pair]] {
def toXml(pairOption: Option[Pair]): NodeSeq = {
pairOption match {
case Some(pair) =>
{getNodeFromFieldName("key", pairOption)}{if (pair.styleUrl.isDefined) getNodeFromFieldName("styleUrl", pairOption)
else getXmlFrom(pair.styleSelector)}
case None => NodeSeq.Empty
}
}
}
implicit object StyleMapToXml extends KmlToXml[Option[StyleMap]] {
def toXml(styleMapOption: Option[StyleMap]): NodeSeq = {
styleMapOption match {
case Some(styleMap) =>
{getXmlSeqFrom(Option(styleMap.pair))}
case None => NodeSeq.Empty
}
}
}
implicit object AtomAuthorToXml extends KmlToXml[Option[Author]] {
def toXml(authorOption: Option[Author]): NodeSeq = {
authorOption match {
case Some(author) =>
{if (author.name.isDefined) author.name.get else null}
{if (author.uri.isDefined) author.uri.get else null}
{if (author.email.isDefined) author.email.get else null}
case None => NodeSeq.Empty
}
}
}
implicit object AtomLinkToXml extends KmlToXml[Option[com.scalakml.atom.Link]] {
def toXml(linkOption: Option[com.scalakml.atom.Link]): NodeSeq = {
linkOption match {
case Some(link) =>
{getNodeFromFieldName("roll", Option(camera))}
{getNodeFromFieldName("longitude", Option(camera))}
{getNodeFromFieldName("latitude", Option(camera))}
{getNodeFromFieldName("altitude", Option(camera))}
{getNodeFromFieldName("heading", Option(camera))}
{getNodeFromFieldName("tilt", Option(camera))}
{getNodeFromFieldName("altitudeMode", Option(camera))}
case lookAt: LookAt =>
{getNodeFromFieldName("range", Option(lookAt))}
{getNodeFromFieldName("longitude", Option(lookAt))}
{getNodeFromFieldName("latitude", Option(lookAt))}
{getNodeFromFieldName("altitude", Option(lookAt))}
{getNodeFromFieldName("heading", Option(lookAt))}
{getNodeFromFieldName("tilt", Option(lookAt))}
{getNodeFromFieldName("altitudeMode", Option(lookAt))}
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object TimePrimitiveToXml extends KmlToXml[Option[TimePrimitive]] {
def toXml(timePrimitiveOption: Option[TimePrimitive]): NodeSeq = {
timePrimitiveOption match {
case Some(timePrimitive) => timePrimitive match {
case timeStamp: TimeStamp =>
{getNodeFromFieldName("when", Option(timeStamp))}
case timeSpan: TimeSpan =>
{getNodeFromFieldName("begin", Option(timeSpan))}{getNodeFromFieldName("end", Option(timeSpan))}
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
// TODO how to get dataExtension
implicit object DataToXml extends KmlToXml[Option[Data]] {
def toXml(dataOption: Option[Data]): NodeSeq = {
dataOption match {
case Some(data) =>
{getNodeFromFieldName("value", dataOption)}{getNodeFromFieldName("displayName", dataOption)}
case None => NodeSeq.Empty
}
}
}
// TODO how to write other
implicit object ExtendedDataToXml extends KmlToXml[Option[ExtendedData]] {
def toXml(extendedDataOption: Option[ExtendedData]): NodeSeq = {
extendedDataOption match {
case Some(extendedData) =>
{if (extendedData.data != Nil) for (x <- extendedData.data) yield getXmlFrom(Option(x))}
{if (extendedData.schemaData != Nil) for (x <- extendedData.schemaData) yield getXmlFrom(Option(x))}
case None => NodeSeq.Empty
}
}
}
implicit object SchemaDataToXml extends KmlToXml[Option[SchemaData]] {
def toXml(schemaDataOption: Option[SchemaData]): NodeSeq = {
schemaDataOption match {
case Some(schemaData) =>
{if (schemaData.simpleData != Nil) for (x <- schemaData.simpleData) yield getXmlFrom(Option(x))}
case None => NodeSeq.Empty
}
}
}
implicit object SimpleDataToXml extends KmlToXml[Option[SimpleData]] {
def toXml(simpleDataOption: Option[SimpleData]): NodeSeq = {
simpleDataOption match {
case Some(simpleData) =>
{if (simpleData.value.isDefined) simpleData.value.get else null}
case None => NodeSeq.Empty
}
}
}
implicit object FolderToXml extends KmlToXml[Option[Folder]] {
def toXml(folderOption: Option[Folder]): NodeSeq = {
folderOption match {
case Some(folder) =>
{getXmlSeqFrom(Option(folder.featurePart))}{for (f <- folder.features) yield getXmlFrom(Option(f))}
case None => NodeSeq.Empty
}
}
}
implicit object LatLonBoxToXml extends KmlToXml[Option[LatLonBox]] {
def toXml(latLonBoxOption: Option[LatLonBox]): NodeSeq = {
latLonBoxOption match {
case Some(latLonBox) =>
{for (field <- latLonBox.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, latLonBoxOption)}
case None => NodeSeq.Empty
}
}
}
implicit object LatLonAltBoxToXml extends KmlToXml[Option[LatLonAltBox]] {
def toXml(latLonAltBoxOption: Option[LatLonAltBox]): NodeSeq = {
latLonAltBoxOption match {
case Some(latLonAltBox) =>
{for (field <- latLonAltBox.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, latLonAltBoxOption)}
case None => NodeSeq.Empty
}
}
}
implicit object LatLonQuadToXml extends KmlToXml[Option[LatLonQuad]] {
def toXml(latLonQuadOption: Option[LatLonQuad]): NodeSeq = {
latLonQuadOption match {
case Some(latLonQuad) =>
{getXmlFrom(latLonQuad.coordinates)}
case None => NodeSeq.Empty
}
}
}
implicit object GroundOverlayToXml extends KmlToXml[Option[GroundOverlay]] {
def toXml(overlayOption: Option[GroundOverlay]): NodeSeq = {
overlayOption match {
case Some(overlay) =>
{getXmlSeqFrom(Option(overlay.featurePart))}
{getNodeFromFieldName("altitude", overlayOption)}
{getNodeFromFieldName("drawOrder", overlayOption)}
{getNodeFromFieldName("altitudeMode", overlayOption)}
{getXmlFrom(overlay.latLonBox)}
{getXmlFrom(overlay.latLonQuad)}
{getXmlFrom(overlay.color)}
{getNodeFromFieldName("drawOrder", overlayOption)}
{getXmlFrom(overlay.icon)}
case None => NodeSeq.Empty
}
}
}
implicit object ViewVolumeToXml extends KmlToXml[Option[ViewVolume]] {
def toXml(viewVolumeOption: Option[ViewVolume]): NodeSeq = {
viewVolumeOption match {
case Some(viewVolume) =>
{getNodeFromFieldName("leftFov", viewVolumeOption)}{getNodeFromFieldName("rightFov", viewVolumeOption)}{getNodeFromFieldName("bottomFov", viewVolumeOption)}{getNodeFromFieldName("topFov", viewVolumeOption)}{getNodeFromFieldName("near", viewVolumeOption)}
case None => NodeSeq.Empty
}
}
}
implicit object ImagePyramidToXml extends KmlToXml[Option[ImagePyramid]] {
def toXml(imagePyramidOption: Option[ImagePyramid]): NodeSeq = {
imagePyramidOption match {
case Some(imagePyramid) =>
{getNodeFromFieldName("tileSize", imagePyramidOption)}{getNodeFromFieldName("maxWidth", imagePyramidOption)}{getNodeFromFieldName("maxHeight", imagePyramidOption)}{getNodeFromFieldName("gridOrigin", imagePyramidOption)}
case None => NodeSeq.Empty
}
}
}
implicit object PhotoOverlayToXml extends KmlToXml[Option[PhotoOverlay]] {
def toXml(overlayOption: Option[PhotoOverlay]): NodeSeq = {
overlayOption match {
case Some(overlay) =>
{getXmlSeqFrom(Option(overlay.featurePart))}{getNodeFromFieldName("rotation", overlayOption)}{getXmlFrom(overlay.viewVolume)}{getXmlFrom(overlay.imagePyramid)}{getXmlFrom(overlay.point.asInstanceOf[Option[Geometry]])}{getNodeFromFieldName("shape", overlayOption)}
{getXmlFrom(overlay.color)}
{getNodeFromFieldName("drawOrder", overlayOption)}
{getXmlFrom(overlay.icon)}
case None => NodeSeq.Empty
}
}
}
implicit object ScreenOverlayToXml extends KmlToXml[Option[ScreenOverlay]] {
def toXml(overlayOption: Option[ScreenOverlay]): NodeSeq = {
overlayOption match {
case Some(overlay) =>
{getXmlSeqFrom(Option(overlay.featurePart))}{getNodeFromFieldName("overlayXY", overlayOption)}{getNodeFromFieldName("screenXY", overlayOption)}{getNodeFromFieldName("rotationXY", overlayOption)}{getNodeFromFieldName("size", overlayOption)}{getNodeFromFieldName("rotation", overlayOption)}
{getXmlFrom(overlay.color)}
{getNodeFromFieldName("drawOrder", overlayOption)}
{getXmlFrom(overlay.icon)}
case None => NodeSeq.Empty
}
}
}
implicit object makeNetworkLinkToXml extends KmlToXml[Option[NetworkLink]] {
def toXml(networkLinkOption: Option[NetworkLink]): NodeSeq = {
networkLinkOption match {
case Some(networkLink) =>
{getXmlSeqFrom(Option(networkLink.featurePart))}{getNodeFromFieldName("refreshVisibility", networkLinkOption)}{getNodeFromFieldName("flyToView", networkLinkOption)}{getNodeFromFieldName("refreshVisibility", networkLinkOption)}{getXmlFrom(networkLink.link)}
case None => NodeSeq.Empty
}
}
}
implicit object LinkToXml extends KmlToXml[Option[com.scalakml.kml.Link]] {
def toXml(linkOption: Option[com.scalakml.kml.Link]): NodeSeq = {
linkOption match {
case Some(link) =>
{for (field <- link.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, linkOption)}
case None => NodeSeq.Empty
}
}
}
implicit object IconTypeToXml extends KmlToXml[Option[Icon]] {
def toXml(linkOption: Option[Icon]): NodeSeq = {
linkOption match {
case Some(link) =>
{for (field <- link.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, linkOption)}
case None => NodeSeq.Empty
}
}
}
implicit object AliasToXml extends KmlToXml[Option[Alias]] {
def toXml(aliasOption: Option[Alias]): NodeSeq = {
aliasOption match {
case Some(alias) =>
{getNodeFromFieldName("targetHref", aliasOption)}{getNodeFromFieldName("sourceHref", aliasOption)}
case None => NodeSeq.Empty
}
}
}
implicit object ResourceMapToXml extends KmlToXml[Option[ResourceMap]] {
def toXml(resourceMapOption: Option[ResourceMap]): NodeSeq = {
resourceMapOption match {
case Some(resourceMap) =>
{for (x <- resourceMap.alias) yield getXmlFrom(Option(x))}
case None => NodeSeq.Empty
}
}
}
implicit object ScaleToXml extends KmlToXml[Option[Scale]] {
def toXml(scaleOption: Option[Scale]): NodeSeq = {
scaleOption match {
case Some(scale) =>
{for (field <- scale.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, scaleOption)}
case None => NodeSeq.Empty
}
}
}
implicit object OrientationToXml extends KmlToXml[Option[Orientation]] {
def toXml(orientationOption: Option[Orientation]): NodeSeq = {
orientationOption match {
case Some(orientation) =>
{for (field <- orientation.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, orientationOption)}
case None => NodeSeq.Empty
}
}
}
implicit object LocationToXml extends KmlToXml[Option[Location]] {
def toXml(locationOption: Option[Location]): NodeSeq = {
locationOption match {
case Some(location) =>
{for (field <- location.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, locationOption)}
case None => NodeSeq.Empty
}
}
}
implicit object LocationsToXml extends KmlToXml[Option[Seq[Location]]] {
def toXml(coordsOption: Option[Seq[Location]]): NodeSeq = {
coordsOption match {
case Some(coords) =>
{for (x <- coords) yield {
if (x.longitude.isDefined && x.latitude.isDefined) {
x.longitude.get.toString + "," + x.latitude.get.toString + (if (x.altitude.isDefined) "," + x.altitude.get.toString else "") + " \n"
}
}}
case None => NodeSeq.Empty
}
}
}
implicit object CoordinatesToXml extends KmlToXml[Option[Seq[Coordinate]]] {
def toXml(coordsOption: Option[Seq[Coordinate]]): NodeSeq = {
coordsOption match {
case Some(coords) =>
{for (x <- coords) yield {
if (x.longitude.isDefined && x.latitude.isDefined) {
x.longitude.get.toString + "," + x.latitude.get.toString + (if (x.altitude.isDefined) "," + x.altitude.get.toString else "") + " \n"
}
}}
case None => NodeSeq.Empty
}
}
}
implicit object CoordinateToXml extends KmlToXml[Option[Coordinate]] {
def toXml(coordsOption: Option[Coordinate]): NodeSeq = {
coordsOption match {
case Some(coord) =>
{
if (coord.longitude.isDefined && coord.latitude.isDefined) {
coord.longitude.get.toString + "," + coord.latitude.get.toString + (if (coord.altitude.isDefined) "," + coord.altitude.get.toString else "") + " \n"
}
}
case None => NodeSeq.Empty
}
}
}
implicit object HexColorToXml extends KmlToXml[Option[HexColor]] {
def toXml(colorOption: Option[HexColor]): NodeSeq = {
colorOption match {
case Some(color) =>
{if ((color.hexString != null) && !color.hexString.isEmpty) color.hexString else null}
case None => NodeSeq.Empty
}
}
}
implicit object SnippetToXml extends KmlToXml[Option[Snippet]] {
def toXml(snippetOption: Option[Snippet]): NodeSeq = {
snippetOption match {
case Some(snippet) => = 0) snippet.maxLines.toString else null}>
{if ((snippet.value != null) && (!snippet.value.isEmpty)) snippet.value else null}
case None => NodeSeq.Empty
}
}
}
implicit object LodToXml extends KmlToXml[Option[Lod]] {
def toXml(lodOption: Option[Lod]): NodeSeq = {
lodOption match {
case Some(lod) =>
{for (field <- lod.getClass.getDeclaredFields) yield getNodeFromFieldName(field.getName, lodOption)}
case None => NodeSeq.Empty
}
}
}
implicit object RegionToXml extends KmlToXml[Option[Region]] {
def toXml(regionOption: Option[Region]): NodeSeq = {
regionOption match {
case Some(region) =>
{getXmlFrom(region.latLonAltBox)}{getXmlFrom(region.lod)}
case None => NodeSeq.Empty
}
}
}
implicit object GeometryToXml extends KmlToXml[Option[Geometry]] {
def toXml(geometryOption: Option[Geometry]): NodeSeq = {
geometryOption match {
case Some(geometry) => geometry match {
case point: Point =>
{getNodeFromFieldName("extrude", Option(point))}{getNodeFromFieldName("altitudeMode", Option(point))}{getXmlFrom(point.coordinates)}
case lineString: LineString =>
{getNodeFromFieldName("extrude", Option(lineString))}{getNodeFromFieldName("tessellate", Option(lineString))}{getNodeFromFieldName("altitudeMode", Option(lineString))}{getXmlFrom(lineString.coordinates)}
case linearRing: LinearRing =>
{getNodeFromFieldName("extrude", Option(linearRing))}{getNodeFromFieldName("tessellate", Option(linearRing))}{getNodeFromFieldName("altitudeMode", Option(linearRing))}{getXmlFrom(linearRing.coordinates)}
case polygon: Polygon =>
{getNodeFromFieldName("extrude", Option(polygon))}{getNodeFromFieldName("tessellate", Option(polygon))}{getNodeFromFieldName("altitudeMode", Option(polygon))}
{if (polygon.outerBoundaryIs.isDefined)
{ if (polygon.outerBoundaryIs.get.linearRing.isDefined)
getXmlFrom(Option(polygon.outerBoundaryIs.get.linearRing.get.asInstanceOf[Geometry]))
else null
}
}
{if (polygon.innerBoundaryIs != Nil)
{for (s <- polygon.innerBoundaryIs) yield
if (s.linearRing.isDefined) getXmlFrom(Option(s.linearRing.get.asInstanceOf[Geometry]))}
}
case multiGeometry: MultiGeometry =>
{for (x <- multiGeometry.geometries) yield getXmlFrom(Option(x))}
case model: Model =>
{getNodeFromFieldName("altitudeMode", Option(model))}{getXmlFrom(model.location)}{getXmlFrom(model.orientation)}{getXmlFrom(model.scale)}{getXmlFrom(model.link)}{getXmlFrom(model.resourceMap)}
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object FeatureToXml extends KmlToXml[Option[Feature]] {
import TourToXml._
def toXml(featureOption: Option[Feature]): NodeSeq = {
featureOption match {
case Some(feature) => feature match {
case placemark: Placemark => getXmlFrom(Option(placemark))
case networkLink: NetworkLink => getXmlFrom(Option(networkLink))
case tour: Tour => getXmlFrom(Option(tour))
case document: Document => getXmlFrom(Option(document))
case folder: Folder => getXmlFrom(Option(folder))
case groundOverlay: GroundOverlay => getXmlFrom(Option(groundOverlay))
case screenOverlay: ScreenOverlay => getXmlFrom(Option(screenOverlay))
case photoOverlay: PhotoOverlay => getXmlFrom(Option(photoOverlay))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object ContainerToXml extends KmlToXml[Option[Container]] {
def toXml(containerOption: Option[Container]): NodeSeq = {
containerOption match {
case Some(container) => container match {
case document: Document => getXmlFrom(Option(document))
case folder: Folder => getXmlFrom(Option(folder))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
implicit object StyleSelectorSeqToXml extends KmlToXmlSeq[Option[Seq[StyleSelector]]] {
def toXml(styleSet: Option[Seq[StyleSelector]]): Seq[NodeSeq] = {
styleSet match {
case Some(styles) => styles collect {
case x => getXmlFrom(Option(x.asInstanceOf[StyleSelector]))
} filter (x => (x != null) && (x != None)) toSeq
case None => Seq.empty
}
}
}
implicit object PairSeqToXml extends KmlToXmlSeq[Option[Seq[Pair]]] {
def toXml(pairSet: Option[Seq[Pair]]): Seq[NodeSeq] = {
pairSet match {
case Some(pSet) => pSet collect {
case x => getXmlFrom(Option(x.asInstanceOf[Pair]))
} filter (x => (x != null) && (x != None)) toSeq
case None => Seq.empty
}
}
}
// ------------------------------------------------------------
// -----------------------def----------------------------------
// ------------------------------------------------------------
implicit object UpdateOptionSeqToXml extends KmlToXmlSeq[Option[Seq[UpdateOption]]] {
def toXml(updateOptionSet: Option[Seq[UpdateOption]]): Seq[NodeSeq] = {
updateOptionSet match {
case Some(uSet) => (uSet collect {
case x => getXmlFrom(Option(x.asInstanceOf[UpdateOption]))
} filter (x => (x != null) && (x != None)) toSeq)
case None => Seq.empty
}
}
}
implicit object ItemIconSeqToXml extends KmlToXmlSeq[Option[Seq[ItemIcon]]] {
def toXml(itemIconSet: Option[Seq[ItemIcon]]): Seq[NodeSeq] = {
itemIconSet match {
case Some(iSet) => iSet collect {
case x => getXmlFrom(Option(x.asInstanceOf[ItemIcon]))
} filter (x => (x != null) && (x != None)) toSeq
case None => Seq.empty
}
}
}
implicit object IconStateSeqToXml extends KmlToXmlSeq[Option[Seq[ItemIconState]]] {
def toXml(itemIconStateSet: Option[Seq[ItemIconState]]): Seq[NodeSeq] = {
itemIconStateSet match {
case Some(iSet) => iSet collect {
case x => getXmlFrom(Option(x.asInstanceOf[ItemIconState]))
} filter (x => (x != null) && (x != None)) toSeq
case None => Seq.empty
}
}
}
implicit object FeaturePartToXml extends KmlToXmlSeq[Option[FeaturePart]] {
def toXml(featurePart: Option[FeaturePart]): Seq[NodeSeq] = {
if (!featurePart.isDefined || (featurePart.get == null)) Seq.empty
else {
val list = new MutableList[NodeSeq]()
list += getNodeFromFieldName("name", featurePart)
list += getNodeFromFieldName("visibility", featurePart)
list += getNodeFromFieldName("open", featurePart)
list += getXmlFrom(featurePart.get.atomAuthor)
list += getXmlFrom(featurePart.get.atomLink)
list += getNodeFromFieldName("address", featurePart)
list += getXmlFrom(featurePart.get.addressDetails)
list += getNodeFromFieldName("phoneNumber", featurePart)
list += getNodeFromFieldName("description", featurePart)
list += getXmlFrom(featurePart.get.extendedData)
list += getXmlFrom(featurePart.get.snippet)
list += getXmlFrom(featurePart.get.region)
list += getXmlFrom(featurePart.get.timePrimitive)
list += getNodeFromFieldName("styleUrl", featurePart)
list ++= getXmlSeqFrom(Option(featurePart.get.styleSelector))
list += getXmlFrom(featurePart.get.abstractView)
list filter (x => (x != null) && (x != None)) toSeq
}
}
}
//-----------------------------------------------------------------------------------------------
//----------------------------------gx-----------------------------------------------------------
//-----------------------------------------------------------------------------------------------
// Note: the AlitudeMode currently does not carry the gx: namespace
implicit object PlaylistToXml extends KmlToXml[Option[Playlist]] {
def toXml(playlistOption: Option[Playlist]): NodeSeq = {
import TourPrimitiveToXml._
playlistOption match {
case Some(playlist) =>
if ((!playlist.tourPrimitiveGroup.isDefined) || (playlist.tourPrimitiveGroup.get == Nil)) NodeSeq.Empty
else
{for (tourPrimitive <- playlist.tourPrimitiveGroup.get) yield getXmlFrom(Option(tourPrimitive))}
case None => NodeSeq.Empty
}
}
}
implicit object TourToXml extends KmlToXml[Option[Tour]] {
def toXml(tourOption: Option[Tour]): NodeSeq = {
tourOption match {
case Some(tour) =>
{getXmlFrom(tour.playlist)}{getXmlSeqFrom(Option(tour.featurePart))}
case None => NodeSeq.Empty
}
}
}
implicit object AnimatedUpdateToXml extends KmlToXml[Option[AnimatedUpdate]] {
def toXml(animatedUpdateOption: Option[AnimatedUpdate]): NodeSeq = {
animatedUpdateOption match {
case Some(animatedUpdate) =>
{getNodeFromFieldName("gx:duration", animatedUpdateOption)}{getXmlFrom(animatedUpdate.update)}
case None => NodeSeq.Empty
}
}
}
implicit object FlyToToXml extends KmlToXml[Option[FlyTo]] {
def toXml(flyToOption: Option[FlyTo]): NodeSeq = {
flyToOption match {
case Some(flyTo) =>
{getNodeFromFieldName("gx:duration", flyToOption)}{getNodeFromFieldName("gx:flyToMode", flyToOption)}{getXmlFrom(flyTo.abstractView)}
case None => NodeSeq.Empty
}
}
}
implicit object SoundCueToXml extends KmlToXml[Option[SoundCue]] {
def toXml(soundCueOption: Option[SoundCue]): NodeSeq = {
soundCueOption match {
case Some(soundCue) =>
{getNodeFromFieldName("href", soundCueOption)}
case None => NodeSeq.Empty
}
}
}
implicit object TourControlToXml extends KmlToXml[Option[TourControl]] {
def toXml(tourControlOption: Option[TourControl]): NodeSeq = {
tourControlOption match {
case Some(tourControl) =>
{getNodeFromFieldName("gx:playMode", tourControlOption)}
case None => NodeSeq.Empty
}
}
}
implicit object WaitToXml extends KmlToXml[Option[Wait]] {
def toXml(waitOption: Option[Wait]): NodeSeq = {
waitOption match {
case Some(waitt) =>
{getNodeFromFieldName("gx:duration", waitOption)}
case None => NodeSeq.Empty
}
}
}
implicit object TourPrimitiveToXml extends KmlToXml[Option[TourPrimitive]] {
def toXml(tourPrimitiveOption: Option[TourPrimitive]): NodeSeq = {
tourPrimitiveOption match {
case Some(tourPrimitive) => tourPrimitive match {
case animatedUpdate: AnimatedUpdate => getXmlFrom(Option(animatedUpdate))
case flyTo: FlyTo => getXmlFrom(Option(flyTo))
case soundCue: SoundCue => getXmlFrom(Option(soundCue))
case waitt: Wait => getXmlFrom(Option(waitt))
case tourControl: TourControl => getXmlFrom(Option(tourControl))
case _ => NodeSeq.Empty
}
case None => NodeSeq.Empty
}
}
}
}