# RELAX NG schema for ISO 11179 Part 3 version 2,
# derived from the XMDR OWL ontology for ISO 11179:
# http://hpcrd.lbl.gov/SDM/XMDR/ont/iso11179-3v2.owl
#
# *Not yet complete*
# This schema currently only covers a part of the OWL ontology.
#
# Kevin D. Keck, Lawrence Berkeley National Lab

default namespace mdr = "http://hpcrd.lbl.gov/SDM/XMDR/ont/iso11179-32.owl#"
namespace rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"

# implicit:
# datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes"

# A document (aka resource) can be an AdministeredItem,
# a ValueMeaning, a ReferenceDocument, a Contact,
# or an Organization (which subsumes RegistrationAuthority)
start = administeredItem | valueMeaning | referenceDocument
 | element Contact {
    base, # xml:base and rdf:about=""
    element name { Any },
    element title { Any }?,
    element information { Any }
 }
 | element Organization { organizationContent }
 | element RegistrationAuthority {
    organizationContent,
    RegistrationAuthorityIdentifier,
    element languageUsed { LanguageIdentification }+
 }
RegistrationAuthorityIdentifier =
   element registrationAuthorityIdentifier {
      attribute rdf:parseType { "Resource" },
      element internationalCodeDesignator { String },
      element organizationIdentifier { String },
      element organizationPartIdentifier { String }?,
      element opiSource { String }?
   }
organizationContent =
   base, # xml:base and rdf:about=""
   element name { Any },
   element mailingAddress { Any }?


# Just completing parts needed for demo EDR content for now:
administeredItem = ConceptualDomain | ValueDomain | ObjectClass
 | element Context { itemContent }
 | element DataElement {
    attribute mdr:type { resource }, # a RepresentationClass
    attribute mdr:domain { resource }, # a ValueDomain
    attribute mdr:meaning { resource }, # a DataElementConcept
    itemContent,
    element example { String }*
 }
 | element DataElementConcept { itemContent,
    attribute mdr:domain { resource } # a ConceptualDomain
 }
 | element RepresentationClass { itemContent }

ConceptualDomain =
   element EnumeratedConceptualDomain {
      itemContent,
      memberValueMeaning+
   }
 | element NonEnumeratedConceptualDomain { itemContent }
memberValueMeaning =
   # Can't have multiple values for an attribute, so needs to be
   # encoded with property elements.
   element memberValue {
      element ValueMeaning { about }
   }

ValueDomain =
   element EnumeratedValueDomain { valueDomainContent, 
    memberPermissibleValue+ }
 | element NonEnumeratedValueDomain { valueDomainContent }
valueDomainContent =
   attribute mdr:type { resource }, # a RepresentationClass
   attribute mdr:meaning { resource }, # a ConceptualDomain
   itemContent,
   element datatype { datatypeContent },
   element format { String },
   element maximumCharacterQuantity { Int },
   element unit { unitContent }
datatypeContent =
   attribute rdf:parseType { "Resource" },
   element name { Any },
   element description { Any }?,
   element datatypeSchemeReference { String },
   element annotation { Any }?
unitContent =
   attribute rdf:parseType { "Resource" },
   element name { Any },
   element precision { Int }

memberPermissibleValue =
   element memberValue {
      attribute rdf:parseType { "Resource" },
      attribute mdr:meaning { resource }, # a ValueMeaning
      dates,
      element value { String }
   }


ObjectClass =
   element Concept { itemContent }
 | element ConceptRelationship {
    itemContent,
    # Exactly two Concept-valued items:
    ConceptItem, ConceptItem
 }
ConceptItem =
   # Can't have multiple values for a property, so needs to be encoded
   # with property elements.
   element item {
      element Concept { about } # a Concept
   }

itemContent =
   base,
   attribute mdr:registrationAuthority { resource }, # a RegistrationAuthority
   element identifier { # ItemIdentifier
      attribute rdf:parseType { "Resource" },
      RegistrationAuthorityIdentifier,
      element dataIdentifier { String },
      element version { String }
   },
   element administrationRecord {
      attribute rdf:parseType { "Resource" },
      element registrationStatus { String },
      element administrativeStatus { String },
      element creationDate { xsd:date },
      element lastChangeDate { xsd:date }?,
      element effectiveDate { xsd:date }?,
      element untilDate { xsd:date }?,
      element changeDescription { Any }?,
      element administrativeNote { Any }?,
      element explanatoryComment { Any }?,
      element unresolvedIssue { Any }?,
      element origin { String }?
   },
   element steward {
      attribute rdf:parseType { "Resource" },
      attribute mdr:organization { resource }, # an Organization
      attribute mdr:contact { resource } # a Contact
   },
   element submitter { # same as steward
      attribute rdf:parseType { "Resource" },
      attribute mdr:organization { resource }, # an Organization
      attribute mdr:contact { resource } # a Contact
   }*, # spec says one, but EDR has any number
   element terminologicalEntry {
      attribute rdf:parseType { "Resource" },
      attribute mdr:entryContext { resource }, # a Context
      element component { LanguageSection }+
   }+,
   element reference {
      # Can't have multiple values for an attribute, so needs to be
      # encoded with property elements.
      element ReferenceDocument { about }
   }*,
   element classification {
      # Can't have multiple values for an attribute, so needs to be
      # encoded with property elements.
      element ClassificationSchemeItem { about }
   }*
LanguageSection =
   attribute rdf:parseType { "Resource" },
   element sectionLanguage { LanguageIdentification },
   ((Designation+, Definition*) | Definition+)
Designation =
   element designation {
      attribute rdf:parseType { "Resource" },
      element name { Any },
      element isPreferred { Boolean }?
   }
Definition =
   element definition {
      attribute rdf:parseType { "Resource" },
      attribute mdr:source { resource }, # a ReferenceDocument
      element text { Any },
      element isPreferred { Boolean }
   }


valueMeaning =
   element ValueMeaning {
      base,
      element identifier { # a ValueMeaningIdentifier
         attribute rdf:parseType { "Resource" },
         element string { String }
      },
      dates,
      element description { Any }
   }


referenceDocument =
   element ReferenceDocument {
      base,
      element title { Any }?,
      element referenceDocumentTypeDescription { Any }?,
      element identifier { # a DocumentIdentifier
         attribute rdf:parseType { "Resource" },
         element string { String }
      },
      element languageUsed { LanguageIdentification }*
   }


LanguageIdentification =
   attribute rdf:parseType { "Resource" },
   element language { String },
   element countryIdentifier { String }?
dates =
   element beginDate { xsd:date },
   element endDate { xsd:date }?


base =
   attribute xml:base { anyURI },
   attribute rdf:about { xsd:anyURI "" } # *must* match base
#  (the about="" idiom is also commonly used in OWL for the Ontology header)

resource =
#   attribute rdfs:label { string }?,
   attribute rdf:resource { xsd:anyURI }
about =
   attribute rdf:about { xsd:anyURI }

# Literal types
# Include rdf:datatype to support RDF parsing:
String =
   attribute rdf:datatype { "http://www.w3.org/2001/XMLSchema#string" },
   xsd:string
Date =
   attribute rdf:datatype { "http://www.w3.org/2001/XMLSchema#date" },
   xsd:date
Int =
   attribute rdf:datatype { "http://www.w3.org/2001/XMLSchema#int" },
   xsd:int
Boolean =
   attribute rdf:datatype { "http://www.w3.org/2001/XMLSchema#boolean" },
   xsd:boolean

# "untyped" literal; allows an xml:lang qualifier
# use of string builtin type blocks whitespace normalization
Any =
   attribute xml:lang { "http://www.w3.org/2001/XMLSchema#language" }?,
   string