/* * 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