Remove gxrio and replace it with stripped down version

d638d634 · Maarten L. Hekkelman · 35196789 · d638d634 · d638d634 · d638d634
Commit d638d634 authored Nov 09, 2022 by Maarten L. Hekkelman
11 changed files
--- a/.gitignore
+++ b/.gitignore
 build/
 .vscode/
 .vs/
-.pc/
-tools/symop-map-generator
-test/unit-test
-test/pdb2cif-test
-test/rename-compound-test
 tools/update-libcifpp-data
 data/components.cif*
 CMakeSettings.json
 msvc/
-Testing/
-rsrc/feature-request.txt
-test/test-create_sugar_?.cif
-test/oprofile_data/
-test/perf.data*
 src/revision.hpp
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -133,14 +133,19 @@ if(GXX_LIBSTDCPP)
 	if(STD_REGEX_RUNNING STREQUAL FAILED_TO_RUN)
 		message(STATUS "You are probably trying to compile using the g++ standard library which contains a crashing std::regex implementation. Will try to use boost::regex instead")
-		set(BOOST_REGEX_STANDALONE ON)
+		find_package(Boost COMPONENTS regex QUIET)
-		find_package(Boost 1.77 COMPONENTS regex QUIET)
 		if(Boost_FOUND)
-			set(BOOST_REGEX_INCLUDE ${Boost_INCLUDE_DIRS})
+			if(Boost_VERSION VERSION_GREATER_EQUAL 1.77)
+				set(BOOST_REGEX_STANDALONE ON)
+				set(BOOST_REGEX_INCLUDE ${Boost_INCLUDE_DIRS})
+			else()
+				list(APPEND CIFPP_REQUIRED_LIBRARIES Boost::regex)
+				set(BOOST_REGEX_SYSTEM ON)
+			endif()
 		else()
-			add_git_submodule(regex EXCLUDE_FROM_ALL)
+			add_git_submodule("https://github.com/boostorg/regex" regex EXCLUDE_FROM_ALL)
+			set(BOOST_REGEX_STANDALONE ON)
 			set(BOOST_REGEX_INCLUDE regex/include)
 		endif()
 	endif()
@@ -151,7 +156,6 @@ set(THREADS_PREFER_PTHREAD_FLAG)
 find_package(Threads)
 find_package(ZLIB REQUIRED)
-find_package(LibLZMA REQUIRED)
 include(FindFilesystem)
 list(APPEND CIFPP_REQUIRED_LIBRARIES ${STDCPPFS_LIBRARY})
@@ -159,14 +163,6 @@ list(APPEND CIFPP_REQUIRED_LIBRARIES ${STDCPPFS_LIBRARY})
 include(FindAtomic)
 list(APPEND CIFPP_REQUIRED_LIBRARIES ${STDCPPATOMIC_LIBRARY})
-if(NOT PDB_REDO_META)
-	find_package(gxrio QUIET)
-	if(NOT gxrio_FOUND)
-		add_git_submodule(gxrio EXCLUDE_FROM_ALL)
-	endif()
-endif()
 # Create a revision file, containing the current git version info
 include(VersionString)
 write_version_header(${PROJECT_SOURCE_DIR}/src/ "LibCIFPP")
@@ -250,7 +246,9 @@ add_library(cifpp::cifpp ALIAS cifpp)
 set_target_properties(cifpp PROPERTIES POSITION_INDEPENDENT_CODE ON)
 if(BOOST_REGEX_STANDALONE)
-	target_compile_definitions(cifpp PUBLIC USE_BOOST_REGEX=1 BOOST_REGEX_STANDALONE=1)
+	target_compile_definitions(cifpp PRIVATE USE_BOOST_REGEX=1 BOOST_REGEX_STANDALONE=1)
+elseif(BOOST_REGEX_SYSTEM)
+	target_compile_definitions(cifpp PRIVATE USE_BOOST_REGEX=1)
 endif()
 target_include_directories(cifpp
@@ -259,14 +257,7 @@ target_include_directories(cifpp
 	"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )
-target_link_libraries(cifpp PUBLIC
+target_link_libraries(cifpp PUBLIC Threads::Threads ZLIB::ZLIB ${CIFPP_REQUIRED_LIBRARIES})
-	Threads::Threads
-	ZLIB::ZLIB
-	LibLZMA::LibLZMA
-	${CIFPP_REQUIRED_LIBRARIES})
-get_target_property(GXRIO_INCLUDE_DIR gxrio::gxrio INTERFACE_INCLUDE_DIRECTORIES)
-target_include_directories(cifpp PRIVATE ${GXRIO_INCLUDE_DIR})
 if(BOOST_REGEX_STANDALONE)
 	target_include_directories(cifpp PRIVATE ${BOOST_REGEX_INCLUDE})
@@ -356,8 +347,14 @@ install(FILES
 	DESTINATION ${CIFPP_DATA_DIR}
 )
+if(BOOST_REGEX_STANDALONE)
+	set(CONFIG_TEMPLATE_FILE ${PROJECT_SOURCE_DIR}/cmake/cifppConfig.cmake.in)
+else()
+	set(CONFIG_TEMPLATE_FILE ${PROJECT_SOURCE_DIR}/cmake/cifppConfig-boost-regex.cmake.in)
+endif()
 configure_package_config_file(
-	${PROJECT_SOURCE_DIR}/cmake/cifppConfig.cmake.in
+	${CONFIG_TEMPLATE_FILE}
 	${CMAKE_CURRENT_BINARY_DIR}/cifpp/cifppConfig.cmake
 	INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cifpp
 	PATH_VARS INCLUDE_INSTALL_DIR LIBRARY_INSTALL_DIR SHARE_INSTALL_DIR
@@ -463,7 +460,7 @@ set(CPACK_SOURCE_TGZ ON)
 set(CPACK_SOURCE_TBZ2 OFF)
 set(CPACK_SOURCE_TXZ OFF)
 set(CPACK_SOURCE_TZ OFF)
-set(CPACK_SOURCE_IGNORE_FILES "/data/components.cif;/build;/.vscode;/.git;/test;/.pc;/tools/symop-map-generator;/regex/doc;/regex/example;/regex/meta;/regex/performance;/regex/test")
+set(CPACK_SOURCE_IGNORE_FILES "/data/components.cif;/build;/.vscode;/.git;/regex")
 set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME ${CPACK_PACKAGE_FILE_NAME})
 include(CPack)
--- a/cmake/AddGitSubmodule.cmake
+++ b/cmake/AddGitSubmodule.cmake
 cmake_minimum_required(VERSION 3.16..3.19)
-function(add_git_submodule dir)
+function(add_git_submodule repo dir)
 	# add a Git submodule directory to CMake, assuming the
 	# Git submodule directory is a CMake project.
 	#
@@ -11,9 +11,9 @@ function(add_git_submodule dir)
 	find_package(Git QUIET)
 	if(NOT EXISTS "${PROJECT_SOURCE_DIR}/${dir}/CMakeLists.txt")
-		if(NOT (GIT_FOUND AND IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.git"))
+		if(NOT(GIT_FOUND))
 			message(FATAL_ERROR "${CMAKE_CURRENT_SOURCE_DIR} is not a git repository and the submodule ${dir} is not complete. Cannot continue.")
-		else()
+		elseif(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.git") # We're in a git repo, we can use submodules
 			if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
 				execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive -- ${dir}
 					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
@@ -22,10 +22,19 @@ function(add_git_submodule dir)
 				execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive -- ${dir}
 					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
 			endif()
+		else()
+			if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
+				execute_process(COMMAND ${GIT_EXECUTABLE} clone "${repo}" --recursive -- ${dir}
+					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+					COMMAND_ERROR_IS_FATAL ANY)
+			else()
+				execute_process(COMMAND ${GIT_EXECUTABLE} clone "${repo}" --recursive -- ${dir}
+					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
+			endif()
 		endif()
 	endif()
 	set(ENABLE_TESTING OFF)
-	add_subdirectory(${dir} ${ARGV})
+	add_subdirectory(${dir} ${ARGV2})
 endfunction(add_git_submodule)
\ No newline at end of file
--- a/cmake/cifppConfig-boost-regex.cmake.in
+++ b/cmake/cifppConfig-boost-regex.cmake.in
+@PACKAGE_INIT@
+include(CMakeFindDependencyMacro)
+find_dependency(Threads)
+find_dependency(ZLIB REQUIRED)
+find_dependency(LibLZMA REQUIRED)
+find_dependency(Boost COMPONENTS regex)
+INCLUDE("${CMAKE_CURRENT_LIST_DIR}/cifppTargets.cmake")
+set_and_check(CIFPP_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set_and_check(CIFPP_LIBRARY_DIR "@PACKAGE_LIBRARY_INSTALL_DIR@")
+set_and_check(CIFPP_SHARE_DIR "@PACKAGE_SHARE_INSTALL_DIR@")
+check_required_components(cifpp)
--- a/gxrio @ a7bb5b5c
+++ b/gxrio @ a7bb5b5c
-Subproject commit a7bb5b5c4b6612215a78267b89e05c39a45429b5
--- a/include/cif++/gzio.hpp
+++ b/include/cif++/gzio.hpp
+//          Copyright Maarten L. Hekkelman, 2022
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+#pragma once
+#include <array>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <utility>
+#include <zlib.h>
+/// \file gzio.hpp
+///
+/// Single header file for the implementation of stream classes
+/// that can transparently read and write compressed files.
+///
+/// The gzio::istream_buf class sniffs the input and decides whether to use
+/// a decompressor if a signature was recognized.
+///
+/// There's also an ifstream and ofstream class here that can
+/// read and write compressed files. In this case the decission
+/// whether to use a compressions/decompression algorithm is
+/// based on the extension of the \a filename argument.
+// This is a stripped down version of the gzio library from
+// https://github.com/mhekkel/gzio.git
+// Most notably, the lzma support has been removed since getting
+// that to work in Windows proved to be too much work.
+namespace cif::gzio
+{
+const size_t kDefaultBufferSize = 256;
+// --------------------------------------------------------------------
+/// \brief A base class for the streambuf classes in gzio
+///
+/// \tparam CharT Type of the character stream.
+/// \tparam Traits Traits for character type, defaults to char_traits<_CharT>.
+///
+/// The base class for all streambuf classes in this library.
+/// It maintains the pointer to the upstream streambuf.
+template <typename CharT, typename Traits>
+class basic_streambuf : public std::basic_streambuf<CharT, Traits>
+{
+  public:
+	using char_type = CharT;
+	using traits_type = Traits;
+	using int_type = typename traits_type::int_type;
+	using pos_type = typename traits_type::pos_type;
+	using off_type = typename traits_type::off_type;
+	using streambuf_type = std::basic_streambuf<CharT, Traits>;
+	basic_streambuf() = default;
+	basic_streambuf(const basic_streambuf &) = delete;
+	basic_streambuf(basic_streambuf &&rhs)
+		: streambuf_type(std::move(rhs))
+	{
+		m_upstream = std::exchange(rhs.m_upstream, nullptr);
+	}
+	basic_streambuf &operator=(const basic_streambuf &) = delete;
+	basic_streambuf &operator=(basic_streambuf &&rhs)
+	{
+		m_upstream = std::exchange(rhs.m_upstream, nullptr);
+		return *this;
+	}
+	void set_upstream(streambuf_type *upstream)
+	{
+		m_upstream = upstream;
+	}
+	virtual basic_streambuf *init(streambuf_type *sb) = 0;
+	virtual basic_streambuf *close() = 0;
+  protected:
+	/// \brief The upstream streambuf object, usually this is a basic_filebuf
+	streambuf_type *m_upstream = nullptr;
+};
+// --------------------------------------------------------------------
+/// \brief A streambuf class that can be used to decompress gzipped data
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+/// \tparam BufferSize	The size of the internal buffers.
+///
+/// This implementation of streambuf can decompress (inflate) data compressed
+/// using zlib.
+template <typename CharT, typename Traits, size_t BufferSize = kDefaultBufferSize>
+class basic_igzip_streambuf : public basic_streambuf<CharT, Traits>
+{
+  public:
+	static_assert(sizeof(CharT) == 1, "Unfortunately, support for wide characters is not implemented yet.");
+	using char_type = CharT;
+	using traits_type = Traits;
+	using streambuf_type = std::basic_streambuf<char_type, traits_type>;
+	using base_type = basic_streambuf<CharT, Traits>;
+	using int_type = typename traits_type::int_type;
+	using pos_type = typename traits_type::pos_type;
+	using off_type = typename traits_type::off_type;
+	basic_igzip_streambuf() = default;
+	basic_igzip_streambuf(const basic_igzip_streambuf &) = delete;
+	/// \brief Move constructor
+	basic_igzip_streambuf(basic_igzip_streambuf &&rhs)
+		: base_type(std::move(rhs))
+	{
+		std::swap(m_zstream, rhs.m_zstream);
+		std::swap(m_gzheader, rhs.m_gzheader);
+		auto p = std::copy(rhs.gptr(), rhs.egptr(), m_out_buffer.begin());
+		this->setg(m_out_buffer.begin(), m_out_buffer.begin(), p);
+		if (m_zstream and m_zstream->avail_in > 0)
+		{
+			auto next_in_offset = m_zstream->next_in - rhs.m_in_buffer.data();
+			std::copy(rhs.m_in_buffer.begin() + next_in_offset,
+				rhs.m_in_buffer.begin() + next_in_offset + m_zstream->avail_in,
+				m_in_buffer.begin());
+			m_zstream->next_in = m_in_buffer.begin();
+		}
+	}
+	basic_igzip_streambuf &operator=(const basic_igzip_streambuf &) = delete;
+	/// \brief Move operator= implementation
+	basic_igzip_streambuf &operator=(basic_igzip_streambuf &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		std::swap(m_zstream, rhs.m_zstream);
+		std::swap(m_gzheader, rhs.m_gzheader);
+		auto p = std::copy(rhs.gptr(), rhs.egptr(), m_out_buffer.begin());
+		this->setg(m_out_buffer.begin(), m_out_buffer.begin(), p);
+		if (m_zstream and m_zstream->avail_in > 0)
+		{
+			auto next_in_offset = m_zstream->next_in - reinterpret_cast<unsigned char *>(rhs.m_in_buffer.data());
+			std::copy(rhs.m_in_buffer.begin() + next_in_offset,
+				rhs.m_in_buffer.begin() + next_in_offset + m_zstream->avail_in,
+				m_in_buffer.begin());
+			m_zstream->next_in = reinterpret_cast<unsigned char *>(m_in_buffer.begin());
+		}
+		return *this;
+	}
+	~basic_igzip_streambuf()
+	{
+		close();
+	}
+	/// \brief This closes the zlib stream and sets the get pointers to null.
+	base_type *close() override
+	{
+		if (m_zstream)
+		{
+			::inflateEnd(m_zstream.get());
+			m_zstream.reset(nullptr);
+			m_gzheader.reset(nullptr);
+		}
+		this->setg(nullptr, nullptr, nullptr);
+		return this;
+	}
+	/// \brief Initialize a zlib stream and set the upstream.
+	///
+	/// \param upstream The upstream streambuf
+	///
+	/// The zstream is constructed and an optional header is
+	/// read from upstream. The contents of the header are ignored
+	/// but we must maintain that structure.
+	base_type *init(streambuf_type *upstream) override
+	{
+		this->set_upstream(upstream);
+		close();
+		m_zstream.reset(new z_stream_s);
+		m_gzheader.reset(new gz_header_s);
+		auto &zstream = *m_zstream.get();
+		zstream = z_stream_s{};
+		auto &header = *m_gzheader.get();
+		header = gz_header_s{};
+		int err = ::inflateInit2(&zstream, 47);
+		if (err == Z_OK)
+		{
+			zstream.next_in = reinterpret_cast<unsigned char *>(m_in_buffer.data());
+			zstream.avail_in = this->m_upstream->sgetn(m_in_buffer.data(), m_in_buffer.size());
+			err = ::inflateGetHeader(&zstream, &header);
+			if (err != Z_OK)
+				::inflateEnd(&zstream);
+		}
+		if (err != Z_OK)
+			zstream = z_stream_s{};
+		return err == Z_OK ? this : nullptr;
+	}
+  private:
+	/// \brief The actual work is done here.
+	int_type underflow() override
+	{
+		if (m_zstream and this->m_upstream)
+		{
+			auto &zstream = *m_zstream.get();
+			const std::streamsize kBufferByteSize = m_out_buffer.size();
+			while (this->gptr() == this->egptr())
+			{
+				zstream.next_out = reinterpret_cast<unsigned char *>(m_out_buffer.data());
+				zstream.avail_out = kBufferByteSize;
+				if (zstream.avail_in == 0)
+				{
+					zstream.next_in = reinterpret_cast<unsigned char *>(m_in_buffer.data());
+					zstream.avail_in = this->m_upstream->sgetn(m_in_buffer.data(), m_in_buffer.size());
+				}
+				int err = ::inflate(&zstream, Z_SYNC_FLUSH);
+				std::streamsize n = kBufferByteSize - zstream.avail_out;
+				if (err == Z_STREAM_END or (err == Z_OK and n > 0))
+				{
+					this->setg(
+						m_out_buffer.begin(),
+						m_out_buffer.begin(),
+						m_out_buffer.begin() + n);
+					break;
+				}
+				if (err < Z_OK)
+					break;
+			}
+		}
+		return this->gptr() != this->egptr() ? traits_type::to_int_type(*this->gptr()) : traits_type::eof();
+	}
+  private:
+	/// \brief The zlib internal structures are mainained as pointers to avoid having
+	/// to copy their content in move constructors.
+	std::unique_ptr<z_stream_s> m_zstream;
+	/// \brief The zlib internal structures are mainained as pointers to avoid having
+	/// to copy their content in move constructors.
+	std::unique_ptr<gz_header> m_gzheader;
+	/// \brief Input buffer, this is the input for zlib
+	std::array<char_type, BufferSize> m_in_buffer;
+	/// \brief Output buffer, where the ostream finds the data
+	std::array<char_type, BufferSize> m_out_buffer;
+};
+// --------------------------------------------------------------------
+/// \brief A streambuf class that can be used to compress data using zlib
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+/// \tparam BufferSize	The size of the internal buffers.
+///
+/// This implementation of streambuf can compress (deflate) data using zlib.
+template <typename CharT, typename Traits, size_t BufferSize = kDefaultBufferSize>
+class basic_ogzip_streambuf : public basic_streambuf<CharT, Traits>
+{
+  public:
+	static_assert(sizeof(CharT) == 1, "Unfortunately, support for wide characters is not implemented yet.");
+	using char_type = CharT;
+	using traits_type = Traits;
+	using streambuf_type = std::basic_streambuf<char_type, traits_type>;
+	using base_type = basic_streambuf<CharT, Traits>;
+	using int_type = typename traits_type::int_type;
+	using pos_type = typename traits_type::pos_type;
+	using off_type = typename traits_type::off_type;
+	basic_ogzip_streambuf() = default;
+	basic_ogzip_streambuf(const basic_ogzip_streambuf &) = delete;
+	/// \brief Move constructor
+	basic_ogzip_streambuf(basic_ogzip_streambuf &&rhs)
+		: base_type(std::move(rhs))
+	{
+		std::swap(m_zstream, rhs.m_zstream);
+		std::swap(m_gzheader, rhs.m_gzheader);
+		this->setp(m_in_buffer.begin(), m_in_buffer.end());
+		this->sputn(rhs.pbase(), rhs.pptr() - rhs.pbase());
+		rhs.setp(nullptr, nullptr);
+	}
+	basic_ogzip_streambuf &operator=(const basic_ogzip_streambuf &) = delete;
+	/// \brief Move operator=
+	basic_ogzip_streambuf &operator=(basic_ogzip_streambuf &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		std::swap(m_zstream, rhs.m_zstream);
+		std::swap(m_gzheader, rhs.m_gzheader);
+		this->setp(m_in_buffer.begin(), m_in_buffer.end());
+		this->sputn(rhs.pbase(), rhs.pptr() - rhs.pbase());
+		rhs.setp(nullptr, nullptr);
+		return *this;
+	}
+	~basic_ogzip_streambuf()
+	{
+		close();
+	}
+	/// \brief This closes the zlib stream and sets the put pointers to null.
+	base_type *close() override
+	{
+		if (m_zstream)
+		{
+			overflow(traits_type::eof());
+			::deflateEnd(m_zstream.get());
+			m_zstream.reset(nullptr);
+			m_gzheader.reset(nullptr);
+		}
+		this->setp(nullptr, nullptr);
+		return this;
+	}
+	/// \brief Initialize the internal zlib structures
+	///
+	/// \param upstream The upstream streambuf
+	///
+	/// The zlib stream is initialized as one that can accept
+	/// a gzip header.
+	base_type *init(streambuf_type *upstream) override
+	{
+		this->set_upstream(upstream);
+		close();
+		m_zstream.reset(new z_stream_s);
+		m_gzheader.reset(new gz_header_s);
+		auto &zstream = *m_zstream.get();
+		zstream = z_stream_s{};
+		auto &header = *m_gzheader.get();
+		header = gz_header_s{};
+		const int WINDOW_BITS = 15, GZIP_ENCODING = 16;
+		int err = deflateInit2(&zstream, Z_BEST_COMPRESSION, Z_DEFLATED,
+			WINDOW_BITS | GZIP_ENCODING, Z_DEFLATED, Z_DEFAULT_STRATEGY);
+		if (err == Z_OK)
+			err = ::deflateSetHeader(&zstream, &header);
+		if (err == Z_OK)
+			this->setp(this->m_in_buffer.begin(), this->m_in_buffer.end());
+		else
+			zstream = z_stream_s{};
+		return err == Z_OK ? this : nullptr;
+	}
+  private:
+	/// \brief The actual work is done here
+	///
+	/// \param ch The character that did not fit, in case it is eof we need to flush
+	///
+	int_type overflow(int_type ch) override
+	{
+		if (not m_zstream)
+			return traits_type::eof();
+		auto &zstream = *m_zstream;
+		zstream.next_in = reinterpret_cast<unsigned char *>(this->pbase());
+		zstream.avail_in = this->pptr() - this->pbase();
+		char_type buffer[BufferSize];
+		for (;;)
+		{
+			zstream.next_out = reinterpret_cast<unsigned char *>(buffer);
+			zstream.avail_out = sizeof(buffer);
+			int err = ::deflate(&zstream, ch == traits_type::eof() ? Z_FINISH : Z_NO_FLUSH);
+			std::streamsize n = sizeof(buffer) - zstream.avail_out;
+			if (n > 0)
+			{
+				auto r = this->m_upstream->sputn(reinterpret_cast<char_type *>(buffer), n);
+				if (r != n)
+					return traits_type::eof();
+			}
+			if (zstream.avail_out == 0)
+				continue;
+			if (err == Z_OK and ch == traits_type::eof())
+				continue;
+			break;
+		}
+		this->setp(this->m_in_buffer.begin(), this->m_in_buffer.end());
+		if (not traits_type::eq_int_type(ch, traits_type::eof()))
+		{
+			*this->pptr() = traits_type::to_char_type(ch);
+			this->pbump(1);
+		}
+		return ch;
+	}
+  private:
+	/// \brief The zlib internal structures are mainained as pointers to avoid having
+	/// to copy their content in move constructors.
+	std::unique_ptr<z_stream_s> m_zstream;
+	/// \brief The zlib internal structures are mainained as pointers to avoid having
+	/// to copy their content in move constructors.
+	std::unique_ptr<gz_header> m_gzheader;
+	/// \brief Input buffer, this is the input for zlib
+	std::array<char_type, BufferSize> m_in_buffer;
+};
+// --------------------------------------------------------------------
+/// \brief An istream implementation that wraps a streambuf with a decompressing streambuf
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+///
+/// This is an istream implementation that can take a source streambuf and then wraps
+/// this streambuf with a decompressing streambuf class defined above.
+/// The class inherits from std::basic_istream and offers all the associated functionality.
+template <typename CharT, typename Traits>
+class basic_istream : public std::basic_istream<CharT, Traits>
+{
+  public:
+	using base_type = std::basic_istream<CharT, Traits>;
+	using traits_type = Traits;
+	using char_type = typename traits_type::char_type;
+	using int_type = typename traits_type::int_type;
+	using z_streambuf_type = basic_streambuf<char_type, traits_type>;
+	using upstreambuf_type = std::basic_streambuf<char_type, traits_type>;
+	using gzip_streambuf_type = basic_igzip_streambuf<char_type, traits_type>;
+	/// \brief Regular move constructor
+	basic_istream(basic_istream &&rhs)
+		: base_type(std::move(rhs))
+	{
+		m_gziobuf = std::move(rhs.m_gziobuf);
+		if (m_gziobuf)
+			this->rdbuf(m_gziobuf.get());
+		else
+			this->rdbuf(nullptr);
+	}
+	/// \brief Regular move operator=
+	basic_istream &operator=(basic_istream &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		m_gziobuf = std::move(rhs.m_gziobuf);
+		if (m_gziobuf)
+			this->rdbuf(m_gziobuf.get());
+		else
+			this->rdbuf(nullptr);
+		return *this;
+	}
+	/// \brief Construct an istream with the passed in streambuf \a buf
+	///
+	/// \param buf The streambuf that provides the compressed data
+	///
+	/// This constructor will initialize the zlib code with the \a buf streambuf.
+	explicit basic_istream(upstreambuf_type *buf)
+		: base_type(nullptr)
+	{
+		init_z(buf);
+	}
+  protected:
+	basic_istream()
+		: base_type(nullptr) {}
+	/// \brief Initialise internals with streambuf \a sb
+	/// \param sb The upstream streambuf class
+	///
+	/// This will sniff the content in \a sb and decide upon what is found
+	/// what implementation is used. If it doesn't look like compressed data
+	/// the \a sb streambuf is used without any decompression being done.
+	void init_z(upstreambuf_type *sb)
+	{
+		int_type ch = sb->sgetc();
+		if (ch == 0x1f)
+		{
+			sb->sbumpc();
+			ch = sb->sgetc();
+			sb->sungetc();
+			if (ch == 0x8b) // Read gzip header
+				m_gziobuf.reset(new gzip_streambuf_type);
+		}
+		if (m_gziobuf)
+		{
+			if (not m_gziobuf->init(sb))
+				this->setstate(std::ios_base::failbit);
+			else
+				this->init(m_gziobuf.get());
+		}
+		else
+			this->init(sb);
+	}
+  protected:
+	/// \brief Our streambuf class
+	std::unique_ptr<z_streambuf_type> m_gziobuf;
+};
+// --------------------------------------------------------------------
+/// \brief Control input from files compressed with gzip.
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+///
+/// This is an ifstream implementation that can read from named files compressed with
+/// gzip directly. The class inherits from std::basic_istream and offers all the
+/// associated functionality.
+template <typename CharT, typename Traits>
+class basic_ifstream : public basic_istream<CharT, Traits>
+{
+  public:
+	using base_type = basic_istream<CharT, Traits>;
+	using char_type = CharT;
+	using traits_type = Traits;
+	using filebuf_type = std::basic_filebuf<char_type, traits_type>;
+	using gzip_streambuf_type = typename base_type::gzip_streambuf_type;
+	/// \brief Default constructor, does not open a file since none is specified
+	basic_ifstream() = default;
+	~basic_ifstream()
+	{
+		close();
+	}
+	/// \brief Construct an ifstream
+	/// \param filename Null terminated string specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ifstream(const char *filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		open(filename, mode);
+	}
+	/// \brief Construct an ifstream
+	/// \param filename std::string specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ifstream(const std::string &filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		open(filename, mode);
+	}
+	/// \brief Construct an ifstream
+	/// \param filename std::filesystem::path specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ifstream(const std::filesystem::path &filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		open(filename, mode);
+	}
+	/// \brief Move constructor
+	basic_ifstream(basic_ifstream &&rhs)
+		: base_type(std::move(rhs))
+	{
+		m_filebuf = std::move(rhs.m_filebuf);
+		if (this->m_gziobuf)
+			this->m_gziobuf->set_upstream(&m_filebuf);
+		else
+			this->rdbuf(&m_filebuf);
+	}
+	basic_ifstream(const basic_ifstream &) = delete;
+	basic_ifstream &operator=(const basic_ifstream &) = delete;
+	/// \brief Move version of operator=
+	basic_ifstream &operator=(basic_ifstream &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		m_filebuf = std::move(rhs.m_filebuf);
+		if (this->m_gziobuf)
+			this->m_gziobuf->set_upstream(&m_filebuf);
+		else
+			this->rdbuf(&m_filebuf);
+		return *this;
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename std::filesystem::path specifying the file to open
+	/// \param mode The mode in which to open the file
+	void open(const std::filesystem::path &filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		if (not m_filebuf.open(filename, mode | std::ios::binary))
+			this->setstate(std::ios_base::failbit);
+		else
+		{
+			if (filename.extension() == ".gz")
+				this->m_gziobuf.reset(new gzip_streambuf_type);
+			if (not this->m_gziobuf)
+			{
+				this->rdbuf(&m_filebuf);
+				this->clear();
+			}
+			else if (not this->m_gziobuf->init(&m_filebuf))
+				this->setstate(std::ios_base::failbit);
+			else
+			{
+				this->rdbuf(this->m_gziobuf.get());
+				this->clear();
+			}
+		}
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename std::string specifying the file to open
+	/// \param mode The mode in which to open the file
+	void open(const std::string &filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		open(std::filesystem::path{filename}, mode);
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename Null terminated string specifying the file to open
+	/// \param mode The mode in which to open the file
+	void open(const char *filename, std::ios_base::openmode mode = std::ios_base::in)
+	{
+		open(std::filesystem::path{filename}, mode);
+	}
+	/// \brief Return true if the file is open
+	/// \return m_filebuf.is_open()
+	bool is_open() const
+	{
+		return m_filebuf.is_open();
+	}
+	/// \brief Close the file
+	///
+	/// Calls m_filebuf.close(). If that fails, the failbit is set.
+	void close()
+	{
+		if (this->m_gziobuf and not this->m_gziobuf->close())
+			this->setstate(std::ios_base::failbit);
+		if (not m_filebuf.close())
+			this->setstate(std::ios_base::failbit);
+	}
+	/// \brief Swap the contents with those of \a rhs
+	/// \param rhs The ifstream to swap with
+	void swap(basic_ifstream &rhs)
+	{
+		base_type::swap(rhs);
+		m_filebuf.swap(rhs.m_filebuf);
+		if (this->m_gziobuf)
+		{
+			this->m_gziobuf.set_upstream(&m_filebuf);
+			this->rdbuf(this->m_gziobuf.get());
+		}
+		else
+			this->rdbuf(&m_filebuf);
+		if (rhs.m_gziobuf)
+		{
+			rhs.m_gziobuf.set_upstream(&rhs.m_filebuf);
+			rhs.rdbuf(rhs.m_gziobuf.get());
+		}
+		else
+			rhs.rdbuf(&rhs.m_filebuf);
+	}
+  private:
+	/// \brief The filebuf
+	filebuf_type m_filebuf;
+};
+// --------------------------------------------------------------------
+/// \brief An ostream implementation that wraps a streambuf with a compressing streambuf
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+///
+/// This is an ostream implementation that can take an upstream streambuf and then wraps
+/// this streambuf with a compressing streambuf class defined above.
+/// The class inherits from std::basic_ostream and offers all the associated functionality.
+template <typename CharT, typename Traits>
+class basic_ostream : public std::basic_ostream<CharT, Traits>
+{
+  public:
+	using base_type = std::basic_ostream<CharT, Traits>;
+	using char_type = CharT;
+	using traits_type = Traits;
+	using z_streambuf_type = basic_streambuf<char_type, traits_type>;
+	using upstreambuf_type = std::basic_streambuf<char_type, traits_type>;
+	/// \brief Regular move constructor
+	basic_ostream(basic_ostream &&rhs)
+		: base_type(std::move(rhs))
+	{
+		m_gziobuf = std::move(rhs.m_gziobuf);
+		this->rdbuf(m_gziobuf.get());
+	}
+	/// \brief Regular move operator=
+	basic_ostream &operator=(basic_ostream &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		m_gziobuf = std::move(rhs.m_gziobuf);
+		this->rdbuf(m_gziobuf.get());
+		return *this;
+	}
+	// One might expect a constructor taking a streambuf pointer
+	// as the regular std::ostream class does. However, that's not
+	// going to work since no information is known at this time
+	// what compression to use.
+	//
+	// explicit basic_ostream(upstreambuf_type *buf)
+	// {
+	// 	init_z(buf);
+	// 	this->init(m_gziobuf.get());
+	// }
+  protected:
+	basic_ostream()
+		: base_type(nullptr) {}
+	/// \brief Initialise internals with streambuf \a sb
+	void init_z(std::streambuf *sb)
+	{
+		if (not m_gziobuf->init(sb))
+			this->setstate(std::ios_base::failbit);
+	}
+  protected:
+	/// \brief Our streambuf class
+	std::unique_ptr<z_streambuf_type> m_gziobuf;
+};
+// --------------------------------------------------------------------
+/// \brief Control output to files compressing the contents with gzip.
+///
+/// \tparam CharT		Type of the character stream.
+/// \tparam Traits		Traits for character type, defaults to char_traits<_CharT>.
+///
+/// This is an ofstream implementation that can writeto named files compressing the content
+/// with gzip directly. The class inherits from std::basic_ostream and offers all the
+/// associated functionality.
+template <typename CharT, typename Traits>
+class basic_ofstream : public basic_ostream<CharT, Traits>
+{
+  public:
+	using base_type = basic_ostream<CharT, Traits>;
+	using char_type = CharT;
+	using traits_type = Traits;
+	using filebuf_type = std::basic_filebuf<char_type, traits_type>;
+	using gzip_streambuf_type = basic_ogzip_streambuf<char_type, traits_type>;
+	basic_ofstream() = default;
+	~basic_ofstream()
+	{
+		close();
+	}
+	/// \brief Construct an ofstream
+	/// \param filename Null terminated string specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ofstream(const char *filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		open(filename, mode);
+	}
+	/// \brief Construct an ofstream
+	/// \param filename std::string specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ofstream(const std::string &filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		open(filename, mode);
+	}
+	/// \brief Construct an ofstream
+	/// \param filename std::filesystem::path specifying the file to open
+	/// \param mode The mode in which to open the file
+	explicit basic_ofstream(const std::filesystem::path &filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		open(filename, mode);
+	}
+	/// \brief Move constructor
+	basic_ofstream(basic_ofstream &&rhs)
+		: base_type(std::move(rhs))
+	{
+		m_filebuf = std::move(rhs.m_filebuf);
+		if (this->m_gziobuf)
+			this->m_gziobuf->set_upstream(&m_filebuf);
+		else
+			this->rdbuf(&m_filebuf);
+	}
+	basic_ofstream(const basic_ofstream &) = delete;
+	basic_ofstream &operator=(const basic_ofstream &) = delete;
+	/// \brief Move operator=
+	basic_ofstream &operator=(basic_ofstream &&rhs)
+	{
+		base_type::operator=(std::move(rhs));
+		m_filebuf = std::move(rhs.m_filebuf);
+		if (this->m_gziobuf)
+			this->m_gziobuf->set_upstream(&m_filebuf);
+		else
+			this->rdbuf(&m_filebuf);
+		return *this;
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename std::filesystem::path specifying the file to open
+	/// \param mode The mode in which to open the file
+	///
+	/// A compression algorithm is chosen upon the contents of the
+	/// extension() of \a filename with .gz mapping to gzip compression
+	/// and .xz to xz compression.
+	void open(const std::filesystem::path &filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		if (not m_filebuf.open(filename, mode | std::ios::binary))
+			this->setstate(std::ios_base::failbit);
+		else
+		{
+			if (filename.extension() == ".gz")
+				this->m_gziobuf.reset(new gzip_streambuf_type);
+			else
+				this->m_gziobuf.reset(nullptr);
+			if (this->m_gziobuf)
+			{
+				if (not this->m_gziobuf->init(&m_filebuf))
+					this->setstate(std::ios_base::failbit);
+				else
+				{
+					this->rdbuf(this->m_gziobuf.get());
+					this->clear();
+				}
+			}
+			else
+			{
+				this->rdbuf(&m_filebuf);
+				this->clear();
+			}
+		}
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename std::string specifying the file to open
+	/// \param mode The mode in which to open the file
+	///
+	/// A compression algorithm is chosen upon the contents of the
+	/// extension of \a filename with .gz mapping to gzip compression
+	/// and .xz to xz compression.
+	void open(const std::string &filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		open(std::filesystem::path{filename}, mode);
+	}
+	/// \brief Open the file \a filename with mode \a mode
+	/// \param filename Null terminated string specifying the file to open
+	/// \param mode The mode in which to open the file
+	///
+	/// A compression algorithm is chosen upon the contents of the
+	/// extension of \a filename with .gz mapping to gzip compression
+	/// and .xz to xz compression.
+	void open(const char *filename, std::ios_base::openmode mode = std::ios_base::out)
+	{
+		open(std::filesystem::path{filename}, mode);
+	}
+	/// \brief Return true if the file is open
+	/// \return m_filebuf.is_open()
+	bool is_open() const
+	{
+		return m_filebuf.is_open();
+	}
+	/// \brief Close the file
+	///
+	/// Calls m_filebuf.close(). If that fails, the failbit is set.
+	void close()
+	{
+		if (this->m_gziobuf and not this->m_gziobuf->close())
+			this->setstate(std::ios_base::failbit);
+		if (not m_filebuf.close())
+			this->setstate(std::ios_base::failbit);
+	}
+	/// \brief Swap the contents with those of \a rhs
+	/// \param rhs The ifstream to swap with
+	void swap(basic_ofstream &rhs)
+	{
+		base_type::swap(rhs);
+		m_filebuf.swap(rhs.m_filebuf);
+		if (this->m_gziobuf)
+		{
+			this->m_gziobuf.set_upstream(&m_filebuf);
+			this->rdbuf(this->m_gziobuf.get());
+		}
+		else
+			this->rdbuf(&m_filebuf);
+		if (rhs.m_gziobuf)
+		{
+			rhs.m_gziobuf.set_upstream(&rhs.m_filebuf);
+			rhs.rdbuf(rhs.m_gziobuf.get());
+		}
+		else
+			rhs.rdbuf(&rhs.m_filebuf);
+	}
+  private:
+	/// \brief The filebuf
+	filebuf_type m_filebuf;
+};
+// --------------------------------------------------------------------
+/// \brief Convenience typedefs
+using istream = basic_istream<char, std::char_traits<char>>;
+using ifstream = basic_ifstream<char, std::char_traits<char>>;
+// using ostream = basic_ostream<char, std::char_traits<char>>;
+using ofstream = basic_ofstream<char, std::char_traits<char>>;
+} // namespace gzio
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -24,9 +24,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#include <gxrio.hpp>
 #include <cif++/file.hpp>
+#include <cif++/gzio.hpp>
 namespace cif
 {
@@ -185,7 +184,7 @@ void file::load(const std::filesystem::path &p)
 {
 	try
 	{
-		gxrio::ifstream in(p);
+		gzio::ifstream in(p);
 		if (not in.is_open())
 			throw std::runtime_error("Could not open file " + p.string());
@@ -213,7 +212,7 @@ void file::load(std::istream &is)
 void file::save(const std::filesystem::path &p) const
 {
-	gxrio::ofstream outFile(p);
+	gzio::ofstream outFile(p);
 	save(outFile);
 }

--- a/src/model.cpp
+++ b/src/model.cpp
@@ -31,8 +31,6 @@
 #include <iomanip>
 #include <numeric>
-#include <gxrio.hpp>
 namespace fs = std::filesystem;
 extern int VERBOSE;
@@ -1193,42 +1191,6 @@ float branch::weight() const
 		return sum; });
 }
-// // --------------------------------------------------------------------
-// // File
-// void File::load(const std::filesystem::path &path)
-// {
-// 	gxrio::ifstream in(path);
-// 	auto ext = path.extension().string();
-// 	if (ext == ".gz" or ext = ".xz")
-// 		ext = path.stem().extension().string();
-// 	if (ext == ".pdb" or ext == ".ent")
-// 		ReadPDBFile(in, *this);
-// 	else
-// 		file::load(in);
-// 	// validate, otherwise lots of functionality won't work
-// 	loadDictionary("mmcif_pdbx");
-// 	if (not isValid() and VERBOSE >= 0)
-// 		std::cerr << "Invalid mmCIF file" << (VERBOSE > 0 ? "." : " use --verbose option to see errors") << std::endl;
-// }
-// void File::save(const std::filesystem::path &path)
-// {
-// 	gxrio::ostream outFile(path);
-// 	auto ext = path.extension().string();
-// 	if (ext == ".gz" or ext = ".xz")
-// 		ext = path.stem().extension().string();
-// 	if (ext == ".pdb" or ext == ".ent")
-// 		WritePDBFile(outFile, data());
-// 	else
-// 		file::save(outFile);
-// }
 // --------------------------------------------------------------------
 //	structure

--- a/src/pdb/cif2pdb.cpp
+++ b/src/pdb/cif2pdb.cpp
@@ -30,9 +30,9 @@
 #include <regex>
 #include <set>
-#include <gxrio.hpp>
 #include <cif++.hpp>
 #include <cif++/pdb/cif2pdb.hpp>
+#include <cif++/gzio.hpp>
 namespace cif::pdb
 {
@@ -3731,7 +3731,7 @@ void write(std::ostream &os, const datablock &db)
 void write(const std::filesystem::path &p, const datablock &db)
 {
-	gxrio::ofstream out(p);
+	gzio::ofstream out(p);
 	bool writePDB = false;
 	if (p.extension() == ".gz")

--- a/src/pdb/pdb2cif.cpp
+++ b/src/pdb/pdb2cif.cpp
@@ -30,10 +30,10 @@
 #include <stack>
 #include <cif++.hpp>
-#include <gxrio.hpp>
 #include <cif++/pdb/pdb2cif.hpp>
 #include <cif++/pdb/pdb2cif_remark_3.hpp>
+#include <cif++/gzio.hpp>
 using cif::category;
 using cif::datablock;
@@ -6225,7 +6225,7 @@ file read(const std::filesystem::path &file)
 {
 	try
 	{
-		gxrio::ifstream in(file);
+		gzio::ifstream in(file);
 		if (not in.is_open())
 			throw std::runtime_error("Could not open file " + file.string() + " for input");

--- a/src/validate.cpp
+++ b/src/validate.cpp
@@ -41,12 +41,11 @@ using boost::regex;
 using std::regex;
 #endif
-#include <gxrio.hpp>
 #include <cif++/dictionary_parser.hpp>
 #include <cif++/validate.hpp>
 #include <cif++/utilities.hpp>
+#include <cif++/gzio.hpp>
 namespace cif
 {
@@ -472,7 +471,7 @@ const validator &validator_factory::operator[](std::string_view dictionary_name)
 		if (std::filesystem::exists(p, ec) and not ec)
 		{
-			gxrio::ifstream in(p);
+			gzio::ifstream in(p);
 			if (not in.is_open())
 				throw std::runtime_error("Could not open dictionary (" + p.string() + ")");