start structure-test unit test

added compare functions for Datablock and Category

CMakeLists.txt

@@ -385,6 +385,7 @@ if(CIFPP_BUILD_TESTS)
 	list(APPEND CIFPP_tests
 	list(APPEND CIFPP_tests
 		# pdb2cif
 		# pdb2cif
 		rename-compound
 		rename-compound
+		structure
 		unit)
 		unit)
 
 
 	foreach(CIFPP_TEST IN LISTS CIFPP_tests)
 	foreach(CIFPP_TEST IN LISTS CIFPP_tests)

include/cif++/Structure.hpp

@@ -397,6 +397,8 @@ class File : public std::enable_shared_from_this<File>
 	File(const File &) = delete;
 	File(const File &) = delete;
 	File &operator=(const File &) = delete;
 	File &operator=(const File &) = delete;
 
 
+	cif::Datablock& createDatablock(const std::string &name);
+
 	void load(const std::string &path);
 	void load(const std::string &path);
 	void save(const std::string &path);
 	void save(const std::string &path);
 
 
@@ -482,6 +484,19 @@ class Structure
 	void changeResidue(const Residue &res, const std::string &newCompound,
 	void changeResidue(const Residue &res, const std::string &newCompound,
 		const std::vector<std::tuple<std::string, std::string>> &remappedAtoms);
 		const std::vector<std::tuple<std::string, std::string>> &remappedAtoms);
 
 
+	/// \brief Create a new non-polymer entity, returns new ID
+	/// \param data		The data to use to fill the entity
+	/// \param mon_id	The mon_id for the new nonpoly
+	/// \param name		The name of the nonpoly
+	/// \return			The ID of the created entity
+	std::string createEntityNonPoly(std::vector<cif::Item> data, const std::string &mon_id);
+
+	/// \brief Create a new NonPolymer struct_asym with atoms constructed from \a atom_data, returns asym_id
+	/// \param entity_id	The entity ID of the new nonpoly
+	/// \param atoms		The array of atom data fields
+	/// \return				The newly create asym ID
+	std::string createNonpoly(const std::string &entity_id, const std::vector<cif::Item> &atoms);
+
 	/// To sort the atoms in order of model > asym-id > res-id > atom-id
 	/// To sort the atoms in order of model > asym-id > res-id > atom-id
 	/// Will asssign new atom_id's to all atoms. Be carefull
 	/// Will asssign new atom_id's to all atoms. Be carefull
 	void sortAtoms();
 	void sortAtoms();

src/Structure.cpp

@@ -1740,6 +1740,14 @@ File::~File()
 	delete mImpl;
 	delete mImpl;
 }
 }
 
 
+cif::Datablock& File::createDatablock(const std::string &name)
+{
+	auto db = new cif::Datablock(name);
+
+	mImpl->mData.append(db);
+	mImpl->mDb = db;
+}
+
 void File::load(const std::string &p)
 void File::load(const std::string &p)
 {
 {
 	mImpl->load(p);
 	mImpl->load(p);
@@ -1778,8 +1786,11 @@ Structure::Structure(File &f, size_t modelNr, StructureOpenOptions options)
 	: mFile(f)
 	: mFile(f)
 	, mModelNr(modelNr)
 	, mModelNr(modelNr)
 {
 {
-	auto &db = *mFile.impl().mDb;
-	auto &atomCat = db["atom_site"];
+	auto db = mFile.impl().mDb;
+	if (db == nullptr)
+		throw std::logic_error("Empty file!");
+
+	auto &atomCat = (*db)["atom_site"];
 
 
 	for (auto &a : atomCat)
 	for (auto &a : atomCat)
 	{
 	{
@@ -2400,6 +2411,31 @@ void Structure::changeResidue(const Residue &res, const std::string &newCompound
 	}
 	}
 }
 }
 
 
+std::string Structure::createEntityNonPoly(std::vector<cif::Item> data, const std::string &mon_id)
+{
+	auto &db = mFile.data();
+
+	auto &entity = db["entity"];
+	std::string entity_id = entity.getUniqueID("");
+
+	// remove any ID fields
+	data.erase(std::remove_if(data.begin(), data.end(), [](cif::Item &item) { return item.name() == "id"; }),
+			data.end());
+
+	// add our new ID
+	data.emplace_back("id", entity_id);
+	data.emplace_back("type", "non-polymer");
+
+	entity.emplace(data.begin(), data.end());
+
+	return entity_id;
+}
+
+std::string Structure::createNonpoly(const std::string &entity_id, const std::vector<cif::Item> &atoms)
+{
+	return {};
+}
+
 void Structure::cleanupEmptyCategories()
 void Structure::cleanupEmptyCategories()
 {
 {
 	using namespace cif::literals;
 	using namespace cif::literals;

test/structure-test.cpp

+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ * 
+ * Copyright (c) 2021 NKI/AVL, Netherlands Cancer Institute
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define BOOST_TEST_MODULE Structure_Test
+#include <boost/test/included/unit_test.hpp>
+
+#include <stdexcept>
+
+#include "cif++/Cif++.hpp"
+#include "cif++/Structure.hpp"
+
+// --------------------------------------------------------------------
+
+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(create_nonpoly_1)
+{
+    cif::VERBOSE = 1;
+
+	// do this now, avoids the need for installing
+	cif::addFileResource("mmcif_pdbx_v50.dic", "../rsrc/mmcif_pdbx_v50.dic");
+
+	auto expected = R"(
+data_TEST
+loop_
+_entity.id
+_entity.type
+_entity.src_method
+_entity.pdbx_description
+_entity.formula_weight
+1 non-polymer syn 'PROTOPORPHYRIN IX CONTAINING FE' 616.487
+	)"_cf;
+
+	expected.loadDictionary("mmcif_pdbx_v50.dic");
+
+	mmcif::File file;
+	file.file().loadDictionary("mmcif_pdbx_v50.dic");
+	file.createDatablock("TEST");	// create a datablock
+	
+	mmcif::Structure structure(file);
+
+	structure.createEntityNonPoly({
+		{ "src_method", "syn" },
+		{ "pdbx_description", "PROTOPORPHYRIN IX CONTAINING FE" },
+		{ "formula_weight", 616.487 }
+	}, "HEM" );
+
+	BOOST_TEST(expected.firstDatablock() == structure.getFile().data());
+
+	std::cout << expected.firstDatablock() << std::endl
+			  << std::endl
+			  << structure.getFile().data() << std::endl;
+
+//     // 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);
+}