/*
* 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_UTILITIES_CSortedNegLinker_H
#define KONCLUDE_UTILITIES_CSortedNegLinker_H
// Libraries includes
// Namespace includes
#include
#include "CAllocationObject.h"
// Other includes
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
namespace Utilities {
template class CSortedNegLinker;
/*!
*
* \class CSortedNegLinker
* \author Andreas Steigmiller
* \version 0.1
* \brief Spezialised Pointer Version to avoid comparison between addresses
*
*/
template
class CSortedNegLinker : public CAllocationObject {
// public methods
public:
//! Constructor
CSortedNegLinker();
CSortedNegLinker(T* dataElement, bool isNegated = false, CSortedNegLinker *nextLink = 0);
//! Destructor
virtual ~CSortedNegLinker();
CSortedNegLinker *init(T* dataElement, bool isNegated = false, CSortedNegLinker *nextLink = 0);
bool hasNext();
CSortedNegLinker *insertSortedNextSorted(CSortedNegLinker *nextLink);
CSortedNegLinker *insertNextSorted(CSortedNegLinker *nextLink);
CSortedNegLinker *insertNext(CSortedNegLinker *nextLink);
CSortedNegLinker *getNext();
CSortedNegLinker *setNext(CSortedNegLinker *nextLink);
T* getData();
CSortedNegLinker *setData(T* dataElement);
bool isNegated();
CSortedNegLinker *setNegated(bool isNegated);
CSortedNegLinker *append(CSortedNegLinker *appendingList);
CSortedNegLinker *removeNext();
CSortedNegLinker *getLastListLink();
qint64 getCount();
bool resortLinkerData();
// protected methods
protected:
// private methods
private:
// private variables
private:
CSortedNegLinker *next;
T* data;
bool negated;
};
template
CSortedNegLinker::CSortedNegLinker() {
next = 0;
negated = false;
}
template
CSortedNegLinker::CSortedNegLinker(T* dataElement, bool isNegated, CSortedNegLinker *nextLink) {
next = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
}
template
CSortedNegLinker *CSortedNegLinker::init(T* dataElement, bool isNegated, CSortedNegLinker *nextLink) {
next = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
return this;
}
template
CSortedNegLinker::~CSortedNegLinker() {
}
template
bool CSortedNegLinker::resortLinkerData() {
bool hasResorted = false;
if (next) {
bool nextHasResorted = true;
while (nextHasResorted) {
nextHasResorted = next->resortLinkerData();
}
if (next->getData() > data) {
T *tmpData = data;
bool tmpNeg = negated;
data = next->getData();
negated = next->isNegated();
next->setData(tmpData);
next->setNegated(tmpNeg);
hasResorted = true;
}
}
return hasResorted;
}
template
bool CSortedNegLinker::hasNext() {
return next != 0;
}
template
CSortedNegLinker *CSortedNegLinker::insertNext(CSortedNegLinker *nextLink) {
if (nextLink) {
CSortedNegLinker *tmpNext = next;
next = nextLink;
if (tmpNext) {
nextLink->append(tmpNext);
}
}
return this;
}
template
CSortedNegLinker *CSortedNegLinker::insertNextSorted(CSortedNegLinker *nextLink) {
CSortedNegLinker *firstLinker = this;
while (nextLink) {
CSortedNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
} else {
nextLink = 0;
}
nIns->setNext(0);
CSortedNegLinker *list = firstLinker;
CSortedNegLinker *lastList = 0;
bool inserted = false;
T* dataIns = nIns->getData();
while (list) {
T* dataList = list->getData();
if (*dataIns <= *dataList) {
if (lastList == 0){
firstLinker = nIns->insertNext(firstLinker);
} else {
lastList->insertNext(nIns);
}
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
}
}
return firstLinker;
}
template
CSortedNegLinker *CSortedNegLinker::insertSortedNextSorted(CSortedNegLinker *nextLink) {
// items from nextLink are already sorted!
CSortedNegLinker *firstLinker = this;
CSortedNegLinker *list = firstLinker;
CSortedNegLinker *lastList = 0;
while (nextLink) {
CSortedNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
} else {
nextLink = 0;
}
nIns->setNext(0);
bool inserted = false;
T* dataIns = nIns->getData();
while (list) {
T* dataList = list->getData();
if (*dataIns <= *dataList) {
if (lastList == 0){
firstLinker = nIns->insertNext(firstLinker);
list = firstLinker->next;
lastList = firstLinker;
} else {
lastList->insertNext(nIns);
lastList = lastList->next;
// list is already on the correct position
}
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
lastList = nIns;
}
}
return firstLinker;
}
template
CSortedNegLinker *CSortedNegLinker::setNext(CSortedNegLinker *nextLink) {
next = nextLink;
return this;
}
template
CSortedNegLinker *CSortedNegLinker::getNext() {
return next;
}
template
T* CSortedNegLinker::getData() {
return data;
}
template
CSortedNegLinker *CSortedNegLinker::setData(T* dataElement) {
data = dataElement;
return this;
}
template
bool CSortedNegLinker::isNegated() {
return negated;
}
template
CSortedNegLinker *CSortedNegLinker::setNegated(bool isNegated) {
negated = isNegated;
return this;
}
template
CSortedNegLinker *CSortedNegLinker::append(CSortedNegLinker *appendingList) {
CSortedNegLinker *last = getLastListLink();
last->insertNext(appendingList);
return this;
}
template
CSortedNegLinker *CSortedNegLinker::removeNext() {
CSortedNegLinker *tmpNext = next;
if (next) {
CSortedNegLinker *tmpNextNext = next->next;
next->next = 0;
setNext(tmpNextNext);
}
return tmpNext;
}
template
CSortedNegLinker *CSortedNegLinker::getLastListLink() {
CSortedNegLinker *lastListLink = this;
while (lastListLink->hasNext()) {
lastListLink = lastListLink->getNext();
}
return lastListLink;
}
template
qint64 CSortedNegLinker::getCount() {
qint64 count = 0;
CSortedNegLinker *linkIt = this;
while (linkIt) {
++count;
linkIt = linkIt->getNext();
}
return count;
}
/*!
*
* \class CSortedNegLinker
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
template
class CSortedNegLinker : public CAllocationObject {
// public methods
public:
//! Constructor
CSortedNegLinker();
CSortedNegLinker(T dataElement, bool isNegated = false, CSortedNegLinker *nextLink = 0);
//! Destructor
virtual ~CSortedNegLinker();
CSortedNegLinker *init(T dataElement, bool isNegated = false, CSortedNegLinker *nextLink = 0);
bool hasNext();
CSortedNegLinker *insertSortedNextSorted(CSortedNegLinker *nextLink);
CSortedNegLinker *insertNextSorted(CSortedNegLinker *nextLink);
CSortedNegLinker *insertNext(CSortedNegLinker *nextLink);
CSortedNegLinker *getNext();
CSortedNegLinker *setNext(CSortedNegLinker *nextLink);
T getData();
CSortedNegLinker *setData(T dataElement);
bool isNegated();
CSortedNegLinker *setNegated(bool isNegated);
CSortedNegLinker *append(CSortedNegLinker *appendingList);
CSortedNegLinker *removeNext();
CSortedNegLinker *getLastListLink();
qint64 getCount();
bool resortLinkerData();
// protected methods
protected:
// protected variables
protected:
CSortedNegLinker *next;
T data;
bool negated;
// private methods
private:
// private variables
private:
};
template
CSortedNegLinker::CSortedNegLinker() {
next = 0;
negated = false;
}
template
CSortedNegLinker::CSortedNegLinker(T dataElement, bool isNegated, CSortedNegLinker *nextLink) {
next = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
}
template
CSortedNegLinker *CSortedNegLinker::init(T dataElement, bool isNegated, CSortedNegLinker *nextLink) {
next = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
return this;
}
template
CSortedNegLinker::~CSortedNegLinker() {
}
template
bool CSortedNegLinker::resortLinkerData() {
bool hasResorted = false;
if (next) {
bool nextHasResorted = true;
while (nextHasResorted) {
nextHasResorted = next->resortLinkerData();
}
if (next->getData() > data) {
T tmpData = data;
bool tmpNeg = negated;
data = next->getData();
negated = next->isNegated();
next->setData(tmpData);
next->setNegated(tmpNeg);
hasResorted = true;
}
}
return hasResorted;
}
template
bool CSortedNegLinker::hasNext() {
return next != 0;
}
template
CSortedNegLinker *CSortedNegLinker::insertNext(CSortedNegLinker *nextLink) {
if (nextLink) {
CSortedNegLinker *tmpNext = next;
next = nextLink;
if (tmpNext) {
nextLink->append(tmpNext);
}
}
return this;
}
template
CSortedNegLinker *CSortedNegLinker::insertNextSorted(CSortedNegLinker *nextLink) {
CSortedNegLinker *firstLinker = this;
while (nextLink) {
CSortedNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
} else {
nextLink = 0;
}
nIns->setNext(0);
CSortedNegLinker *list = firstLinker;
CSortedNegLinker *lastList = 0;
bool inserted = false;
T dataIns = nIns->getData();
while (list) {
T dataList = list->getData();
if (dataIns <= dataList) {
if (lastList == 0){
firstLinker = nIns->insertNext(firstLinker);
} else {
lastList->insertNext(nIns);
}
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
}
}
return firstLinker;
}
template
CSortedNegLinker *CSortedNegLinker::insertSortedNextSorted(CSortedNegLinker *nextLink) {
// items from nextLink are already sorted!
CSortedNegLinker *firstLinker = this;
CSortedNegLinker *list = firstLinker;
CSortedNegLinker *lastList = 0;
while (nextLink) {
CSortedNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
} else {
nextLink = 0;
}
nIns->setNext(0);
bool inserted = false;
T dataIns = nIns->getData();
while (list) {
T dataList = list->getData();
if (dataIns <= dataList) {
if (lastList == 0){
firstLinker = nIns->insertNext(firstLinker);
list = firstLinker->next;
lastList = firstLinker;
} else {
lastList->insertNext(nIns);
lastList = lastList->next;
// list is already on the correct position
}
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
lastList = nIns;
}
}
return firstLinker;
}
template
CSortedNegLinker *CSortedNegLinker::setNext(CSortedNegLinker *nextLink) {
next = nextLink;
return this;
}
template
CSortedNegLinker *CSortedNegLinker::getNext() {
return next;
}
template
T CSortedNegLinker::getData() {
return data;
}
template
CSortedNegLinker *CSortedNegLinker::setData(T dataElement) {
data = dataElement;
return this;
}
template
bool CSortedNegLinker::isNegated() {
return negated;
}
template
CSortedNegLinker *CSortedNegLinker::setNegated(bool isNegated) {
negated = isNegated;
return this;
}
template
CSortedNegLinker *CSortedNegLinker::append(CSortedNegLinker *appendingList) {
CSortedNegLinker *last = getLastListLink();
last->insertNext(appendingList);
return this;
}
template
CSortedNegLinker *CSortedNegLinker::removeNext() {
CSortedNegLinker *tmpNext = next;
if (next) {
CSortedNegLinker *tmpNextNext = next->next;
next->next = 0;
setNext(tmpNextNext);
}
return tmpNext;
}
template
CSortedNegLinker *CSortedNegLinker::getLastListLink() {
CSortedNegLinker *lastListLink = this;
while (lastListLink->hasNext()) {
lastListLink = lastListLink->getNext();
}
return lastListLink;
}
template
qint64 CSortedNegLinker::getCount() {
qint64 count = 0;
CSortedNegLinker *linkIt = this;
while (linkIt) {
++count;
linkIt = linkIt->getNext();
}
return count;
}
}; // end namespace Utilities
}; // end namespace Konclude
#endif // KONCLUDE_UTILITIES_CSortedNegLinker_H