;;; -*- Mode: Lisp; Syntax: Lisp; -*-
;;; Peter Denno, 2004-11-05
;;; SUMO extension for CCT
;;; This represent my guess at what the CCTS intends.
;;; Convention: Where the CCTS writes "X. Type" I write "X.Type"
;;; Where the CCTS writes "Abc Def" I write "AbcDef"
;;; The ontology uses the name CctX to refer to the CCT X.
;;; Interpretation:
;;;
;;; (1) An oddity of the CCTs is the idea that an "Object Class" has a "Property Term" that
;;; might be "Type." This appears to get wrong the fundamental notion that a type is
;;; distinguished by its properties. It appears as though the type is *one* of
;;; the properties. Perhaps it is just an anomaly in the naming schema. After some study
;;; I think what is intended is as follows:
;;;
;;; - X is type (a "CoreComponentType") whose name is a "Representation Term" in the
;;; naming scheme. 10 such types are defined in the spec: (Text, Identifier, Code, etc.)
;;; and more can be defined through the "discovery process".
;;; X, being a type, may have instances. The situation with Code and Code List needs
;;; further explanation: both are types. Instances of Code are the elements of a
;;; Code List (e.g. "us" an element of ISO 3166). Instances of Code List are things
;;; such as ISO 3166. The Supplementary Component Code List is not about the Code "us"
;;; but about the code list ISO 3166. The SCs Code.Content and Code.Text.Name are
;;; properties of the code list element ("us" and "United States" respectively). In
;;; all other uses of .Content and .Text.Name (e.g. DateTime.Content) the value provided
;;; is a restriction on the type. That is, the type is constrainted to (a single instance?)
;;; having that content. I can see no other interpretation of this that doesn't go about
;;; collecting instance data (all the dates used in some particular instance of a message
;;; type, etc.).
;;;
;;; - X.Type is the "Dictionary Entry Name" of metadata about an *instance* of type X.
;;; In that sense, it is the metaobject of the type X, (but I am not taking that approach to
;;; representation). X.Type only serves the purpose of naming a concept
;;; which *can be* related to the metadata. The actual metadata is registered under
;;; dictionary entry names called "Supplementary Components" and "Core Component Type Content."
;;; Though the name X.Type *can be* related to the metadata, the spec doesn't
;;; specify this relation. (e.g. a Code.Type is presumably related to a CodeList, but how?).
;;; I added relationships of this sort.
;;;
;;; - Dictionary Entry Names (of "Supplementary Components" "Core Component Type Content", and
;;; CCs generally) name &%BinaryRelations which are part of the implementation of the
;;; "ontology-as-registry." The first domain of the relation references an instance of
;;; the CC. The second domain of the relation provides a value of the property named by
;;; the relation. Thus (instance ISO-3166-cl CctCodeList), (CodeList.Agency.Name ISO-3166-cl "ISO")
;;;
;;; (2) The spec does not distinguish Identifier/Code/Text adequately.
;;; Finding a useful distinction is torturous. I'll suppose the following. The
;;; consequence will be that we can attach domain knowledge to Codes but not to Identifiers.
;;; That distinction suggest to me that I have it right.
;;;
;;; - Code
;;; Code describes a space of symbols for which knowledge of the
;;; referent is established by a mapping described in a code list. A code list
;;; is published (all parties can know it) and is essentialy a list of
;;; binary relations between the symbols in the space and definite descriptions.
;;; Example: There are Codes for ISO-3166 and the ISO-3166 spec defines its
;;; code list.
;;;
;;; - Identifier
;;; Identifier describes a space of symbols for which the referent is not
;;; established in any *known* code list. This is almost certainly NOT what
;;; was intended because the definition speaks of an 'identification scheme'
;;; (a term used often in EDIFACT) but it IS consistent with how Identifier is used
;;; in the Primer. [Footnote: A specification of identification schemes are the
;;; two parts of ISO-6523. I have not yet read these, and they only concerns ISs for
;;; organizations. I doubt that they would shed much light anyway.)]
;;;
;;; The Primer uses Identifiers for things such as "Quotation Number" "Customer Order Number"
;;; and "Part Number". With that in mind, I define the Identifier type:
;;;
;;; IDENTIFIER = a type that describes a space of symbols for which the
;;; referent is not established in any *known* code list, but for which
;;; may exist an identification scheme based on (1) an ordering of the symbols;
;;; and (2) an inductive rule that identifies the intended referent.
;;; NOTE: An example "inductive rule" : the item with serial number S003
;;; is the item manufactured directly after item S002 was manufactured.
;;; NOTE: The metadata recorded by the Identifier CCTs does not reference a Code List,
;;; therefore the nature of the "identification scheme" is implicit, known perhaps
;;; to the communicating agents.
;;;
;;; I summary, I have disregarded the definition of Identifier in the CCTS and
;;; invented one that I think is consistent with the Primer. Also, I have not
;;; implemented any of the Identification Scheme SCs because in those cases where
;;; it is known, the "identifier" is a Code, (by my definintion) and Code List metadata
;;; can be used.
;;;
;;; - Text
;;; My interpretation of Text ignores the "Remark" in Section 8.1: "shall
;;; be used for names (i.e. words or phrases that constitutes the distinctive
;;; designation of a person, place, thing or concept.)". The Identifier CCT does this.
;;; The Text CCT is just free-form text -- because such a thing is needed (for descriptions,
;;; remarks etc.). This, and not as the remark suggests, is how it is used in the
;;; examples and Primer.
;;;
;;; (3) The CCTS seems to use Code as a type in many places, for example, where it is a
;;; representation term. This is consistent with my saying that a Code defines a space of
;;; symbols with mappings to referents. Code List contains Supplementary Components (metadata)
;;; for the code. Where things fall apart is in registering Codes in the registry:
;;; The spec says Code.Name and Code.Content are the code value and its referent respectively.
;;; It appears that the registry is not normalized (in RDB terms). Was it intended that the
;;; strings Code.Name and Code.Content are *lists* (like comma seperated values)?
;;; The UBL Code List document glosses over this question too. Everything there goes straight
;;; to XSD without showing what is in the registry. As things stand, I can't find a way to use
;;; the Code.Name and Code.Content registry entries.
;;;
;;; (4) Two potential modeling routes, exemplified by : (instance incotermsCodeTerm CctCode) versus
;;; (subclass incotermsCodeTerm CctCode). I chose the former because I am assuming that the
;;; the CCTS machinery, and not the ontology, is doing the work of placing restrictions on the
;;; type. The equivalent ontology restrictions will be inferred from the registry data. If this
;;; fails to be effective, it ought to be noted. Note that this arrangement couldn't possibly
;;; work in a description logic, since the instance incotermsCodeTerm has instances. (Whether
;;; it will work in SUMO remains to be seen). The first casualty of this approach is that I
;;; can't use sumo "disjoint" to say that the elements (would be instances) of one code list
;;; are not elements of another code list.
;;;
;;; (5) I suspect that the CCTS conceptualization of Numeric, Quantity, and Measure as distinct types
;;; is flawed, but I haven't had time to think about it, and anyway, that's not my job right now.
(instance CoreComponentType ContentBearingObject)
(documentation CoreComponentType "Types (similar to XML Schema built-in types) of which 10
are defined in the CCTS (&%CCTS_V201) and more can be defined through the CCTS
'discovery proces.'")
;;; Use of &%version would be nice
(instance CCTS_V201 ContentBearingObject)
(documentation CCTS_V201 "CCTS Version 2.01 Final is the UN/CEFACT Core Component
Technology Technical Specification version 2.01, Part 8 of the ebXML Framework.
http://www.unece.org/cefact/ebxml/CCTS_V2-01_Final.pdf")
(instance SupplementaryComponent ContentBearingObject)
(documentation SupplementaryComponent "A object that carries CC metadata similar to the
'X.Type' CCT objects. But whereas X names a 'Representation Term' (e.g. X = Code) these
do not (e.g. CodeList is a SupplementaryComponent and there is no CodeList.Type and
CodeList is not a Representation Term.")
(subclass CctPrimitiveString ContentBearingObject)
(subclass CctPrimitiveDecimal RationalNumber) ; POD....
(sublcass URI SymbolicString) ; POD SUMO has one...
(documentation URI "A Uniform Resource Identifier, &%URI, is an Internet protocol element
consisting of a short string of characters that conform to a certain syntax. The string indicates
a name or address that can be used to refer to an abstract or physical resource. The IETF codified
it as RFC 2396, based on earlier proposals from Tim Berners-Lee. The URI syntax is essentially a
URI scheme name like 'http', 'ftp', 'mailto', 'urn', etc., followed by a colon character, and then
a scheme-specific part. (Wikipedia, 2004-11-08)")
;;; POD SUMO subrelation doesn't allow narrowing the domains ???
(subrelation supplementsComponent containsInformation)
(instance supplementsComponent InheritableRelation)
(domain supplementsComponent 1 CoreComponentType) ; pod need to add SupplementaryComponent.
(domain supplementsComponent 2 Proposition)
(documentation supplementsComponent "(supplementsComponent ?CCT ?PROPOSITION) means that ?CCT 'has
value' ?PROPOSITION for the property named supplementsComponent. 'has value' is used here in the
manner of &%containsInformation. The 'properties' represented are those properties described by
the 'Supplementary Components' or 'Core Component Type Content' of the ?CCT.
So as to implement the 'ontology-as-registry,' &%supplementsComponent is an abstract relation
whose &%subRelations name a Supplementary Component (e.g. &%codeListAgencyIdentifier).")
;;;----- Text. Type -----
(subclass CctText CoreComponentType)
(documentation CctText "&%CctText is a &%CoreComponentType describing the space of
text objects.")
(subrelation textContent supplementsComponent)
(domain textContent 1 CctText)
(domain textContent 2 CctPrimitiveString)
(documentation textContent "(textContent ?CCTTEXT ?STRING) means that the instance
?CCTTEXT of type &CctText is required to contain the string ?STRING. It is assumed
that this would be used to represent constraints like FIXED in XML DTTs.")
;;;----- Code. Type -----
(subclass CctCode CoreComponentType)
(documentation CctCode "&%CctCode is a &%CoreComponentType describing, for each
such type, a space of identifiers whose meaning is described in a &%CctCodeList.
Instances of &%CctCode are the identifiers themselves, (e.g. 'us' in ISO 3166).")
(subrelation codeContent supplementsComponent)
(domain codeContent 1 CctCode)
(domain codeContent 2 SymbolicString) ; pod spec would say CctPrimitiveString
(documentation codeContent "A character string (letters, figures or symbols) that for
brevity and/or language independence may be used to represent or replace a definitive value
or text of an attribute. [&%CCTS_V201] (&%codeNameText ?CODE ?STRING) associates
a descriptive string with the code. The CCTS and the UBL CodeList document,
2004-04-20 do not describe how this entry might be used. It appears to me to violate
relational normalization. (Is it a list of entries for a given code? Otherwise
there is no relation to the code list.) (see also &%code.Name.Text).")
(subrelation codeNameText supplementsComponent)
(subrelation codeNameText names)
(domain codeNameText 1 CctCode)
(domain codeNameText 2 CctPrimitiveString)
(documentation codeNameText "The textual equivalent of the code content. [&%CCTS_V201]
The CCTS and the UBL CodeList document, 2004-04-20 do not describe how this entry might be used.
It appears to me to violate relational normalization. (Is it a list of entries for a given code?
Otherwise there is no relation to the code list.) (see also &%codeNameContent).")
;;;----- CodeList -----
(subclass CctCodeList SupplementaryComponent)
(documentation CctCodeList "A &%CctCodeList is a &%SupplementaryComponent that represents
a real-world code, such as ISO-3166, Incoterms-2000, etc.")
(subrelation codeListAgencyIdentifier supplementsComponent)
(domain codeListAgencyIdentifier 1 CctCodeList)
(domain codeListAgencyIdentifier 2 CctPrimitiveString)
(documentation codeListAgencyIdentifier "(&%CodeListAgencyIdentifier ?CODELIST ?ID)
relates a codeList (e.g. the codeList representing ISO-3166) to an &%Organization responsible
for the specification, by used of an 'Identfier' (actually a code value). &%CCTS_V201 says that
Identifier is typically a value from UN/EDIFACT code list 3055, thus we may have
(codeListAgencyIdentifier ISO-3166-cl 5) where 5 represents ISO in UN/EDIFACT 3055.")
(subrelation codeListAgencyNameText supplementsComponent)
(subrelation codeListAgencyNameText names)
(domain codeListAgencyNameText 1 CctCodeList)
(domain codeListAgencyNameText 2 CctPrimitiveString)
(documentation codeListAgencyNameText "(&%CodeListAgencyNameText ?CODELIST ?STRING)
relates a codeList (e.g. the codeList representing ISO-3166) to a string naming the
&%Organization responsible for the specification of the CodeList.
(e.g. 'International Organization for Standards' for ISO-3166)")
(subrelation codeListNameText supplementsComponent)
(subrelation codeListNameText names)
(domain codeListNameText 1 CctCodeList)
(domain codeListNameText 2 CctPrimitiveString)
(documentation codeListNameText "(&%CodeListNameText ?CODELIST ?STRING)
relates a codeList (e.g. the codeList representing ISO-3166) to a string naming it
(e.g. 'ISO-3166' for ISO-3166)")
(subrelation codeListIdentifier supplementsComponent)
(domain codeListIdentifier 1 CctCodeList)
(domain codeListIdentifier 2 SymbolicString)
(documentation codeListIdentifier "(&%CodeListIdentifier ?CODELIST ?STRING)
relates a codeList (e.g. the codeList representing ISO-3166) to an identifier
(such as a URI) identifying it.")
(subrelation codeListSchemeURI supplementsComponent)
(domain codeListSchemeURI 1 CctCodeList)
(domain codeListSchemeURI 2 URI)
(documentation codeListSchemeURI "(&%codeListSchemeURI ?CODELIST ?STRING)
relates a codeList (e.g. the codeList representing ISO-3166) to a URI identifying
its identification scheme.")
(subrelation codeListURI supplementsComponent)
(domain codeListURI 1 CctCodeList)
(domain codeListURI 2 URI)
(documentation codeListURI "(&%codeListURI ?CODELIST ?STRING)
relates a codeList (e.g. the codeList representing ISO-3166) to a URI
identifying its identification scheme.")
; Use of &%version would be nice
(subrelation codeListVersionIdentifier supplementsComponent)
(domain codeListVersionIdentifier 1 CctCodeList)
(domain codeListVersionIdentifier 2 SymbolicString)
(documentation codeListVersionIdentifier "(&%codeListVersionIdentifier ?CODELIST ?STRING)
describes the version designation of ?CODELIST.")
;;;----- DateTime. Type -----
(subclass CctDateTime CoreComponentType)
(documentation cctDateTime "&%cctDateTime is a &%CoreComponentType representing
a &%TimePoint")
(subrelation cctDateTimeContent supplementsComponent)
(domain cctDateTimeContent 1 CctDateTime)
(domain cctDateTimeContent 2 SymbolicString)
(documentation cctDateTimeContent "(&%cctDateTimeContent ?DT ?STRING) associates
a string representing a &%TimePoint with an instance of the DateTime type. This
is useful in cases where the type ?DT is restricted to just that one particular
timepoint.")
(subrelation cctDateTimeFormatText supplementsComponent)
(domain cctDateTimeFormatText 1 CctDateTime)
(domain cctDateTimeFormatText 2 SymbolicString)
(documentation cctDateTimeFormatText "(&%cctDateFormatText ?DT ?STRING) means ?STRING
is a string describing how instances of the &%CctDateTime type, ?DT,
represent a &%TimePoint.")
;;;----- Amount. Type -----
(subclass CctAmount CoreComponentType)
(documentation CctAmount "A number of monetary units specified in a currency where the
unit of currency is explicit or implied. [&%CCTS_V201]. CctAmount is a &%CoreComponentType.")
(subrelation cctAmountContent supplementsComponent)
(domain cctAmountContent 1 CctAmount)
(domain cctAmountContent 2 CctPrimitiveDecimal)
(documentation cctAmountContent "(&%cctAmountContent ?AMT ?DECIMAL) relates a number
of monetary units ?DECIMAL, specified in a currency (implied or explict) to an instance
of a &%CctAmount. This is useful in cases where the type ?AMT is restricted to just
that one particular value, ?DECIMAL.")
(subrelation cctAmountCurrencyIdentifier supplementsComponent)
(domain cctAmountCurrencyIdentifier 1 CctAmount)
(domain cctAmountCurrencyIdentifier 2 SymbolicString)
(documentation cctAmountCurrencyIdentifier "(&%cctAmountCurrencyIdentifier ?AMT ?STRING)
relates a currency identifier ?STRING expressed as a &%SymbolicString to the &%CctAmount ?AMT.
The &%SymbolicString is a value in the code list defined in ISO 4217 (also available as
UN/ECE Rec 9).")
; Use of &%version would be nice
(subrelation cctAmountCurrencyCodeListVersionIdentifier supplementsComponent)
(domain cctAmountCurrencyCodeListVersionIdentifier 1 CctAmount)
(domain cctAmountCurrencyCodeListVersionIdentifier 2 SymbolicString)
(documentation cctAmountCurrencyCodeListVersionIdentifier
"(&%cctAmountCurrencyCodeListVersionIdentifier
?AMT ?STRING) relates ?STRING, a version of ISO 4217 (also known as UN/ECE Rec 9) with
the &%CctAmount type ?AMT. ISO 4217 is a code list of currency codes.")
;;;----- Numeric. Type -----
(subclass CctNumeric CoreComponentType)
(documentation CctNumeric "Numeric infomation that is assigned or is determined by
calculation, counting, or sequencing [&%CCTS_V201]")
(subrelation cctNumericContent supplementsComponent)
(domain cctNumericContent 1 CctNumeric)
(domain cctNumericContent 2 CctPrimitiveString)
(documentation cctNumericContent "(&%cctNumericContent ?NUM ?VAL) relates a single
value ?VAL to the &%CctNumeric type ?NUM. This is useful in cases where the type
?NUM is restricted to just the one particular value, ?VAL. The meaning of
the string ?VAL is described by string ?STR in (&%cctNumericFormatText ?NUM ?STR).")
(subrelation cctNumericFormatText supplementsComponent)
(domain cctNumericFormatText 1 CctNumeric)
(domain cctNumericFormatText 2 CctPrimitiveString)
(documentation cctNumericFormatText "(&%cctNumericFormatText ?NUM ?VAL) relates a single
value ?VAL to the &%CctNumeric type ?NUM. This is useful in cases where the type
?NUM (a &%CctNumeric) is restricted to just the one particular value, ?VAL. The meaning of
the string ?VAL is described by string ?STR in (&%cctNumericFormatText ?NUM ?STR).")
;;;----- Identifier. Type -----
(subclass CctIdentifier CoreComponentType)
(documentation CctIdentifier "&%CctIdentifier a type (a &%CoreComponentType) that describes
a space of &%SymbolicStrings for which the referent is not established in any *known*
code list, but for which may exist an identification scheme based on (1) an ordering of
the symbols; and (2) an inductive rule that identifies the intended referent.
NOTE: An example 'inductive rule' : the item with serial number S003 is the item manufactured
directly after item S002 was manufactured.
NOTE: The metadata recorded by the Identifier CCTs
does not reference a Code List, therefore the nature of the 'identification scheme' is implicit,
known perhaps to the communicating agents.
NOTE: This is NOT the definition provided in &%CCTS_V201.")
(subrelation cctIdentifierContent supplementsComponent)
(domain cctIdentifierContent 1 CctIdentifier)
(domain cctIdentifierContent 2 SymbolicString)
(documentation cctIdentifierContent "(&%cctIdentifierContent ?ID ?STRING) relates a single
&%SymbolicString value ?STR to the &%CctIdentifier type ?ID. This is useful in cases where
the type ?ID (a &%CctIdentifier) is restricted to just the one particular value, ?STRING.")
;;;----- Indicator. Type -----
; POD work in &%TruthValue
(subclass CctIndicator CoreComponentType)
(documentation "&%CctIndicator is a &%CoreComponentType representing a &%TruthValue
containing just two values (often &%True / &%False, yes / no, on / off etc) where the logical
complement of one value is the other value.")
(subrelation cctIndicatorContent supplementsComponent)
(domain cctIndicatorContent 1 CctIndicator)
(domain cctIndicatorContent 2 SymbolicString)
(documentation cctIndicatorContent "(&%cctIndicatorContent ?BOOL ?VAL) relates a single
&%SymbolicString value ?VAL to the &%CctIndicator type ?BOOL. This is useful in cases where
the type ?BOOL (a &%CctIndicator) is restricted to just the one particular value, ?VAL.")
(subrelation cctIndicatorFormatText supplementsComponent)
(domain cctIndicatorFormatText 1 CctIndicator)
(domain cctIndicatorFormatText 2 CctPrimitiveString)
(documentation cctIndicatorFormatText "(&%cctIndicatorFormatText ?BOOL ?STRING) relates
the type ?BOOL (a &%CctIndicator) with the string ?STRING which describes how the two
values of the type map (bijectively, we hope ;^) to the logical values TRUE and FALSE.")
;;;----- Binary Object. Type -----
(subclass CctBinaryObject CoreComponentType)
(documentation CctBinaryObject "A &%CctBinaryObject is a &%CoreComponentType representing
a finite length sequence of binary octets. [&%CCTS_V201]")
(subrelation cctBinaryObjectContent supplementsComponent)
(domain cctBinaryObjectContent 1 CctBinaryObject)
(domain cctBinaryObjectContent 2 SymbolicString)
(documentation cctBinaryObjectContent "(&%cctBinaryObjectContent ?TYPE ?VAL) relates a single
&%CctBinaryObject instance ?VAL to the &%CctBinaryObject type ?TYPE. This is useful in cases
where the type ?TYPE (a &%CctBinaryObject) is restricted to just the one particular value, ?VAL.")
(subrelation cctBinaryObjectFormatText supplementsComponent)
(domain cctBinaryObjectFormatText 1 CctBinaryObject)
(domain cctBinaryObjectFormatText 2 CctPrimitiveString)
(documentation cctBinaryObjectFormatText "(&%cctBinaryObjectFormatText ?TYPE ?STRING) relates
type ?TYPE (a &%CctBinaryObject) with a &%CctPrimitiveString which describes the encoding
discipline used in ?TYPE. (This is not the definition provided in &%CCTS_V201.)")
(subrelation cctBinaryObjectMimeCode supplementsComponent)
(domain cctBinaryObjectMimeCode 1 CctBinaryObject)
(domain cctBinaryObjectMimeCode 2 SymbolicString)
(documentation cctBinaryObjectMimeCode "(&%cctBinaryObjectMimeCode ?TYPE ?STRING) relates
type ?TYPE (a &%CctBinaryObject) with a &%SymbolicString which identifies the mimetype
(IETF RFC 2045, 2046, 2047) associated with instances of this type.")
(subrelation cctBinaryObjectCharacterSetCode supplementsComponent)
(domain cctBinaryObjectCharacterSetCode 1 CctBinaryObject)
(domain cctBinaryObjectCharacterSetCode 2 SymbolicString)
(documentation cctBinaryObjectCharacterSetCode "(&%cctBinaryObjectCharacterSetCode ?TYPE ?STRING)
relates type ?TYPE (a &%CctBinaryObject) with a &%CctPrimitiveString which identifies the
character set used in cases where the mime type (IETF RFC 2045, 2046, 2047) of ?TYPE is 'Text'")
(subrelation cctBinaryObjectEncodingCode supplementsComponent)
(domain cctBinaryObjectEncodingCode 1 CctBinaryObject)
(domain cctBinaryObjectEncodingCode 2 SymbolicString)
(documentation cctBinaryObjectEncodingCode "(&%cctBinaryObjectEncodingCode ?TYPE ?STRING)
relates type ?TYPE (a &%CctBinaryObject) with a &%CctPrimitiveString which identifies the
decoding algorithm (IETF RFC 2045, 2046, 2047) used in ?TYPE")
(subrelation cctBinaryObjectURI supplementsComponent)
(domain cctBinaryObjectURI 1 CctBinaryObject)
(domain cctBinaryObjectURI 2 URI)
(documentation cctBinaryObjectURI "(&%cctBinaryObjectURI ?TYPE ?URI)
relates type ?TYPE (a &%CctBinaryObject) with a &%URI where it is located.
This is useful in cases where the type ?TYPE contains just one instance.")
(subrelation cctBinaryObjectFilenameText supplementsComponent)
(domain cctBinaryObjectFilenameText 1 CctBinaryObject)
(domain cctBinaryObjectFilenameText 2 FilenameText)
(documentation cctBinaryObjectFilenameText "(&%cctBinaryObjectFilenameText ?TYPE ?FILENAME)
relates type ?TYPE (a &%CctBinaryObject) with a filename, ?FILENAME where it is located.
This is useful in cases where the type ?TYPE contains just one instance.")
;;;----- Measure. Type -----
(subclass CctMeasure CoreComponentType)
(documentation CctMeasure "The numeric value determined by measuring an object [&%CCTS_V201]")
(subrelation cctMeasureContent supplementsComponent)
(domain cctMeasureContent 1 CctMeasure)
(domain cctMeasureContent 2 CctPrimitiveDecimal)
(documentation cctMeasureContent "(&%cctMeasureContent ?MEASURE ?VAL) relates a single
&%CctPrimitiveDecimal value ?VAL to the &%CctMeasure type ?MEASURE. This is useful in cases
where the type ?MEASURE is restricted to just the one particular value, ?VAL.")
(subrelation cctMeasureUnitCode supplementsComponent)
(domain cctMeasureUnitCode 1 CctMeasure)
(domain cctMeasureUnitCode 2 CctPrimitiveDecimal)
(documentation cctMeasureUnitCode "(&%cctMeasureUnitCode ?MEASURE ?UNITS) associates a
Units Code ?UNITS (from the code list UN/ECE Rec 20) to the type ?MEASURE.")
; Use of &%version would be nice
(subrelation cctMeasureUnitCodeListVersionIdentifier supplementsComponent)
(domain cctMeasureUnitCodeListVersionIdentifier 1 CctMeasure)
(domain cctMeasureUnitCodeListVersionIdentifier 2 SymbolicString)
(documentation cctMeasureUnitCodeListVersionIdentifier
"(&%cctMeasureUnitCodeListVersionIdentifier ?MEASURE ?VERSION) indicates the
version, ?VERSION, of UN/ECE Rec 20 is used in assigning Units to the type ?MEASURE.
(See also &%cctMeasureUnitCode).")
;;;----- Quantity. Type -----
(subclass CctQuantity CoreComponentType)
(documentation cctQuantity "A counted number of non-monetary units. [&%CCTS_V201]")
(subrelation cctQuantityContent supplementsComponent)
(domain cctQuantityContent 1 CctQuantity)
(domain cctQuantityContent 2 CctPrimitiveDecimal)
(documentation cctQuantityContent "(&%cctQuantityContent ?TYPE ?VAL) relates a single
&%CctPrimitiveDecimal value ?VAL to the &%CctQuantity type ?TYPE. This is useful in cases
where the type is restricted to just the one particular value, ?VAL.")
(subrelation cctQuantityUnitCode supplementsComponent)
(domain cctQuantityUnitCode 1 CctQuantity)
(domain cctQuantityUnitCode 2 CctPrimitiveDecimal)
(documentation cctQuantityUnitCode "(&%cctQuantityUnitCode ?QUANTITY ?UNITS) associates a
Units Code ?UNITS (from the code list UN/ECE Rec 20) to the type ?QUANTITY.")
(subrelation cctQuantityUnitCodeListIdentifier supplementsComponent)
(domain cctQuantityUnitCodeListIdentifier 1 CctQuantity)
(domain cctQuantityUnitCodeListIdentifier 2 SymbolicString)
(documentation cctQuantityUnitCodeListIdentifier
"(&%cctQuantityUnitCodeListIdentifier ?QUANTITY ?ID) identifies the agency
responsible of the code list describing the Quantity using the Code list UN/EDIFACT 3055.")
(subrelation cctQuantityUnitCodeListAgencyName supplementsComponent)
(subrelation cctQuantityUnitCodeListAgencyName names)
(domain cctQuantityUnitCodeListAgencyName 1 CctQuantity)
(domain cctQuantityUnitCodeListAgencyName 2 SymbolicString)
(documentation cctQuantityUnitCodeListAgencyName
"(&%cctQuantityUnitCodeListAgencyName ?QUANTITY ?AGENCY) identifies the &%Organization, ?AGENCY,
responsible of the code list describing the Quantity.")
;;; Additional (not part of the spec).
(subrelation codeCodeList supplementsComponent)
(domain codeCodeList 1 CctCode)
(domain codeCodeList 1 CctCodeList)
(documentation codeCodeList "(codeCodeList ?CODE ?CODELIST) means that ?CODE, a &%CctCode is
an element of the &%CctCodeList ?CODELIST). This relation is NOT defined in &%CCTS_V201.")
(instance codeListDisjoint BinaryPredicate)
(instance codeListDisjoint SymmetricRelation)
(domain codeListDisjoint 1 CctCodeList)
(domain codeListDisjoint 2 CctCodeList)
(documentation codeListDisjoint "&%CctCodeLists are &%codeListDisjoint only if they share no
&%CctCodes. This will usually be the case, excepting perhaps two different versions of a &%CodeList.")
(<=>
(codeListDisjoint ?CL1 ?CL2)
(and
(instance ?CL1 CctCodeList)
(instance ?CL2 CctCodeList)
(forall (?INST)
(not
(and
(codeCodeList ?INST ?CL1)
(codeCodeList ?INST ?CL2))))))