/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#ifndef KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONALGORITHMCONTEXT_H
#define KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONALGORITHMCONTEXT_H
// Libraries includes
// Namespace includes
#include "AlgorithmSettings.h"
// Other includes
#include "Scheduler/CTaskContext.h"
#include "Scheduler/CTaskProcessorContext.h"
#include "Reasoner/Kernel/Process/CProcessContext.h"
#include "Reasoner/Kernel/Process/CProcessingDataBox.h"
#include "Reasoner/Kernel/Process/CProcessingStatisticGathering.h"
#include "Reasoner/Kernel/Strategy/CConceptProcessingPriorityStrategy.h"
#include "Reasoner/Kernel/Strategy/CIndividualProcessingPriorityStrategy.h"
#include "Reasoner/Kernel/Strategy/CTaskProcessingPriorityStrategy.h"
#include "Reasoner/Kernel/Strategy/CUnsatisfiableCacheRetrievalStrategy.h"
#include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h"
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
using namespace Scheduler;
namespace Reasoner {
namespace Kernel {
using namespace Process;
using namespace Strategy;
using namespace Task;
namespace Algorithm {
#ifdef KONCLUDE_FORCE_STATISTIC_DEACTIVATED
#define STATINC(STATDESC,calcAlgContext)
#define STATINCM(STATDESC,incCount,calcAlgContext)
#else
#define STATINC(STATDESC,calcAlgContext) STATDATAINC(STATDESC,calcAlgContext->getUsedProcessingStatisticsGathering())
#define STATINCM(STATDESC,incCount,calcAlgContext) STATDATAINCM(STATDESC,incCount,calcAlgContext->getUsedProcessingStatisticsGathering())
#endif
/*!
*
* \class CCalculationAlgorithmContext
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CCalculationAlgorithmContext : public CContext {
// public methods
public:
//! Constructor
CCalculationAlgorithmContext();
//! Destructor
virtual ~CCalculationAlgorithmContext();
virtual CProcessTagger* getProcessTagger() = 0;
virtual CProcessContext* getProcessContext() = 0;
virtual CMemoryAllocationManager* getProcessTaskMemoryAllocationManager() = 0;
virtual CTaskHandleMemoryAllocationManager* getTemporaryMemoryAllocationManager() = 0;
virtual CConceptProcessingPriorityStrategy* getConceptPriorityStrategy() = 0;
virtual CIndividualProcessingPriorityStrategy* getIndividualPriorityStrategy() = 0;
virtual CProcessingDataBox* getProcessingDataBox() = 0;
virtual CSatisfiableCalculationTask* getSatisfiableCalculationTask() = 0;
virtual CTaskProcessorContext* getTaskProcessorContext() = 0;
virtual CTaskProcessingPriorityStrategy* getTaskPriorityStrategy() = 0;
virtual CProcessingStatisticGathering* getProcessingStatisticsGathering() = 0;
virtual CBranchTreeNode* getBranchTreeNode() = 0;
virtual CBranchTreeNode* getNewBranchTreeNode() = 0;
virtual CDependencyNode* getBaseDependencyNode() = 0;
virtual CUnsatisfiableCacheHandler* getUnsatisfiableCacheHandler() = 0;
virtual CIndividualNodeManager* getIndividualNodeManager() = 0;
virtual CClashDescriptorFactory* getClashDescriptorFactory() = 0;
virtual CUnsatisfiableCacheRetrievalStrategy* getUnsatisfiableCacheRetrievalStrategy() = 0;
virtual CDependencyFactory* getDependencyFactory() = 0;
virtual CSatisfiableExpanderCacheHandler* getSatisfiableExpanderCacheHandler() = 0;
virtual CSaturationNodeExpansionCacheHandler* getSaturationNodeExpansionCacheHandler() = 0;
inline CProcessTagger* getUsedProcessTagger();
inline CMemoryAllocationManager* getUsedProcessTaskMemoryAllocationManager();
inline CTaskHandleMemoryAllocationManager* getUsedTemporaryMemoryAllocationManager();
inline CProcessContext* getUsedProcessContext();
inline CConceptProcessingPriorityStrategy* getUsedConceptPriorityStrategy();
inline CIndividualProcessingPriorityStrategy* getUsedIndividualPriorityStrategy();
inline CProcessingDataBox* getUsedProcessingDataBox();
inline CSatisfiableCalculationTask* getUsedSatisfiableCalculationTask();
inline CTaskProcessorContext* getUsedTaskProcessorContext();
inline CTaskProcessingPriorityStrategy* getUsedTaskPriorityStrategy();
inline CProcessingStatisticGathering* getUsedProcessingStatisticsGathering();
inline CBranchTreeNode* getUsedBranchTreeNode();
inline CDependencyNode* getUsedBaseDependencyNode();
inline CUnsatisfiableCacheHandler* getUsedUnsatisfiableCacheHandler();
inline CIndividualNodeManager* getUsedIndividualNodeManager();
inline CClashDescriptorFactory* getUsedClashDescriptorFactory();
inline CUnsatisfiableCacheRetrievalStrategy* getUsedUnsatisfiableCacheRetrievalStrategy();
inline CDependencyFactory* getUsedDependencyFactory();
inline CSatisfiableExpanderCacheHandler* getUsedSatisfiableExpanderCacheHandler();
inline CSaturationNodeExpansionCacheHandler* getUsedSaturationNodeExpansionCacheHandler();
inline bool setMinModificationAncestorDepthCandidate(cint64 ancDepthCandidate);
inline bool setMinModificationIndividualIDCandidate(cint64 indiIDCandidate);
inline bool setMinModificationIndividualCandidate(CIndividualProcessNode* indiNode);
bool isMinModificationUpdated();
CCalculationAlgorithmContext* setMinModificationAncestorDepth(cint64 ancDepth);
cint64 getMinModificationAncestorDepth();
CCalculationAlgorithmContext* setMinModificationIndividualID(cint64 indiID);
cint64 getMinModificationIndividualID();
CCalculationAlgorithmContext* setMinModificationIndividual(CIndividualProcessNode* indiNode);
cint64 getMaxCompletionGraphCachedIndividualNodeID();
cint64 getCompletionGraphCachedLocalizationTag();
bool hasCompletionGraphCachedIndividualNodes();
CIndividualProcessNode* getCurrentIndividualNode();
CCalculationAlgorithmContext* setCurrentIndividualNode(CIndividualProcessNode* indiNode);
CTaskHandleMemoryAllocationManager* mUsedTempMemMan;
// protected methods
protected:
// protected variables
protected:
CMemoryAllocationManager* mUsedPrTaskMemMan;
CProcessTagger* mUsedProcessTagger;
CProcessContext* mUsedProcessContext;
CConceptProcessingPriorityStrategy* mUsedConceptPriorityStrategy;
CIndividualProcessingPriorityStrategy* mUsedIndividualPriorityStrategy;
CProcessingDataBox* mUsedProcessingDataBox;
CSatisfiableCalculationTask* mUsedSatCalcTask;
CTaskProcessorContext* mUsedTaskProcessorContext;
CTaskProcessingPriorityStrategy* mUsedTaskPriorityStrategy;
CProcessingStatisticGathering* mUsedProcessStatGath;
CBranchTreeNode* mUsedBranchTreeNode;
CDependencyNode* mUsedBaseDepNode;
cint64 mMinModificationAncestorDepth;
cint64 mMinModificationIndividualID;
bool mMinModificationUpdated;
CUnsatisfiableCacheHandler* mUsedUnsatCacheHandler;
CIndividualNodeManager* mUsedIndividualNodeManager;
CClashDescriptorFactory* mUsedClashDescriptorFactory;
CUnsatisfiableCacheRetrievalStrategy* mUsedUnsatCachRetStrategy;
CDependencyFactory* mUsedDepFactory;
CSatisfiableExpanderCacheHandler* mUsedSatExpCacheHandler;
cint64 mMaxCompletionGraphCachedIndiNodeID;
CIndividualProcessNode* mCurrentIndiNode;
cint64 mCompletionGraphCachedLocalizationTag;
CSaturationNodeExpansionCacheHandler* mUsedSatNodeExpCacheHandler;
// private methods
private:
// private variables
private:
};
CProcessTagger* CCalculationAlgorithmContext::getUsedProcessTagger() {
return mUsedProcessTagger;
}
CProcessContext* CCalculationAlgorithmContext::getUsedProcessContext() {
return mUsedProcessContext;
}
CMemoryAllocationManager* CCalculationAlgorithmContext::getUsedProcessTaskMemoryAllocationManager() {
return mUsedPrTaskMemMan;
}
CTaskHandleMemoryAllocationManager* CCalculationAlgorithmContext::getUsedTemporaryMemoryAllocationManager() {
return mUsedTempMemMan;
}
CConceptProcessingPriorityStrategy* CCalculationAlgorithmContext::getUsedConceptPriorityStrategy() {
return mUsedConceptPriorityStrategy;
}
CIndividualProcessingPriorityStrategy* CCalculationAlgorithmContext::getUsedIndividualPriorityStrategy() {
return mUsedIndividualPriorityStrategy;
}
CProcessingDataBox* CCalculationAlgorithmContext::getUsedProcessingDataBox() {
return mUsedProcessingDataBox;
}
CSatisfiableCalculationTask* CCalculationAlgorithmContext::getUsedSatisfiableCalculationTask() {
return mUsedSatCalcTask;
}
CTaskProcessorContext* CCalculationAlgorithmContext::getUsedTaskProcessorContext() {
return mUsedTaskProcessorContext;
}
CTaskProcessingPriorityStrategy* CCalculationAlgorithmContext::getUsedTaskPriorityStrategy() {
return mUsedTaskPriorityStrategy;
}
CProcessingStatisticGathering* CCalculationAlgorithmContext::getUsedProcessingStatisticsGathering() {
return mUsedProcessStatGath;
}
CBranchTreeNode* CCalculationAlgorithmContext::getUsedBranchTreeNode() {
return mUsedBranchTreeNode;
}
CDependencyNode* CCalculationAlgorithmContext::getUsedBaseDependencyNode() {
return mUsedBaseDepNode;
}
bool CCalculationAlgorithmContext::setMinModificationAncestorDepthCandidate(cint64 ancDepthCandidate) {
bool updated = ancDepthCandidate < mMinModificationIndividualID;
mMinModificationIndividualID = qMin(ancDepthCandidate,mMinModificationIndividualID);
return updated;
}
bool CCalculationAlgorithmContext::setMinModificationIndividualIDCandidate(cint64 indiIDCandidate) {
bool updated = indiIDCandidate < mMinModificationIndividualID;
mMinModificationIndividualID = qMin(indiIDCandidate,mMinModificationIndividualID);
return updated;
}
bool CCalculationAlgorithmContext::setMinModificationIndividualCandidate(CIndividualProcessNode* indiNode) {
return setMinModificationIndividualIDCandidate(indiNode->getIndividualNodeID()) || setMinModificationAncestorDepthCandidate(indiNode->getIndividualAncestorDepth());
}
CUnsatisfiableCacheHandler* CCalculationAlgorithmContext::getUsedUnsatisfiableCacheHandler() {
return mUsedUnsatCacheHandler;
}
CIndividualNodeManager* CCalculationAlgorithmContext::getUsedIndividualNodeManager() {
return mUsedIndividualNodeManager;
}
CClashDescriptorFactory* CCalculationAlgorithmContext::getUsedClashDescriptorFactory() {
return mUsedClashDescriptorFactory;
}
CUnsatisfiableCacheRetrievalStrategy* CCalculationAlgorithmContext::getUsedUnsatisfiableCacheRetrievalStrategy() {
return mUsedUnsatCachRetStrategy;
}
CDependencyFactory* CCalculationAlgorithmContext::getUsedDependencyFactory() {
return mUsedDepFactory;
}
CSatisfiableExpanderCacheHandler* CCalculationAlgorithmContext::getUsedSatisfiableExpanderCacheHandler() {
return mUsedSatExpCacheHandler;
}
CSaturationNodeExpansionCacheHandler* CCalculationAlgorithmContext::getUsedSaturationNodeExpansionCacheHandler() {
return mUsedSatNodeExpCacheHandler;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONALGORITHMCONTEXT_H