Debian Codegraph @

Source/Reasoner/Ontology/CIndividual.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 "CIndividual.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CIndividual::CIndividual(qint64 id) : CIndividualIdentifier(id) {
32 mAssertionConceptLinker = nullptr;
33 mAssertionRoleLinker = nullptr;
34 mAssertionDataLinker = nullptr;
35 mReverseAssertionRoleLinker = nullptr;
36 mNominalConcept = nullptr;
37 mAnonymousIndividual = false;
38 mTemporaryIndividual = false;
39 mFakeIndividual = false;
40 mIndividualData = nullptr;
41 }
42
43
44
45 bool CIndividual::hasIndividualName() {
46 return hasName();
47 }
48
49 CIndividual *CIndividual::setIndividualNameLinker(CLinker<CName *> *individualNameLinker) {
50 setNameLinker(individualNameLinker);
51 return this;
52 }
53
54 CIndividual *CIndividual::addIndividualNameLinker(CLinker<CName *> *individualNameLinker) {
55 addNameLinker(individualNameLinker);
56 return this;
57 }
58
59 CLinker<CName *> *CIndividual::getIndividualNameLinker() {
60 return getNameLinker();
61 }
62
63 CConcept* CIndividual::getIndividualNominalConcept() {
64 return mNominalConcept;
65 }
66
67 CIndividual* CIndividual::setIndividualNominalConcept(CConcept* nomConcept) {
68 mNominalConcept = nomConcept;
69 return this;
70 }
71
72
73 CConceptAssertionLinker* CIndividual::getAssertionConceptLinker() {
74 return mAssertionConceptLinker;
75 }
76
77 CIndividual* CIndividual::addAssertionConceptLinker(CConceptAssertionLinker* assConLinker) {
78 mAssertionConceptLinker = assConLinker->append(mAssertionConceptLinker);
79 return this;
80 }
81
82 CIndividual* CIndividual::setAssertionConceptLinker(CConceptAssertionLinker* assConLinker) {
83 mAssertionConceptLinker = assConLinker;
84 return this;
85 }
86
87
88
89 CRoleAssertionLinker* CIndividual::getAssertionRoleLinker() {
90 return mAssertionRoleLinker;
91 }
92
93 CIndividual* CIndividual::addAssertionRoleLinker(CRoleAssertionLinker* assRoleLinker) {
94 mAssertionRoleLinker = assRoleLinker->append(mAssertionRoleLinker);
95 return this;
96 }
97
98 CIndividual* CIndividual::setAssertionRoleLinker(CRoleAssertionLinker* assRoleLinker) {
99 mAssertionRoleLinker = assRoleLinker;
100 return this;
101 }
102
103
104
105 CDataAssertionLinker* CIndividual::getAssertionDataLinker() {
106 return mAssertionDataLinker;
107 }
108
109 CIndividual* CIndividual::addAssertionDataLinker(CDataAssertionLinker* assDataLinker) {
110 mAssertionDataLinker = assDataLinker->append(mAssertionDataLinker);
111 return this;
112 }
113
114 CIndividual* CIndividual::setAssertionDataLinker(CDataAssertionLinker* assDataLinker) {
115 mAssertionDataLinker = assDataLinker;
116 return this;
117 }
118
119
120
121 CReverseRoleAssertionLinker* CIndividual::getReverseAssertionRoleLinker() {
122 return mReverseAssertionRoleLinker;
123 }
124
125 CIndividual* CIndividual::addReverseAssertionRoleLinker(CReverseRoleAssertionLinker* revAssRoleLinker) {
126 mReverseAssertionRoleLinker = revAssRoleLinker->append(mReverseAssertionRoleLinker);
127 return this;
128 }
129
130 CIndividual* CIndividual::setReverseAssertionRoleLinker(CReverseRoleAssertionLinker* revAssRoleLinker) {
131 mReverseAssertionRoleLinker = revAssRoleLinker;
132 return this;
133 }
134
135
136 CIndividual* CIndividual::initIndividual(qint64 indiID) {
137 mTag = indiID;
138 mAssertionConceptLinker = nullptr;
139 mNominalConcept = nullptr;
140 mAnonymousIndividual = false;
141 mTemporaryIndividual = false;
142 mFakeIndividual = false;
143 return this;
144 }
145
146
147
148 CIndividual *CIndividual::initIndividualCopy(CIndividual* individual, CMemoryAllocationManager* memMan) {
149 mNameLinker = individual->getIndividualNameLinker();
150 mTag = individual->mTag;
151 CConceptAssertionLinker* assConIt = individual->mAssertionConceptLinker;
152 while (assConIt) {
153 CConcept *con = assConIt->getData();
154 bool negated = assConIt->isNegated();
155 CConceptAssertionLinker *assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(memMan);
156 assLinker->initNegLinker(con,negated);
157 addAssertionConceptLinker(assLinker);
158 assConIt = assConIt->getNext();
159 }
160
161 mNominalConcept = individual->mNominalConcept;
162 mAnonymousIndividual = individual->mAnonymousIndividual;
163 mFakeIndividual = individual->mFakeIndividual;
164 mTemporaryIndividual = individual->mTemporaryIndividual;
165 return this;
166 }
167
168
169 bool CIndividual::hasAssertedConcept(CConcept* concept) {
170 CConceptAssertionLinker* assertionConceptLinkerIt = mAssertionConceptLinker;
171 while (assertionConceptLinkerIt) {
172 CConcept* assConcept = assertionConceptLinkerIt->getData();
173 if (assConcept->getConceptTag() == concept->getConceptTag()) {
174 return true;
175 }
176 assertionConceptLinkerIt = assertionConceptLinkerIt->getNext();
177 }
178 return false;
179 }
180
181 CIndividual* CIndividual::setAnonymousIndividual(bool anonymous) {
182 mAnonymousIndividual = anonymous;
183 return this;
184 }
185
186 bool CIndividual::isAnonymousIndividual() {
187 return mAnonymousIndividual;
188 }
189
190
191 CIndividual* CIndividual::setTemporaryFakeIndividual(bool temporaryFake) {
192 mFakeIndividual = mTemporaryIndividual = temporaryFake;
193 return this;
194 }
195
196
197 CIndividual* CIndividual::setTemporaryIndividual(bool temporary) {
198 mTemporaryIndividual = temporary;
199 return this;
200 }
201
202 bool CIndividual::isTemporaryIndividual() {
203 return mTemporaryIndividual;
204 }
205
206
207
208 CIndividual* CIndividual::setFakeIndividual(bool fake) {
209 mFakeIndividual = fake;
210 return this;
211 }
212
213 bool CIndividual::isFakeIndividual() {
214 return mFakeIndividual;
215 }
216
217
218
219 bool CIndividual::hasIndividualData() {
220 return mIndividualData != nullptr;
221 }
222
223
224 CIndividualData* CIndividual::getIndividualData() {
225 return mIndividualData;
226 }
227
228 CIndividual* CIndividual::setIndividualData(CIndividualData* individualData) {
229 mIndividualData = individualData;
230 return this;
231 }
232
233
234 }; // end namespace Ontology
235
236 }; // end namespace Reasoner
237
238 }; // end namespace Konclude