- fix in prepper code

- added erase_nocascade

git-svn-id: svn+ssh://gitlab/srv/svn-repos/pdb-redo/trunk@515 a1961a4f-ab94-4bcc-80e8-33b5a54de466

include/cif++/Cif++.h

@@ -1217,9 +1217,27 @@ class Category
 	template<class Iter>
 	template<class Iter>
 	std::tuple<Row,bool> emplace(Iter b, Iter e);
 	std::tuple<Row,bool> emplace(Iter b, Iter e);
 
 
-	void erase(Condition&& cond);
+	size_t erase(Condition&& cond);
+	size_t erase(Condition&& cond, std::function<void(const Row&)>&& visit);
+
 	void erase(Row r);
 	void erase(Row r);
-	void erase(iterator ri);
+	iterator erase(iterator ri);
+
+	// erase without cascade, should only be used when speed is needed
+
+	size_t erase_nocascade(Condition&& cond)
+	{
+		return erase_nocascade(std::forward<Condition>(cond), [](auto r){});
+	}
+
+	size_t erase_nocascade(Condition&& cond, std::function<void(const Row&)>&& visit)
+	{
+		auto savedValidator = mValidator;
+		mValidator = nullptr;
+		auto result = erase(std::forward<Condition>(cond), std::forward<std::function<void(const Row&)>>(visit));
+		mValidator = savedValidator;
+		return result;
+	}
 
 
 	void eraseOrphans(Condition&& cond);
 	void eraseOrphans(Condition&& cond);
 
 

include/cif++/Symmetry.h

@@ -16,7 +16,7 @@ int GetSpacegroupNumber(std::string spacegroup);	// alternative for clipper's pa
 // std::string SpacegroupToHall(std::string spacegroup);
 // std::string SpacegroupToHall(std::string spacegroup);
 
 
 // --------------------------------------------------------------------
 // --------------------------------------------------------------------
-// To iterate over all near symmetry copies of an atom
+// To iterate over all symmetry copies of an atom
 
 
 class SymmetryAtomIteratorFactory
 class SymmetryAtomIteratorFactory
 {
 {

src/Cif++.cpp

@@ -1513,20 +1513,47 @@ tuple<Row,bool> Category::emplace(Row r)
 	return emplace(r.begin(), r.end());
 	return emplace(r.begin(), r.end());
 }
 }
 
 
-void Category::erase(Condition&& cond)
+size_t Category::erase(Condition&& cond)
 {
 {
-	RowSet remove(*this);
-	
+	size_t result = 0;
+
 	cond.prepare(*this);
 	cond.prepare(*this);
 
 
-	for (auto r: *this)
+	auto ri = begin();
+	while (ri != end())
 	{
 	{
-		if (cond(*this, r))
-			remove.push_back(r);
+		if (cond(*this, *ri))
+		{
+			ri = erase(ri);
+			++result;
+		}
+		else
+			++ri;
 	}
 	}
 
 
-	for (auto r: remove)
-		erase(r);
+	return result;	
+}
+
+size_t Category::erase(Condition&& cond, std::function<void(const Row&)>&& verbose)
+{
+	size_t result = 0;
+
+	cond.prepare(*this);
+
+	auto ri = begin();
+	while (ri != end())
+	{
+		if (cond(*this, *ri))
+		{
+			verbose(*ri);
+			ri = erase(ri);
+			++result;
+		}
+		else
+			++ri;
+	}
+
+	return result;
 }
 }
 
 
 void Category::eraseOrphans(Condition&& cond)
 void Category::eraseOrphans(Condition&& cond)
@@ -1552,13 +1579,16 @@ void Category::eraseOrphans(Condition&& cond)
 		erase(r);
 		erase(r);
 }
 }
 
 
-void Category::erase(iterator p)
+void Category::erase(Row r)
 {
 {
-	erase(*p);
+	erase(iterator(r.mData));
 }
 }
 
 
-void Category::erase(Row r)
+auto Category::erase(iterator pos) -> iterator
 {
 {
+	auto r = *pos;
+	iterator result = ++pos;
+
 	iset keys;
 	iset keys;
 	if (mCatValidator)
 	if (mCatValidator)
 		keys = iset(mCatValidator->mKeys.begin(), mCatValidator->mKeys.end());
 		keys = iset(mCatValidator->mKeys.begin(), mCatValidator->mKeys.end());
@@ -1595,22 +1625,25 @@ void Category::erase(Row r)
 	// If all values in a child are the same as the specified parent ones
 	// If all values in a child are the same as the specified parent ones
 	// the child is removed as well, recursively of course.
 	// the child is removed as well, recursively of course.
 
 
-	for (auto& link: mValidator->getLinksForParent(mName))
+	if (mValidator != nullptr)
 	{
 	{
-		auto childCat = mDb.get(link->mChildCategory);
-		if (childCat == nullptr)
-			continue;
-		
-		Condition cond;
-		
-		for (size_t ix = 0; ix < link->mParentKeys.size(); ++ix)
+		for (auto& link: mValidator->getLinksForParent(mName))
 		{
 		{
-			const char* value = r[link->mParentKeys[ix]].c_str();
+			auto childCat = mDb.get(link->mChildCategory);
+			if (childCat == nullptr)
+				continue;
 			
 			
-			cond = move(cond) && (Key(link->mChildKeys[ix]) == value);
-		}
+			Condition cond;
+			
+			for (size_t ix = 0; ix < link->mParentKeys.size(); ++ix)
+			{
+				const char* value = r[link->mParentKeys[ix]].c_str();
+				
+				cond = move(cond) && (Key(link->mChildKeys[ix]) == value);
+			}
 
 
-		childCat->eraseOrphans(move(cond));
+			childCat->eraseOrphans(move(cond));
+		}
 	}
 	}
 
 
 	delete r.mData;
 	delete r.mData;
@@ -1623,6 +1656,8 @@ void Category::erase(Row r)
 			while (mTail->mNext != nullptr)
 			while (mTail->mNext != nullptr)
 				mTail = mTail->mNext;
 				mTail = mTail->mNext;
 	}
 	}
+
+	return result;
 }
 }
 
 
 void Category::getTagOrder(vector<string>& tags) const
 void Category::getTagOrder(vector<string>& tags) const

test/unit-test.cpp

+#define BOOST_TEST_MODULE LibCifPP_Test
+#include <boost/test/included/unit_test.hpp>
+
+#include "cif++/DistanceMap.h"
+
+// --------------------------------------------------------------------
+
+cif::File operator""_cf(const char* text, size_t length)
+{
+	struct membuf : public std::streambuf
+	{
+		membuf(char* text, size_t length)
+		{
+			this->setg(text, text, text + length);
+		}
+	} buffer(const_cast<char*>(text), length);
+
+	std::istream is(&buffer);
+	return cif::File(is);
+}
+
+// --------------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(ut1)
+{
+	using namespace mmcif;
+
+	auto f = R"(data_TEST
+#
+loop_
+_test.id
+_test.name
+1 aap
+2 noot
+3 mies
+	)"_cf;
+
+	auto& db = f.firstDatablock();
+
+	BOOST_CHECK(db.getName() == "TEST");
+	
+	auto& test = db["test"];
+	BOOST_CHECK(test.size() == 3);
+
+	// wrong! the next lines will crash. And that's OK, don't do that
+	// for (auto r: test)
+	// 	test.erase(r);
+	
+	// BOOST_CHECK(test.empty());
+
+	// test.purge();
+
+	auto n = test.erase(cif::Key("id") == 1, [](const cif::Row& r) {
+		BOOST_CHECK_EQUAL(r["id"].as<int>(), 1);
+		BOOST_CHECK_EQUAL(r["name"].as<std::string>(), "aap");
+  	});
+
+	BOOST_CHECK_EQUAL(n, 1);
+}
\ No newline at end of file