/*
* 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_CSORTEDDBLNEGLINKER_H
#define KONCLUDE_UTILITIES_CSORTEDDBLNEGLINKER_H
// Libraries includes
// Namespace includes
#include
// Other includes
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
namespace Utilities {
template class CSortedDblNegLinker;
/*!
*
* \class CSortedDblNegLinker
* \author Andreas Steigmiller
* \version 0.1
* \brief Spezialised Pointer Version to avoid comparison between addresses
*
*/
template
class CSortedDblNegLinker {
// public methods
public:
//! Constructor
CSortedDblNegLinker();
CSortedDblNegLinker(T* dataElement, bool isNegated = false, CSortedDblNegLinker *nextLink = 0);
//! Destructor
virtual ~CSortedDblNegLinker();
CSortedDblNegLinker *init(T* dataElement, bool isNegated = false, CSortedDblNegLinker *nextLink = 0);
bool hasNext();
bool hasPrev();
CSortedDblNegLinker *insertSortedNextSorted(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *insertNextSorted(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *insertNext(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *getNext();
CSortedDblNegLinker *insertPrev(CSortedDblNegLinker *prevLink);
CSortedDblNegLinker *getPrev();
CSortedDblNegLinker *setNext(CSortedDblNegLinker *prevLink);
CSortedDblNegLinker *setPrev(CSortedDblNegLinker *prevLink);
T* getData();
CSortedDblNegLinker *setData(T* dataElement);
bool isNegated();
CSortedDblNegLinker *setNegated(bool isNegated);
CSortedDblNegLinker *prepend(CSortedDblNegLinker *prependingList);
CSortedDblNegLinker *append(CSortedDblNegLinker *appendingList);
CSortedDblNegLinker *removeNext();
CSortedDblNegLinker *removePrev();
CSortedDblNegLinker *getLastListLink();
CSortedDblNegLinker *getFirstListLink();
// protected methods
protected:
// private methods
private:
// private variables
private:
CSortedDblNegLinker *next;
CSortedDblNegLinker *prev;
T* data;
bool negated;
};
template
CSortedDblNegLinker::CSortedDblNegLinker() {
next = 0;
prev = 0;
negated = false;
}
template
CSortedDblNegLinker::CSortedDblNegLinker(T* dataElement, bool isNegated, CSortedDblNegLinker *nextLink) {
next = 0;
prev = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::init(T* dataElement, bool isNegated, CSortedDblNegLinker *nextLink) {
next = 0;
prev = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
return this;
}
template
CSortedDblNegLinker::~CSortedDblNegLinker() {
}
template
bool CSortedDblNegLinker::hasNext() {
return next != 0;
}
template
bool CSortedDblNegLinker::hasPrev() {
return prev != 0;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertNext(CSortedDblNegLinker *nextLink) {
if (nextLink) {
CSortedDblNegLinker *tmpNext = next;
next = nextLink;
nextLink->prev = this;
if (tmpNext) {
nextLink->append(tmpNext);
}
}
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertNextSorted(CSortedDblNegLinker *nextLink) {
while (nextLink) {
CSortedDblNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
nextLink->removePrev();
} else {
nextLink = 0;
}
CSortedDblNegLinker *list = this;
CSortedDblNegLinker *lastList = list;
bool inserted = false;
T* dataIns = nIns->getData();
while (list) {
T* dataList = list->getData();
if (*dataIns <= *dataList) {
list->insertPrev(nIns);
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
}
}
return getFirstListLink();
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertSortedNextSorted(CSortedDblNegLinker *nextLink) {
// items from nextLink are already sorted!
CSortedDblNegLinker *list = this;
while (nextLink) {
CSortedDblNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
nextLink->removePrev();
} else {
nextLink = 0;
}
CSortedDblNegLinker *lastList = list;
bool inserted = false;
T* dataIns = nIns->getData();
while (list) {
T* dataList = list->getData();
if (*dataIns <= *dataList) {
list = list->insertPrev(nIns);
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
list = lastList;
}
}
return getFirstListLink();
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertPrev(CSortedDblNegLinker *prevLink) {
if (prevLink) {
CSortedDblNegLinker *pLlast = prevLink->getLastListLink();
CSortedDblNegLinker *tmpPrev = prev;
prev = pLlast;
pLlast->next = this;
if (tmpPrev) {
tmpPrev->next = 0;
prevLink->prepend(tmpPrev);
}
return prevLink;
} else {
return this;
}
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setNext(CSortedDblNegLinker *nextLink) {
next = nextLink;
if (nextLink) {
nextLink->prev = this;
}
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setPrev(CSortedDblNegLinker *prevLink) {
if (prevLink) {
CSortedDblNegLinker *pLlast = prevLink->getLastListLink();
pLlast->next = this;
prev = pLlast;
return prevLink;
} else {
prev = 0;
return this;
}
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getNext() {
return next;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getPrev() {
return prev;
}
template
T* CSortedDblNegLinker::getData() {
return data;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setData(T* dataElement) {
data = dataElement;
return this;
}
template
bool CSortedDblNegLinker::isNegated() {
return negated;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setNegated(bool isNegated) {
negated = isNegated;
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::prepend(CSortedDblNegLinker *prependingList) {
CSortedDblNegLinker *last = prependingList->getLastListLink();
last->insertNext(this);
return prependingList;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::append(CSortedDblNegLinker *appendingList) {
CSortedDblNegLinker *last = getLastListLink();
last->insertNext(appendingList);
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::removeNext() {
CSortedDblNegLinker *next = getNext();
if (next) {
next->next = 0;
next->prev = 0;
setNext(next->getNext());
}
return next;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::removePrev() {
CSortedDblNegLinker *prev = getPrev();
if (prev) {
prev->next = 0;
prev->prev = 0;
setPrev(prev->getPrev());
}
return prev;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getLastListLink() {
CSortedDblNegLinker *lastListLink = this;
while (lastListLink->hasNext()) {
lastListLink = lastListLink->getNext();
}
return lastListLink;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getFirstListLink() {
CSortedDblNegLinker *firstListLink = this;
while (firstListLink->hasPrev()) {
firstListLink = firstListLink->getPrev();
}
return firstListLink;
}
/*!
*
* \class CSortedDblNegLinker
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
template
class CSortedDblNegLinker {
// public methods
public:
//! Constructor
CSortedDblNegLinker();
CSortedDblNegLinker(T dataElement, bool isNegated = false, CSortedDblNegLinker *nextLink = 0);
//! Destructor
virtual ~CSortedDblNegLinker();
CSortedDblNegLinker *init(T dataElement, bool isNegated = false, CSortedDblNegLinker *nextLink = 0);
bool hasNext();
bool hasPrev();
CSortedDblNegLinker *insertSortedNextSorted(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *insertNextSorted(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *insertNext(CSortedDblNegLinker *nextLink);
CSortedDblNegLinker *getNext();
CSortedDblNegLinker *insertPrev(CSortedDblNegLinker *prevLink);
CSortedDblNegLinker *getPrev();
CSortedDblNegLinker *setNext(CSortedDblNegLinker *prevLink);
CSortedDblNegLinker *setPrev(CSortedDblNegLinker *prevLink);
T getData();
CSortedDblNegLinker *setData(T dataElement);
bool isNegated();
CSortedDblNegLinker *setNegated(bool isNegated);
CSortedDblNegLinker *prepend(CSortedDblNegLinker *prependingList);
CSortedDblNegLinker *append(CSortedDblNegLinker *appendingList);
CSortedDblNegLinker *removeNext();
CSortedDblNegLinker *removePrev();
CSortedDblNegLinker *getLastListLink();
CSortedDblNegLinker *getFirstListLink();
// protected methods
protected:
// private methods
private:
// private variables
private:
CSortedDblNegLinker *next;
CSortedDblNegLinker *prev;
T data;
bool negated;
};
template
CSortedDblNegLinker::CSortedDblNegLinker() {
next = 0;
prev = 0;
negated = false;
}
template
CSortedDblNegLinker::CSortedDblNegLinker(T dataElement, bool isNegated, CSortedDblNegLinker *nextLink) {
next = 0;
prev = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::init(T dataElement, bool isNegated, CSortedDblNegLinker *nextLink) {
next = 0;
prev = 0;
setNext(nextLink);
data = dataElement;
negated = isNegated;
return this;
}
template
CSortedDblNegLinker::~CSortedDblNegLinker() {
}
template
bool CSortedDblNegLinker::hasNext() {
return next != 0;
}
template
bool CSortedDblNegLinker::hasPrev() {
return prev != 0;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertNext(CSortedDblNegLinker *nextLink) {
if (nextLink) {
CSortedDblNegLinker *tmpNext = next;
next = nextLink;
nextLink->prev = this;
if (tmpNext) {
nextLink->append(tmpNext);
}
}
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertNextSorted(CSortedDblNegLinker *nextLink) {
while (nextLink) {
CSortedDblNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
nextLink->removePrev();
} else {
nextLink = 0;
}
CSortedDblNegLinker *list = this;
CSortedDblNegLinker *lastList = list;
bool inserted = false;
T dataIns = nIns->getData();
while (list) {
T dataList = list->getData();
if (dataIns <= dataList) {
list->insertPrev(nIns);
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
}
}
return getFirstListLink();
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertSortedNextSorted(CSortedDblNegLinker *nextLink) {
// items from nextLink are already sorted!
CSortedDblNegLinker *list = this;
while (nextLink) {
CSortedDblNegLinker *nIns = nextLink;
if (nextLink->hasNext()) {
nextLink = nextLink->getNext();
nextLink->removePrev();
} else {
nextLink = 0;
}
CSortedDblNegLinker *lastList = list;
bool inserted = false;
T dataIns = nIns->getData();
while (list) {
T dataList = list->getData();
if (dataIns <= dataList) {
list = list->insertPrev(nIns);
inserted = true;
break;
}
lastList = list;
list = list->next;
}
if (!inserted) {
lastList->insertNext(nIns);
list = lastList;
}
}
return getFirstListLink();
}
template
CSortedDblNegLinker *CSortedDblNegLinker::insertPrev(CSortedDblNegLinker *prevLink) {
if (prevLink) {
CSortedDblNegLinker *pLlast = prevLink->getLastListLink();
CSortedDblNegLinker *tmpPrev = prev;
prev = pLlast;
pLlast->next = this;
if (tmpPrev) {
tmpPrev->next = 0;
prevLink->prepend(tmpPrev);
}
return prevLink;
} else {
return this;
}
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setNext(CSortedDblNegLinker *nextLink) {
next = nextLink;
if (nextLink) {
nextLink->prev = this;
}
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setPrev(CSortedDblNegLinker *prevLink) {
if (prevLink) {
CSortedDblNegLinker *pLlast = prevLink->getLastListLink();
pLlast->next = this;
prev = pLlast;
return prevLink;
} else {
prev = 0;
return this;
}
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getNext() {
return next;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getPrev() {
return prev;
}
template
T CSortedDblNegLinker::getData() {
return data;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setData(T dataElement) {
data = dataElement;
return this;
}
template
bool CSortedDblNegLinker::isNegated() {
return negated;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::setNegated(bool isNegated) {
negated = isNegated;
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::prepend(CSortedDblNegLinker *prependingList) {
CSortedDblNegLinker *last = prependingList->getLastListLink();
last->insertNext(this);
return prependingList;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::append(CSortedDblNegLinker *appendingList) {
CSortedDblNegLinker *last = getLastListLink();
last->insertNext(appendingList);
return this;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::removeNext() {
CSortedDblNegLinker *next = getNext();
if (next) {
next->next = 0;
next->prev = 0;
setNext(next->getNext());
}
return next;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::removePrev() {
CSortedDblNegLinker *prev = getPrev();
if (prev) {
prev->next = 0;
prev->prev = 0;
setPrev(prev->getPrev());
}
return prev;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getLastListLink() {
CSortedDblNegLinker *lastListLink = this;
while (lastListLink->hasNext()) {
lastListLink = lastListLink->getNext();
}
return lastListLink;
}
template
CSortedDblNegLinker *CSortedDblNegLinker::getFirstListLink() {
CSortedDblNegLinker *firstListLink = this;
while (firstListLink->hasPrev()) {
firstListLink = firstListLink->getPrev();
}
return firstListLink;
}
}; // end namespace Utilities
}; // end namespace Konclude
#endif // KONCLUDE_UTILITIES_CSORTEDDBLNEGLINKER_H