/* * 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 . * */ #include "CConcept.h" namespace Konclude { namespace Reasoner { namespace Ontology { CConcept::CConcept() { initConcept(); } CConcept* CConcept::initConcept() { mTag = 0; mOperatorCode = CConceptOperator::getConceptOperator(CCNONE); operandCount = 0; operands = 0; opParameter = 0; operatorRole = 0; tax = 0; mNameLinker = 0; mNominalIndiviual = nullptr; mConceptData = nullptr; mVariableLinker = nullptr; mMappingNegated = false; mDataLiteral = nullptr; mDatatype = nullptr; return this; } CConcept *CConcept::init(CConcept *concept) { mNameLinker = concept->getClassNameLinker(); mTag = concept->mTag; mOperatorCode = concept->mOperatorCode; operandCount = concept->operandCount; operands = 0; opParameter = concept->opParameter; operatorRole = concept->operatorRole; tax = 0; mNominalIndiviual = concept->mNominalIndiviual; mVariableLinker = concept->mVariableLinker; mMappingNegated = concept->mMappingNegated; mConceptData = nullptr; mDataLiteral = concept->mDataLiteral; mDatatype = concept->mDatatype; return this; } CConcept *CConcept::init(qint64 conTag) { initTag(conTag); mTag = conTag; mOperatorCode = CConceptOperator::getConceptOperator(CCNONE); operandCount = 0; operands = 0; opParameter = 0; operatorRole = 0; tax = 0; mNominalIndiviual = nullptr; mConceptData = nullptr; mVariableLinker = nullptr; mMappingNegated = false; mDataLiteral = nullptr; mDatatype = nullptr; return this; } CConcept *CConcept::initConceptCopy(CConcept *concept, CMemoryAllocationManager* memMan) { mNameLinker = concept->getClassNameLinker(); mTag = concept->mTag; mOperatorCode = concept->mOperatorCode; operandCount = concept->operandCount; opParameter = concept->opParameter; operatorRole = concept->operatorRole; tax = 0; operands = 0; mNominalIndiviual = concept->mNominalIndiviual; mMappingNegated = concept->mMappingNegated; mDataLiteral = concept->mDataLiteral; mDatatype = concept->mDatatype; mVariableLinker = nullptr; mConceptData = nullptr; CSortedNegLinker *opIt = concept->operands; while (memMan && opIt) { CConcept *con = opIt->getData(); bool negated = opIt->isNegated(); CSortedNegLinker *opLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); opLinker->init(con,negated); addOperandLinker(opLinker); opIt = (CSortedNegLinker *)opIt->getNext(); } CSortedLinker* varIt = concept->mVariableLinker; while (memMan && varIt) { CVariable* var = varIt->getData(); CSortedLinker* varLinker = CObjectAllocator< CSortedLinker >::allocateAndConstruct(memMan); varLinker->init(var); addVariableLinker(varLinker); varIt = (CSortedLinker *)varIt->getNext(); } return this; } CVariable* CConcept::getVariable() { if (mVariableLinker) { return mVariableLinker->getData(); } return nullptr; } CSortedLinker* CConcept::getVariableLinker() { return mVariableLinker; } CConcept* CConcept::setVariableLinker(CSortedLinker* variableLinker) { mVariableLinker = variableLinker; return this; } CConcept* CConcept::addVariableLinker(CSortedLinker* variableLinker) { mVariableLinker = variableLinker->insertSortedNextSorted(mVariableLinker); return this; } CConcept *CConcept::setConceptTag(qint64 conTag) { mTag = conTag; return this; } qint64 CConcept::getConceptTag() const { return mTag; } CConcept *CConcept::setOperatorCode(qint64 opCode) { mOperatorCode = CConceptOperator::getConceptOperator(opCode); return this; } qint64 CConcept::getOperatorCode() { return mOperatorCode->getOperatorCode(); } CConceptOperator* CConcept::getConceptOperator() { return mOperatorCode; } CConcept *CConcept::setOperatorTag(qint64 opTag) { mOperatorCode = CConceptOperator::getConceptOperator(opTag); return this; } qint64 CConcept::getDefinitionOperatorTag() { return getOperatorCode(); } qint64 CConcept::getProcessingOperatorTag() { qint64 tag = getOperatorCode(); if (tag == CCEQ || tag == CCSUB) { tag = CCAND; } return tag; } CConcept *CConcept::setTerminology(CTerminology *terminology) { tax = terminology; return this; } CTerminology *CConcept::getTerminology() { return tax; } qint64 CConcept::getTerminologyTag() const { qint64 taxTag = 0; if (tax) { taxTag = tax->getTerminologyID(); } return taxTag; } QPair CConcept::getTerminologyConceptTagPair() { return QPair(getTerminologyTag(),mTag); } CConcept *CConcept::setParameter(qint64 parameter) { opParameter = parameter; return this; } qint64 CConcept::getParameter() { return opParameter; } CConcept *CConcept::setOperandCount(qint64 count) { operandCount = count; return this; } CConcept* CConcept::incOperandCount(cint64 incCount) { operandCount += incCount; return this; } qint64 CConcept::getOperandCount() { return operandCount; } CConcept *CConcept::setOperandList(CSortedNegLinker *operandList) { operands = operandList; return this; } CConcept *CConcept::addOperandLinker(CSortedNegLinker *operandLinker) { if (operands) { operands = operands->insertSortedNextSorted(operandLinker); } else { operands = operandLinker; } return this; } CSortedNegLinker *CConcept::getOperandList() { return operands; } bool CConcept::operator<=(const CConcept &concept) { if (mTag < concept.mTag) { return true; } else if (mTag > concept.mTag) { return false; } else { return getTerminologyTag() <= concept.getTerminologyTag(); } } bool CConcept::operator==(const CConcept &concept) { return mTag == concept.mTag && tax == concept.tax; } CConcept *CConcept::setRole(CRole *role) { operatorRole = role; return this; } CRole *CConcept::getRole() { return operatorRole; } CIndividual* CConcept::getNominalIndividual() { return mNominalIndiviual; } bool CConcept::hasNominalIndividual() { return mNominalIndiviual != nullptr; } CConcept* CConcept::setNominalIndividual(CIndividual* nominalIndividual) { mNominalIndiviual = nominalIndividual; return this; } bool CConcept::isGeneratingOperator(bool negated) { cint64 operatorTag = mOperatorCode->getOperatorCode(); if (!negated) { return (operatorTag == CCSOME || operatorTag == CCATLEAST); } else { return (operatorTag == CCALL || operatorTag == CCATMOST); } } bool CConcept::isNegatedGeneratingOperator() { return isGeneratingOperator(true); } bool CConcept::isNonGeneratingOperator() { return !isGeneratingOperator(); } bool CConcept::hasClassName() { return hasName(); } CConcept *CConcept::setClassNameLinker(CLinker *conceptNameLinker) { setNameLinker(conceptNameLinker); return this; } CConcept *CConcept::addClassNameLinker(CLinker *conceptNameLinker) { addNameLinker(conceptNameLinker); return this; } CLinker *CConcept::getClassNameLinker() { return getNameLinker(); } bool CConcept::isEqualsToBOTTOM(bool negated) { cint64 operatorTag = mOperatorCode->getOperatorCode(); return (!negated && operatorTag == CCBOTTOM || negated && operatorTag == CCTOP); } bool CConcept::isEqualsToTOP(bool negated) { cint64 operatorTag = mOperatorCode->getOperatorCode(); return (negated && operatorTag == CCBOTTOM || !negated && operatorTag == CCTOP); } bool CConcept::hasOperandConceptTag(CConcept *concept) { return hasOperandConceptTag(concept->getConceptTag()); } bool CConcept::hasOperandConceptTag(qint64 conTag) { CSortedNegLinker *opIt = operands; while (opIt) { qint64 opConTag = opIt->getData()->getConceptTag(); if (opConTag == conTag) { return true; } else if (opConTag > conTag) { return false; } opIt = (CSortedNegLinker *)opIt->getNext(); } return false; } bool CConcept::hasOperandConceptTag(CConcept *concept, bool negation) { return hasOperandConceptTag(concept->getConceptTag(),negation); } bool CConcept::hasOperandConceptTag(qint64 conTag, bool negation) { CSortedNegLinker *opIt = operands; while (opIt) { qint64 opConTag = opIt->getData()->getConceptTag(); bool opNeg = opIt->isNegated(); if (opConTag == conTag && negation == opNeg) { return true; } else if (opConTag > conTag) { return false; } opIt = (CSortedNegLinker *)opIt->getNext(); } return false; } bool CConcept::hasOperandConcept(CConcept *concept) { CSortedNegLinker *opIt = operands; while (opIt) { CConcept* opConcept = opIt->getData(); if (opConcept == concept) { return true; } opIt = (CSortedNegLinker *)opIt->getNext(); } return false; } bool CConcept::hasOperandConcept(CConcept *concept, bool negation) { CSortedNegLinker *opIt = operands; while (opIt) { CConcept* opConcept = opIt->getData(); bool opNeg = opIt->isNegated(); if (opConcept == concept && negation == opNeg) { return true; } opIt = (CSortedNegLinker *)opIt->getNext(); } return false; } CConceptData* CConcept::getConceptData() { return mConceptData; } CConcept* CConcept::setConceptData(CConceptData* conceptData) { mConceptData = conceptData; return this; } bool CConcept::hasConceptData() { return mConceptData != nullptr; } bool CConcept::hasMappingNegation() { return mMappingNegated; } CConcept* CConcept::setMappingNegation(bool negation) { mMappingNegated = negation; return this; } CDataLiteral* CConcept::getDataLiteral() { return mDataLiteral; } CConcept* CConcept::setDataLiteral(CDataLiteral* dataLiteral) { mDataLiteral = dataLiteral; return this; } CDatatype* CConcept::getDatatype() { return mDatatype; } CConcept* CConcept::setDatatype(CDatatype* datatype) { mDatatype = datatype; return this; } }; // end namespace Ontology }; // end namespace Reasoner }; // end namespace Konclude