/*
* 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_PROCESS_CINDIVIDUALPROCESSNODE_H
#define KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALPROCESSNODE_H
// Libraries includes
// Namespace includes
#include "ProcessSettings.h"
#include "CProcessContext.h"
#include "CIndividualProcessNodeReference.h"
#include "CReapplyQueue.h"
#include "CConceptLabelSet.h"
#include "CRoleReapplyHash.h"
#include "CConceptReapplyHash.h"
#include "CRoleSuccessorHash.h"
#include "CReapplyRoleSuccessorHash.h"
#include "CReapplyConceptLabelSet.h"
#include "CSuccessorRoleHash.h"
#include "CConnectionSuccessorCorrectionHash.h"
#include "CConnectionSuccessorSet.h"
#include "CConceptProcessingQueue.h"
#include "CLocalizationTag.h"
#include "CBlockedTestTag.h"
#include "CDistinctHash.h"
#include "CDisjointSuccessorRoleHash.h"
#include "CDependencyTracker.h"
#include "CBlockingFollowSet.h"
#include "CRoleBackwardPropagationHash.h"
#include "CIndividualProcessNode.h"
#include "CIndividualProcessNodeLinker.h"
#include "CConceptProcessLinker.h"
#include "CIndividualProcessNodePriority.h"
#include "CIndividualNodeModelData.h"
#include "CIndividualNodeBlockData.h"
#include "CBlockingVariableBindingsAnalogousPropagationData.h"
#include "CIndividualNodeSatisfiableCacheRetrievalData.h"
#include "CIndividualNodeBackendCacheSynchronisationData.h"
#include "CIndividualNodeSatisfiableCacheStoringData.h"
#include "CIndividualNodeUnsatisfiableCacheRetrievalData.h"
#include "CIndividualNodeAnalizedConceptExpansionData.h"
#include "CSignatureBlockingIndividualNodeConceptExpansionData.h"
#include "CReusingIndividualNodeConceptExpansionData.h"
#include "CIndividualNodeSaturationBlockingData.h"
#include "CNominalCachingLossReactivationData.h"
#include "CSuccessorConnectedNominalSet.h"
#include "CSuccessorIndividualATMOSTReactivationData.h"
#include "CPropagationBindingSet.h"
#include "CConceptPropagationBindingSetHash.h"
#include "CConceptVariableBindingPathSetHash.h"
#include "CConceptRepresentativePropagationSetHash.h"
#include "CIndividualNodeIncrementalExpansionData.h"
#include "CDatatypesValueSpaceData.h"
#include "CAdditionalProcessRoleAssertionsLinker.h"
#include "CAdditionalProcessDataAssertionsLinker.h"
#include "CProcessAssertedDataLiteralLinker.h"
#include "CIndividualMergingHash.h"
// Other includes
#include "Reasoner/Ontology/CConcept.h"
#include "Reasoner/Ontology/CRole.h"
#include "Reasoner/Ontology/CIndividual.h"
#include "Reasoner/Ontology/CIRIName.h"
#include "Utilities/Memory/CObjectParameterizingAllocator.h"
#include "Utilities/Container/CSortedNegLinker.h"
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
using namespace Utilities::Memory;
using namespace Utilities::Container;
namespace Reasoner {
using namespace Ontology;
namespace Kernel {
namespace Process {
/*!
*
* \class CIndividualProcessNode
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CIndividualProcessNode : public CIndividualProcessNodeReference, public CLocalizationTag, public CBlockedTestTag, public CDependencyTracker {
// public methods
public:
//! Constructor
CIndividualProcessNode(CProcessContext* processContext = nullptr);
CIndividualProcessNode* initIndividualProcessNode(CIndividualProcessNode* prevIndividual);
CIndividualProcessNode* initIndividualProcessNodeCopy(CIndividualProcessNode* prevIndividual, bool adobtConceptLabels = true, bool adobtRoleSuccessors = false, bool adobtStatus = false);
CIndividualProcessNode* setReapplyConceptLabelSet(CReapplyConceptLabelSet* reapplyConSet);
CReapplyConceptLabelSet* getReapplyConceptLabelSet(bool create = true);
CConceptProcessingQueue* getConceptProcessingQueue(bool create = true);
CReapplyRoleSuccessorHash* getReapplyRoleSuccessorHash(bool create = true);
CRoleSuccessorLinkIterator getRoleSuccessorLinkIterator(CRole* role);
CRoleSuccessorLinkIterator getRoleSuccessorHistoryLinkIterator(CRole* role, CIndividualLinkEdge* lastLink);
cint64 getRoleSuccessorCount(CRole* role);
CRoleSuccessorIterator getRoleIterator();
CSuccessorRoleHash* getSuccessorRoleHash(bool create = true);
CSuccessorRoleIterator getSuccessorRoleIterator(cint64 indiID);
CSuccessorRoleIterator getSuccessorRoleIterator(CIndividualProcessNode* indiNode);
bool hasSuccessorIndividualNode(cint64 indiID);
bool hasSuccessorIndividualNode(CIndividualProcessNode* indiNode);
bool hasDisjointRoleConnections();
CIndividualProcessNode* setDisjointRoleConnections(bool disjointRoleConnections);
CDisjointSuccessorRoleHash* getDisjointSuccessorRoleHash(bool create = true);
CDisjointSuccessorRoleIterator getDisjointSuccessorRoleIterator(cint64 succIndiId);
CDisjointSuccessorRoleIterator getDisjointSuccessorRoleIterator(CIndividualProcessNode* indiNode);
bool hasNegationDisjointToIndividual(CRole* role, cint64 destinationIndiID);
bool hasNegationDisjointToIndividual(CRole* role, CIndividualProcessNode* desIndi);
CIndividualProcessNode* installDisjointLink(CNegationDisjointEdge* link);
CIndividualProcessNode* removeDisjointLinks(cint64 succIndiID);
bool hasRoleSuccessorToIndividual(CRole* role, cint64 destinationIndiID, bool locateable);
bool hasRoleSuccessorToIndividual(CRole* role, CIndividualProcessNode* desIndi, bool locateable);
CIndividualLinkEdge* getRoleSuccessorToIndividualLink(CRole* role, cint64 destinationIndiID, bool locateable);
CIndividualLinkEdge* getRoleSuccessorToIndividualLink(CRole* role, CIndividualProcessNode* desIndi, bool locateable);
CSuccessorIterator getSuccessorIterator();
CConnectionSuccessorSet* getConnectionSuccessorSet(bool create = true);
CConnectionSuccessorSetIterator getConnectionSuccessorIterator();
CReapplyQueue* getRoleReapplyQueue(CRole* role, bool create = true);
CReapplyQueueIterator getRoleReapplyIterator(CRole* role, bool clearDynamicReapllyQueue = true);
CCondensedReapplyQueue* getConceptReapplyQueue(CConcept* concept, bool conceptNegation, bool create = true);
CCondensedReapplyQueueIterator getConceptReapplyIterator(CConcept* concept, bool conceptNegation, bool clearDynamicReapllyQueue = true);
CDistinctHash* getDistinctHash(bool create = true);
CIndividualLinkEdge* getLastAddedRoleLink();
cint64 installIndividualLink(CIndividualLinkEdge* link, CReapplyQueueIterator* reapplyQueueIt = nullptr);
CIndividualProcessNode* removeIndividualLink(CIndividualLinkEdge* link);
CIndividualProcessNode* removeIndividualConnection(CIndividualProcessNode* indi);
CIndividualLinkEdge* getAncestorLink();
CIndividualProcessNode* setAncestorLink(CIndividualLinkEdge* link);
bool isIndividualAncestor(CIndividualProcessNode* individual);
bool hasIndividualAncestor();
CIndividualProcessNode* addBlockedIndividualsLinker(CXLinker* linker);
CXLinker* getBlockedIndividualsLinker();
CIndividualProcessNode* setBlockedIndividualsLinker(CXLinker* linker = nullptr);
CIndividualProcessNode* clearBlockedIndividualsLinker();
bool hasBlockedIndividualsLinker();
CIndividualNodeModelData* getIndividualModelData();
CIndividualProcessNode* setIndividualModelData(CIndividualNodeModelData* individualModel);
CIndividualNodeBlockData* getIndividualBlockData(bool localBlockData = false);
CIndividualProcessNode* setIndividualBlockData(CIndividualNodeBlockData* individualBlock);
CBlockingVariableBindingsAnalogousPropagationData* getVariableBindingsPropagationBlockingData(bool localBlockData = false);
CIndividualProcessNode* setVariableBindingsPropagationBlockingData(CBlockingVariableBindingsAnalogousPropagationData* blockData);
CIndividualNodeSaturationBlockingData* getIndividualSaturationBlockingData(bool localBlockData = false);
CIndividualProcessNode* setIndividualSaturationBlockingData(CIndividualNodeSaturationBlockingData* individualBlock);
CIndividualNodeUnsatisfiableCacheRetrievalData* getIndividualUnsatisfiableCacheRetrievalData(bool localUnsatCacheRetData = false);
CIndividualProcessNode* setIndividualUnsatisfiableCacheRetrievalData(CIndividualNodeUnsatisfiableCacheRetrievalData* individualUnsatCacheRetData);
CIndividualNodeSatisfiableCacheRetrievalData* getIndividualSatisfiableCacheRetrievalData(bool localCacheData = false);
CIndividualProcessNode* setIndividualSatisfiableCacheRetrievalData(CIndividualNodeSatisfiableCacheRetrievalData* satCacheRetrievalData);
CIndividualNodeBackendCacheSynchronisationData* getIndividualBackendCacheSynchronisationData(bool localCacheData = false);
CIndividualProcessNode* setIndividualBackendCacheSynchronisationData(CIndividualNodeBackendCacheSynchronisationData* backendSyncData);
CIndividualNodeSatisfiableCacheStoringData* getIndividualSatisfiableCacheStoringData(bool localCacheData = false);
CIndividualProcessNode* setIndividualSatisfiableCacheStoringData(CIndividualNodeSatisfiableCacheStoringData* satCacheStoringData);
CIndividualNodeAnalizedConceptExpansionData* getAnalizedConceptExpansionData(bool createOrLocalize = true);
CBlockingFollowSet* getBlockingFollowSet(bool createOrLocalize = true);
bool hasBlockingFollower();
CSignatureBlockingIndividualNodeConceptExpansionData* getSignatureBlockingIndividualNodeConceptExpansionData(bool localBlockingData);
CIndividualProcessNode* setSignatureBlockingIndividualNodeConceptExpansionData(CSignatureBlockingIndividualNodeConceptExpansionData* individualBlockingData);
CReusingIndividualNodeConceptExpansionData* getReusingIndividualNodeConceptExpansionData(bool localBlockingData);
CIndividualProcessNode* setReusingIndividualNodeConceptExpansionData(CReusingIndividualNodeConceptExpansionData* individualBlockingData);
cint64 getIndividualAncestorDepth();
CIndividualProcessNode* setIndividualAncestorDepth(cint64 depth);
cint64 getIndividualNominalLevel();
CIndividualProcessNode* setIndividualNominalLevel(cint64 level);
cint64 getIndividualNominalLevelOrAncestorDepth();
cint64 getMergedIntoIndividualNodeID();
bool hasMergedIntoIndividualNodeID();
CIndividualProcessNode* setMergedIntoIndividualNodeID(cint64 indiNodeID);
bool isBlockableIndividual();
bool isNominalIndividualNode();
CIndividual* getNominalIndividual();
CIndividualProcessNode* setNominalIndividual(CIndividual* indi);
enum CIndividualType { BLOCKABLEINDIVIDUALTYPE, NOMINALINDIVIDUALTYPE };
CIndividualType getIndividualType();
CIndividualProcessNode* setIndividualType(CIndividualType indiType);
cint64 getIndividualNodeID();
CIndividualProcessNode* setIndividualNodeID(cint64 indiID);
bool hasInitializingConcepts();
CIndividualProcessNode* clearProcessInitializingConcepts();
CXSortedNegLinker* getInitializingConceptLinker();
CXSortedNegLinker* getProcessInitializingConceptLinker();
CIndividualProcessNode* setInitializingConceptLinker(CXSortedNegLinker* initializingConceptLinkerIt);
CIndividualProcessNode* addInitializingConceptLinker(CXSortedNegLinker* initializingConceptLinkerIt);
bool hasAssertionConcepts();
CIndividualProcessNode* clearAssertionConcepts();
CConceptAssertionLinker* getAssertionConceptLinker();
CIndividualProcessNode* setAssertionConceptLinker(CConceptAssertionLinker* assertionConceptLinkerIt);
bool hasAssertionData();
CIndividualProcessNode* clearAssertionData();
CDataAssertionLinker* getAssertionDataLinker();
CIndividualProcessNode* setAssertionDataLinker(CDataAssertionLinker* assertionDataLinker);
CDataAssertionLinker* getLastProcessedAssertionDataLinker();
CIndividualProcessNode* setLastProcessedAssertionDataLinker(CDataAssertionLinker* assDataLinker);
bool hasAssertedDataLiterals();
CProcessAssertedDataLiteralLinker* getAssertedDataLiteralLinker();
CIndividualProcessNode* setAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker);
CIndividualProcessNode* addAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker);
CIndividualProcessNode* clearAssertedDataLiterals();
CProcessAssertedDataLiteralLinker* getLastAssertedDataLiteralLinker();
CIndividualProcessNode* setLastAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker);
bool hasAssertionRoles();
CIndividualProcessNode* clearAssertionRoles();
CRoleAssertionLinker* getAssertionRoleLinker();
CIndividualProcessNode* setAssertionRoleLinker(CRoleAssertionLinker* assertionRoleLinkerIt);
cint64 getRoleAssertionCreationID();
CIndividualProcessNode* setRoleAssertionCreationID(cint64 creationID);
bool hasReverseAssertionRoles();
CIndividualProcessNode* clearReverseAssertionRoles();
CReverseRoleAssertionLinker* getReverseAssertionRoleLinker();
CIndividualProcessNode* setReverseAssertionRoleLinker(CReverseRoleAssertionLinker* reverseAssertionRoleLinkerIt);
bool hasAdditionalRoleAssertionsLinker();
CIndividualProcessNode* clearAdditionalRoleAssertionsLinker();
CAdditionalProcessRoleAssertionsLinker* getAdditionalRoleAssertionsLinker();
CIndividualProcessNode* setAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker);
CIndividualProcessNode* addAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker);
bool hasAdditionalDataAssertionsLinker();
CIndividualProcessNode* clearAdditionalDataAssertionsLinker();
CAdditionalProcessDataAssertionsLinker* getAdditionalDataAssertionsLinker();
CIndividualProcessNode* setAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker);
CIndividualProcessNode* addAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker);
CAdditionalProcessDataAssertionsLinker* getLastProcessedAdditionalDataAssertionLinker();
CIndividualProcessNode* setLastProcessedAdditionalDataAssertionLinker(CAdditionalProcessDataAssertionsLinker* dataLiteralLinker);
bool hasBaseConceptsInitialized();
CIndividualProcessNode* setBaseConceptsInitialized(bool initialized);
bool hasUniversallyConnectionIndividualInitialized();
CIndividualProcessNode* setUniversallyConnectionIndividualInitialized(bool initialized);
bool hasRoleAssertionsInitialized();
CIndividualProcessNode* setRoleAssertionsInitialized(bool initialized);
bool hasReverseRoleAssertionsInitialized();
CIndividualProcessNode* setReverseRoleAssertionsInitialized(bool initialized);
bool hasNominalIndividualTriplesAssertions();
CIndividualProcessNode* setNominalIndividualTriplesAssertions(bool hasNominalAssertions);
bool areNominalIndividualTriplesAssertionsLoaded();
CIndividualProcessNode* setNominalIndividualTriplesAssertionsLoaded(bool loaded);
bool isNominalIndividualRepresentativeBackendDataLoaded();
CIndividualProcessNode* setNominalIndividualRepresentativeBackendDataLoaded(bool loaded);
CIndividualProcessNode* getProcessingBlockTestIndividual();
CIndividualProcessNode* clearProcessingBlockTestIndividual();
CIndividualProcessNode* setProcessingBlockTestIndividual(CIndividualProcessNode* ancestorBlockTestIndi);
CIndividualProcessNode* addProcessingBlockedIndividualsLinker(CXLinker* linker);
CXLinker* getProcessingBlockedIndividualsLinker();
CIndividualProcessNode* setIndirectBlockedIndividualsLinker(CXLinker* linker = nullptr);
CIndividualProcessNode* clearSatisfiableCachedAbsorbedDisjunctionsLinker();
CReapplyConceptDescriptor* getSatisfiableCachedAbsorbedDisjunctionsLinker();
CIndividualProcessNode* addSatisfiableCachedAbsorbedDisjunctionsLinker(CReapplyConceptDescriptor* disjunctionReapplyConDes);
CIndividualProcessNode* clearSatisfiableCachedAbsorbedGeneratingLinker();
CReapplyConceptDescriptor* getSatisfiableCachedAbsorbedGeneratingLinker();
CIndividualProcessNode* addSatisfiableCachedAbsorbedGeneratingLinker(CReapplyConceptDescriptor* successorGeneratingReapplyConDes);
cint64 getProcessingRestrictionFlags();
bool addProcessingRestrictionFlags(cint64 flags);
bool clearProcessingRestrictionFlags(cint64 flags);
bool hasProcessingRestrictionFlags(cint64 testFlags);
bool hasPartialProcessingRestrictionFlags(cint64 testFlags);
CConceptDescriptor* getIndividualInitializationConcept();
CIndividualProcessNode* setIndividualInitializationConcept(CConceptDescriptor* initConDes);
cint64 getLastConceptCountCachedBlockingCandidate();
CIndividualProcessNode* setLastConceptCountCachedBlockingCandidate(cint64 conCount);
cint64 getLastConceptCountSearchBlockingCandidate();
CIndividualProcessNode* setLastConceptCountSearchBlockingCandidate(cint64 conCount);
cint64 getBlockingCachingSavedCandidateCount();
CIndividualProcessNode* setBlockingCachingSavedCandidateCount(cint64 conCount);
CIndividualProcessNode* incBlockingCachingSavedCandidateCount(cint64 incCount = 1);
bool isInvalidSignatureBlocking();
CIndividualProcessNode* setInvalidSignatureBlocking(bool invalid);
cint64 getLastSearchBlockerCandidateCount();
CIndividualProcessNode* setLastSearchBlockerCandidateCount(cint64 canCount);
cint64 getLastSearchBlockerCandidateSignature();
CIndividualProcessNode* setLastSearchBlockerCandidateSignature(cint64 signature);
CIndividualProcessNode* addSuccessorIndividualNodeBackwardDependencyLinker(CXLinker* linker);
CXLinker* getSuccessorIndividualNodeBackwardDependencyLinker();
CIndividualProcessNode* setSuccessorIndividualNodeBackwardDependencyLinker(CXLinker* linker = nullptr);
CIndividualProcessNode* clearSuccessorIndividualNodeBackwardDependencyLinker();
bool hasSuccessorIndividualNodeBackwardDependencyLinker();
bool hasBackwardDependencyToAncestorIndividualNode();
CIndividualProcessNode* setBackwardDependencyToAncestorIndividualNode(bool backwardDependency);
bool hasBlockingRetestProcessingRestrictionFlags();
bool clearBlockingRetestProcessingRestrictionFlags();
bool hasBlockedProcessingRestrictionFlags();
bool hasDirectBlockedProcessingRestrictionFlags();
bool hasProcessingBlockedProcessingRestrictionFlags();
bool hasPurgedBlockedProcessingRestrictionFlags();
bool hasIndirectBlockedProcessingRestrictionFlags();
bool clearBlockedProcessingRestrictionFlags();
CRoleBackwardPropagationHash* getRoleBackwardPropagationHash(bool create = true);
CIndividualProcessNodeLinker* getIndividualProcessNodeLinker();
CIndividualProcessNode* setIndividualProcessNodeLinker(CIndividualProcessNodeLinker* processNodeLinker);
CConceptProcessLinker* getConceptProcessLinker();
CConceptProcessLinker* takeConceptProcessLinker();
CIndividualProcessNode* setConceptProcessLinker(CConceptProcessLinker* conProcessLinker);
CIndividualProcessNode* addConceptProcessLinker(CConceptProcessLinker* conProcessLinker);
CIndividualProcessNode* clearConceptProcessLinker();
bool getRequiredBackwardPropagation();
CIndividualProcessNode* setRequiredBackwardPropagation(bool requiredBackProp);
bool hasSubstituteIndividualNode();
CIndividualProcessNode* getSubstituteIndividualNode();
CIndividualProcessNode* setSubstituteIndividualNode(CIndividualProcessNode* indiNode);
bool isProcessingQueued();
bool isExtendedQueueProcessing();
bool isImmediatelyProcessingQueued();
bool isDeterministicExpandingProcessingQueued();
bool isRegularDepthProcessingQueued();
bool isBlockedReactivationProcessingQueued();
bool isBackendSynchronRetestProcessingQueued();
bool isIncrementalCompatibilityCheckingQueued();
bool isIncrementalExpansionQueued();
bool isBackendIndirectCompatibilityExpansionQueued();
bool isBackendDirectInfluenceExpansionQueued();
bool isBackendReuseExpansionQueued();
bool isBackendNeighbourExpansionQueued();
CIndividualProcessNode* setProcessingQueued(bool processingQueued);
CIndividualProcessNode* setExtendedQueueProcessing(bool extendedQueueProcessing);
CIndividualProcessNode* setImmediatelyProcessingQueued(bool immProQue);
CIndividualProcessNode* setDeterministicExpandingProcessingQueued(bool detExpPro);
CIndividualProcessNode* setRegularDepthProcessingQueued(bool depthPro);
CIndividualProcessNode* setBlockedReactivationProcessingQueued(bool backendSyncRetest);
CIndividualProcessNode* setBackendSynchronRetestProcessingQueued(bool backendSyncRetest);
CIndividualProcessNode* setBackendIndirectCompatibilityExpansionQueued(bool queued);
CIndividualProcessNode* setBackendDirectInfluenceExpansionQueued(bool queued);
CIndividualProcessNode* setIncrementalCompatibilityCheckingQueued(bool incCompChecking);
CIndividualProcessNode* setIncrementalExpansionQueued(bool incExpQueued);
CIndividualProcessNode* setBackendReuseExpansionQueued(bool queued);
CIndividualProcessNode* setBackendNeighbourExpansionQueued(bool queued);
CIndividualProcessNode* clearProcessingQueued();
bool isDelayedNominalProcessingQueued();
bool hasNominalProcessingDelayingChecked();
CIndividualProcessNode* setDelayedNominalProcessingQueued(bool delayedProcessingQueued);
CIndividualProcessNode* setNominalProcessingDelayingChecked(bool nominalProcessingDelayingChecked);
CIndividualProcessNode* setAssertionInitialisationSignatureValue(cint64 sigValue);
cint64 getAssertionInitialisationSignatureValue();
CIndividualProcessNode* setLastProcessingPriority(const CIndividualProcessNodePriority& priority);
CIndividualProcessNodePriority getLastProcessingPriority();
CIndividualProcessNode* resetLastProcessingPriority();
bool isCachingLossNodeReactivationInstalled();
CIndividualProcessNode* setCachingLossNodeReactivationInstalled(bool reactivationInstalled);
CNominalCachingLossReactivationData* getNominalCachingLossReactivationData(bool create = true);
CSuccessorIndividualATMOSTReactivationData* getSuccessorIndividualATMOSTReactivationData(bool create = true);
CSuccessorConnectedNominalSet* getSuccessorNominalConnectionSet(bool create = true);
bool hasSuccessorConnectionToNominal(cint64 nominalID);
bool addSuccessorConnectionToNominal(cint64 nominalID);
CDatatypesValueSpaceData* getDatatypesValueSpaceData(bool create = true);
CIndividualNodeIncrementalExpansionData* getIncrementalExpansionData(bool create = true);
CIndividualProcessNode* setIncrementalExpansionID(cint64 incExpID);
cint64 getIncrementalExpansionID();
CConceptPropagationBindingSetHash* getConceptPropagationBindingSetHash(bool create = true);
CConceptVariableBindingPathSetHash* getConceptVariableBindingPathSetHash(bool create = true);
CConceptRepresentativePropagationSetHash* getConceptRepresentativePropagationSetHash(bool create = true);
CIndividualMergingHash* getIndividualMergingHash(bool create = true);
CDependencyTrackPoint* getMergedDependencyTrackPoint();
CIndividualProcessNode* setMergedDependencyTrackPoint(CDependencyTrackPoint* depTrackPoint);
CIndividualProcessNode* getLastMergedIntoIndividualNode();
CIndividualProcessNode* setLastMergedIntoIndividualNode(CIndividualProcessNode* indiNode);
CIndividualProcessNode* setBlockerIndividualNode(CIndividualProcessNode* indiNode);
CIndividualProcessNode* getBlockerIndividualNode();
CIndividualProcessNode* setFollowingIndividualNode(CIndividualProcessNode* indiNode);
CIndividualProcessNode* getFollowingIndividualNode();
const static cint64 PRFDIRECTBLOCKED = Q_UINT64_C(0x1);
const static cint64 PRFPROCESSINGBLOCKED = Q_UINT64_C(0x2);
const static cint64 PRFINDIRECTBLOCKED = Q_UINT64_C(0x4);
const static cint64 PRFPURGEDBLOCKED = Q_UINT64_C(0x8);
const static cint64 PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED = Q_UINT64_C(0x10);
const static cint64 PRFINVALIDBLOCKINGORCACHING = Q_UINT64_C(0x20);
const static cint64 PRFBLOCKINGRETESTDUEANCESTORMODIFIED = Q_UINT64_C(0x100);
const static cint64 PRFBLOCKINGRETESTDUEDIRECTMODIFIED = Q_UINT64_C(0x200);
const static cint64 PRFBLOCKINGRETESTDUEBLOCKERMODIFIED = Q_UINT64_C(0x400);
const static cint64 PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS = Q_UINT64_C(0x800);
const static cint64 PRFPROCESSINGCOMPLETED = Q_UINT64_C(0x1000);
const static cint64 PRFANCESTORALLPROCESSED = Q_UINT64_C(0x2000);
const static cint64 PRFCONSNODEPREPARATIONINDINODE = Q_UINT64_C(0x10000);
const static cint64 PRFCONCRETEDATAINDINODE = Q_UINT64_C(0x20000);
const static cint64 PRFSATISFIABLECACHED = Q_UINT64_C(0x100000);
const static cint64 PRFANCESTORSATISFIABLECACHED = Q_UINT64_C(0x200000);
const static cint64 PRFRETESTSATISFIABLECACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x400000);
const static cint64 PRFANCESTORSATISFIABLECACHEDABOLISHED = Q_UINT64_C(0x800000);
const static cint64 PRFSIGNATUREBLOCKINGCACHED = Q_UINT64_C(0x1000000);
const static cint64 PRFANCESTORSIGNATUREBLOCKINGCACHED = Q_UINT64_C(0x2000000);
const static cint64 PRFRETESTSIGNATUREBLOCKINGCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x4000000);
const static cint64 PRFANCESTORSIGNATUREBLOCKINGCACHEDABOLISHED = Q_UINT64_C(0x8000000);
const static cint64 PRFSATURATIONBLOCKINGCACHED = Q_UINT64_C(0x10000000);
const static cint64 PRFANCESTORSATURATIONBLOCKINGCACHED = Q_UINT64_C(0x20000000);
const static cint64 PRFRETESTSATURATIONBLOCKINGCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x40000000);
const static cint64 PRFANCESTORSATURATIONBLOCKINGCACHEDABOLISHED = Q_UINT64_C(0x80000000);
const static cint64 PRFSATURATIONSUCCESSORCREATIONBLOCKINGCACHED = Q_UINT64_C(0x100000000);
const static cint64 PRFSATURATIONBLOCKINGCACHEDINVALIDATED = Q_UINT64_C(0x200000000);
const static cint64 PRFSATURATIONBLOCKINGCACHEDRETESTDUETOMODIFICATION = Q_UINT64_C(0x400000000);
const static cint64 PRFCOMPLETIONGRAPHCACHED = Q_UINT64_C(0x1000000000);
const static cint64 PRFCOMPLETIONGRAPHCACHINGINVALID = Q_UINT64_C(0x2000000000);
const static cint64 PRFCOMPLETIONGRAPHCACHINGINVALIDATED = Q_UINT64_C(0x4000000000);
const static cint64 PRFRETESTCOMPLETIONGRAPHCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x8000000000);
const static cint64 PRFCOMPLETIONGRAPHCACHEDNODELOCATED = Q_UINT64_C(0x10000000000);
const static cint64 PRFCOMPLETIONGRAPHCACHEDNODEEXTENDED = Q_UINT64_C(0x20000000000);
const static cint64 PRFSUCCESSORNOMINALCONNECTION = Q_UINT64_C(0x40000000000);
const static cint64 PRFSUCCESSORNEWNOMINALCONNECTION = Q_UINT64_C(0x80000000000);
const static cint64 PRFREUSINGINDIVIDUAL = Q_UINT64_C(0x100000000000);
const static cint64 PRFANCESTORREUSINGINDIVIDUALBLOCKED = Q_UINT64_C(0x200000000000);
const static cint64 PRFANCESTORREUSINGINDIVIDUALBLOCKEDABOLISHED = Q_UINT64_C(0x400000000000);
const static cint64 PRFCACHEDCOMPUTEDTYPESADDED = Q_UINT64_C(0x1000000000000);
const static cint64 PRFSYNCHRONIZEDBACKEND = Q_UINT64_C(0x10000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENDNEIGHBOUREXPANSIONBLOCKED = Q_UINT64_C(0x20000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENDSUCCESSOREXPANSIONBLOCKED = Q_UINT64_C(0x40000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENDINDIRECTNOMINALEXPANSIONBLOCKED = Q_UINT64_C(0x80000000000000);
const static cint64 PRFRETESTBACKENDSYNCHRONIZATIONDUEDIRECTMODIFIED = Q_UINT64_C(0x100000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION = Q_UINT64_C(0x200000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION = Q_UINT64_C(0x400000000000000);
const static cint64 PRFSYNCHRONIZEDBACKENPROCESSINGDELAYING = Q_UINT64_C(0x800000000000000);
const static cint64 PRFBACKENDEXPANSIONREUSINGINDIVIDUAL = Q_UINT64_C(0x1000000000000000);
const static cint64 PRFBACKENDEXPANSIONREUSEDISCARDED = Q_UINT64_C(0x2000000000000000);
const static cint64 PRFINCREMENTALEXPANDING = Q_UINT64_C(0x4000000000000000);
const static cint64 PRFINCREMENTALEXPANSIONRETESTDUEDIRECTMODIFIED = Q_UINT64_C(0x8000000000000000);
const static cint64 PRFBLOCKINGRELATEDFLAGCOMPINATION = PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED |
PRFBLOCKINGRETESTDUEANCESTORMODIFIED | PRFBLOCKINGRETESTDUEDIRECTMODIFIED | PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED |
PRFBLOCKINGRETESTDUEBLOCKERMODIFIED | PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS;
const static cint64 PRFINVALIDATEBLOCKERFLAGSCOMPINATION = PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED | PRFPURGEDBLOCKED | PRFSATISFIABLECACHED |
PRFANCESTORSATISFIABLECACHED | PRFSIGNATUREBLOCKINGCACHED | PRFANCESTORSIGNATUREBLOCKINGCACHED |
PRFREUSINGINDIVIDUAL | PRFANCESTORREUSINGINDIVIDUALBLOCKED | PRFANCESTORSATURATIONBLOCKINGCACHED | PRFCONCRETEDATAINDINODE;
CConceptDescriptor* mDebugBlockerLastConceptDes;
// protected methods
protected:
// protected variables
protected:
cint64 mIndiID;
CIndividualType mIndiType;
CIndividual* mNomIndi;
cint64 mProcessingRestrictionFlags;
cint64 indiAncDepth;
cint64 mNominalLevel;
CIndividualLinkEdge* mAncestorLink;
cint64 mMergeIntoID;
CProcessContext* mProcessContext;
CMemoryAllocationManager* mMemAllocMan;
CIndividualProcessNode* mPrevIndividual;
CConceptProcessingQueue* mConceptProcessingQueue;
CConceptProcessingQueue* mUseConceptProcessingQueue;
CConceptProcessingQueue* mPrevConceptProcessingQueue;
CReapplyConceptLabelSet* mReapplyConLabelSet;
CReapplyConceptLabelSet* mUseReapplyConLabelSet;
CReapplyConceptLabelSet* mPrevReapplyConLabelSet;
CReapplyRoleSuccessorHash* mReapplyRoleSuccHash;
CReapplyRoleSuccessorHash* mUseReapplyRoleSuccHash;
CReapplyRoleSuccessorHash* mPrevReapplyRoleSuccHash;
CSuccessorRoleHash* mSuccRoleHash;
CSuccessorRoleHash* mUseSuccRoleHash;
CSuccessorRoleHash* mPrevSuccRoleHash;
CIndividualLinkEdge* mLastAddedLink;
CIndividualProcessNode* mBlockerIndiNode;
CIndividualProcessNode* mFollowingIndiNode;
CConnectionSuccessorSet* mConnSuccSet;
CConnectionSuccessorSet* mUseConnSuccSet;
CConnectionSuccessorSet* mPrevConnSuccSet;
CDistinctHash* mDistinctHash;
CDistinctHash* mUseDistinctHash;
CDistinctHash* mPrevDistinctHash;
bool mDisjointRoleConnections;
CDisjointSuccessorRoleHash* mDisjointSuccRoleHash;
CDisjointSuccessorRoleHash* mUseDisjointSuccRoleHash;
CDisjointSuccessorRoleHash* mPrevDisjointSuccRoleHash;
CIndividualNodeSaturationBlockingData* mIndiSatBlockData;
CIndividualNodeSaturationBlockingData* mPrevIndiSatBlockData;
CIndividualNodeBlockData* mIndiBlock;
CIndividualNodeBlockData* mPrevIndiBlock;
CBlockingVariableBindingsAnalogousPropagationData* mIndiVarPropBlockData;
CBlockingVariableBindingsAnalogousPropagationData* mPrevIndiVarPropBlockData;
CIndividualNodeUnsatisfiableCacheRetrievalData* mIndiUnsatCacheRet;
CIndividualNodeUnsatisfiableCacheRetrievalData* mPrevIndiUnsatCacheRet;
CIndividualNodeAnalizedConceptExpansionData* mSigBlockIndExplData;
CIndividualNodeAnalizedConceptExpansionData* mUseSigBlockIndExplData;
CIndividualNodeAnalizedConceptExpansionData* mPrevSigBlockIndExplData;
CSignatureBlockingIndividualNodeConceptExpansionData* mSigBlockConExpData;
CSignatureBlockingIndividualNodeConceptExpansionData* mPrevSigBlockConExpData;
CReusingIndividualNodeConceptExpansionData* mReusingConExpData;
CReusingIndividualNodeConceptExpansionData* mPrevReusingConExpData;
CBlockingFollowSet* mSigBlockFollowSet;
CBlockingFollowSet* mUseSigBlockFollowSet;
CBlockingFollowSet* mPrevSigBlockFollowSet;
CConceptPropagationBindingSetHash* mConceptPropBindingSetHash;
CConceptPropagationBindingSetHash* mUseConceptPropBindingSetHash;
CConceptPropagationBindingSetHash* mPrevConceptPropBindingSetHash;
CConceptVariableBindingPathSetHash* mConceptVarBindPathSetHash;
CConceptVariableBindingPathSetHash* mUseConceptVarBindPathSetHash;
CConceptVariableBindingPathSetHash* mPrevConceptVarBindPathSetHash;
CConceptRepresentativePropagationSetHash* mConceptRepPropSetHash;
CConceptRepresentativePropagationSetHash* mUseConceptRepPropSetHash;
CConceptRepresentativePropagationSetHash* mPrevConceptRepPropSetHash;
bool mInvalidSignatureBlocking;
CConceptDescriptor* mInitConceptDescriptor;
CXSortedNegLinker* mInitializingConceptLinkerIt;
CXSortedNegLinker* mProcessInitializingConceptLinkerIt;
CConceptAssertionLinker* mAssertionConceptLinkerIt;
CDataAssertionLinker* mAssertionDataLinkerIt;
CDataAssertionLinker* mLastProcessedAssertionDataLinker;
CRoleAssertionLinker* mAssertionRoleLinkerIt;
CReverseRoleAssertionLinker* mReverseAssertionRoleLinkerIt;
CAdditionalProcessRoleAssertionsLinker* mAdditionalRoleAssertionsLinker;
CAdditionalProcessDataAssertionsLinker* mAdditionalDataAssertionsLinker;
CAdditionalProcessDataAssertionsLinker* mLastProcessedAdditionalDataAssertionsLinker;
bool mRoleAssertionsInitialized;
bool mReverseRoleAssertionsInitialized;
cint64 mRoleAssertionCreationID;
CProcessAssertedDataLiteralLinker* mAssertedDataLiteralLinker;
CProcessAssertedDataLiteralLinker* mLastAssertedDataLiteralLinker;
bool mBaseConceptsInitialized;
bool mUniversallyConnectionIndividualInitialized;
bool mNominalIndiTriplesAssertions;
bool mLoadedNominalIndiTriplesAssertions;
bool mLoadedNominalIndiRepresentativeBackendData;
cint64 mLastConceptCountCachedBlockerCandidate;
cint64 mLastConceptCountSearchBlockerCandidate;
cint64 mLastSearchBlockerCandidateCount;
cint64 mLastSearchBlockerCandidateSignature;
cint64 mBlockingCachingSavedCandidateCount;
CXLinker* mBlockedIndividualsLinker;
CXLinker* mSuccessorIndiNodeBackwardDependencyLinker;
bool mBackwardDependencyToAncestorIndividualNode;
CIndividualNodeModelData* indiModel;
CIndividualNodeSatisfiableCacheRetrievalData* mSatCacheRetData;
CIndividualNodeSatisfiableCacheRetrievalData* mPrevSatCacheRetData;
CIndividualNodeSatisfiableCacheStoringData* mSatCacheStoringData;
CIndividualNodeSatisfiableCacheStoringData* mPrevSatCacheStoringData;
CIndividualNodeBackendCacheSynchronisationData* mBackendSyncData;
CIndividualNodeBackendCacheSynchronisationData* mPrevBackendSyncData;
CIndividualProcessNode* mProcessingBlockedIndi;
CXLinker* mProcessingBlockedIndividualsLinker;
CReapplyConceptDescriptor* mSatCachedAbsorbedDisjunctionsReapplyConDes;
CReapplyConceptDescriptor* mSatCachedAbsorbedSuccessorReapplyConDes;
CRoleBackwardPropagationHash* mRoleBackPropHash;
CIndividualProcessNodeLinker* mIndiProcessLinker;
CConceptProcessLinker* mConceptProcessLinker;
bool mRequiredBackProp;
CIndividualProcessNode* mSubstituteIndiNode;
bool mExtendedQueueProcessing;
bool mImmediatelyProcessingQueued;
bool mDetExpProcessingQueued;
bool mDepthProcessingQueued;
bool mBlockedReactProcessingQueued;
bool mBackendSynchronRetestProcessingQueued;
bool mBackendIndirectCompatibilityExpansionQueued;
bool mBackendDirectInfluenceExpansionQueued;
bool mIncrementalCompatibilityCheckingQueued;
bool mIncrementalExpansionQueued;
bool mProcessingQueued;
bool mBackendReuseExpansionQueued;
bool mBackendNeighbourExpansionQueued;
CIndividualProcessNodePriority mLastProcessingPriority;
bool mDelayedNominalProcessingQueued;
bool mNominalProcessingDelayingChecked;
cint64 mAssertionInitialisationSignatureValue;
bool mCachingLossNodeReactivationInstalled;
CNominalCachingLossReactivationData* mUseReactivationData;
CNominalCachingLossReactivationData* mLocReactivationData;
CSuccessorIndividualATMOSTReactivationData* mUseSuccIndiATMOSTReactivationData;
CSuccessorIndividualATMOSTReactivationData* mLocSuccIndiATMOSTReactivationData;
CSuccessorConnectedNominalSet* mUseNominalConnectionSet;
CSuccessorConnectedNominalSet* mLocNominalConnectionSet;
CDatatypesValueSpaceData* mUseDatatypesValueSpaceData;
CDatatypesValueSpaceData* mLocDatatypesValueSpaceData;
CIndividualNodeIncrementalExpansionData* mUseIncExpData;
CIndividualNodeIncrementalExpansionData* mLocIncExpData;
cint64 mIncExpID;
CIndividualMergingHash* mUseIndividualMergingHash;
CIndividualMergingHash* mLocIndividualMergingHash;
CDependencyTrackPoint* mMergedDepTrackPoint;
CIndividualProcessNode* mLastMergedIntoIndividualNode;
// private methods
private:
// private variables
private:
};
}; // end namespace Process
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALPROCESSNODE_H