/*
* 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_DEPENDENCY_CDEPENDENCYNODE_H
#define KONCLUDE_REASONER_KERNEL_PROCESS_DEPENDENCY_CDEPENDENCYNODE_H
// Libraries includes
// Namespace includes
#include "DependencySettings.h"
#include "CDependency.h"
#include "CDependencyTrackPoint.h"
#include "CDependencyIterator.h"
// Other includes
#include "Reasoner/Kernel/Process/Marker/CMarker.h"
#include "Reasoner/Kernel/Process/CProcessingTag.h"
#include "Reasoner/Kernel/Process/CConceptDescriptor.h"
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
namespace Reasoner {
using namespace Ontology;
namespace Kernel {
namespace Process {
using namespace Marker;
namespace Dependency {
/*!
*
* \class CDependencyNode
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CDependencyNode : public CProcessingTag {
// public methods
public:
//! Constructor
CDependencyNode(CProcessContext* processContext = nullptr);
enum DEPENDENCNODEYTYPE { DNTUNDEFINED, DNTINDEPENDENTBASE, DNTANDDEPENDENCY, DNTAUTOMATCHOOSEDEPENDENCY, DNTORDEPENDENCY,
DNTALLDEPENDENCY, DNTAUTOMATTRANSACTIONDEPENDENCY, DNTSOMEDEPENDENCY, DNTSELFDEPENDENCY, DNTVALUEDEPENDENCY,
DNTNEGVALUEDEPENDENCY, DNTDISTINCTDEPENDENCY, DNTATLEASTDEPENDENCY, DNTMERGEDCONCEPT, DNTMERGEDLINK, DNTMERGEDINDIVIDUAL,
DNTMERGEDEPENDENCY, DNTATMOSTDEPENDENCY, DNTQUALIFYDEPENDENCY, DNTFUNCTIONALDEPENDENCY, DNTNOMINALDEPENDENCY,
DNTIMPLICATIONDEPENDENCY, DNTEXPANDEDDEPENDENCY, DNTCONNECTIONDEPENDENCY, DNTREUSEINDIVIDUALDEPENDENCY,
DNTREUSECONCEPTSDEPENDENCY, DNTREUSECOMPLETIONGRAPHDEPENDENCY, DNTDATATYPETRIGGERDEPENDENCY, DNTDATATYPECONNECTIONDEPENDENCY,
DNTROLEASSERTIONDEPENDENCY, DNTDATAASSERTIONDEPENDENCY, DNTMERGEPOSSIBLEINSTANCEINDIVIDUALDEPENDENCY, DNTSAMEINDIVIDUALSMERGEDEPENDENCY,
DNTORONLYOPTIONDEPENDENCY,
DNTBINDVARIABLEDEPENDENCY, DNTPROPAGATEBINDINGDEPENDENCY, DNTBINDPROPAGATEAND, DNTBINDPROPAGATEIMPLICATION,
DNTPROPAGATEBINDINGSUCCESSORDEPENDENCY, DNTBINDPROPAGATEALL, DNTBINDPROPAGATECYCLE, DNTPROPAGATECONNECTIONDEPENDENCY,
DNTPROPAGATECONNECTIONAWAYDEPENDENCY, DNTBINDPROPAGATEGROUNDINGDEPENDENCY,
DNTVARBINDPROPAGATEAND, DNTPROPAGATEVARIABLEBINDINGDEPENDENCY, DNTVARBINDPROPAGATEALL, DNTPROPAGATEVARIABLEBINDINGSUCCESSORDEPENDENCY,
DNTVARBINDVARIABLEDEPENDENCY, DNTVARBINDPROPAGATEJOIN, DNTVARBINDPROPAGATEGROUNDINGDEPENDENCY, DNTPROPAGATEVARIABLECONNECTIONDEPENDENCY,
DNTVARBINDPROPAGATEIMPLICATION,
DNTRESOLVEREPRESENTATIVE, DNTREPRESENTATIVEAND, DNTREPRESENTATIVEALL, DNTREPRESENTATIVEIMPLICATION, DNTREPRESENTATIVEBINDVARIABLE,
DNTREPRESENTATIVEJOIN, DNTREPRESENTATIVEGROUNDING,
DNTREUSEBACKENDEXPANSIONMODESDEPENDENCY, DNTREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDEPENDENCY, DNTREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDEPENDENCY,
DNTREUSEBACKENDVALUEDEPENDENCY
};
CDependencyNode* initDependencyNode(DEPENDENCNODEYTYPE depType, CConceptDescriptor* conceptDescriptor = nullptr);
CDependencyNode* initDependencyNode(DEPENDENCNODEYTYPE depType, CIndividualProcessNode* individualNode, CConceptDescriptor* conceptDescriptor = nullptr);
CConceptDescriptor* getConceptDescriptor();
CDependencyNode* setConceptDescriptor(CConceptDescriptor* conceptDescriptor);
CDependencyTrackPoint* getPreviousDependencyTrackPoint();
virtual CDependencyTrackPoint* getContinueDependencyTrackPoint() = 0;
virtual bool isDeterministiDependencyNode() = 0;
bool isNonDeterministiDependencyNode();
//CMarker* getMarker();
//CDependencyNode* setMarker(CMarker* depMarker);
//CDependencyNode* addMarker(CMarker* depMarker);
CDependencyIterator getAdditionalDependencyIterator(bool aheadDependencies = true, bool afterDependencies = true);
//CDependency* getAdditionalAheadDependencies();
CDependency* getAdditionalAfterDependencies();
cint64 getAdditionalDependencyCount();
bool hasAdditionalDependencies();
//bool hasAdditionalAheadDependencies();
bool hasAdditionalAfterDependencies();
bool hasDependencies();
cint64 getDependencyCount();
cint64 getDependedBranchingTag();
cint64 getDependedBranchingLevel();
DEPENDENCNODEYTYPE getDependencyType();
bool isDependencyType(DEPENDENCNODEYTYPE depType);
bool isIndependentBaseDependencyType();
bool isUndefinedDependencyType();
CIndividualProcessNode* getAppropriateIndividualNode();
bool hasAppropriateIndividualNode();
CDependencyNode* setAppropriateIndividualNode(CIndividualProcessNode* indiNode);
virtual bool isRepresentativeResolveDependencyNode();
virtual bool isRepresentativeSelectDependencyNode();
// protected methods
protected:
//CDependencyNode* addAheadDependency(CDependency* conceptDependency);
CDependencyNode* addAfterDependency(CDependency* linkDependency);
bool updateDependencyTrackPointBranchingTag(CDependencyTrackPoint* depTrackPoint, cint64 branchinLevelTag);
// protected variables
protected:
CProcessContext* mProcessContext;
CConceptDescriptor* mConceptDescriptor;
CIndividualProcessNode* mIndividualNode;
DEPENDENCNODEYTYPE mDepNodeType;
//CMarker* mMarker;
CDependencyTrackPoint* mDepTrackPoint;
//CDependency* mAdditionalAheadDepLinker;
CDependency* mAdditionalAfterDepLinker;
// private methods
private:
// private variables
private:
};
}; // end namespace Dependency
}; // end namespace Process
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_KERNEL_PROCESS_DEPENDENCY_CDEPENDENCYNODE_H