Debian Codegraph @

Source/Reasoner/Ontology/CDataLiteralStringValue.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 "CDataLiteralStringValue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CDataLiteralStringValue::CDataLiteralStringValue(CContext* context) {
32 mContext = context;
33 clearValue();
34 }
35
36
37 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE CDataLiteralStringValue::getDataValueType() {
38 return CDataLiteralValue::DLVT_STRING;
39 }
40
41
42 CDataLiteralCompareValue* CDataLiteralStringValue::initValue(CDataLiteralCompareValue* value) {
43 clearValue();
44 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
45 if (stringValue) {
46 mInfiniteLength = stringValue->mInfiniteLength;
47 mLength = stringValue->mLength;
48
49 mStringByteDataArraySize = stringValue->mStringByteDataArraySize;
50 mStringByteDataArray = createStringByteDataArrayCopy(stringValue->mStringByteDataArray, mStringByteDataArraySize);
51
52 mLanguageByteDataArraySize = stringValue->mLanguageByteDataArraySize;
53 mLanguageByteDataArray = createStringByteDataArrayCopy(stringValue->mLanguageByteDataArray, mLanguageByteDataArraySize);
54 }
55 return this;
56 }
57
58
59 QChar* CDataLiteralStringValue::createStringByteDataArrayCopy(QChar* stringByteDataArray, cint64 arrayLength) {
60 QChar* stringByteDataArrayCopy = CObjectAllocator<QChar>::allocateArray(CContext::getMemoryAllocationManager(mContext), arrayLength);
61 for (cint64 i = 0; i < arrayLength; ++i) {
62 stringByteDataArrayCopy[i] = stringByteDataArray[i];
63 }
64 return stringByteDataArrayCopy;
65 }
66
67
68 QChar* CDataLiteralStringValue::createStringByteDataArray(const QString& string) {
69 QChar* stringByteDataArrayCopy = CObjectAllocator<QChar>::allocateArray(CContext::getMemoryAllocationManager(mContext), string.length());
70 const QChar* stringData = string.constData();
71 for (cint64 i = 0; i < string.length(); ++i) {
72 stringByteDataArrayCopy[i] = stringData[i];
73 }
74 return stringByteDataArrayCopy;
75 }
76
77
78
79 QString CDataLiteralStringValue::getValueString() {
80 if (mLanguageByteDataArraySize <= 0) {
81 return QString(mStringByteDataArray, mStringByteDataArraySize);
82 } else {
83 return QString("%1@%2").arg(QString::fromRawData(mStringByteDataArray, mStringByteDataArraySize)).arg(QString::fromRawData(mLanguageByteDataArray, mLanguageByteDataArraySize));
84 }
85 }
86
87
88
89 CDataLiteralStringValue* CDataLiteralStringValue::initValueFromInfiniteLength() {
90 clearValue();
91 mInfiniteLength = true;
92 return this;
93 }
94
95 CDataLiteralStringValue* CDataLiteralStringValue::initValueFromLength(cuint64 length) {
96 clearValue();
97 mLength = length;
98 return this;
99 }
100
101
102 CDataLiteralStringValue* CDataLiteralStringValue::initValueFromString(const QString& string, const QString& langString) {
103 clearValue();
104 mStringByteDataArray = createStringByteDataArray(string);
105 mStringByteDataArraySize = string.length();
106 mLanguageByteDataArray = createStringByteDataArray(langString);
107 mLanguageByteDataArraySize = langString.length();
108
109 return this;
110 }
111
112
113 CDataLiteralStringValue* CDataLiteralStringValue::initValue(CDataLiteralStringValue* value) {
114 if (value) {
115 mInfiniteLength = value->mInfiniteLength;
116 mLength = value->mLength;
117
118 mStringByteDataArraySize = value->mStringByteDataArraySize;
119 mStringByteDataArray = createStringByteDataArrayCopy(value->mStringByteDataArray, mStringByteDataArraySize);
120
121 mLanguageByteDataArraySize = value->mLanguageByteDataArraySize;
122 mLanguageByteDataArray = createStringByteDataArrayCopy(value->mLanguageByteDataArray, mLanguageByteDataArraySize);
123
124 }
125 return this;
126 }
127
128
129 CDataLiteralStringValue* CDataLiteralStringValue::clearValue() {
130 mInfiniteLength = false;
131 mLength = 0;
132
133 mStringByteDataArray = nullptr;
134 mStringByteDataArraySize = 0;
135
136 mLanguageByteDataArray = nullptr;
137 mLanguageByteDataArraySize = 0;
138
139 return this;
140 }
141
142 bool CDataLiteralStringValue::isInfiniteLength() {
143 return mInfiniteLength;
144 }
145
146 bool CDataLiteralStringValue::hasLanguageTag() {
147 return mLanguageByteDataArraySize > 0;
148 }
149
150
151 cuint64 CDataLiteralStringValue::getLength() {
152 if (mLength > 0) {
153 return mLength;
154 } else {
155 return mStringByteDataArraySize;
156 }
157 }
158
159 QString CDataLiteralStringValue::getStringValue() {
160 return QString(mStringByteDataArray, mStringByteDataArraySize);
161 }
162
163
164 bool CDataLiteralStringValue::isEqualTo(CDataLiteralValue* value) {
165 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
166 if (stringValue) {
167 return isEqualTo(stringValue);
168 }
169 return false;
170 }
171
172
173
174 bool CDataLiteralStringValue::isLessEqualThan(CDataLiteralCompareValue* value) {
175 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
176 if (stringValue) {
177 return isEqualTo(stringValue) || isLessThan(stringValue);
178 }
179 return false;
180 }
181
182 bool CDataLiteralStringValue::isLessEqualThan(CDataLiteralStringValue* stringValue) {
183 return isEqualTo(stringValue) || isLessThan(stringValue);
184 }
185
186
187 bool CDataLiteralStringValue::isEqualTo(CDataLiteralCompareValue* value) {
188 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
189 if (stringValue) {
190 return isEqualTo(stringValue);
191 }
192 return false;
193 }
194
195 bool CDataLiteralStringValue::isEqualTo(CDataLiteralStringValue* stringValue) {
196 if (mInfiniteLength && stringValue->mInfiniteLength) {
197 return true;
198 }
199 if (mInfiniteLength || stringValue->mInfiniteLength) {
200 return false;
201 }
202 if (mLength > 0 && mLength == stringValue->mLength) {
203 return true;
204 }
205 if (QString::fromRawData(mLanguageByteDataArray, mLanguageByteDataArraySize) != QString::fromRawData(stringValue->mLanguageByteDataArray, stringValue->mLanguageByteDataArraySize)) {
206 return false;
207 }
208 if (QString::fromRawData(mStringByteDataArray, mStringByteDataArraySize) != QString::fromRawData(stringValue->mStringByteDataArray, stringValue->mStringByteDataArraySize)) {
209 return false;
210 }
211 return true;
212 }
213
214 bool CDataLiteralStringValue::isGreaterEqualThan(CDataLiteralStringValue* stringValue) {
215 return isEqualTo(stringValue) || isGreaterThan(stringValue);
216 }
217
218 bool CDataLiteralStringValue::isGreaterEqualThan(CDataLiteralCompareValue* value) {
219 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
220 if (stringValue) {
221 return isEqualTo(stringValue) || isGreaterThan(stringValue);
222 }
223 return false;
224 }
225
226 bool CDataLiteralStringValue::isGreaterThan(CDataLiteralCompareValue* value) {
227 return value->isLessThan(this);
228 }
229
230 bool CDataLiteralStringValue::isGreaterThan(CDataLiteralStringValue* stringValue) {
231 return stringValue->isLessThan(this);
232 }
233
234
235 bool CDataLiteralStringValue::isLessThan(CDataLiteralCompareValue* value) {
236 CDataLiteralStringValue* stringValue = dynamic_cast<CDataLiteralStringValue*>(value);
237 if (stringValue) {
238 return isLessThan(stringValue);
239 }
240 return false;
241 }
242
243
244
245
246
247 bool CDataLiteralStringValue::isLessThan(CDataLiteralStringValue* stringValue) {
248 if (mInfiniteLength) {
249 return false;
250 }
251 if (!mInfiniteLength && stringValue->mInfiniteLength) {
252 return true;
253 }
254 if (getLength() < stringValue->getLength()) {
255 return true;
256 } else if (getLength() > stringValue->getLength()) {
257 return false;
258 } else {
259 int stringComp = QString::fromRawData(mStringByteDataArray, mStringByteDataArraySize).compare(QString::fromRawData(stringValue->mStringByteDataArray, stringValue->mStringByteDataArraySize));
260 if (stringComp < 0) {
261 return true;
262 } else if (stringComp > 0) {
263 return false;
264 }
265 int lanComp = QString::fromRawData(mLanguageByteDataArray, mLanguageByteDataArraySize).compare(QString::fromRawData(stringValue->mLanguageByteDataArray, stringValue->mLanguageByteDataArraySize));
266 return lanComp < 0;
267 }
268 return false;
269 }
270
271
272
273 }; // end namespace Ontology
274
275 }; // end namespace Reasoner
276
277 }; // end namespace Konclude