mirror of
https://github.com/rdkit/rdkit.git
synced 2026-06-03 21:44:30 +08:00
94 lines
2.3 KiB
C++
94 lines
2.3 KiB
C++
//
|
|
//
|
|
// Copyright (C) 2020 Schrödinger, LLC
|
|
//
|
|
// @@ All Rights Reserved @@
|
|
// This file is part of the RDKit.
|
|
// The contents are covered by the terms of the BSD license
|
|
// which is included in the file license.txt, found at the root
|
|
// of the RDKit source tree.
|
|
//
|
|
|
|
#include "Sort.h"
|
|
#include "rules/SequenceRule.h"
|
|
|
|
namespace RDKit {
|
|
namespace CIPLabeler {
|
|
|
|
Sort::Sort(const SequenceRule *comparator) : d_rules{comparator} {}
|
|
|
|
Sort::Sort(std::vector<const SequenceRule *> comparators)
|
|
: d_rules{std::move(comparators)} {}
|
|
|
|
const std::vector<const SequenceRule *> &Sort::getRules() const {
|
|
return d_rules;
|
|
}
|
|
|
|
Priority Sort::prioritize(const Node *node, std::vector<Edge *> &edges,
|
|
bool deep) const {
|
|
bool unique = true;
|
|
int numPseudoAsym = 0;
|
|
|
|
for (auto i = 0u; i < edges.size(); ++i) {
|
|
for (auto j = i; j > 0; --j) {
|
|
int cmp = compareSubstituents(node, edges[j - 1], edges[j], deep);
|
|
|
|
if (cmp < -1 || cmp > +1) {
|
|
++numPseudoAsym;
|
|
}
|
|
|
|
if (cmp < 0) {
|
|
std::swap(edges[j], edges[j - 1]);
|
|
} else {
|
|
if (cmp == 0) {
|
|
unique = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return {unique, numPseudoAsym == 1};
|
|
}
|
|
|
|
int Sort::compareSubstituents(const Node *node, const Edge *a, const Edge *b,
|
|
bool deep) const {
|
|
// ensure 'out' edges are moved to the front
|
|
if (!a->isBeg(node) && b->isBeg(node)) {
|
|
return +1;
|
|
} else if (a->isBeg(node) && !b->isBeg(node)) {
|
|
return -1;
|
|
}
|
|
|
|
for (const auto &rule : d_rules) {
|
|
int cmp = rule->getComparision(a, b, deep);
|
|
|
|
if (cmp != 0) {
|
|
return cmp;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::vector<std::vector<Edge *>> Sort::getGroups(
|
|
const std::vector<Edge *> &sorted) const {
|
|
// would be nice to have this integrated whilst sorting - may provide a
|
|
// small speed increase but as most of our lists are small we take use
|
|
// ugly sort then group approach
|
|
std::vector<std::vector<Edge *>> groups;
|
|
|
|
Edge *prev = nullptr;
|
|
for (auto *edge : sorted) {
|
|
if (prev == nullptr ||
|
|
compareSubstituents(prev->getBeg(), prev, edge, true) != 0) {
|
|
groups.emplace_back();
|
|
}
|
|
prev = edge;
|
|
groups.back().push_back(edge);
|
|
}
|
|
|
|
return groups;
|
|
}
|
|
|
|
} // namespace CIPLabeler
|
|
} // namespace RDKit
|