Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualDepthProcessingQueue.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 "CIndividualDepthProcessingQueue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CIndividualDepthProcessingQueue::CIndividualDepthProcessingQueue(CProcessContext* processContext)
34 : mProcessContext(processContext),mPriorityIndiDesMap(processContext),mRemainingDepthIndiLinkerMap(processContext) {
35
36 mNextRemainingDepth = 1;
37 mAdditionalPriorityIndiDesMap = nullptr;
38 }
39
40 CIndividualDepthProcessingQueue* CIndividualDepthProcessingQueue::initProcessingQueue(CIndividualDepthProcessingQueue* processingQueue) {
41 if (processingQueue) {
42 if (!processingQueue->mAdditionalPriorityIndiDesMap && processingQueue->mPriorityIndiDesMap.size() <= 100 || processingQueue->mAdditionalPriorityIndiDesMap && processingQueue->mPriorityIndiDesMap.size()*5 < processingQueue->mAdditionalPriorityIndiDesMap->size()) {
43 mPriorityIndiDesMap = processingQueue->mPriorityIndiDesMap;
44 mAdditionalPriorityIndiDesMap = processingQueue->mAdditionalPriorityIndiDesMap;
45 mAdditionalPriIndiDesMapIt = processingQueue->mAdditionalPriIndiDesMapIt;
46 } else {
47 if (processingQueue->mAdditionalPriorityIndiDesMap) {
48 mAdditionalPriorityIndiDesMap = CObjectParameterizingAllocator< CPROCESSMAP<CIndividualDepthPriority,CIndividualProcessNode*>,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getMemoryAllocationManager(),mProcessContext);
49 if (processingQueue->mAdditionalPriIndiDesMapIt == processingQueue->mAdditionalPriorityIndiDesMap->constBegin()) {
50 *mAdditionalPriorityIndiDesMap = *processingQueue->mAdditionalPriorityIndiDesMap;
51 for (CPROCESSMAP<CIndividualDepthPriority,CIndividualProcessNode*>::const_iterator it = processingQueue->mPriorityIndiDesMap.constBegin(), itEnd = processingQueue->mPriorityIndiDesMap.constEnd(); it != itEnd; ++it) {
52 mAdditionalPriorityIndiDesMap->insert(it.key(),it.value());
53 }
54 } else {
55 *mAdditionalPriorityIndiDesMap = processingQueue->mPriorityIndiDesMap;
56 for (CPROCESSMAP<CIndividualDepthPriority,CIndividualProcessNode*>::const_iterator it = processingQueue->mAdditionalPriIndiDesMapIt, itEnd = processingQueue->mAdditionalPriorityIndiDesMap->constEnd(); it != itEnd; ++it) {
57 mAdditionalPriorityIndiDesMap->tryInsert(it.key(),it.value());
58 }
59 }
60 } else {
61 mAdditionalPriorityIndiDesMap = &processingQueue->mPriorityIndiDesMap;
62 }
63 mAdditionalPriIndiDesMapIt = mAdditionalPriorityIndiDesMap->constBegin();
64 mPriorityIndiDesMap.clear();
65 }
66 mRemainingDepthIndiLinkerMap = processingQueue->mRemainingDepthIndiLinkerMap;
67 mNextRemainingDepth = processingQueue->mNextRemainingDepth;
68 } else {
69 mPriorityIndiDesMap.clear();
70 mRemainingDepthIndiLinkerMap.clear();
71 mNextRemainingDepth = 1;
72 mAdditionalPriIndiDesMapIt = mPriorityIndiDesMap.constEnd();
73 }
74 return this;
75 }
76
77
78 CIndividualProcessNode* CIndividualDepthProcessingQueue::takeNextProcessIndividual() {
79 CIndividualProcessNode* nextNode = nullptr;
80
81 if (mPriorityIndiDesMap.isEmpty() && (!mAdditionalPriorityIndiDesMap || mAdditionalPriIndiDesMapIt == mAdditionalPriorityIndiDesMap->constEnd())) {
82 CPROCESSMAP<cint64,CXLinker<CIndividualProcessNode*>*>::iterator it = mRemainingDepthIndiLinkerMap.begin();
83 mNextRemainingDepth = it.key()+1;
84 for (CXLinker<CIndividualProcessNode*>* indiLinker = it.value(); indiLinker; indiLinker = indiLinker->getNext()) {
85 CIndividualProcessNode* individual = indiLinker->getData();
86 CIndividualDepthPriority priority(individual->getIndividualNominalLevelOrAncestorDepth(),individual->getIndividualNodeID());
87 mPriorityIndiDesMap.tryInsert(priority,individual);
88 }
89 mRemainingDepthIndiLinkerMap.erase(it);
90 }
91
92 if (!mPriorityIndiDesMap.isEmpty() || mAdditionalPriorityIndiDesMap && mAdditionalPriIndiDesMapIt != mAdditionalPriorityIndiDesMap->constEnd()) {
93 if (!mAdditionalPriorityIndiDesMap || mAdditionalPriIndiDesMapIt == mAdditionalPriorityIndiDesMap->constEnd()) {
94 CPROCESSMAP<CIndividualDepthPriority,CIndividualProcessNode*>::iterator it = mPriorityIndiDesMap.begin();
95 nextNode = it.value();
96 mPriorityIndiDesMap.erase(it);
97 } else if (mPriorityIndiDesMap.isEmpty()) {
98 nextNode = mAdditionalPriIndiDesMapIt.value();
99 ++mAdditionalPriIndiDesMapIt;
100 } else {
101 CPROCESSMAP<CIndividualDepthPriority,CIndividualProcessNode*>::iterator it = mPriorityIndiDesMap.begin();
102 if (it.key() == mAdditionalPriIndiDesMapIt.key()) {
103 nextNode = it.value();
104 ++mAdditionalPriIndiDesMapIt;
105 mPriorityIndiDesMap.erase(it);
106 } else if (it.key() < mAdditionalPriIndiDesMapIt.key()) {
107 nextNode = it.value();
108 mPriorityIndiDesMap.erase(it);
109 } else {
110 nextNode = mAdditionalPriIndiDesMapIt.value();
111 ++mAdditionalPriIndiDesMapIt;
112 }
113 }
114 }
115 return nextNode;
116 }
117
118
119 CIndividualDepthProcessingQueue* CIndividualDepthProcessingQueue::insertProcessIndiviudal(CIndividualProcessNode* individual) {
120 cint64 depth = individual->getIndividualNominalLevelOrAncestorDepth();
121 CIndividualDepthPriority priority(depth,individual->getIndividualNodeID());
122 if (depth >= mNextRemainingDepth) {
123 CXLinker<CIndividualProcessNode*>* indiLinker = CObjectAllocator< CXLinker<CIndividualProcessNode*> >::allocateAndConstruct(mProcessContext->getMemoryAllocationManager());
124 indiLinker->initLinker(individual);
125 CXLinker<CIndividualProcessNode*>*& storedIndiLinker = mRemainingDepthIndiLinkerMap[depth];
126 storedIndiLinker = indiLinker->append(storedIndiLinker);
127 } else {
128 mPriorityIndiDesMap.insert(priority,individual);
129 }
130 return this;
131 }
132
133
134 bool CIndividualDepthProcessingQueue::isEmpty() {
135 return mPriorityIndiDesMap.isEmpty() && (!mAdditionalPriorityIndiDesMap || mAdditionalPriIndiDesMapIt == mAdditionalPriorityIndiDesMap->constEnd()) && mRemainingDepthIndiLinkerMap.isEmpty();
136 }
137
138
139
140 }; // end namespace Process
141
142 }; // end namespace Kernel
143
144 }; // end namespace Reasoner
145
146 }; // end namespace Konclude