void deleteSubtree(Node *root)
{
if (root != NULL)
{
deleteSubtree(root->left);
deleteSubtree(root->right);
delete root;
}
}
void
CTNode::removeAndDeleteAllChilds (void)
{
for (CTChilds::const_iterator chIt = childs_.begin();
chIt != childs_.end(); ++ chIt) {
deleteSubtree (*chIt);
}
childs_.clear();
}
void MolpherMol::removeFromTree() {
auto tree = pimpl->tree;
if (tree) {
pimpl->tree.reset();
auto smiles = getSMILES();
if (tree->hasMol(smiles)) {
tree->deleteSubtree(smiles, false);
}
}
}
void ProjectModel::po_rowsInserted(const QModelIndex& po_parent, int first, int last)
{
QModelIndex parent = indexForPoIndex(po_parent);
QModelIndex pot_parent = potIndexForOuter(parent);
ProjectNode* node = nodeForIndex(parent);
//insert po rows
beginInsertRows(parent, first, last);
for (int pos = first; pos <= last; pos ++)
{
ProjectNode * childNode = new ProjectNode(node, pos, pos, -1);
node->rows.insert(pos, childNode);
}
node->poCount += last - first + 1;
//update rowNumber
for (int pos = last + 1; pos < node->rows.count(); pos++)
node->rows[pos]->rowNumber = pos;
endInsertRows();
//remove unneeded pot rows, update PO rows
if (pot_parent.isValid() || !parent.isValid())
{
QVector<int> pot2PoMapping;
generatePOTMapping(pot2PoMapping, po_parent, pot_parent);
for (int pos = node->poCount; pos < node->rows.count(); pos ++)
{
ProjectNode* potNode = node->rows.at(pos);
int potIndex = potNode->potRowNumber;
int poIndex = pot2PoMapping[potIndex];
if (poIndex != -1)
{
//found pot node, that now has a PO index.
//remove the pot node and change the corresponding PO node
beginRemoveRows(parent, pos, pos);
node->rows.removeAt(pos);
deleteSubtree(potNode);
endRemoveRows();
node->rows[poIndex]->potRowNumber = potIndex;
//This change does not need notification
//dataChanged(index(poIndex, 0, parent), index(poIndex, ProjectModelColumnCount, parent));
pos--;
}
}
}
enqueueNodeForMetadataUpdate(node);
}
void
CTNode::deleteSubtree (CTNode* n)
{
assert (n);
const CTChilds& childs = n->childs();
for (CTChilds::const_iterator chIt = childs.begin();
chIt != childs.end(); ++ chIt) {
deleteSubtree (*chIt);
}
delete n;
}
void ProjectModel::deleteSubtree(ProjectNode* node)
{
for (int row = 0; row < node->rows.count(); row ++)
deleteSubtree(node->rows.at(row));
m_dirsWaitingForMetadata.remove(node);
if ((m_activeJob != NULL) && (m_activeNode == node))
m_activeJob->setStatus(-1);
delete node;
}
void ProjectModel::setUrl(const KUrl &poUrl, const KUrl &potUrl)
{
//kDebug() << "ProjectModel::openUrl("<< poUrl.pathOrUrl() << +", " << potUrl.pathOrUrl() << ")";
//cleanup old data
m_dirsWaitingForMetadata.clear();
if (m_activeJob != NULL)
m_activeJob->setStatus(-1);
m_activeJob = NULL;
if (m_rootNode.rows.count())
{
beginRemoveRows(QModelIndex(), 0, m_rootNode.rows.count());
for (int pos = 0; pos < m_rootNode.rows.count(); pos ++)
deleteSubtree(m_rootNode.rows.at(pos));
m_rootNode.rows.clear();
m_rootNode.poCount = 0;
m_rootNode.translated = -1;
m_rootNode.translated_reviewer = -1;
m_rootNode.translated_approver = -1;
m_rootNode.untranslated = -1;
m_rootNode.fuzzy = -1;
m_rootNode.fuzzy_reviewer = -1;
m_rootNode.fuzzy_approver = -1;
endRemoveRows();
}
//add trailing slashes to base URLs, needed for potToPo and poToPot
m_poUrl = poUrl;
m_potUrl = potUrl;
m_poUrl.adjustPath(KUrl::AddTrailingSlash);
m_potUrl.adjustPath(KUrl::AddTrailingSlash);
emit loading();
if (!poUrl.isEmpty())
m_poModel.dirLister()->openUrl(m_poUrl, KDirLister::Reload);
if (!potUrl.isEmpty())
m_potModel.dirLister()->openUrl(m_potUrl, KDirLister::Reload);
}
~SkewHeap()
{
deleteSubtree(root);
}
void ProjectModel::pot_rowsRemoved(const QModelIndex& pot_parent, int start, int end)
{
QModelIndex parent = indexForPotIndex(pot_parent);
QModelIndex po_parent = poIndexForOuter(parent);
ProjectNode * node = nodeForIndex(parent);
int removedCount = end + 1 - start;
if ((!parent.isValid()) && (node->rows.count() == 0))
{
//events after removing entire contents
return;
}
//First remove POT nodes
int firstPOTToRemove = node->poCount;
int lastPOTToRemove = node->rows.count() - 1;
while (firstPOTToRemove <= lastPOTToRemove && node->rows[firstPOTToRemove]->potRowNumber < start)
firstPOTToRemove ++;
while (lastPOTToRemove >= firstPOTToRemove && node->rows[lastPOTToRemove]->potRowNumber > end)
lastPOTToRemove --;
if (firstPOTToRemove <= lastPOTToRemove)
{
beginRemoveRows(parent, firstPOTToRemove, lastPOTToRemove);
for (int pos = lastPOTToRemove; pos >= firstPOTToRemove; pos --)
{
ProjectNode* childNode = node->rows.at(pos);
Q_ASSERT(childNode->potRowNumber >= start);
Q_ASSERT(childNode->potRowNumber <= end);
deleteSubtree(childNode);
node->rows.removeAt(pos);
}
//renumber remaining rows
for (int pos = firstPOTToRemove; pos < node->rows.count(); pos ++)
{
node->rows[pos]->rowNumber = pos;
node->rows[pos]->potRowNumber -= removedCount;
}
endRemoveRows();
}
//now remove POT indices form PO rows
if (po_parent.isValid() || !parent.isValid())
{
for (int poIndex = 0; poIndex < node->poCount; poIndex ++)
{
ProjectNode * childNode = node->rows[poIndex];
int potIndex = childNode->potRowNumber;
if (potIndex >= start && potIndex <= end)
{
//found PO node, that has a POT index in range.
//change the corresponding PO node
node->rows[poIndex]->potRowNumber = -1;
//this change does not affect the model
//dataChanged(index(poIndex, 0, parent), index(poIndex, ProjectModelColumnCount, parent));
}
else if (childNode->potRowNumber > end)
{
//reassign POT indices
childNode->potRowNumber -= removedCount;
}
}
}
enqueueNodeForMetadataUpdate(node);
}
void ProjectModel::po_rowsRemoved(const QModelIndex& po_parent, int start, int end)
{
QModelIndex parent = indexForPoIndex(po_parent);
QModelIndex pot_parent = potIndexForOuter(parent);
ProjectNode* node = nodeForIndex(parent);
int removedCount = end + 1 - start;
if ((!parent.isValid()) && (node->rows.count() == 0))
{
//events after removing entire contents
return;
}
//remove PO rows
QList<int> potRowsToInsert;
beginRemoveRows(parent, start, end);
//renumber all rows after removed.
for (int pos = end + 1; pos < node->rows.count(); pos ++)
{
ProjectNode* childNode = node->rows.at(pos);
childNode->rowNumber -= removedCount;
if (childNode->poRowNumber > end)
node->rows[pos]->poRowNumber -= removedCount;
}
//remove
for (int pos = end; pos >= start; pos --)
{
int potIndex = node->rows.at(pos)->potRowNumber;
deleteSubtree(node->rows.at(pos));
node->rows.removeAt(pos);
if (potIndex != -1)
potRowsToInsert.append(potIndex);
}
node->poCount -= removedCount;
endRemoveRows(); //< fires removed event - the list has to be consistent now
//add back rows that have POT files and fix row order
qSort(potRowsToInsert.begin(), potRowsToInsert.end());
int insertionPoint = node->poCount;
for (int pos = 0; pos < potRowsToInsert.count(); pos ++)
{
int potIndex = potRowsToInsert.at(pos);
while (insertionPoint < node->rows.count() && node->rows[insertionPoint]->potRowNumber < potIndex)
{
node->rows[insertionPoint]->rowNumber = insertionPoint;
insertionPoint ++;
}
beginInsertRows(parent, insertionPoint, insertionPoint);
ProjectNode * childNode = new ProjectNode(node, insertionPoint, -1, potIndex);
node->rows.insert(insertionPoint, childNode);
insertionPoint++;
endInsertRows();
}
//renumber remaining rows
while (insertionPoint < node->rows.count())
{
node->rows[insertionPoint]->rowNumber = insertionPoint;
insertionPoint++;
}
enqueueNodeForMetadataUpdate(node);
}
void GenerateMorphsOper::GenerateMorphsOperImpl::operator()() {
auto tree = getTree();
if (tree) {
auto tree_pimpl = tree->pimpl;
ConcurrentMolVector leaves;
tree_pimpl->fetchLeaves(tree, true, leaves);
tree_pimpl->candidates.clear();
std::shared_ptr<CollectMorphs> collector(new CollectMorphs(
tree_pimpl->candidates
, tree
, mSetTreeOwnershipForMorphs
, tree_pimpl->target
, (FingerprintSelector) tree_pimpl->fingerprint
, (SimCoeffSelector) tree_pimpl->simCoeff
));
std::vector<std::shared_ptr<MorphCollector> > collectors;
collectors.push_back(std::static_pointer_cast<MorphCollector>(collector));
collectors.insert(collectors.end(), this->collectors.begin(), this->collectors.end());
for (auto& leaf : leaves) {
unsigned int morphAttempts = tree_pimpl->params.cntMorphs;
if (leaf->getDistToTarget() < tree_pimpl->params.distToTargetDepthSwitch) {
morphAttempts = tree_pimpl->params.cntMorphsInDepth;
}
// generate morphs for the current leaf
try {
Molpher molpher(
leaf
, tree_pimpl->chemOpers
, tree_pimpl->threadCnt
, morphAttempts
, collectors
);
tree_pimpl->candidates.reserve(tree_pimpl->candidates.size() + morphAttempts);
molpher();
} catch (std::exception exp) {
Cerr("Morphing failed for leaf: " + leaf->getSMILES());
if (!leaf->getParentSMILES().empty()) {
tree->deleteSubtree(leaf->getSMILES(), false);
}
continue;
}
MorphDerivationMap::accessor ac;
if (tree_pimpl->morphDerivations.find(ac, leaf->getSMILES())) {
ac->second += collector->WithdrawCollectAttemptCount();
} else {
tree_pimpl->morphDerivations.insert(ac, leaf->getSMILES());
ac->second = collector->WithdrawCollectAttemptCount();
}
}
tree_pimpl->candidates.shrink_to_fit();
tree_pimpl->candidatesMask.clear();
tree_pimpl->candidatesMask.resize(tree_pimpl->candidates.size(), true);
// SynchCout("Generated " + parseNumber(tree_pimpl->candidates.size()) + " morphs.");
} else {
throw std::runtime_error("Cannot generate morphs. No tree associated with this instance.");
}
}
