/* $Id: xmlvoc.ltm,v 1.4 2002/08/29 16:19:18 larsga Exp $ */

/*
   This topic map captures the output of the XMLvoc TC discussions
   in Montreal and also includes instances of each of the types
   identified at that meeting.

   Caveat: It was transcribed and extended by Steve Pepper, who
   wasn't even at the meeting :-)

   Structure:

     1. housekeeping topics
     2. topic types
     3. association types and corresponding role types
     4. superclass-subclass relationships
     5. templating associations
     6. topic instances
     7. association instances

     1-4 are all necessary to the ontology itself and would be merged
     into any topic map conforming to the XMLvoc ontology

     5 contains ("templating") associations between topic types, useful
     for understanding the kinds of relationships that exist, but not
     normally part of an "instance" topic map

     6 and 7 are instances of topics and associations, included only
     for sanity checking purposes

   Comments:

     Apart from the instances (sections 6 and 7) this topic map captures
     contains only what was on the charts drawn in Montreal. Some names
     have been modified slightly for consistency. Association role types
     were not shown on the chart, so the names given here are not the
     committee's work. Some of them are not even English (e.g. "usee"),
     but they were chosen for maximum clarity in this draft. The committee
     will need to commission someone to take on the thankless task of
     proposing more suitable names...

*/

/* -------------- housekeeping topics -------------- */

[super-sub = "superclass-subclass relationship"
           = "superclass(es)" /sub
           = "subclass(es)" /super
 @"http://www.topicmaps.org/xtm/1.0/core.xtm#superclass-subclass"]
[super     = "superclass"
 @"http://www.topicmaps.org/xtm/1.0/core.xtm#superclass"]
[sub       = "subclass"
 @"http://www.topicmaps.org/xtm/1.0/core.xtm#subclass"]
[sort      = "sort"
 @"http://www.topicmaps.org/xtm/1.0/core.xtm#sort"]


/* -------------- topic types -------------- */

[application_domain = "application domain"
 @"http://psi.xml.org/stdsreg/#application_domain"]
[application_programming_interface = "application programming interface"
 @"http://psi.xml.org/stdsreg/#application_programming_interface"]
[character_set = "character set"
 @"http://psi.xml.org/stdsreg/#character_set"]
[character_encoding = "character encoding"
 @"http://psi.xml.org/stdsreg/#character_encoding"]
[data_model = "data model"
 @"http://psi.xml.org/stdsreg/#data_model"]
[document = "document"
 @"http://psi.xml.org/stdsreg/#document"]
[document_stage = "document stage"
 @"http://psi.xml.org/stdsreg/#document_stage"]
[legal_entity = "legal entity"
 @"http://psi.xml.org/stdsreg/#legal_entity"]
 [organization = "organization"
  @"http://psi.xml.org/stdsreg/#organization"]
  [standards_body = "standards body"
   @"http://psi.xml.org/stdsreg/#standards_body"]
 [person = "person"
  @"http://psi.xml.org/stdsreg/#person"]
[standards_body_subdivision = "standards body subdivision"
 @"http://psi.xml.org/stdsreg/#standards_body_subdivision"]
[technology = "technology"
 @"http://psi.xml.org/stdsreg/#technology"]
 [formal_language = "formal language"
  @"http://psi.xml.org/stdsreg/#formal_language"]
  [constraint_language = "constraint language"
   @"http://psi.xml.org/stdsreg/#constraint_language"]
  [interface_definition_language = "interface definition language"
   @"http://psi.xml.org/stdsreg/#interface_definition_language"]
  [processing_language = "processing language"
   @"http://psi.xml.org/stdsreg/#processing_language"]
  [programming_language = "programming language"
   @"http://psi.xml.org/stdsreg/#programming_language"]
  [protocol = "protocol"
   @"http://psi.xml.org/stdsreg/#protocol"]
  [query_language = "query language"
   @"http://psi.xml.org/stdsreg/#query_language"]
  [serialization_syntax = "serialization syntax"
   @"http://psi.xml.org/stdsreg/#serialization_syntax"]
 [metalanguage = "metalanguage"
  @"http://psi.xml.org/stdsreg/#metalanguage"]


/* -------------- association types and corresponding role types -------------- */

[approval = "approval"
 @"http://psi.xml.org/stdsreg/#approval"]
   /* role types declared elsewhere: document, standards_body[_subdivision] */

[authorship = "authorship"
 @"http://psi.xml.org/stdsreg/#authorship"]
  [author = "author"
   @"http://psi.xml.org/stdsreg/#author"]
   /* other role type declared elsewhere: document */

[containment = "containment"
 @"http://psi.xml.org/stdsreg/#containment"]
  [container = "container"
   @"http://psi.xml.org/stdsreg/#container"]
  [containee = "containee"
   @"http://psi.xml.org/stdsreg/#containee"]

[contribution = "contribution"
 @"http://psi.xml.org/stdsreg/#contribution"]
  [contributor = "contributor"
   @"http://psi.xml.org/stdsreg/#contributor"]
   /* other role type declared elsewhere: document */

[document-document_stage = "document/document stage"
 @"http://psi.xml.org/stdsreg/#document-document_stage"]
   /* role types declared elsewhere: document, document_stage */

[editorship = "editorship"
 @"http://psi.xml.org/stdsreg/#editorship"]
  [editor = "editor"
   @"http://psi.xml.org/stdsreg/#editor"]
   /* other role type declared elsewhere: document */

[encoding = "encoding"
 @"http://psi.xml.org/stdsreg/#encoding"]
  [encoder = "encoder"
   @"http://psi.xml.org/stdsreg/#encoder"]
  [encodee = "encodee"
   @"http://psi.xml.org/stdsreg/#encodee"]

[expression = "expression"
 @"http://psi.xml.org/stdsreg/#expression"]
  [expressor = "expressor"
   @"http://psi.xml.org/stdsreg/#expressor"]
  [expressee = "expressee"
   @"http://psi.xml.org/stdsreg/#expressee"]

[maintenance = "maintenance"
 @"http://psi.xml.org/stdsreg/#maintenance"]
   /* role types declared elsewhere: document, standards_body[_subdivision] */

[membership = "membership"
 @"http://psi.xml.org/stdsreg/#membership"]
  [member = "member"
   @"http://psi.xml.org/stdsreg/#member"]
  [collection = "collection"
   @"http://psi.xml.org/stdsreg/#collection"]

[operation = "operation"
 @"http://psi.xml.org/stdsreg/#operation"]
  [operator = "operator"
   @"http://psi.xml.org/stdsreg/#operator"]
  [operatee = "operatee"
   @"http://psi.xml.org/stdsreg/#operatee"]

[representation = "representation"
 @"http://psi.xml.org/stdsreg/#representation"]
  /* role types declared elsewhere: person, organization, standards_body_subdivision */

[data_model_representation = "data model representation"
 @"http://psi.xml.org/stdsreg/#data_model_representation"]
  [representor = "representor"
   @"http://psi.xml.org/stdsreg/#representor"]
  [representee = "representee"
   @"http://psi.xml.org/stdsreg/#representee"]

[specification = "specification"
 @"http://psi.xml.org/stdsreg/#specification"]
   /* role types declared elsewhere: document, technology */

[usage = "usage"
 @"http://psi.xml.org/stdsreg/#usage"]
  [user = "user"
   @"http://psi.xml.org/stdsreg/#user"]
  [usee = "usee"
   @"http://psi.xml.org/stdsreg/#usee"]


/* -------------- superclass-subclass relationships -------------- */

 /* page 1 */

  /* superclass: legal_entity */
super-sub( person : sub, legal_entity : super )
super-sub( organization : sub, legal_entity : super )

  /* superclass: organization */
super-sub( standards_body : sub, organization : super )

 /* page 2 */

  /* superclass: technology */
super-sub( metalanguage : sub, technology : super )
super-sub( formal_language : sub, technology : super )
super-sub( data_model : sub, technology : super )
super-sub( character_encoding : sub, technology : super )
super-sub( character_set : sub, technology : super )
super-sub( application_programming_interface : sub, technology : super )

  /* superclass: formal_language */
super-sub( interface_definition_language : sub, formal_language : super )
super-sub( programming_language : sub, formal_language : super )
super-sub( serialization_syntax : sub, formal_language : super )
super-sub( constraint_language : sub, formal_language : super )
super-sub( query_language : sub, formal_language : super )
super-sub( processing_language : sub, formal_language : super )
super-sub( protocol : sub, formal_language : super )

/* -------------- templating associations -------------- */

approval( standards_body : organization, document : document )
approval( standards_body_subdivision : organization, document : document )

authorship( person : author, document : document )

containment( standards_body : container, standards_body_subdivision : containee )
containment( standards_body_subdivision : container, standards_body_subdivision : containee )

contribution( person : contributor, document : document )

data_model_representation( application_programming_interface : representor, data_model : representee )
data_model_representation( serialization_syntax : representor, data_model : representee )

document-document_stage( document : document, document_stage : document_stage )

editorship( person : editor, document : document )

encoding( character_set : encoder, character_encoding : encodee )

expression( application_programming_interface : expressee, interface_definition_language : expressor )
expression( application_programming_interface : expressee, programming_language : expressor )

maintenance( standards_body_subdivision : organization, document : document )

membership( legal_entity : member, standards_body : collection )
membership( legal_entity : member, standards_body_subdivision : collection )

operation( constraint_language : operator, data_model : operatee )
operation( processing_language : operator, data_model : operatee )
operation( query_language : operator, data_model : operatee )

representation( person : person, organization : organization, standards_body_subdivision : standards_body_subdivision)

specification( document : document, technology : technology )

usage( formal_language : user, metalanguage : usee )


/* -------------- topic instances -------------- */

 /* document */
[iso18048 : document = "ISO/IEC 18048: Topic Map Query Language"]
[sam-spec : document = "The Standard Application Model for Topic Maps"]

 /* document stage */
[committee-draft : document_stage = "Committee Draft"]

 /* legal entity */
 /* organization */
[empolis : organization = "Empolis"]
[ontopia : organization = "Ontopia"]
[din : organization = "Deutsches Institut für Normung (DIN)"]
[nts : organization = "Norsk teknologistandardisering (NTS)"]
[bsi : organization = "British Standards Institute"]

 /* standards body */
[iso : standards_body = "International Organization for Standardization"]

 /* standards body subdivision */
[sc34 : standards_body_subdivision = "ISO/IEC JTC 1/SC 34"]
[wg3  : standards_body_subdivision = "ISO/IEC JTC 1/SC 34/WG 3"]

 /* person */
[hhr : person = "Hans Holger Rath"]
[lmg : person = "Lars Marius Garshol"]
[gdm : person = "Graham Moore"]

 /* technology */
 /* formal language */
 /* constraint language */
[tmcl : constraint_language = "Topic Map Constraint Language"]
[osl : constraint_language = "Ontopia Schema Language (OSL)"]

 /* interface definition language */
[idl : interface_definition_language = "IDL"]

 /* processing language */
[xslt : processing_language = "XSLT"]

 /* programming language */
[java : programming_language = "Java"]

 /* protocol */
[http : protocol = "HTTP"]

 /* query language */
[tmql : query_language = "Topic Map Query Language"]
[tolog : query_language = "tolog"]
[xquery : query_language = "XQuery"]
[xpath : query_language = "XPath"]

 /* serialization syntax */
[hytm : serialization_syntax = "HyTM"]
[xtm : serialization_syntax = "XTM"]
[xml : serialization_syntax = "Extensible Markup Language"]

 /* application programming interface */
[tmapi : application_programming_interface = "TM API"]
[sax : application_programming_interface = "SAX"]

 /* data model */
[standard_application_model : data_model = "Standard Application Model"]
[xml_infoset : data_model = "XML Infoset"]

 /* character set */
[unicode : character_set = "Unicode"]

 /* character encoding */
[utf-8 : character_encoding = "UTF-8"]

 /* application domain */
[x5 : application_domain = "application domain X"]

 /* metalanguage */
[xml : metalanguage = "XML"]


/* -------------- association instances -------------- */

 /* approval */
    approval( iso : organization, iso18048 : document )
    approval( sc34 : organization, iso18048 : document )
    approval( wg3 : organization, sam-spec : document )

 /* authorship */
    authorship( lmg : author, sam-spec : document )

 /* containment */
    containment( iso : container, sc34 : containee )
    containment( sc34 : container, wg3 : containee )

 /* contribution */
    contribution( gdm : contributor, sam-spec : document )

 /* data model representation */
    data_model_representation( xtm : representor, standard_application_model : representee )
    data_model_representation( tmapi : representor, standard_application_model : representee )
    data_model_representation( xml : representor, xml_infoset : representee )
    data_model_representation( sax : representor, xml_infoset : representee )

 /* document/document stage */
    document-document_stage( iso18048 : document, committee-draft : document_stage )

 /* editorship */
    editorship( hhr : editor, iso18048 : document )
    editorship( lmg : editor, iso18048 : document )
    editorship( lmg : editor, sam-spec : document )
    editorship( gdm : editor, sam-spec : document )

 /* encoding */
    encoding( utf-8 : encoder, unicode : encodee )

 /* expression */
    expression( sax : expressee, java : expressor )
    expression( tmapi : expressee, java : expressor )

 /* maintenance */
    maintenance( sc34 : organization, iso18048 : document )

 /* membership */
    membership( din : member, sc34 : collection )
    membership( nts : member,  sc34 : collection )

 /* operation */
    operation( tmql : operator, standard_application_model : operatee )
    operation( tmcl : operator, standard_application_model : operatee )
    operation( xquery : operator, xml_infoset : operatee )
    operation( xpath : operator, xml_infoset : operatee )

 /* representation */
    representation( hhr : person, din : organization, sc34 : standards_body_subdivision)
    representation( lmg : person, nts : organization, sc34 : standards_body_subdivision)
    representation( gdm : person, bsi : organization, sc34 : standards_body_subdivision)

 /* specification */
    specification( iso18048 : document, tmql : technology )

 /* usage */
    usage( xtm : user, xml : usee)