Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualProcessingQueue.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 "CIndividualProcessingQueue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CIndividualProcessingQueue::CIndividualProcessingQueue(CProcessContext* processContext)
34 : mProcessContext(processContext),mPriorityIndiDesMap(processContext),mIndiDesPriorityHash(processContext) {
35
36 mIndiProDesCount = 0;
37 mHasMaxIndiPriority = false;
38 mLastCheckIndi = nullptr;
39 }
40
41
42 CIndividualProcessingQueue::~CIndividualProcessingQueue() {
43 }
44
45 CIndividualProcessingQueue* CIndividualProcessingQueue::initProcessingQueue(CIndividualProcessingQueue* processingQueue) {
46 if (processingQueue) {
47 mPriorityIndiDesMap = processingQueue->mPriorityIndiDesMap;
48 mIndiDesPriorityHash = processingQueue->mIndiDesPriorityHash;
49 mIndiProDesCount = processingQueue->mIndiProDesCount;
50 } else {
51 mPriorityIndiDesMap.clear();
52 mIndiDesPriorityHash.clear();
53 mIndiProDesCount = 0;
54 }
55 return this;
56 }
57
58
59 CIndividualProcessingQueue *CIndividualProcessingQueue::insertIndiviudalProcessDescriptor(CIndividualProcessNodeDescriptor *indiProDes) {
60 CIndividualProcessNode *individual = indiProDes->getIndividual();
61 CIndividualProcessNodePriority indiPriority = indiProDes->getProcessPriority();
62 if (individual == mLastCheckIndi) {
63 mLastCheckIndiPriority = qMax(indiPriority,mLastCheckIndiPriority);
64 }
65 cint64 indiID = individual->getIndividualNodeID();
66 if (mHasMaxIndiPriority) {
67 mMaxIndiPriority = qMax(indiPriority,mMaxIndiPriority);
68 }
69
70 //cint64 prevCount = mPriorityIndiDesMap.count();
71
72 mIndiDesPriorityHash.insert(indiID,indiPriority);
73 mPriorityIndiDesMap.insertMulti(indiPriority,indiProDes);
74 ++mIndiProDesCount;
75
76 //if (mPriorityIndiDesMap.count() != mIndiProDesCount) {
77 // mPriorityIndiDesMap.insertMulti(indiPriority,indiProDes);
78 // bool bug = true;
79 //}
80
81 return this;
82 }
83
84
85 bool CIndividualProcessingQueue::isIndividualQueued(CIndividualProcessNode *individual) {
86 cint64 indiID = individual->getIndividualNodeID();
87 mLastCheckIndiPriority = mIndiDesPriorityHash.value(indiID,CIndividualProcessNodePriority());
88 return !mLastCheckIndiPriority.isNullPriority();
89 }
90
91
92 bool CIndividualProcessingQueue::needsIndiviudalInsertion(CIndividualProcessNode *individual, CIndividualProcessNodePriority priority) {
93 if (mLastCheckIndi == individual) {
94 if (!mLastCheckIndiPriority.isNullPriority() && priority >= mLastCheckIndiPriority) {
95 return false;
96 } else {
97 return true;
98 }
99 } else {
100 cint64 indiID = individual->getIndividualNodeID();
101 mLastCheckIndi = individual;
102 mLastCheckIndiPriority = mIndiDesPriorityHash.value(indiID,CIndividualProcessNodePriority());
103 if (!mLastCheckIndiPriority.isNullPriority() && priority >= mLastCheckIndiPriority) {
104 return false;
105 }
106 return true;
107 }
108 }
109
110
111 bool CIndividualProcessingQueue::hasHigherPriorityIndividual(CIndividualProcessNodePriority priority) {
112 if (!mHasMaxIndiPriority) {
113 CIndividualProcessNodeDescriptor* nextIndiDes = getNextProcessIndividualDescriptor();
114 if (nextIndiDes) {
115 mMaxIndiPriority = nextIndiDes->getProcessPriority();
116 mHasMaxIndiPriority = true;
117 }
118 }
119 if (mHasMaxIndiPriority) {
120 return mMaxIndiPriority < priority;
121 }
122 return false;
123 }
124
125
126 CIndividualProcessNodeDescriptor* CIndividualProcessingQueue::takeNextProcessIndividualDescriptor() {
127 CIndividualProcessNodeDescriptor* indiProDes = nullptr;
128 if (mIndiProDesCount > 0) {
129 --mIndiProDesCount;
130 CPROCESSMAP<CIndividualProcessNodePriority,CIndividualProcessNodeDescriptor*>::iterator it = mPriorityIndiDesMap.begin();
131 indiProDes = it.value();
132 mPriorityIndiDesMap.erase(it);
133 cint64 indiID = indiProDes->getIndividual()->getIndividualNodeID();
134 mIndiDesPriorityHash.insert(indiID,0.);
135 mLastCheckIndi = nullptr;
136
137 //if (mPriorityIndiDesMap.count() != mIndiProDesCount) {
138 // bool bug = true;
139 //}
140 }
141 mHasMaxIndiPriority = false;
142 return indiProDes;
143 }
144
145 CIndividualProcessNodeDescriptor* CIndividualProcessingQueue::getNextProcessIndividualDescriptor() {
146 CIndividualProcessNodeDescriptor* indiProDes = nullptr;
147 if (mIndiProDesCount > 0) {
148 CPROCESSMAP<CIndividualProcessNodePriority,CIndividualProcessNodeDescriptor*>::iterator it = mPriorityIndiDesMap.begin();
149 indiProDes = it.value();
150 }
151 return indiProDes;
152 }
153
154 bool CIndividualProcessingQueue::isEmpty() {
155 return mIndiProDesCount <= 0;
156 }
157
158 bool CIndividualProcessingQueue::hasIndividualProcessDescriptor() {
159 return mIndiProDesCount > 0;
160 }
161
162
163
164 }; // end namespace Process
165
166 }; // end namespace Kernel
167
168 }; // end namespace Reasoner
169
170 }; // end namespace Konclude