001: /*****************************************************************************
002: * Source code information
003: * -----------------------
004: * Original author Ian Dickinson, HP Labs Bristol
005: * Author email Ian.Dickinson@hp.com
006: * Package Jena
007: * Created 16 Jan 2001
008: * Filename $RCSfile: DAML_OIL.java,v $
009: * Revision $Revision: 1.13 $
010: * Release status Preview-release $State: Exp $
011: *
012: * Last modified on $Date: 2008/01/02 12:07:29 $
013: * by $Author: andy_seaborne $
014: *
015: * (c) Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
016: * (see footer for full conditions)
017: *****************************************************************************/package com.hp.hpl.jena.vocabulary;
018:
019: // Imports
020: ///////////////
021: import com.hp.hpl.jena.rdf.model.*;
022:
023: /**
024: * <p>
025: * Defines a vocabulary of RDF constants used by the latest release of DAML+oil
026: * for class and property names. The contract maintained by the DAML_OIL class
027: * is that it will be periodically updated to reflect the latest release of DAML+OIL.
028: * Currently this is the March 2001 release. Older versions of the DAML+OIL
029: * vocabulary, for compatability with older ontology documents, are maintained in
030: * classes named <code>DAML_OIL_YYYY_MM</code>, for example DAML_OIL_2000_12.
031: * </p>
032: * <p>
033: * <b>Note</b> that rudimentary support for multiple versions of DAML namespaces is
034: * included in this release, by the mechanism of providing methods with the same
035: * names as the static constants in the {@link DAMLVocabulary} interface. This mechanism
036: * is still under design review, and may change in future versions of Jena.
037: * </p>
038: * <p>
039: * Note also that the capitalisation of
040: * the constants herein is designed to follow normal practice in the RDF community, rather
041: * than normal practice in the Java community. This is consistent with the capitalisation
042: * of constants in Jena.
043: * </p>
044: *
045: * @author Ian Dickinson, HP Labs (<a href="mailto:Ian.Dickinson@hp.com">email</a>)
046: * @version CVS info: $Id: DAML_OIL.java,v 1.13 2008/01/02 12:07:29 andy_seaborne Exp $
047: */
048: public class DAML_OIL implements DAMLVocabulary {
049: // Constants
050: //////////////////////////////////
051:
052: /** Singleton instance reference */
053: private static DAML_OIL s_instance = new DAML_OIL();
054:
055: /** Model to hold the vocab resoures */
056: private static Model s_model = ModelFactory.createDefaultModel();
057:
058: /* Resources */
059:
060: /** DAML namespace resource for the current release */
061: public static final Resource NAMESPACE_DAML = s_model
062: .createResource(NAMESPACE_DAML_2001_03_URI);
063:
064: /** DAML namespace resource for daml:collection. Note: strictly
065: * daml:collection is only a string, not a resource in the DAML namespace. */
066: public static final Resource collection = s_model
067: .createResource(NAMESPACE_DAML_2001_03_URI + "collection");
068:
069: /** RDF resource for DAML List class. */
070: public static final Resource List = s_model
071: .createResource(NAMESPACE_DAML_2001_03_URI + "List");
072:
073: /** RDF resource for DAML UniqueProperty class */
074: public static final Resource UniqueProperty = s_model
075: .createResource(NAMESPACE_DAML_2001_03_URI
076: + "UniqueProperty");
077:
078: /** RDF resource for DAML TransitiveProperty class */
079: public static final Resource TransitiveProperty = s_model
080: .createResource(NAMESPACE_DAML_2001_03_URI
081: + "TransitiveProperty");
082:
083: /** RDF resource for DAML UnambiguousProperty class */
084: public static final Resource UnambiguousProperty = s_model
085: .createResource(NAMESPACE_DAML_2001_03_URI
086: + "UnambiguousProperty");
087:
088: /** RDF resource for DAML Restriction class */
089: public static final Resource Restriction = s_model
090: .createResource(NAMESPACE_DAML_2001_03_URI + "Restriction");
091:
092: /** RDF resource for DAML Ontology class */
093: public static final Resource Ontology = s_model
094: .createResource(NAMESPACE_DAML_2001_03_URI + "Ontology");
095:
096: /** RDF resource for the nil (empty) list. */
097: public static final Resource nil = s_model
098: .createResource(NAMESPACE_DAML_2001_03_URI + "nil");
099:
100: /** RDF resource for the top type (i.e. the super-type of all types). */
101: public static final Resource Thing = s_model
102: .createResource(NAMESPACE_DAML_2001_03_URI + "Thing");
103:
104: /** RDF resource for the bottom type (i.e. the super-type of no types). */
105: public static final Resource Nothing = s_model
106: .createResource(NAMESPACE_DAML_2001_03_URI + "Nothing");
107:
108: /** Alias for rdfs:Literal in the daml namespace. */
109: public static final Resource Literal = s_model
110: .createResource(NAMESPACE_DAML_2001_03_URI + "Literal");
111:
112: /** RDF resource for DAML Class class (a DAML sub-class of rdfs:Class). */
113: public static final Resource Class = s_model
114: .createResource(NAMESPACE_DAML_2001_03_URI + "Class");
115:
116: /** RDF resource for DAML Datatype class (a DAML sub-class of rdfs:Class). */
117: public static final Resource Datatype = s_model
118: .createResource(NAMESPACE_DAML_2001_03_URI + "Datatype");
119:
120: /** RDF resource for DAML DatatypeProperty class (a DAML sub-class of rdf:Property). */
121: public static final Resource DatatypeProperty = s_model
122: .createResource(NAMESPACE_DAML_2001_03_URI
123: + "DatatypeProperty");
124:
125: /** RDF resource for DAML ObjectProperty class (a DAML sub-class of rdf:Property). */
126: public static final Resource ObjectProperty = s_model
127: .createResource(NAMESPACE_DAML_2001_03_URI
128: + "ObjectProperty");
129:
130: /** Alias for rdfs:Property in the daml namespace. From 2001/03 onwards, use of ObjectProperty or DatatypeProperty is suggested. */
131: public static final Resource Property = s_model
132: .createResource(NAMESPACE_DAML_2001_03_URI + "Property");
133:
134: /* Properties */
135:
136: /** RDF Property for the DAML versionInfo property */
137: public static Property versionInfo = null;
138:
139: /** RDF Property for the DAML imports property on Ontologies */
140: public static Property imports = null;
141:
142: /** RDF Property for the DAML disjointWith property on Classes */
143: public static Property disjointWith = null;
144:
145: /** RDF Property for the DAML disjointUnionOf property on Classes */
146: public static Property disjointUnionOf = null;
147:
148: /** RDF Property for the DAML sameClassAs property on Classes */
149: public static Property sameClassAs = null;
150:
151: /** RDF Property for the DAML samePropertyAs property on Properties */
152: public static Property samePropertyAs = null;
153:
154: /** RDF Property for the oneOf property on DAML class expressions */
155: public static Property oneOf = null;
156:
157: /** RDF Property for the intersectionOf property on class expressions */
158: public static Property intersectionOf = null;
159:
160: /** RDF Property for the unionOf property on class expressions */
161: public static Property unionOf = null;
162:
163: /** RDF Property for the complementOf property on class expressions */
164: public static Property complementOf = null;
165:
166: /** RDF Property for the equivalentTo property on DAML values */
167: public static Property equivalentTo = null;
168:
169: /** RDF Property for the DAML onProperty property on Restrictions */
170: public static Property onProperty = null;
171:
172: /** RDF Property for the DAML toClass property on Restrictions */
173: public static Property toClass = null;
174:
175: /** RDF Property for the DAML hasValue property on Restrictions */
176: public static Property hasValue = null;
177:
178: /** RDF Property for the DAML hasClass property on Restrictions */
179: public static Property hasClass = null;
180:
181: /** RDF Property for the DAML hasClassQ property on Restrictions */
182: public static Property hasClassQ = null;
183:
184: /** RDF Property for the DAML cardinality property on Restrictions */
185: public static Property cardinality = null;
186:
187: /** RDF Property for the DAML minCardinality property on Restrictions */
188: public static Property minCardinality = null;
189:
190: /** RDF Property for the DAML maxCardinality property on Restrictions */
191: public static Property maxCardinality = null;
192:
193: /** RDF Property for the DAML cardinalityQ property on Restrictions */
194: public static Property cardinalityQ = null;
195:
196: /** RDF Property for the DAML minCardinalityQ property on Restrictions */
197: public static Property minCardinalityQ = null;
198:
199: /** RDF Property for the DAML maxCardinalityQ property on Restrictions */
200: public static Property maxCardinalityQ = null;
201:
202: /** RDF Property for the DAML inverseOf property on Properties */
203: public static Property inverseOf = null;
204:
205: /** RDF Property for the DAML first property on Lists */
206: public static Property first = null;
207:
208: /** RDF Property for the DAML rest property on Lists */
209: public static Property rest = null;
210:
211: /** RDF Property for the DAML item property on Lists */
212: public static Property item = null;
213:
214: /** Alias for rdfs:subPropertyOf in daml namespace */
215: public static Property subPropertyOf = null;
216:
217: /** Alias for rdf:type in daml namespace */
218: public static Property type = null;
219:
220: /** Alias for rdf:value in daml namespace */
221: public static Property value = null;
222:
223: /** Alias for rdfs:subClassOf in daml namespace */
224: public static Property subClassOf = null;
225:
226: /** Alias for rdfs:domain in daml namespace */
227: public static Property domain = null;
228:
229: /** Alias for rdfs:range in daml namespace */
230: public static Property range = null;
231:
232: /** Alias for rdfs:label in daml namespace */
233: public static Property label = null;
234:
235: /** Alias for rdfs:comment in daml namespace */
236: public static Property comment = null;
237:
238: /** Alias for rdfs:seeAlso in daml namespace */
239: public static Property seeAlso = null;
240:
241: /** Alias for rdfs:isDefinedBy in daml namespace */
242: public static Property isDefinedBy = null;
243:
244: /** RDF Property for the DAML sameIndividualAs property on instances */
245: public static Property sameIndividualAs = null;
246:
247: /** RDF Property for the DAML differentIndvidualFrom property on instances */
248: public static Property differentIndividualFrom = null;
249:
250: // Static variables
251: //////////////////////////////////
252:
253: static {
254: // properties:
255: versionInfo = s_model.createProperty(
256: NAMESPACE_DAML_2001_03_URI, "versionInfo");
257: imports = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
258: "imports");
259: disjointWith = s_model.createProperty(
260: NAMESPACE_DAML_2001_03_URI, "disjointWith");
261: disjointUnionOf = s_model.createProperty(
262: NAMESPACE_DAML_2001_03_URI, "disjointUnionOf");
263: sameClassAs = s_model.createProperty(
264: NAMESPACE_DAML_2001_03_URI, "sameClassAs");
265: samePropertyAs = s_model.createProperty(
266: NAMESPACE_DAML_2001_03_URI, "samePropertyAs");
267: equivalentTo = s_model.createProperty(
268: NAMESPACE_DAML_2001_03_URI, "equivalentTo");
269: oneOf = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
270: "oneOf");
271: intersectionOf = s_model.createProperty(
272: NAMESPACE_DAML_2001_03_URI, "intersectionOf");
273: unionOf = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
274: "unionOf");
275: complementOf = s_model.createProperty(
276: NAMESPACE_DAML_2001_03_URI, "complementOf");
277: onProperty = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
278: "onProperty");
279: toClass = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
280: "toClass");
281: hasValue = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
282: "hasValue");
283: hasClass = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
284: "hasClass");
285: hasClassQ = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
286: "hasClassQ");
287: cardinality = s_model.createProperty(
288: NAMESPACE_DAML_2001_03_URI, "cardinality");
289: cardinalityQ = s_model.createProperty(
290: NAMESPACE_DAML_2001_03_URI, "cardinalityQ");
291: minCardinality = s_model.createProperty(
292: NAMESPACE_DAML_2001_03_URI, "minCardinality");
293: minCardinalityQ = s_model.createProperty(
294: NAMESPACE_DAML_2001_03_URI, "minCardinalityQ");
295: maxCardinality = s_model.createProperty(
296: NAMESPACE_DAML_2001_03_URI, "maxCardinality");
297: maxCardinalityQ = s_model.createProperty(
298: NAMESPACE_DAML_2001_03_URI, "maxCardinalityQ");
299: inverseOf = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
300: "inverseOf");
301: first = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
302: "first");
303: rest = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
304: "rest");
305: item = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
306: "item");
307: subPropertyOf = s_model.createProperty(
308: NAMESPACE_DAML_2001_03_URI, "subPropertyOf");
309: type = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
310: "type");
311: value = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
312: "value");
313: subClassOf = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
314: "subClassOf");
315: domain = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
316: "domain");
317: range = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
318: "range");
319: label = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
320: "label");
321: comment = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
322: "comment");
323: seeAlso = s_model.createProperty(NAMESPACE_DAML_2001_03_URI,
324: "seeAlso");
325: isDefinedBy = s_model.createProperty(
326: NAMESPACE_DAML_2001_03_URI, "isDefinedBy");
327:
328: sameIndividualAs = s_model.createProperty(
329: NAMESPACE_DAML_2001_03_URI, "sameIndividualAs");
330: differentIndividualFrom = s_model.createProperty(
331: NAMESPACE_DAML_2001_03_URI, "differentIndividualFrom");
332: }
333:
334: // Instance variables
335: //////////////////////////////////
336:
337: // Constructors
338: //////////////////////////////////
339:
340: /**
341: * Constructor is private to ensure that only a single instance is available.
342: */
343: private DAML_OIL() {
344: }
345:
346: // External signature methods
347: //////////////////////////////////
348:
349: /**
350: * Answer the namespace URI for a the current vocabulary. Note that this value is used to
351: * construct the constants in the vocabulary, assuring that they are in the correct namespace
352: * for this release.
353: *
354: * @return the namespace URI as a string.
355: */
356: public String getNamespace() {
357: return NAMESPACE_DAML_2001_03_URI;
358: }
359:
360: /**
361: * Answer the singleton instance of this vocabulary
362: *
363: * @return The singleton instance
364: */
365: public static DAMLVocabulary getInstance() {
366: return s_instance;
367: }
368:
369: // The following methods provide the implementations for the DAMLVocabulary interface
370:
371: /** Answer the DAML namespace resource for the current release */
372: public Resource NAMESPACE_DAML() {
373: return NAMESPACE_DAML;
374: }
375:
376: /** Answer the RDF resource for DAML List class. */
377: public Resource List() {
378: return List;
379: }
380:
381: /** Answer the RDF resource for DAML UniqueProperty class */
382: public Resource UniqueProperty() {
383: return UniqueProperty;
384: }
385:
386: /** Answer the RDF resource for DAML TransitiveProperty class */
387: public Resource TransitiveProperty() {
388: return TransitiveProperty;
389: }
390:
391: /** Answer the RDF resource for DAML UnambiguousProperty class */
392: public Resource UnambiguousProperty() {
393: return UnambiguousProperty;
394: }
395:
396: /** Answer the RDF resource for DAML Restriction class */
397: public Resource Restriction() {
398: return Restriction;
399: }
400:
401: /** Answer the RDF resource for DAML Ontology class */
402: public Resource Ontology() {
403: return Ontology;
404: }
405:
406: /** Answer the RDF resource for the nil (empty) list. */
407: public Resource nil() {
408: return nil;
409: }
410:
411: /** Answer the RDF resource for the top type (i.e. the super-type of all types). */
412: public Resource Thing() {
413: return Thing;
414: }
415:
416: /** Answer the RDF resource for the bottom type (i.e. the super-type of no types). */
417: public Resource Nothing() {
418: return Nothing;
419: }
420:
421: /** Answer the Alias for rdfs:Literal in the daml namespace. */
422: public Resource Literal() {
423: return Literal;
424: }
425:
426: /** Answer the RDF resource for DAML Class class (a DAML sub-class of rdfs:Class). */
427: public Resource Class() {
428: return Class;
429: }
430:
431: /** Answer the RDF resource for DAML Datatype class (a DAML sub-class of rdfs:Class). */
432: public Resource Datatype() {
433: return Datatype;
434: }
435:
436: /** Answer the RDF resource for DAML DatatypeProperty class (a DAML sub-class of rdf:Property). */
437: public Resource DatatypeProperty() {
438: return DatatypeProperty;
439: }
440:
441: /** Answer the RDF resource for DAML ObjectProperty class (a DAML sub-class of rdf:Property). */
442: public Resource ObjectProperty() {
443: return ObjectProperty;
444: }
445:
446: /* Properties */
447:
448: /** Answer the RDF Property for the DAML versionInfo property */
449: public Property versionInfo() {
450: return versionInfo;
451: }
452:
453: /** Answer the RDF Property for the DAML imports property on Ontologies */
454: public Property imports() {
455: return imports;
456: }
457:
458: /** Answer the RDF Property for the DAML disjointWith property on Classes */
459: public Property disjointWith() {
460: return disjointWith;
461: }
462:
463: /** Answer the RDF Property for the DAML disjointUnionOf property on Classes */
464: public Property disjointUnionOf() {
465: return disjointUnionOf;
466: }
467:
468: /** Answer the RDF Property for the DAML sameClassAs property on Classes */
469: public Property sameClassAs() {
470: return sameClassAs;
471: }
472:
473: /** Answer the RDF Property for the DAML samePropertyAs property on Properties */
474: public Property samePropertyAs() {
475: return samePropertyAs;
476: }
477:
478: /** Answer the RDF Property for the oneOf property on DAML class expressions */
479: public Property oneOf() {
480: return oneOf;
481: }
482:
483: /** Answer the RDF Property for the intersectionOf property on class expressions */
484: public Property intersectionOf() {
485: return intersectionOf;
486: }
487:
488: /** Answer the RDF Property for the unionOf property on class expressions */
489: public Property unionOf() {
490: return unionOf;
491: }
492:
493: /** Answer the RDF Property for the complementOf property on class expressions */
494: public Property complementOf() {
495: return complementOf;
496: }
497:
498: /** Answer the RDF Property for the equivalentTo property on DAML values */
499: public Property equivalentTo() {
500: return equivalentTo;
501: }
502:
503: /** Answer the RDF Property for the DAML onProperty property on Restrictions */
504: public Property onProperty() {
505: return onProperty;
506: }
507:
508: /** Answer the RDF Property for the DAML toClass property on Restrictions */
509: public Property toClass() {
510: return toClass;
511: }
512:
513: /** Answer the RDF Property for the DAML hasValue property on Restrictions */
514: public Property hasValue() {
515: return hasValue;
516: }
517:
518: /** Answer the RDF Property for the DAML hasClass property on Restrictions */
519: public Property hasClass() {
520: return hasClass;
521: }
522:
523: /** Answer the RDF Property for the DAML hasClassQ property on Restrictions */
524: public Property hasClassQ() {
525: return hasClassQ;
526: }
527:
528: /** Answer the RDF Property for the DAML cardinality property on Restrictions */
529: public Property cardinality() {
530: return cardinality;
531: }
532:
533: /** Answer the RDF Property for the DAML minCardinality property on Restrictions */
534: public Property minCardinality() {
535: return minCardinality;
536: }
537:
538: /** Answer the RDF Property for the DAML maxCardinality property on Restrictions */
539: public Property maxCardinality() {
540: return maxCardinality;
541: }
542:
543: /** Answer the RDF Property for the DAML cardinalityQ property on Restrictions */
544: public Property cardinalityQ() {
545: return cardinalityQ;
546: }
547:
548: /** Answer the RDF Property for the DAML minCardinalityQ property on Restrictions */
549: public Property minCardinalityQ() {
550: return minCardinalityQ;
551: }
552:
553: /** Answer the RDF Property for the DAML maxCardinalityQ property on Restrictions */
554: public Property maxCardinalityQ() {
555: return maxCardinalityQ;
556: }
557:
558: /** Answer the RDF Property for the DAML inverseOf property on Properties */
559: public Property inverseOf() {
560: return inverseOf;
561: }
562:
563: /** Answer the RDF Property for the DAML first property on Lists */
564: public Property first() {
565: return first;
566: }
567:
568: /** Answer the RDF Property for the DAML rest property on Lists */
569: public Property rest() {
570: return rest;
571: }
572:
573: /** Answer the RDF Property for the DAML item property on Lists */
574: public Property item() {
575: return item;
576: }
577:
578: /** Answer the alias for rdfs:subPropertyOf in daml namespace */
579: public Property subPropertyOf() {
580: return subPropertyOf;
581: }
582:
583: /** Answer the alias for rdf:type in daml namespace */
584: public Property type() {
585: return type;
586: }
587:
588: /** Answer the alias for rdf:value in daml namespace */
589: public Property value() {
590: return value;
591: }
592:
593: /** Answer the alias for rdfs:subClassOf in daml namespace */
594: public Property subClassOf() {
595: return subClassOf;
596: }
597:
598: /** Answer the alias for rdfs:domain in daml namespace */
599: public Property domain() {
600: return domain;
601: }
602:
603: /** Answer the alias for rdfs:range in daml namespace */
604: public Property range() {
605: return range;
606: }
607:
608: /** Answer the alias for rdfs:label in daml namespace */
609: public Property label() {
610: return label;
611: }
612:
613: /** Answer the alias for rdfs:comment in daml namespace */
614: public Property comment() {
615: return comment;
616: }
617:
618: /** Answer the alias for rdfs:seeAlso in daml namespace */
619: public Property seeAlso() {
620: return seeAlso;
621: }
622:
623: /** Answer the alias for rdfs:isDefinedBy in daml namespace */
624: public Property isDefinedBy() {
625: return isDefinedBy;
626: }
627:
628: /** Answer the RDF Property for the DAML sameIndividualAs property on instances */
629: public Property sameIndividualAs() {
630: return sameIndividualAs;
631: }
632:
633: /** Answer the RDF Property for the DAML differentIndvidualFrom property on instances */
634: public Property differentIndividualFrom() {
635: return differentIndividualFrom;
636: }
637:
638: /** Answer the alias for rdfs:Property in the daml namespace. From 2001/03 onwards, it is preferable to use either DatatypeProperty or ObjectProperty. */
639: public Resource Property() {
640: return Property;
641: }
642:
643: }
644:
645: /*
646: (c) Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
647: All rights reserved.
648:
649: Redistribution and use in source and binary forms, with or without
650: modification, are permitted provided that the following conditions
651: are met:
652:
653: 1. Redistributions of source code must retain the above copyright
654: notice, this list of conditions and the following disclaimer.
655:
656: 2. Redistributions in binary form must reproduce the above copyright
657: notice, this list of conditions and the following disclaimer in the
658: documentation and/or other materials provided with the distribution.
659:
660: 3. The name of the author may not be used to endorse or promote products
661: derived from this software without specific prior written permission.
662:
663: THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
664: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
665: OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
666: IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
667: INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
668: NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
669: DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
670: THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
671: (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
672: THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
673: */
|