Debian Codegraph @

Source/Reasoner/Kernel/Process/CBranchingMergingProcessingRestrictionSpecification.h

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 #ifndef KONCLUDE_REASONER_KERNEL_PROCESS_CBRANCHINGMERGINGPROCESSINGRESTRICTIONSPECIFICATION_H
22 #define KONCLUDE_REASONER_KERNEL_PROCESS_CBRANCHINGMERGINGPROCESSINGRESTRICTIONSPECIFICATION_H
23
24 // Libraries includes
25
26
27 // Namespace includes
28 #include "ProcessSettings.h"
29 #include "CProcessContext.h"
30 #include "CProcessingRestrictionSpecification.h"
31 #include "CBranchingMergingIndividualNodeCandidateLinker.h"
32 #include "CIndividualProcessNode.h"
33 #include "CDependencyTracker.h"
34
35 // Other includes
36 #include "Utilities/Memory/CObjectParameterizingAllocator.h"
37
38 // Logger includes
39 #include "Logger/CLogger.h"
40
41 #include <iostream>
42 using namespace std;
43
44 namespace Konclude {
45
46 using namespace Utilities::Memory;
47
48 namespace Reasoner {
49
50 namespace Kernel {
51
52 namespace Process {
53
54 /*!
55 *
56 * \class CBranchingMergingProcessingRestrictionSpecification
57 * \author Andreas Steigmiller
58 * \version 0.1
59 * \brief TODO
60 *
61 */
62 class CBranchingMergingProcessingRestrictionSpecification : public CProcessingRestrictionSpecification, public CDependencyTracker {
63 // public methods
64 public:
65 //! Constructor
66 CBranchingMergingProcessingRestrictionSpecification(CProcessContext* processContext = nullptr);
67
68 CBranchingMergingProcessingRestrictionSpecification* initBranchingMergingProcessingRestriction(CBranchingMergingProcessingRestrictionSpecification* prevRest = nullptr);
69
70 CPROCESSSET<cint64>* getDistinctMergedNodesSet(bool create = true);
71
72 CBranchingMergingIndividualNodeCandidateLinker* getMergingCandidateNodeLinker();
73 CBranchingMergingIndividualNodeCandidateLinker* takeNextMergingCandidateNodeLinker();
74 CBranchingMergingProcessingRestrictionSpecification* addMergingCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
75
76
77 CBranchingMergingIndividualNodeCandidateLinker* getMergingInitializationCandidateNodeLinker();
78 CBranchingMergingIndividualNodeCandidateLinker* takeNextMergingInitializationCandidateNodeLinker();
79 CBranchingMergingProcessingRestrictionSpecification* addMergingInitializationCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
80
81
82 CBranchingMergingIndividualNodeCandidateLinker* getOnlyPosQualifyCandidateNodeLinker();
83 CBranchingMergingProcessingRestrictionSpecification* addOnlyPosQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
84 CBranchingMergingProcessingRestrictionSpecification* clearOnlyPosQualifyCandidateNodeLinker();
85
86 CBranchingMergingIndividualNodeCandidateLinker* getOnlyNegQualifyCandidateNodeLinker();
87 CBranchingMergingProcessingRestrictionSpecification* addOnlyNegQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
88 CBranchingMergingProcessingRestrictionSpecification* clearOnlyNegQualifyCandidateNodeLinker();
89
90 CBranchingMergingIndividualNodeCandidateLinker* getBothQualifyCandidateNodeLinker();
91 CBranchingMergingProcessingRestrictionSpecification* addBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
92 CBranchingMergingProcessingRestrictionSpecification* setBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker);
93
94 CBranchingMergingProcessingRestrictionSpecification* addDistinctMergedNode(cint64 mergedIndiNode);
95 CBranchingMergingProcessingRestrictionSpecification* removeDistinctMergedNode(cint64 mergedIndiNode);
96
97
98 cint64 getRemainingLinkerMergingCandidateIndividualNodeCount();
99 CBranchingMergingProcessingRestrictionSpecification* setRemainingLinkerMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount);
100
101 cint64 getRemainingValidMergingCandidateIndividualNodeCount();
102 CBranchingMergingProcessingRestrictionSpecification* setRemainingValidMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount);
103 CBranchingMergingProcessingRestrictionSpecification* incRemainingValidMergingCandidateIndividualNodeCount();
104
105 bool hasValidRemainingMergingCandidates();
106
107 CIndividualLinkEdge* getLastIndividualLink();
108 CBranchingMergingProcessingRestrictionSpecification* setLastIndividualLink(CIndividualLinkEdge* indiLink);
109
110 bool hasRemainingMergingCandidates();
111 bool hasMergingInitializationCandidates();
112 bool hasRemainingMergingInitializationCandidates();
113
114
115 CBranchingMergingProcessingRestrictionSpecification* setDistinctSetFixed(bool fixed);
116 bool isDistinctSetFixed();
117
118 CBranchingMergingProcessingRestrictionSpecification* setRemainingNominalCreationCount(cint64 nomCount);
119 CBranchingMergingProcessingRestrictionSpecification* decRemainingNominalCreationCount(cint64 decCount = 1);
120 cint64 getRemainingNominalCreationCount();
121
122
123 bool hasAddedBlockablePredecessorMergingNodeCandidate();
124 CDependencyTrackPoint* getAddedBlockablePredecessorDependencyTrackPoint();
125
126
127
128 CBranchingMergingProcessingRestrictionSpecification* initMergingDependencyNode(CNonDeterministicDependencyNode* depNode);
129 CNonDeterministicDependencyNode* getMergingDependencyNode();
130
131 CBranchingMergingProcessingRestrictionSpecification* setMultipleMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes);
132 CClashedDependencyDescriptor* getMultipleMergingNodesInitializationClashesDescriptors();
133
134 CBranchingMergingProcessingRestrictionSpecification* setMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes);
135 CClashedDependencyDescriptor* getMergingNodesInitializationClashesDescriptors();
136
137 //bool addIndividualToContainer(cint64 container, cint64 individual);
138 //void printIndividualContainer();
139
140
141 bool isDistinctSetNodeRelocated();
142 CBranchingMergingProcessingRestrictionSpecification* setDistinctSetNodeRelocated(bool distinctSetNodeRelocated);
143
144 bool hasSuccessorChoiceTriggeringInstalled();
145 CBranchingMergingProcessingRestrictionSpecification* setSuccessorChoiceTriggeringInstalled(bool succChoiceTriggeringInstalled);
146
147 cint64 getSuccessorChoiceTriggeringInstalledCount();
148 CBranchingMergingProcessingRestrictionSpecification* incSuccessorChoiceTriggeringInstalledCount(cint64 count = 1);
149 CBranchingMergingProcessingRestrictionSpecification* decSuccessorChoiceTriggeringInstalledCount(cint64 count = 1);
150
151 CXLinker<CIndividualLinkEdge*>* getLastCheckedSuccessorChoiceTriggerLinker();
152 CBranchingMergingProcessingRestrictionSpecification* setLastCheckedSuccessorChoiceTriggerLinker(CXLinker<CIndividualLinkEdge*>* indiLinker);
153
154
155 // protected methods
156 protected:
157 CPROCESSSET<cint64>* createLocalizedDistinctMergedNodeSet();
158
159 // protected variables
160 protected:
161 //QStringList mList;
162 cint64 mRemainingNominalCreationCount;
163 CIndividualLinkEdge* mIndiLink;
164 cint64 mRemainingLinkerMergingCandidateIndiNodeCount;
165 cint64 mRemainingValidMergingCandidateIndiNodeCount;
166 bool mDistinctSetFixed;
167 bool mHasMergingInitCandidates;
168 CPROCESSSET<cint64>* mDistinctMergedNodesSet;
169 CPROCESSSET<cint64>* mLastDistinctMergedNodesSet;
170 CBranchingMergingIndividualNodeCandidateLinker* mNominalMergingNodesLinker;
171 CBranchingMergingIndividualNodeCandidateLinker* mMergingNodesLinker;
172 CBranchingMergingIndividualNodeCandidateLinker* mMergingInitNodesLinker;
173 CBranchingMergingIndividualNodeCandidateLinker* mOnlyPosQualifyNodesLinker;
174 CBranchingMergingIndividualNodeCandidateLinker* mOnlyNegQualifyNodesLinker;
175 CBranchingMergingIndividualNodeCandidateLinker* mBothQualifyNodesLinker;
176 CNonDeterministicDependencyNode* mMergingDependencyNode;
177 CClashedDependencyDescriptor* mInitMergingNodesClashes;
178 CClashedDependencyDescriptor* mMultipleInitMergingNodesClashes;
179 CProcessContext* mProcessContext;
180 bool mAddedBlockablePredMergingNodeCandidate;
181 CDependencyTrackPoint* mAddedBlockablePredDepTrackPoint;
182
183 bool mDistinctSetNodeRelocated;
184
185 bool mSuccChoiceTriggeringInstalled;
186 cint64 mSuccChoiceTriggeringInstalledCount;
187 CXLinker<CIndividualLinkEdge*>* mLastCheckedSuccChoiceTriggerLinker;
188
189
190
191 // private methods
192 private:
193
194 // private variables
195 private:
196
197 };
198
199 }; // end namespace Process
200
201 }; // end namespace Kernel
202
203 }; // end namespace Reasoner
204
205 }; // end namespace Konclude
206
207 #endif // KONCLUDE_REASONER_KERNEL_PROCESS_CBRANCHINGMERGINGPROCESSINGRESTRICTIONSPECIFICATION_H