/*
* 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 "CCommand.h"
#include "Records/CClosureProcessCommandRecord.h"
namespace Konclude {
namespace Control {
namespace Command {
using namespace Records;
CCommand::CCommand(CCommand *parentSuperCommand) {
subCommandLinker = 0;
superCommand = parentSuperCommand;
processed = false;
processing = false;
recordData = 0;
recorder = 0;
closured = false;
errorLevel = 0;
mUnclosedCommandCount = 1;
if (parentSuperCommand) {
parentSuperCommand->makeToSubCommand(this);
}
reportErrorFromSubCommands = true;
}
CCommand::~CCommand() {
deleteDependencies();
}
bool CCommand::hasReportErrorFromSubCommands() {
return reportErrorFromSubCommands;
}
CCommand *CCommand::setReportErrorFromSubCommands(bool reportSubCommandErrors) {
reportErrorFromSubCommands = reportSubCommandErrors;
return this;
}
double CCommand::getMaxErrorLevel() {
return errorLevel;
}
CCommand *CCommand::reportError(double errorLevelReport) {
if (errorLevelReport > errorLevel) {
errorSyncMutex.lock();
errorLevel = qMax(errorLevel,errorLevelReport);
errorSyncMutex.unlock();
if (superCommand && superCommand->hasReportErrorFromSubCommands()) {
superCommand->reportError(errorLevelReport);
}
}
return this;
}
CLinker *CCommand::getSubCommandLinker() {
return subCommandLinker;
}
CCommand *CCommand::addSubCommand(CCommand *subCommand) {
subCommandLinker = new CLinker(subCommand,subCommandLinker);
return this;
}
CCommand *CCommand::makeToSubCommand(CCommand *subCommand) {
++mUnclosedCommandCount;
addSubCommand(subCommand);
subCommand->setSuperCommand(this);
subCommand->setRecorder(recorder);
return this;
}
CCommand *CCommand::getSuperCommand() {
return superCommand;
}
CCommand *CCommand::setSuperCommand(CCommand *parentSuperCommand) {
superCommand = parentSuperCommand;
return this;
}
CCommand *CCommand::setProcessed(bool processedCommand) {
if (processed) {
closureSyncMutex.lock();
mUnclosedCommandCount++;
processed = processedCommand;
closureSyncMutex.unlock();
} else {
processed = processedCommand;
reduceUnclosedCheckCallback();
}
return this;
}
bool CCommand::areAllSubCommandsProcessed() {
bool allSubCommPro = true;
CLinker *subCommIt = subCommandLinker;
while (subCommIt) {
CCommand *subCommand = subCommIt->getData();
if (!subCommand->isProcessed()) {
allSubCommPro = false;
break;
}
subCommIt = (CLinker *)subCommIt->getNext();
}
return allSubCommPro;
}
bool CCommand::isProcessed() {
return mUnclosedCommandCount <= 0;
}
bool CCommand::isThisCommandProcessed() {
return processed;
}
CCommand *CCommand::getNextProcessableSubCommand() {
CLinker *subCommandIt = subCommandLinker;
while (subCommandIt) {
CCommand *subCommand = subCommandIt->getData();
if (subCommand && subCommand->isProcessable() && !subCommand->isProcessing()) {
return subCommand;
}
}
return 0;
}
QString CCommand::getBriefCommandDescription() {
return QString("Undefined Command");
}
CCommand *CCommand::setProcessing(bool processingCommand) {
processing = processingCommand;
return this;
}
bool CCommand::isProcessing() {
return processing;
}
CCommandRecordData *CCommand::getRecordData() {
return recordData;
}
CCommand *CCommand::setRecordData(CCommandRecordData *takeRecordData) {
if (recordData) {
delete recordData;
}
recordData = takeRecordData;
return this;
}
CCommand *CCommand::overwriteRecordData(CCommandRecordData *takeRecordData) {
recordData = takeRecordData;
return this;
}
CCommand *CCommand::appendRecordData(CCommandRecordData *takeRecordData) {
takeRecordData->setNextRecordData(recordData);
recordData = takeRecordData;
return this;
}
CCommandRecorder *CCommand::getRecorder() {
return recorder;
}
CCommand *CCommand::setRecorder(CCommandRecorder *useCommandRecorder) {
recorder = useCommandRecorder;
return this;
}
CCommand *CCommand::deleteDependencies() {
deleteSubCommands();
deleteRecordData();
return this;
}
CCommand *CCommand::deleteSubCommands() {
CLinker *subCommandIt = subCommandLinker;
while (subCommandIt) {
CCommand *subCommand = subCommandIt->getData();
subCommand->deleteDependencies();
delete subCommand;
CLinker *tmpSubCommIt = subCommandIt;
subCommandIt = (CLinker *)subCommandIt->getNext();
delete tmpSubCommIt;
}
return this;
}
CCommand *CCommand::deleteRecordData() {
CCommandRecordData *recordIt = recordData;
while (recordIt) {
CCommandRecordData *tmpRecordData = recordIt;
recordIt = recordIt->getNextCommandRecordData();
delete tmpRecordData;
}
return this;
}
CCommand *CCommand::addProcessedCallback(CCallbackData *callback) {
if (isProcessed()) {
callback->doCallback();
} else {
processedCallbackExecuter.addCallbackData(callback);
}
return this;
}
CCommand* CCommand::closedSubCommand() {
reduceUnclosedCheckCallback();
return this;
}
CCommand *CCommand::reduceUnclosedCheckCallback() {
closureSyncMutex.lock();
mUnclosedCommandCount--;
bool closeCommand = false;
if (mUnclosedCommandCount == 0) {
closeCommand = true;
}
closureSyncMutex.unlock();
if (!closured && closeCommand) {
CClosureProcessCommandRecord::makeRecord(recorder,"::Konclude::Command::Command",this);
closured = true;
CCommand* tmpSuperCommand = superCommand;
processedCallbackExecuter.doCallback();
if (tmpSuperCommand) {
tmpSuperCommand->closedSubCommand();
}
}
return this;
}
}; // end namespace Command
}; // end namespace Control
}; // end namespace Konclude