• Home
• com.azavea.geotrellis
• geotrellis-server-opengis_2.12
• 4.6.0
• source code
• wfs.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

sbt-scalaxb.opengis.wfs.wfs.scala Maven / Gradle / Ivy

// Generated by scalaxb.
package opengis.wfs


trait BaseRequestType {
  def service: String
  def version: String
  def handle: Option[String]
}


case class XlinkPropertyName(value: String,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val traverseXlinkDepth = attributes("@traverseXlinkDepth").as[String]
  lazy val traverseXlinkExpiry = attributes.get("@traverseXlinkExpiry") map { _.as[BigInt]}
}

      
      

sealed trait StarStringType

object StarStringType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.StarStringType]): StarStringType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: StarStringType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[StarStringType] = Seq(U42)
}

case object U42 extends StarStringType { override def toString = "*" }


case class GetCapabilitiesType(AcceptVersions: Option[opengis.sld.ows.AcceptVersionsType] = None,
  Sections: Option[opengis.sld.ows.SectionsType] = None,
  AcceptFormats: Option[opengis.sld.ows.AcceptFormatsType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends opengis.sld.ows.GetCapabilitiesTypable {
  lazy val updateSequence = attributes.get("@updateSequence") map { _.as[String]}
  lazy val service = attributes("@service").as[String]
}

      
      


case class WFS_CapabilitiesType(ServiceIdentification: Option[opengis.sld.ows.ServiceIdentification] = None,
  ServiceProvider: Option[opengis.sld.ows.ServiceProvider] = None,
  OperationsMetadata: Option[opengis.sld.ows.OperationsMetadata] = None,
  FeatureTypeList: Option[opengis.wfs.FeatureTypeListType] = None,
  ServesGMLObjectTypeList: Option[opengis.wfs.GMLObjectTypeListType] = None,
  SupportsGMLObjectTypeList: Option[opengis.wfs.GMLObjectTypeListType] = None,
  Filter_Capabilities: opengis.ogc.Filter_Capabilities,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends opengis.sld.ows.CapabilitiesBaseTypable {
  lazy val version = attributes("@version").as[String]
  lazy val updateSequence = attributes.get("@updateSequence") map { _.as[String]}
}

      
      


case class FeatureTypeListType(Operations: Option[opengis.wfs.OperationsType] = None,
  FeatureType: Seq[opengis.wfs.FeatureTypeType] = Nil)
      
      


case class NoSRS() extends FeatureTypeTypeOption
      
      


case class FeatureTypeType(Name: javax.xml.namespace.QName,
  Title: String,
  AbstractValue: Option[String] = None,
  Keywords: Seq[opengis.sld.ows.KeywordsType] = Nil,
  featuretypetypeoption: scalaxb.DataRecord[opengis.wfs.FeatureTypeTypeOption],
  Operations: Option[opengis.wfs.OperationsType] = None,
  OutputFormats: Option[opengis.wfs.OutputFormatListType] = None,
  WGS84BoundingBox: Seq[opengis.sld.ows.WGS84BoundingBoxType] = Nil,
  MetadataURL: Seq[opengis.wfs.MetadataURLType] = Nil)
      
      

trait FeatureTypeTypeOption
case class FeatureTypeTypeSequence1(DefaultSRS: java.net.URI,
  OtherSRS: Seq[java.net.URI] = Nil) extends FeatureTypeTypeOption
      


case class OperationsType(Operation: Seq[opengis.wfs.OperationType] = Nil)
      
      

sealed trait OperationType

object OperationType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.OperationType]): OperationType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: OperationType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[OperationType] = Seq(Insert, Update, Delete, Query, Lock, GetGmlObject)
}

case object Insert extends OperationType { override def toString = "Insert" }
case object Update extends OperationType { override def toString = "Update" }
case object Delete extends OperationType { override def toString = "Delete" }
case object Query extends OperationType { override def toString = "Query" }
case object Lock extends OperationType { override def toString = "Lock" }
case object GetGmlObject extends OperationType { override def toString = "GetGmlObject" }


case class OutputFormatListType(outputformatlisttypesequence1: Seq[opengis.wfs.OutputFormatListTypeSequence1] = Nil)
      
      

case class OutputFormatListTypeSequence1(Format: String)
      

sealed trait Type

object Type {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.Type]): Type = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Type) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Type] = Seq(TC211, FGDC, Number19115, Number19139)
}

case object TC211 extends Type { override def toString = "TC211" }
case object FGDC extends Type { override def toString = "FGDC" }
case object Number19115 extends Type { override def toString = "19115" }
case object Number19139 extends Type { override def toString = "19139" }

sealed trait Format

object Format {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.Format]): Format = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Format) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Format] = Seq(Textu47xml, Textu47html, Textu47sgml, Textu47plain)
}

case object Textu47xml extends Format { override def toString = "text/xml" }
case object Textu47html extends Format { override def toString = "text/html" }
case object Textu47sgml extends Format { override def toString = "text/sgml" }
case object Textu47plain extends Format { override def toString = "text/plain" }


case class MetadataURLType(value: String,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val typeValue = attributes("@type").as[Type]
  lazy val format = attributes("@format").as[Format]
}

      
      


case class GMLObjectTypeListType(GMLObjectType: Seq[opengis.wfs.GMLObjectTypeType] = Nil)
      
      


case class GMLObjectTypeType(Name: javax.xml.namespace.QName,
  Title: Option[String] = None,
  AbstractValue: Option[String] = None,
  Keywords: Seq[opengis.sld.ows.KeywordsType] = Nil,
  OutputFormats: Option[opengis.wfs.OutputFormatListType] = None)
      
      


case class DescribeFeatureTypeType(TypeName: Seq[javax.xml.namespace.QName] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val outputFormat = attributes("@outputFormat").as[String]
}

      
      


case class GetFeatureType(Query: Seq[opengis.wfs.QueryType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val resultType = attributes("@resultType").as[ResultTypeType]
  lazy val outputFormat = attributes("@outputFormat").as[String]
  lazy val maxFeatures = attributes.get("@maxFeatures") map { _.as[BigInt]}
  lazy val traverseXlinkDepth = attributes.get("@traverseXlinkDepth") map { _.as[String]}
  lazy val traverseXlinkExpiry = attributes.get("@traverseXlinkExpiry") map { _.as[BigInt]}
}

      
      

sealed trait ResultTypeType

object ResultTypeType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.ResultTypeType]): ResultTypeType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ResultTypeType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ResultTypeType] = Seq(Results, Hits)
}

case object Results extends ResultTypeType { override def toString = "results" }
case object Hits extends ResultTypeType { override def toString = "hits" }


case class QueryType(querytypeoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  Filter: Option[opengis.ogc.FilterType] = None,
  SortBy: Option[opengis.ogc.SortByType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val typeName = attributes("@typeName").as[String]
  lazy val featureVersion = attributes.get("@featureVersion") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
}

      
      

trait QueryTypeOption

case class FeatureCollectionType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  boundedBy: Option[opengis.gml.BoundingShapeType] = None,
  location: Option[scalaxb.DataRecord[Any]] = None,
  featureMember: Seq[opengis.gml.FeaturePropertyType] = Nil,
  featureMembers: Option[opengis.gml.FeatureArrayPropertyType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends opengis.gml.AbstractFeatureCollectionType {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val lockId = attributes.get("@lockId") map { _.as[String]}
  lazy val timeStamp = attributes.get("@timeStamp") map { _.as[javax.xml.datatype.XMLGregorianCalendar]}
  lazy val numberOfFeatures = attributes.get("@numberOfFeatures") map { _.as[BigInt]}
}

      
      


case class GetGmlObjectType(GmlObjectId: opengis.ogc.GmlObjectIdType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val outputFormat = attributes("@outputFormat").as[String]
  lazy val traverseXlinkDepth = attributes("@traverseXlinkDepth").as[String]
  lazy val traverseXlinkExpiry = attributes.get("@traverseXlinkExpiry") map { _.as[BigInt]}
}

      
      


case class GetFeatureWithLockType(Query: Seq[opengis.wfs.QueryType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val expiry = attributes("@expiry").as[BigInt]
  lazy val resultType = attributes("@resultType").as[ResultTypeType]
  lazy val outputFormat = attributes("@outputFormat").as[String]
  lazy val maxFeatures = attributes.get("@maxFeatures") map { _.as[BigInt]}
  lazy val traverseXlinkDepth = attributes.get("@traverseXlinkDepth") map { _.as[String]}
  lazy val traverseXlinkExpiry = attributes.get("@traverseXlinkExpiry") map { _.as[BigInt]}
}

      
      


case class LockFeatureType(Lock: Seq[opengis.wfs.LockType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val expiry = attributes("@expiry").as[BigInt]
  lazy val lockAction = attributes("@lockAction").as[AllSomeType]
}

      
      

sealed trait AllSomeType

object AllSomeType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.AllSomeType]): AllSomeType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: AllSomeType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[AllSomeType] = Seq(ALL, SOME)
}

case object ALL extends AllSomeType { override def toString = "ALL" }
case object SOME extends AllSomeType { override def toString = "SOME" }


case class LockType(Filter: Option[opengis.ogc.FilterType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val typeName = attributes("@typeName").as[javax.xml.namespace.QName]
}

      
      


case class LockFeatureResponseType(LockId: String,
  FeaturesLocked: Option[opengis.wfs.FeaturesLockedType] = None,
  FeaturesNotLocked: Option[opengis.wfs.FeaturesNotLockedType] = None)
      
      


case class FeaturesLockedType(featureslockedtypesequence1: Seq[opengis.wfs.FeaturesLockedTypeSequence1] = Nil)
      
      

case class FeaturesLockedTypeSequence1(FeatureId: opengis.ogc.FeatureIdType)
      


case class FeaturesNotLockedType(featuresnotlockedtypesequence1: Seq[opengis.wfs.FeaturesNotLockedTypeSequence1] = Nil)
      
      

case class FeaturesNotLockedTypeSequence1(FeatureId: opengis.ogc.FeatureIdType)
      


case class TransactionType(LockId: Option[String] = None,
  transactiontypeoption: Seq[scalaxb.DataRecord[opengis.wfs.TransactionTypeOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BaseRequestType {
  lazy val service = attributes("@service").as[String]
  lazy val version = attributes("@version").as[String]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val releaseAction = attributes.get("@releaseAction") map { _.as[AllSomeType]}
}

      
      

trait TransactionTypeOption

case class InsertElementType(_Feature: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TransactionTypeOption {
  lazy val idgen = attributes("@idgen").as[IdentifierGenerationOptionType]
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val inputFormat = attributes("@inputFormat").as[String]
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
}

      
      

sealed trait IdentifierGenerationOptionType

object IdentifierGenerationOptionType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.wfs.IdentifierGenerationOptionType]): IdentifierGenerationOptionType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: IdentifierGenerationOptionType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[IdentifierGenerationOptionType] = Seq(UseExisting, ReplaceDuplicate, GenerateNew)
}

case object UseExisting extends IdentifierGenerationOptionType { override def toString = "UseExisting" }
case object ReplaceDuplicate extends IdentifierGenerationOptionType { override def toString = "ReplaceDuplicate" }
case object GenerateNew extends IdentifierGenerationOptionType { override def toString = "GenerateNew" }


case class UpdateElementType(Property: Seq[opengis.wfs.PropertyType] = Nil,
  Filter: Option[opengis.ogc.FilterType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TransactionTypeOption {
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val typeName = attributes("@typeName").as[javax.xml.namespace.QName]
  lazy val inputFormat = attributes("@inputFormat").as[String]
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
}

      
      


case class PropertyType(Name: javax.xml.namespace.QName,
  Value: Option[scalaxb.DataRecord[Any]] = None)
      
      


case class DeleteElementType(Filter: opengis.ogc.FilterType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TransactionTypeOption {
  lazy val handle = attributes.get("@handle") map { _.as[String]}
  lazy val typeName = attributes("@typeName").as[javax.xml.namespace.QName]
}

      
      


case class NativeType(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TransactionTypeOption {
  lazy val vendorId = attributes("@vendorId").as[String]
  lazy val safeToIgnore = attributes("@safeToIgnore").as[Boolean]
}

      
      


case class TransactionResponseType(TransactionSummary: opengis.wfs.TransactionSummaryType,
  TransactionResults: Option[opengis.wfs.TransactionResultsType] = None,
  InsertResults: Option[opengis.wfs.InsertResultsType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val version = attributes("@version").as[String]
}

      
      


case class TransactionSummaryType(totalInserted: Option[BigInt] = None,
  totalUpdated: Option[BigInt] = None,
  totalDeleted: Option[BigInt] = None)
      
      


case class TransactionResultsType(Action: Seq[opengis.wfs.ActionType] = Nil)
      
      


case class ActionType(Message: Option[String] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val locator = attributes("@locator").as[String]
  lazy val code = attributes.get("@code") map { _.as[String]}
}

      
      


case class InsertResultsType(Feature: Seq[opengis.wfs.InsertedFeatureType] = Nil)
      
      


case class InsertedFeatureType(FeatureId: Seq[opengis.ogc.FeatureIdType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val handle = attributes.get("@handle") map { _.as[String]}
}