Debian Codegraph @

Source/Reasoner/Preprocess/CDatatypeNormalizerPreProcess.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CDatatypeNormalizerPreProcess.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Preprocess {
29
30
31 CDatatypeNormalizerPreProcess::CDatatypeNormalizerPreProcess() {
32 mLastDataTypeId = 0;
33 mContext = nullptr;
34 }
35
36
37 CDatatypeNormalizerPreProcess::~CDatatypeNormalizerPreProcess() {
38 }
39
40
41 CConcreteOntology *CDatatypeNormalizerPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
42 mOntology = ontology;
43 mLastDataTypeId = 0;
44 mContext = context;
45 if (ontology) {
46 mTBox = ontology->getDataBoxes()->getTBox();
47 mABox = ontology->getDataBoxes()->getABox();
48 mRBox = ontology->getDataBoxes()->getRBox();
49 mMBox = ontology->getDataBoxes()->getMBox();
50
51 mBoxContext = ontology->getDataBoxes()->getBoxContext();
52
53
54 mIntegerRestrictionConcept = nullptr;
55 mStringRestrictionConcept = nullptr;
56 mNormalizedStringRestrictionConcept = nullptr;
57 mTokenRestrictionConcept = nullptr;
58 mNMTokenRestrictionConcept = nullptr;
59 mNameRestrictionConcept = nullptr;
60 mNCNameRestrictionConcept = nullptr;
61 mLanguageRestrictionConcept = nullptr;
62 mDatetimeStampRestrictionConcept = nullptr;
63 mTopDataRangeConcept = mTBox->getTopDataRangeConcept();
64
65 mRolesVector = mRBox->getRoleVector();
66 mConceptVector = mTBox->getConceptVector();
67 mIndiVec = mABox->getIndividualVector();
68
69 mDataRangeConceptHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDataRangeTermConceptMappingHash();
70 mConceptDataRangeHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptDataRangeTermMappingHash();
71
72 mDatatypeExpressionDatatpyeHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeExpressionDatatypeHash();
73 mDatatpyeDatatypeExpressionHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeDatatypeExpessionHash();
74
75 mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
76
77 mValueSpaceTypes = ontology->getDataBoxes()->getDatatypeValueSpaceTypes();
78 mDatatypeVector = mTBox->getDatatypeVector(false);
79
80 }
81
82 return continuePreprocessing();
83 }
84
85
86 CConcreteOntology* CDatatypeNormalizerPreProcess::continuePreprocessing() {
87 if (mOntology) {
88 QList<CDatatype*> datatypeNormalisationList;
89
90
91 if (mDatatypeVector) {
92 cint64 datatypeCount = mDatatypeVector->getItemCount();
93 for (cint64 i = 0; i < datatypeCount; ++i) {
94 CDatatype* datatype = mDatatypeVector->getData(i);
95 if (datatype) {
96 QString datatypeIRI = datatype->getDatatypeIRI();
97 mIRIDatatypeHash.insert(datatypeIRI, datatype);
98 }
99 }
100
101 for (cint64 i = mLastDataTypeId; i < datatypeCount; ++i) {
102 CDatatype* datatype = mDatatypeVector->getLocalData(i);
103 if (datatype) {
104 if (!datatype->hasDatatypeConcept()) {
105 CConcept* datatypeConcept = nullptr;
106 CDatatypeExpression* datatypeExpression = mDatatpyeDatatypeExpressionHash->value(datatype);
107 if (datatypeExpression) {
108 datatypeConcept = mDataRangeConceptHash->value(datatypeExpression);
109 }
110 if (!datatypeConcept) {
111 datatypeConcept = createDatatypeConcept(datatype);
112 if (datatypeExpression) {
113 mDataRangeConceptHash->insert(datatypeExpression, datatypeConcept);
114 mConceptDataRangeHash->insert(datatypeConcept, datatypeExpression);
115 }
116 datatypeConcept->setDatatype(datatype);
117 }
118 datatype->setDatatypeConcept(datatypeConcept);
119 }
120 if (!datatype->isNormalized()) {
121 datatypeNormalisationList.append(datatype);
122 }
123 }
124 }
125 mLastDataTypeId = datatypeCount;
126
127 foreach(CDatatype* datatype, datatypeNormalisationList) {
128 normalizeDatatype(datatype, mContext);
129 datatype->setNormalized(true);
130 }
131
132 }
133 }
134 return mOntology;
135 }
136
137
138
139 CConcept* CDatatypeNormalizerPreProcess::createConcept() {
140 CConcept* concept = CObjectAllocator<CConcept>::allocateAndConstruct(mMemMan);
141 cint64 nextConTag = mTBox->getNextConceptID();
142 concept->initConcept();
143 concept->setTag(nextConTag);
144 mConceptVector->setData(nextConTag,concept);
145 return concept;
146 }
147
148 CConcept* CDatatypeNormalizerPreProcess::createDatatypeConcept(CDatatype* datatype) {
149 CConcept* datatypeConcept = createConcept();
150 datatypeConcept->setOperatorCode(CCDATATYPE);
151 return datatypeConcept;
152 }
153
154
155 CConcept* CDatatypeNormalizerPreProcess::addConceptOperand(CConcept* concept, CConcept* operand, bool negated) {
156 CSortedNegLinker<CConcept*>* opConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
157 opConLinker->init(operand,negated);
158 concept->addOperandLinker(opConLinker);
159 concept->incOperandCount();
160 return concept;
161 }
162
163
164 CConcept* CDatatypeNormalizerPreProcess::getNumberRestrictionConcept(cint64 restrictionCode, const QString& value) {
165 CConcept* restrictionConcept = mNumberRestrictionConceptHash.value(QPair<cint64,QString>(restrictionCode,value));
166 if (!restrictionConcept) {
167 restrictionConcept = createConcept();
168 restrictionConcept->setParameter(restrictionCode);
169 restrictionConcept->setOperatorCode(CCDATARESTRICTION);
170 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
171 restrictionConcept->setDatatype(realDatatype);
172 CDataLiteral* dataLiteral = CObjectParameterizingAllocator<CDataLiteral, CContext*>::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
173 dataLiteral->initDataLiteral(value,realDatatype);
174 restrictionConcept->setDataLiteral(dataLiteral);
175 mNumberRestrictionConceptHash.insert(QPair<cint64,QString>(restrictionCode,value),restrictionConcept);
176 }
177 return restrictionConcept;
178 }
179
180
181
182 CDatatype* CDatatypeNormalizerPreProcess::getDatatype(const QString& datatypeIRI) {
183 return mIRIDatatypeHash.value(datatypeIRI,nullptr);
184 }
185
186
187
188 CConcept* CDatatypeNormalizerPreProcess::getIntegerRestrictionConcept() {
189 if (!mIntegerRestrictionConcept) {
190 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
191 mIntegerRestrictionConcept = createConcept();
192 mIntegerRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
193 mIntegerRestrictionConcept->setDatatype(realDatatype);
194 mIntegerRestrictionConcept->setParameter(CDFC_INTEGER);
195 }
196 return mIntegerRestrictionConcept;
197 }
198
199
200 CConcept* CDatatypeNormalizerPreProcess::getStringRestrictionConcept() {
201 if (!mStringRestrictionConcept) {
202 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
203 mStringRestrictionConcept = createConcept();
204 mStringRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
205 mStringRestrictionConcept->setDatatype(plainLiteralDatatype);
206 mStringRestrictionConcept->setParameter(CDFC_STRING);
207 }
208 return mStringRestrictionConcept;
209 }
210
211 CConcept* CDatatypeNormalizerPreProcess::getNormalizedStringRestrictionConcept() {
212 if (!mNormalizedStringRestrictionConcept) {
213 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
214 mNormalizedStringRestrictionConcept = createConcept();
215 mNormalizedStringRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
216 mNormalizedStringRestrictionConcept->setDatatype(plainLiteralDatatype);
217 mNormalizedStringRestrictionConcept->setParameter(CDFC_NORMALIZED_STRING);
218 }
219 return mNormalizedStringRestrictionConcept;
220 }
221
222 CConcept* CDatatypeNormalizerPreProcess::getTokenRestrictionConcept() {
223 if (!mTokenRestrictionConcept) {
224 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
225 mTokenRestrictionConcept = createConcept();
226 mTokenRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
227 mTokenRestrictionConcept->setDatatype(plainLiteralDatatype);
228 mTokenRestrictionConcept->setParameter(CDFC_TOKEN);
229 }
230 return mTokenRestrictionConcept;
231 }
232
233 CConcept* CDatatypeNormalizerPreProcess::getNMTokenRestrictionConcept() {
234 if (!mNMTokenRestrictionConcept) {
235 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
236 mNMTokenRestrictionConcept = createConcept();
237 mNMTokenRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
238 mNMTokenRestrictionConcept->setDatatype(plainLiteralDatatype);
239 mNMTokenRestrictionConcept->setParameter(CDFC_NMTOKEN);
240 }
241 return mNMTokenRestrictionConcept;
242 }
243
244 CConcept* CDatatypeNormalizerPreProcess::getNameRestrictionConcept() {
245 if (!mNameRestrictionConcept) {
246 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
247 mNameRestrictionConcept = createConcept();
248 mNameRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
249 mNameRestrictionConcept->setDatatype(plainLiteralDatatype);
250 mNameRestrictionConcept->setParameter(CDFC_NAME);
251 }
252 return mNameRestrictionConcept;
253 }
254
255 CConcept* CDatatypeNormalizerPreProcess::getNCNameRestrictionConcept() {
256 if (!mNCNameRestrictionConcept) {
257 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
258 mNCNameRestrictionConcept = createConcept();
259 mNCNameRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
260 mNCNameRestrictionConcept->setDatatype(plainLiteralDatatype);
261 mNCNameRestrictionConcept->setParameter(CDFC_NCNAME);
262 }
263 return mNCNameRestrictionConcept;
264 }
265
266 CConcept* CDatatypeNormalizerPreProcess::getLanguageRestrictionConcept() {
267 if (!mLanguageRestrictionConcept) {
268 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
269 mLanguageRestrictionConcept = createConcept();
270 mLanguageRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
271 mLanguageRestrictionConcept->setDatatype(plainLiteralDatatype);
272 mLanguageRestrictionConcept->setParameter(CDFC_LANGUAGE);
273 }
274 return mLanguageRestrictionConcept;
275 }
276
277 CConcept* CDatatypeNormalizerPreProcess::getDateTimeStampRestrictionConcept() {
278 if (!mDatetimeStampRestrictionConcept) {
279 CDatatype* dateTimeDatatype = getDatatype(PREFIX_XML_DATETIMESTAMP_DATATYPE);
280 mDatetimeStampRestrictionConcept = createConcept();
281 mDatetimeStampRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
282 mDatetimeStampRestrictionConcept->setDatatype(dateTimeDatatype);
283 mDatetimeStampRestrictionConcept->setParameter(CDFC_DATETIMESTAMP);
284 }
285 return mDatetimeStampRestrictionConcept;
286 }
287
288
289 CDatatypeNormalizerPreProcess* CDatatypeNormalizerPreProcess::normalizeDatatype(CDatatype* datatype, CPreProcessContext* context) {
290 QString datatypeIRI = datatype->getDatatypeIRI();
291 CConcept* datatypeConcept = datatype->getDatatypeConcept();
292
293
294 if (datatypeIRI == PREFIX_XML_INTEGER_DATATYPE) {
295 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
296
297 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
298 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
299
300 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
301 datatype->setBasicDatatype(realDatatype);
302 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
303 datatype->setDatatypeType(CDatatype::DT_INTEGER);
304
305
306 } else if (datatypeIRI == PREFIX_XML_DECIMAL_DATATYPE) {
307 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
308
309 CConcept* decimalRestrictionConcept = createConcept();
310 decimalRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
311 decimalRestrictionConcept->setDatatype(realDatatype);
312 decimalRestrictionConcept->setParameter(CDFC_DECIMAL);
313 addConceptOperand(datatypeConcept,decimalRestrictionConcept,false);
314
315 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
316 datatype->setBasicDatatype(realDatatype);
317 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
318 datatype->setDatatypeType(CDatatype::DT_DECIMAL);
319
320
321 } else if (datatypeIRI == PREFIX_OWL_RATIONAL_DATATYPE) {
322 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
323
324 CConcept* rationalRestrictionConcept = createConcept();
325 rationalRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
326 rationalRestrictionConcept->setDatatype(realDatatype);
327 rationalRestrictionConcept->setParameter(CDFC_RATIONAL);
328 addConceptOperand(datatypeConcept,rationalRestrictionConcept,false);
329
330
331 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
332 datatype->setBasicDatatype(realDatatype);
333 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
334 datatype->setDatatypeType(CDatatype::DT_RATIONAL);
335
336
337 } else if (datatypeIRI == PREFIX_OWL_REAL_DATATYPE) {
338 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
339 datatype->setBasicDatatype(true);
340 datatype->setBasicDatatype(datatype);
341 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
342 datatype->setDatatypeType(CDatatype::DT_REAL);
343
344
345 } else if (datatypeIRI == PREFIX_OWL_TOP_DATATYPE) {
346
347 } else if (datatypeIRI == PREFIX_OWL_BOTTOM_DATATYPE) {
348 if (mTopDataRangeConcept) {
349 addConceptOperand(datatypeConcept,mTopDataRangeConcept,true);
350 }
351
352
353
354
355 } else if (datatypeIRI == PREFIX_XML_NONNEGATIVEINTEGER_DATATYPE) {
356 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
357
358 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
359 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
360
361 CConcept* minInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"0");
362 addConceptOperand(datatypeConcept,minInclusiveZeroRestrictionConcept,false);
363
364 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
365 datatype->setBasicDatatype(realDatatype);
366 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
367
368
369
370 } else if (datatypeIRI == PREFIX_XML_POSITIVEINTEGER_DATATYPE) {
371 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
372
373 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
374 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
375
376 CConcept* minExclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_EXCLUSIVE,"0");
377 addConceptOperand(datatypeConcept,minExclusiveZeroRestrictionConcept,false);
378
379 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
380 datatype->setBasicDatatype(realDatatype);
381 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
382
383
384
385 } else if (datatypeIRI == PREFIX_XML_NONPOSITIVEINTEGER_DATATYPE) {
386 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
387
388 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
389 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
390
391 CConcept* maxInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"0");
392 addConceptOperand(datatypeConcept,maxInclusiveZeroRestrictionConcept,false);
393
394 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
395 datatype->setBasicDatatype(realDatatype);
396 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
397
398
399 } else if (datatypeIRI == PREFIX_XML_NEGATIVEINTEGER_DATATYPE) {
400 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
401
402 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
403 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
404
405 CConcept* maxExclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_EXCLUSIVE,"0");
406 addConceptOperand(datatypeConcept,maxExclusiveZeroRestrictionConcept,false);
407
408 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
409 datatype->setBasicDatatype(realDatatype);
410 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
411
412
413
414 } else if (datatypeIRI == PREFIX_XML_LONG_DATATYPE) {
415 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
416
417 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
418 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
419
420 CConcept* minInclusiveLongRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"-9223372036854775808");
421 addConceptOperand(datatypeConcept,minInclusiveLongRestrictionConcept,false);
422 CConcept* maxInclusiveLongRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"9223372036854775807");
423 addConceptOperand(datatypeConcept,maxInclusiveLongRestrictionConcept,false);
424
425 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
426 datatype->setBasicDatatype(realDatatype);
427 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
428
429
430
431
432 } else if (datatypeIRI == PREFIX_XML_INT_DATATYPE) {
433 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
434
435 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
436 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
437
438 CConcept* minInclusiveIntRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"-2147483647");
439 addConceptOperand(datatypeConcept,minInclusiveIntRestrictionConcept,false);
440 CConcept* maxInclusiveIntRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"2147483647");
441 addConceptOperand(datatypeConcept,maxInclusiveIntRestrictionConcept,false);
442
443 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
444 datatype->setBasicDatatype(realDatatype);
445 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
446
447
448
449
450 } else if (datatypeIRI == PREFIX_XML_SHORT_DATATYPE) {
451 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
452
453 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
454 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
455
456 CConcept* minInclusiveShortRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"-32767");
457 addConceptOperand(datatypeConcept,minInclusiveShortRestrictionConcept,false);
458 CConcept* maxInclusiveShortRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"32767");
459 addConceptOperand(datatypeConcept,maxInclusiveShortRestrictionConcept,false);
460
461 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
462 datatype->setBasicDatatype(realDatatype);
463 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
464
465
466
467
468 } else if (datatypeIRI == PREFIX_XML_BYTE_DATATYPE) {
469 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
470
471 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
472 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
473
474 CConcept* minInclusiveByteRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"-127");
475 addConceptOperand(datatypeConcept,minInclusiveByteRestrictionConcept,false);
476 CConcept* maxInclusiveByteRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"127");
477 addConceptOperand(datatypeConcept,maxInclusiveByteRestrictionConcept,false);
478
479 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
480 datatype->setBasicDatatype(realDatatype);
481 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
482
483
484
485
486 } else if (datatypeIRI == PREFIX_XML_UNSIGNEDLONG_DATATYPE) {
487 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
488
489 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
490 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
491
492 CConcept* minInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"0");
493 addConceptOperand(datatypeConcept,minInclusiveZeroRestrictionConcept,false);
494 CConcept* maxInclusiveULongRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"18446744073709551615");
495 addConceptOperand(datatypeConcept,maxInclusiveULongRestrictionConcept,false);
496
497 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
498 datatype->setBasicDatatype(realDatatype);
499 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
500
501
502
503 } else if (datatypeIRI == PREFIX_XML_UNSIGNEDINT_DATATYPE) {
504 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
505
506 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
507 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
508
509 CConcept* minInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"0");
510 addConceptOperand(datatypeConcept,minInclusiveZeroRestrictionConcept,false);
511 CConcept* maxInclusiveUIntRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"4294967295");
512 addConceptOperand(datatypeConcept,maxInclusiveUIntRestrictionConcept,false);
513
514 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
515 datatype->setBasicDatatype(realDatatype);
516 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
517
518
519
520 } else if (datatypeIRI == PREFIX_XML_UNSIGNEDSHORT_DATATYPE) {
521 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
522
523 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
524 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
525
526 CConcept* minInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"0");
527 addConceptOperand(datatypeConcept,minInclusiveZeroRestrictionConcept,false);
528 CConcept* maxInclusiveUShortRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"65535");
529 addConceptOperand(datatypeConcept,maxInclusiveUShortRestrictionConcept,false);
530
531 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
532 datatype->setBasicDatatype(realDatatype);
533 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
534
535
536 } else if (datatypeIRI == PREFIX_XML_UNSIGNEDBYTE_DATATYPE) {
537 CDatatype* realDatatype = getDatatype(PREFIX_OWL_REAL_DATATYPE);
538
539 CConcept* integerRestrictionConcept = getIntegerRestrictionConcept();
540 addConceptOperand(datatypeConcept,integerRestrictionConcept,false);
541
542 CConcept* minInclusiveZeroRestrictionConcept = getNumberRestrictionConcept(CDFC_MIN_INCLUSIVE,"0");
543 addConceptOperand(datatypeConcept,minInclusiveZeroRestrictionConcept,false);
544 CConcept* maxInclusiveUByteRestrictionConcept = getNumberRestrictionConcept(CDFC_MAX_INCLUSIVE,"255");
545 addConceptOperand(datatypeConcept,maxInclusiveUByteRestrictionConcept,false);
546
547 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceRealType());
548 datatype->setBasicDatatype(realDatatype);
549 datatype->setBasicDatatypeType(CDatatype::DBT_REAL);
550
551
552
553
554
555
556
557
558
559 } else if (datatypeIRI == PREFIX_XML_PLAINLITERAL_DATATYPE) {
560 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
561 datatype->setBasicDatatype(datatype);
562 datatype->setBasicDatatype(true);
563 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
564 datatype->setDatatypeType(CDatatype::DT_PLAINLITERAL);
565
566
567 } else if (datatypeIRI == PREFIX_XML_STRING_DATATYPE) {
568 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
569
570 addConceptOperand(datatypeConcept,plainLiteralDatatype->getDatatypeConcept(),false);
571
572
573 CConcept* stringRestrictionConcept = getStringRestrictionConcept();
574 addConceptOperand(datatypeConcept,stringRestrictionConcept,false);
575
576 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
577 datatype->setBasicDatatype(plainLiteralDatatype);
578 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
579 datatype->setDatatypeType(CDatatype::DT_STRING);
580
581
582 } else if (datatypeIRI == PREFIX_XML_NORMALIZEDSTRING_DATATYPE) {
583 CDatatype* stringDatatype = getDatatype(PREFIX_XML_STRING_DATATYPE);
584 addConceptOperand(datatypeConcept,stringDatatype->getDatatypeConcept(),false);
585
586 CConcept* normalizedStringRestrictionConcept = getStringRestrictionConcept();
587 addConceptOperand(datatypeConcept,normalizedStringRestrictionConcept,false);
588
589 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
590 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
591 datatype->setBasicDatatype(plainLiteralDatatype);
592 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
593
594
595
596 } else if (datatypeIRI == PREFIX_XML_TOKEN_DATATYPE) {
597 CDatatype* normalizedStringDatatype = getDatatype(PREFIX_XML_NORMALIZEDSTRING_DATATYPE);
598 addConceptOperand(datatypeConcept,normalizedStringDatatype->getDatatypeConcept(),false);
599
600 CConcept* tokenRestrictionConcept = getTokenRestrictionConcept();
601 addConceptOperand(datatypeConcept,tokenRestrictionConcept,false);
602
603 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
604 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
605 datatype->setBasicDatatype(plainLiteralDatatype);
606 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
607
608
609
610 } else if (datatypeIRI == PREFIX_XML_NAME_DATATYPE) {
611 CDatatype* tokenDatatype = getDatatype(PREFIX_XML_TOKEN_DATATYPE);
612 addConceptOperand(datatypeConcept,tokenDatatype->getDatatypeConcept(),false);
613
614 CConcept* nameRestrictionConcept = getNameRestrictionConcept();
615 addConceptOperand(datatypeConcept,nameRestrictionConcept,false);
616
617 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
618 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
619 datatype->setBasicDatatype(plainLiteralDatatype);
620 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
621
622
623 } else if (datatypeIRI == PREFIX_XML_NCNAME_DATATYPE) {
624 CDatatype* nameDatatype = getDatatype(PREFIX_XML_NAME_DATATYPE);
625 addConceptOperand(datatypeConcept,nameDatatype->getDatatypeConcept(),false);
626
627 CConcept* ncnameRestrictionConcept = getNCNameRestrictionConcept();
628 addConceptOperand(datatypeConcept,ncnameRestrictionConcept,false);
629
630 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
631 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
632 datatype->setBasicDatatype(plainLiteralDatatype);
633 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
634
635
636 } else if (datatypeIRI == PREFIX_XML_NMTOKEN_DATATYPE) {
637 CDatatype* tokenDatatype = getDatatype(PREFIX_XML_TOKEN_DATATYPE);
638 addConceptOperand(datatypeConcept,tokenDatatype->getDatatypeConcept(),false);
639
640 CConcept* nmTokenRestrictionConcept = getNMTokenRestrictionConcept();
641 addConceptOperand(datatypeConcept,nmTokenRestrictionConcept,false);
642
643 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
644 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
645 datatype->setBasicDatatype(plainLiteralDatatype);
646 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
647
648
649 } else if (datatypeIRI == PREFIX_XML_LANGUAGE_DATATYPE) {
650 CDatatype* plainLiteralDatatype = getDatatype(PREFIX_XML_PLAINLITERAL_DATATYPE);
651 addConceptOperand(datatypeConcept,plainLiteralDatatype->getDatatypeConcept(),false);
652
653 CConcept* languageRestrictionConcept = getLanguageRestrictionConcept();
654 addConceptOperand(datatypeConcept,languageRestrictionConcept,false);
655
656 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceStringType());
657 datatype->setBasicDatatype(plainLiteralDatatype);
658 datatype->setBasicDatatypeType(CDatatype::DBT_STRING);
659
660
661
662
663
664
665
666
667
668
669 } else if (datatypeIRI == PREFIX_XML_BOOLEAN_DATATYPE) {
670 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceBooleanType());
671 datatype->setBasicDatatype(datatype);
672 datatype->setBasicDatatype(true);
673 datatype->setBasicDatatypeType(CDatatype::DBT_BOOLEAN);
674 datatype->setDatatypeType(CDatatype::DT_BOOLEAN);
675
676
677
678
679
680
681
682 } else if (datatypeIRI == PREFIX_XML_DOUBLE_DATATYPE) {
683 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceDoubleType());
684 datatype->setBasicDatatype(datatype);
685 datatype->setBasicDatatype(true);
686 datatype->setBasicDatatypeType(CDatatype::DBT_DOUBLE);
687 datatype->setDatatypeType(CDatatype::DT_DOUBLE);
688
689
690 } else if (datatypeIRI == PREFIX_XML_FLOAT_DATATYPE) {
691 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceFloatType());
692 datatype->setBasicDatatype(datatype);
693 datatype->setBasicDatatype(true);
694 datatype->setBasicDatatypeType(CDatatype::DBT_FLOAT);
695 datatype->setDatatypeType(CDatatype::DT_FLOAT);
696
697
698
699
700
701
702
703 } else if (datatypeIRI == PREFIX_XML_IRI_DATATYPE) {
704 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceIRIType());
705 datatype->setBasicDatatype(datatype);
706 datatype->setBasicDatatype(true);
707 datatype->setBasicDatatypeType(CDatatype::DBT_IRI);
708 datatype->setDatatypeType(CDatatype::DT_IRI);
709
710
711
712
713 } else if (datatypeIRI == PREFIX_XML_XML_DATATYPE) {
714 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceXMLType());
715 datatype->setBasicDatatype(datatype);
716 datatype->setBasicDatatype(true);
717 datatype->setBasicDatatypeType(CDatatype::DBT_XML);
718 datatype->setDatatypeType(CDatatype::DT_XML);
719
720
721
722
723
724
725 } else if (datatypeIRI == PREFIX_XML_BINARYHEX_DATATYPE) {
726 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceBinaryHexDataType());
727 datatype->setBasicDatatype(datatype);
728 datatype->setBasicDatatype(true);
729 datatype->setBasicDatatypeType(CDatatype::DBT_HEXBINARY);
730
731
732 } else if (datatypeIRI == PREFIX_XML_BINARYBASE64_DATATYPE) {
733 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceBinaryBase64DataType());
734 datatype->setBasicDatatype(datatype);
735 datatype->setBasicDatatype(true);
736 datatype->setBasicDatatypeType(CDatatype::DBT_BASE64BINARY);
737
738
739
740
741
742
743
744 } else if (datatypeIRI == PREFIX_XML_DATETIME_DATATYPE) {
745 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceDateTimeType());
746 datatype->setBasicDatatype(datatype);
747 datatype->setBasicDatatype(true);
748 datatype->setBasicDatatypeType(CDatatype::DBT_DATETIME);
749
750
751 } else if (datatypeIRI == PREFIX_XML_DATETIMESTAMP_DATATYPE) {
752 CDatatype* dateTimeDatatype = getDatatype(PREFIX_XML_DATETIME_DATATYPE);
753 addConceptOperand(datatypeConcept,dateTimeDatatype->getDatatypeConcept(),false);
754
755 CConcept* dateTimeStampRestrictionConcept = getDateTimeStampRestrictionConcept();
756 addConceptOperand(datatypeConcept,dateTimeStampRestrictionConcept,false);
757
758 datatype->setValueSpaceType(mValueSpaceTypes->getValueSpaceDateTimeType());
759 datatype->setBasicDatatype(dateTimeDatatype);
760 datatype->setBasicDatatypeType(CDatatype::DBT_DATETIME);
761
762
763
764 }
765 return this;
766 }
767
768
769 }; // end namespace Preprocess
770
771 }; // end namespace Reasoner
772
773 }; // end namespace Konclude