/*
* 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 "CSignatureSatisfiableExpanderCacheHasher.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Cache {
CSignatureSatisfiableExpanderCacheHasher::CSignatureSatisfiableExpanderCacheHasher(CCACHINGSET* cacheValueSet) {
mCacheValueSet = cacheValueSet;
mHashValue = 0;
mCacheValueCount = cacheValueSet->count();
mCacheValueLinker = nullptr;
calculateHashValue(mCacheValueSet);
}
CSignatureSatisfiableExpanderCacheHasher::CSignatureSatisfiableExpanderCacheHasher(CExpanderCacheValueLinker* cacheValueLinker, cint64 count) {
mCacheValueSet = nullptr;
mHashValue = 0;
mCacheValueCount = count;
mCacheValueLinker = cacheValueLinker;
calculateHashValue(mCacheValueLinker,mCacheValueCount);
}
CSignatureSatisfiableExpanderCacheHasher::CSignatureSatisfiableExpanderCacheHasher(const CSignatureSatisfiableExpanderCacheHasher& hasher) {
mHashValue = hasher.mHashValue;
mCacheValueSet = hasher.mCacheValueSet;
mCacheValueLinker = hasher.mCacheValueLinker;
mCacheValueCount = hasher.mCacheValueCount;
}
cint64 CSignatureSatisfiableExpanderCacheHasher::getHashValue() const {
return mHashValue;
}
bool CSignatureSatisfiableExpanderCacheHasher::operator==(const CSignatureSatisfiableExpanderCacheHasher& hasher) const {
if (mHashValue != hasher.mHashValue) {
return false;
}
if (mCacheValueCount != hasher.mCacheValueCount) {
return false;
}
if (mCacheValueLinker && hasher.mCacheValueLinker) {
if (!hasEqualCacheValues(mCacheValueLinker,hasher.mCacheValueLinker,mCacheValueCount)) {
return false;
}
} else if (mCacheValueSet && hasher.mCacheValueSet) {
if (!hasEqualCacheValues(mCacheValueSet,hasher.mCacheValueSet)) {
return false;
}
} else if (mCacheValueLinker && hasher.mCacheValueSet) {
if (!hasEqualCacheValues(mCacheValueLinker,hasher.mCacheValueSet,mCacheValueCount)) {
return false;
}
} else {
if (!hasEqualCacheValues(hasher.mCacheValueLinker,mCacheValueSet,mCacheValueCount)) {
return false;
}
}
return false;
}
void CSignatureSatisfiableExpanderCacheHasher::calculateHashValue(CCACHINGSET* cacheValueSet) {
mHashValue = 0;
for (CCACHINGSET::const_iterator it = cacheValueSet->constBegin(), itEnd = cacheValueSet->constEnd(); it != itEnd; ++it) {
CCacheValue cacheValue(*it);
extendHashValue(&cacheValue);
}
}
void CSignatureSatisfiableExpanderCacheHasher::calculateHashValue(CExpanderCacheValueLinker* cacheValueLinker, cint64 count) {
mHashValue = 0;
CExpanderCacheValueLinker* cacheValueLinkerIt = cacheValueLinker;
cint64 nr = 0;
while (cacheValueLinkerIt && nr++ < count) {
extendHashValue(cacheValueLinkerIt->getCacheValue());
cacheValueLinkerIt = cacheValueLinkerIt->getNext();
}
}
void CSignatureSatisfiableExpanderCacheHasher::extendHashValue(CCacheValue* cacheValue) {
uint nextHashValue = qHash(*cacheValue);
mHashValue += nextHashValue;
}
bool CSignatureSatisfiableExpanderCacheHasher::hasEqualCacheValues(CExpanderCacheValueLinker* cacheValueLinker, CExpanderCacheValueLinker* cacheValueLinker2, cint64 count) const {
cint64 nr = 0;
while (cacheValueLinker && cacheValueLinker2 && nr++ < count) {
if (*cacheValueLinker->getCacheValue() != *cacheValueLinker2->getCacheValue()) {
return false;
}
cacheValueLinker = cacheValueLinker->getNext();
cacheValueLinker2 = cacheValueLinker2->getNext();
}
if (nr < count) {
if (cacheValueLinker || cacheValueLinker2) {
return false;
}
}
return true;
}
bool CSignatureSatisfiableExpanderCacheHasher::hasEqualCacheValues(CCACHINGSET* cacheValueSet, CCACHINGSET* cacheValueSet2) const {
CCACHINGSET::const_iterator it1 = cacheValueSet->constBegin(), it1End = cacheValueSet->constEnd();
CCACHINGSET::const_iterator it2 = cacheValueSet2->constBegin(), it2End = cacheValueSet2->constEnd();
while (it1 != it1End) {
if (*it1 != *it2) {
return false;
}
++it1;
++it2;
}
return true;
}
bool CSignatureSatisfiableExpanderCacheHasher::hasEqualCacheValues(CExpanderCacheValueLinker* cacheValueLinker, CCACHINGSET* cacheValueSet, cint64 count) const {
CExpanderCacheValueLinker* cacheValueLinkerIt = cacheValueLinker;
cint64 nr = 0;
while (cacheValueLinkerIt && nr++ < count) {
if (!cacheValueSet->contains(*cacheValueLinkerIt->getCacheValue())) {
return false;
}
cacheValueLinkerIt = cacheValueLinkerIt->getNext();
}
return true;
}
}; // end namespace Cache
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude