WIP: Add C++ bindings

10 files changed, 3244 insertions, 9 deletions

diff --git a/.clang-tidy b/.clang-tidy
index 6c239a72..e453ebbf 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,19 +1,41 @@
 Checks: >
   *,
+  -*-deprecated-headers,
   -*-magic-numbers,
+  -*-non-private-member-variables-in-classes,
   -*-uppercase-literal-suffix,
   -android-cloexec-fopen,
   -bugprone-branch-clone,
   -bugprone-suspicious-string-compare,
+  -cert-dcl50-cpp,
   -clang-analyzer-alpha.*,
   -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
   -clang-analyzer-valist.Uninitialized,
+  -clang-diagnostic-*,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -fuchsia-default-argument*,
+  -fuchsia-multiple-inheritance,
+  -fuchsia-overloaded-operator,
+  -google-explicit-constructor,
   -google-readability-todo,
+  -google-runtime-references,
+  -hicpp-explicit-conversions,
   -hicpp-multiway-paths-covered,
+  -hicpp-no-array-decay,
   -hicpp-signed-bitwise,
+  -hicpp-vararg,
   -llvm-header-guard,
+  -modernize-use-nullptr,
+  -modernize-use-trailing-return-type,
+  -modernize-use-using,
+  -performance-unnecessary-value-param,
   -readability-else-after-return,
   -readability-implicit-bool-conversion,
+  -readability-named-parameter,
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*'
 FormatStyle: file
diff --git a/doc/reference.doxygen.in b/doc/reference.doxygen.in
index a30e5b8a..28c2f8e0 100644
--- a/doc/reference.doxygen.in
+++ b/doc/reference.doxygen.in
@@ -521,7 +521,7 @@ CASE_SENSE_NAMES       = YES
 # scope will be hidden.
 # The default value is: NO.
 
-HIDE_SCOPE_NAMES       = NO
+HIDE_SCOPE_NAMES       = YES
 
 # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
 # append additional text to a page's title, such as Class Reference. If set to
@@ -670,7 +670,7 @@ SHOW_FILES             = NO
 # Folder Tree View (if specified).
 # The default value is: YES.
 
-SHOW_NAMESPACES        = NO
+SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
@@ -782,6 +782,7 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = @SERD_SRCDIR@/serd/serd.h \
+                         @SERD_SRCDIR@/serd/serd.hpp \
                          @SERD_SRCDIR@/doc/mainpage.md
 
 # This tag can be used to specify the character encoding of the source files
@@ -807,7 +808,7 @@ INPUT_ENCODING         = UTF-8
 # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
 # *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
 
-FILE_PATTERNS          =
+FILE_PATTERNS          = *.h *.hpp
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -849,7 +850,7 @@ EXCLUDE_PATTERNS       =
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
-EXCLUDE_SYMBOLS        =
+EXCLUDE_SYMBOLS        = detail
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include
@@ -1143,7 +1144,7 @@ HTML_EXTRA_FILES       =
 # Minimum value: 0, maximum value: 359, default value: 220.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_HUE    = 160
+HTML_COLORSTYLE_HUE    = 120
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
 # in the HTML output. For a value of 0 the output will use grayscales only. A
@@ -1151,7 +1152,7 @@ HTML_COLORSTYLE_HUE    = 160
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_SAT    = 32
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
 # luminance component of the colors in the HTML output. Values below 100
diff --git a/serd/detail/Copyable.hpp b/serd/detail/Copyable.hpp
new file mode 100644
index 00000000..df5305d4
--- /dev/null
+++ b/serd/detail/Copyable.hpp
@@ -0,0 +1,150 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_DETAIL_COPYABLE_HPP
+#define SERD_DETAIL_COPYABLE_HPP
+
+#include "serd/detail/Wrapper.hpp"
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+
+namespace serd {
+namespace detail {
+
+/// Copy function for a C object
+template <class T>
+using CopyFunc = T* (*)(const T*);
+
+template <class T, Mutable<T>* Copy(const T*)>
+typename std::enable_if<std::is_const<T>::value, T>::type*
+copy(const T* ptr)
+{
+	return ptr; // Making a view (const reference), do not copy
+}
+
+template <class T, Mutable<T>* Copy(const T*)>
+typename std::enable_if<!std::is_const<T>::value, T>::type*
+copy(const T* ptr)
+{
+	return Copy(ptr); // Making a mutable wrapper, copy
+}
+
+template <class T,
+          Mutable<T>* Copy(const T*),
+          bool        Equals(const T*, const T*),
+          void        Free(Mutable<T>*)>
+class BasicCopyable : public Wrapper<T, BasicDeleter<T, Free>>
+{
+public:
+	using Deleter = BasicDeleter<T, Free>;
+	using Base    = Wrapper<T, Deleter>;
+
+	explicit BasicCopyable(T* ptr) : Base{ptr} {}
+
+	BasicCopyable(const BasicCopyable& wrapper)
+	    : Base(copy<T, Copy>(wrapper.cobj()))
+	{
+	}
+
+	template <class U, void UFree(Mutable<U>*)>
+	explicit BasicCopyable(const BasicCopyable<U, Copy, Equals, UFree>& wrapper)
+	    : Base(copy<T, Copy>(wrapper.cobj()))
+	{
+	}
+
+	BasicCopyable(BasicCopyable&&) noexcept = default;
+	~BasicCopyable() noexcept               = default;
+
+	BasicCopyable& operator=(BasicCopyable&&) noexcept = default;
+
+	BasicCopyable& operator=(const BasicCopyable& wrapper)
+	{
+		if (&wrapper != this) {
+			this->_ptr =
+			    std::unique_ptr<T, Deleter>(copy<T, Copy>(wrapper.cobj()));
+		}
+		return *this;
+	}
+
+	template <class U>
+	bool operator==(const BasicCopyable<U, Copy, Equals, Free>& wrapper) const
+	{
+		return Equals(this->cobj(), wrapper.cobj());
+	}
+
+	template <class U>
+	bool operator!=(const BasicCopyable<U, Copy, Equals, Free>& wrapper) const
+	{
+		return !operator==(wrapper);
+	}
+};
+
+/// Generic C++ wrapper for a copyable C object
+template <class T,
+          Mutable<T>* Copy(const T*),
+          bool        Equals(const T*, const T*),
+          void        Free(Mutable<T>*)>
+class DynamicCopyable : public Wrapper<T, DynamicDeleter<T, Free>>
+{
+public:
+	using Deleter = DynamicDeleter<T, Free>;
+	using Base    = Wrapper<T, Deleter>;
+	using UPtr    = typename Base::UPtr;
+
+	explicit DynamicCopyable(UPtr ptr) : Base(std::move(ptr)) {}
+
+	DynamicCopyable(const DynamicCopyable& wrapper)
+	    : Base(Copy(wrapper.cobj()), Ownership::owned)
+	{
+	}
+
+	DynamicCopyable(DynamicCopyable&&) noexcept = default;
+	DynamicCopyable& operator=(DynamicCopyable&&) noexcept = default;
+
+	~DynamicCopyable() noexcept = default;
+
+	DynamicCopyable& operator=(const DynamicCopyable& wrapper)
+	{
+		if (&wrapper != this) {
+			this->_ptr = std::unique_ptr<T, Deleter>(Copy(wrapper.cobj()),
+			                                         Ownership::owned);
+		}
+
+		return *this;
+	}
+
+	template <class U>
+	bool operator==(const DynamicCopyable<U, Copy, Equals, Free>& wrapper) const
+	{
+		return Equals(this->cobj(), wrapper.cobj());
+	}
+
+	template <class U>
+	bool operator!=(const DynamicCopyable<U, Copy, Equals, Free>& wrapper) const
+	{
+		return !operator==(wrapper);
+	}
+
+protected:
+	explicit DynamicCopyable(std::nullptr_t) : Base(nullptr) {}
+};
+
+} // namespace detail
+} // namespace serd
+
+#endif // SERD_DETAIL_COPYABLE_HPP
diff --git a/serd/detail/Flags.hpp b/serd/detail/Flags.hpp
new file mode 100644
index 00000000..637b3aec
--- /dev/null
+++ b/serd/detail/Flags.hpp
@@ -0,0 +1,76 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_DETAIL_FLAGS_HPP
+#define SERD_DETAIL_FLAGS_HPP
+
+#include <type_traits>
+
+namespace serd {
+namespace detail {
+
+/**
+   Type-safe bit flags
+
+  This is a minimal interface for a type-safe bit flags field, which only
+  allows values from the given enum to be set.
+
+  @tparam Flag Enum class of flag values.
+*/
+template <typename Flag>
+class Flags
+{
+public:
+	static_assert(std::is_enum<Flag>::value, "");
+
+	using FlagUnderlyingType = typename std::underlying_type<Flag>::type;
+	using Value = typename std::make_unsigned<FlagUnderlyingType>::type;
+
+	constexpr Flags() noexcept : _value(0) {}
+	constexpr explicit Flags(const Value value) noexcept : _value{value} {}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	constexpr Flags(const Flag f) noexcept
+	    : _value(static_cast<Value>(f))
+	{
+	}
+
+	constexpr Flags operator|(const Flag rhs) const noexcept
+	{
+		return Flags{_value | static_cast<Value>(rhs)};
+	}
+
+	constexpr Flags operator|(const Flags rhs) const noexcept
+	{
+		return Flags{_value | rhs._value};
+	}
+
+	constexpr bool operator==(const Flag rhs) const noexcept
+	{
+		return _value == static_cast<Value>(rhs);
+	}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	constexpr operator Value() const noexcept { return _value; }
+
+private:
+	Value _value{};
+};
+
+} // namespace detail
+} // namespace serd
+
+#endif // SERD_DETAIL_FLAGS_HPP
diff --git a/serd/detail/Optional.hpp b/serd/detail/Optional.hpp
new file mode 100644
index 00000000..24a5acce
--- /dev/null
+++ b/serd/detail/Optional.hpp
@@ -0,0 +1,127 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_DETAIL_OPTIONAL_HPP
+#define SERD_DETAIL_OPTIONAL_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <utility>
+
+namespace serd {
+namespace detail {
+
+struct ConstructNullOptional
+{
+};
+
+/**
+   A simple optional wrapper around a wrapped type with a pointer-like API
+
+   This works like a typical optional type, but only works with Wrapper types,
+   and exploits the fact that these are interally just pointers to avoid adding
+   space overhead for an "is_set" flag, like a generic optional class would.
+
+   Types must explicitly opt-in to being optional by providing a constructor
+   that takes a single ContructNullOptional argument.  This constructor should
+   only be used by the Optional implementation, which guarantees that such an
+   object will not be used except by calling its cobj() method.
+*/
+template <typename T>
+class Optional
+{
+public:
+	using CType = typename T::CType;
+
+	Optional() : _value(nullptr) {}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions, modernize-pass-by-value)
+	Optional(const T& value) : _value(value) {}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	Optional(T&& value) : _value(std::move(value)) {}
+
+	template <typename U,
+	          typename = typename std::enable_if<
+	                  std::is_convertible<U, T>::value>::type>
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	Optional(U&& value) : _value(std::forward<U>(value))
+	{
+	}
+
+	void reset() { _value = T{nullptr}; }
+
+	const T& operator*() const
+	{
+		assert(_value.cobj());
+		return _value;
+	}
+
+	T& operator*()
+	{
+		assert(_value.cobj());
+		return _value;
+	}
+
+	const T* operator->() const
+	{
+		assert(_value.cobj());
+		return &_value;
+	}
+
+	T* operator->()
+	{
+		assert(_value.cobj());
+		return &_value;
+	}
+
+	bool operator==(const Optional& optional)
+	{
+		return (!*this && !optional) ||
+		       (*this && optional && _value == optional._value);
+	}
+
+	bool operator!=(const Optional& optional) { return !operator==(optional); }
+
+	explicit operator bool() const { return _value.cobj(); }
+	bool     operator!() const { return !_value.cobj(); }
+
+	inline CType*       cobj() { return _value.cobj(); }
+	inline const CType* cobj() const { return _value.cobj(); }
+
+private:
+	T _value;
+};
+
+} // namespace detail
+
+template <class T>
+constexpr detail::Optional<T>
+make_optional(T&& value)
+{
+	return detail::Optional<T>{std::forward<T>(value)};
+}
+
+template <class T, class... Args>
+constexpr detail::Optional<T>
+make_optional(Args&&... args)
+{
+	return detail::Optional<T>{std::forward<Args>(args)...};
+}
+
+} // namespace serd
+
+#endif // SERD_DETAIL_OPTIONAL_HPP
diff --git a/serd/detail/StringView.hpp b/serd/detail/StringView.hpp
new file mode 100644
index 00000000..dab3aecd
--- /dev/null
+++ b/serd/detail/StringView.hpp
@@ -0,0 +1,204 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_DETAIL_STRINGVIEW_HPP
+#define SERD_DETAIL_STRINGVIEW_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+
+namespace serd {
+namespace detail {
+
+/**
+   Immutable slice of a string.
+
+   This is a minimal implementation that is compatible with std::string_view
+   and std::string for most basic use cases.  This could be replaced with
+   std::string_view once C++17 support can be relied on.
+*/
+class StringView
+{
+public:
+	using char_type       = char;
+	using size_type       = size_t;
+	using traits_type     = std::char_traits<char>;
+	using value_type      = char;
+	using pointer         = value_type*;
+	using const_pointer   = const value_type*;
+	using reference       = value_type&;
+	using const_reference = const value_type&;
+	using iterator        = const char*;
+	using const_iterator  = const char*;
+
+	static constexpr size_type npos = size_t(-1);
+
+	constexpr StringView() noexcept = default;
+
+	constexpr StringView(const char* const str, const size_t len) noexcept
+	    : _str{str}, _len{len}
+	{
+	}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	StringView(const char* const str) noexcept
+	    : _str{str}, _len{str ? strlen(str) : 0}
+	{
+	}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	StringView(const std::string& str) noexcept
+	    : _str{str.c_str()}, _len{str.length()}
+	{
+	}
+
+	constexpr size_t      size() const { return _len; }
+	constexpr size_t      length() const { return _len; }
+	constexpr bool        empty() const { return _len == 0; }
+	constexpr const char* c_str() const { return _str; }
+	constexpr const char* data() const { return _str; }
+	constexpr const char& front() const { return _str[0]; }
+	constexpr const char& back() const { return _str[_len - 1]; }
+
+	constexpr const_iterator begin() const { return _str; }
+	constexpr const_iterator end() const { return _str + _len; }
+	constexpr const_iterator cbegin() const { return begin(); }
+	constexpr const_iterator cend() const { return end(); }
+
+	constexpr const char& operator[](size_t pos) const { return _str[pos]; }
+
+	const char& at(size_t pos) const
+	{
+		if (pos >= size()) {
+			throw std::out_of_range("serd::StringView::at pos");
+		}
+
+		return _str[pos];
+	}
+
+	StringView substr(size_t pos, size_t n = npos) const
+	{
+		if (pos > size()) {
+			throw std::out_of_range("serd::StringView::substr pos");
+		}
+
+		return StringView{data() + pos, std::min(size() - pos, n)};
+	}
+
+	int compare(StringView rhs) const noexcept
+	{
+		const size_type len = std::min(size(), rhs.size());
+		const int       cmp = strncmp(data(), rhs.data(), len);
+		if (cmp) {
+			return cmp;
+		} else if (size() == rhs.size()) {
+			return 0;
+		} else if (size() < rhs.size()) {
+			return -1;
+		}
+		return 1;
+	}
+
+	template <class Alloc = std::allocator<char>>
+	std::basic_string<char, traits_type, Alloc>
+	str(const Alloc& alloc = {}) const
+	{
+		return std::basic_string<char, traits_type, Alloc>(
+		        data(), size(), alloc);
+	}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	explicit operator std::string() const { return str(); }
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	explicit operator const char*() const { return _str; }
+
+private:
+	const char* const _str{};
+	const size_t      _len{};
+};
+
+inline bool
+operator==(const detail::StringView& lhs, const detail::StringView& rhs)
+{
+	return !lhs.compare(rhs);
+}
+
+inline bool
+operator==(const detail::StringView& lhs, const std::string& rhs)
+{
+	return lhs.length() == rhs.length() &&
+	       !strncmp(lhs.c_str(), rhs.c_str(), lhs.length());
+}
+
+inline bool
+operator==(const detail::StringView& lhs, const char* rhs)
+{
+	return !strncmp(lhs.c_str(), rhs, lhs.length());
+}
+
+inline bool
+operator!=(const detail::StringView& lhs, const detail::StringView& rhs)
+{
+	return lhs.compare(rhs);
+}
+
+inline bool
+operator!=(const detail::StringView& lhs, const std::string& rhs)
+{
+	return lhs.length() != rhs.length() ||
+	       strncmp(lhs.c_str(), rhs.c_str(), lhs.length());
+}
+
+inline bool
+operator!=(const detail::StringView& lhs, const char* rhs)
+{
+	return strncmp(lhs.c_str(), rhs, lhs.length());
+}
+
+inline bool
+operator<(const detail::StringView& lhs, const detail::StringView& rhs)
+{
+	return lhs.compare(rhs) < 0;
+}
+
+inline bool
+operator<(const detail::StringView& lhs, const std::string& rhs)
+{
+	return lhs.c_str() < StringView(rhs);
+}
+
+inline bool
+operator<(const detail::StringView& lhs, const char* rhs)
+{
+	return strncmp(lhs.c_str(), rhs, lhs.length()) < 0;
+}
+
+inline std::ostream&
+operator<<(std::ostream& os, const StringView& str)
+{
+	os.write(str.data(), std::streamsize(str.size()));
+	return os;
+}
+
+} // namespace detail
+} // namespace serd
+
+#endif // SERD_DETAIL_STRINGVIEW_HPP
diff --git a/serd/detail/Wrapper.hpp b/serd/detail/Wrapper.hpp
new file mode 100644
index 00000000..ad38b121
--- /dev/null
+++ b/serd/detail/Wrapper.hpp
@@ -0,0 +1,127 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_DETAIL_WRAPPER_HPP
+#define SERD_DETAIL_WRAPPER_HPP
+
+#include <cstddef>
+#include <memory>
+
+namespace serd {
+namespace detail {
+
+template <typename T>
+class Optional;
+
+/// Free function for a C object
+template <typename T>
+using FreeFunc = void (*)(T*);
+
+template <class T>
+using Mutable = typename std::remove_const<T>::type;
+
+/**
+   Simple overhead-free deleter for a C object.
+
+   Can be used with const or mutable pointers, but only mutable pointers will
+   be freed.  This makes it simple to wrap APIs where constness conveys
+   ownership, but can not handle unowned mutable pointers.
+*/
+template <typename T, void Free(Mutable<T>*)>
+struct BasicDeleter
+{
+	template <typename = std::enable_if<!std::is_const<T>::value>>
+	void operator()(typename std::remove_const<T>::type* ptr)
+	{
+		Free(ptr);
+	}
+
+	template <typename = std::enable_if<std::is_const<T>::value>>
+	void operator()(const T*)
+	{
+	}
+};
+
+/// Ownership for `DynamicDeleter`
+enum class Ownership { owned, view };
+
+/**
+   Deleter for a C object that can handle dynamic ownership.
+
+   Unlike `BasicDeleter`, this can be used to handle non-owned references to
+   mutable objects, at the cost of an extra word for tracking the ownership
+   (since constness in the type can't convey this information).
+*/
+template <typename T, void Free(Mutable<T>*)>
+struct DynamicDeleter : BasicDeleter<T, Free>
+{
+	DynamicDeleter(Ownership ownership) : _ownership{ownership} {}
+
+	void operator()(T* ptr)
+	{
+		if (_ownership == Ownership::owned) {
+			BasicDeleter<T, Free>::operator()(ptr);
+		}
+	}
+
+private:
+	Ownership _ownership;
+};
+
+/// Generic C++ wrapper for a C object
+template <typename T, class Deleter>
+class Wrapper
+{
+public:
+	using CType = T;
+	using UPtr  = std::unique_ptr<T, Deleter>;
+
+	explicit Wrapper(T* ptr) : _ptr(ptr, Deleter{}) {}
+	Wrapper(T* ptr, Deleter deleter) : _ptr(ptr, std::move(deleter)) {}
+	Wrapper(UPtr ptr) : _ptr(std::move(ptr)) {}
+
+	Wrapper(Wrapper&&) noexcept = default;
+	Wrapper& operator=(Wrapper&&) noexcept = default;
+
+	Wrapper(const Wrapper&) = delete;
+	Wrapper& operator=(const Wrapper&) = delete;
+
+	~Wrapper() = default;
+
+	T*       cobj() { return _ptr.get(); }
+	const T* cobj() const { return _ptr.get(); }
+
+protected:
+	friend class detail::Optional<T>;
+
+	explicit Wrapper(std::nullptr_t) : _ptr(nullptr) {}
+
+	void reset() { _ptr.reset(); }
+
+	std::unique_ptr<T, Deleter> _ptr;
+};
+
+template <typename T, void Free(Mutable<T>*)>
+class BasicWrapper : public Wrapper<T, BasicDeleter<T, Free>>
+{
+public:
+	explicit BasicWrapper(T* ptr) : Wrapper<T, BasicDeleter<T, Free>>{ptr} {}
+};
+
+} // namespace detail
+} // namespace serd
+
+#endif // SERD_DETAIL_WRAPPER_HPP
diff --git a/serd/serd.hpp b/serd/serd.hpp
new file mode 100644
index 00000000..ee133462
--- /dev/null
+++ b/serd/serd.hpp
@@ -0,0 +1,1653 @@
+/*
+  Copyright 2019-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/// @file serd.hpp C++ API for Serd, a lightweight RDF syntax library
+
+#ifndef SERD_SERD_HPP
+#define SERD_SERD_HPP
+
+#include "serd/detail/Copyable.hpp"
+#include "serd/detail/Flags.hpp"
+#include "serd/detail/Optional.hpp"
+#include "serd/detail/StringView.hpp"
+#include "serd/detail/Wrapper.hpp"
+
+#include "serd/serd.h"
+
+#include <cassert>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+/**
+   @defgroup serdxx Serdxx
+   C++ bindings for Serd, a lightweight RDF syntax library.
+
+   @ingroup serd
+   @{
+*/
+
+/**
+   Serd C++ API namespace.
+*/
+namespace serd {
+
+template <typename T>
+using Optional = detail::Optional<T>;
+
+using StringView = detail::StringView;
+
+template <typename Flag>
+inline constexpr typename std::enable_if<std::is_enum<Flag>::value,
+                                         detail::Flags<Flag>>::type
+operator|(const Flag lhs, const Flag rhs) noexcept
+{
+	return detail::Flags<Flag>{lhs} | rhs;
+}
+
+/// @copydoc SerdStatus
+enum class Status {
+	success        = SERD_SUCCESS,        ///< @copydoc SERD_SUCCESS
+	failure        = SERD_FAILURE,        ///< @copydoc SERD_FAILURE
+	err_unknown    = SERD_ERR_UNKNOWN,    ///< @copydoc SERD_ERR_UNKNOWN
+	err_bad_syntax = SERD_ERR_BAD_SYNTAX, ///< @copydoc SERD_ERR_BAD_SYNTAX
+	err_bad_arg    = SERD_ERR_BAD_ARG,    ///< @copydoc SERD_ERR_BAD_ARG
+	err_bad_iter   = SERD_ERR_BAD_ITER,   ///< @copydoc SERD_ERR_BAD_ITER
+	err_not_found  = SERD_ERR_NOT_FOUND,  ///< @copydoc SERD_ERR_NOT_FOUND
+	err_id_clash   = SERD_ERR_ID_CLASH,   ///< @copydoc SERD_ERR_ID_CLASH
+	err_bad_curie  = SERD_ERR_BAD_CURIE,  ///< @copydoc SERD_ERR_BAD_CURIE
+	err_internal   = SERD_ERR_INTERNAL,   ///< @copydoc SERD_ERR_INTERNAL
+	err_overflow   = SERD_ERR_OVERFLOW,   ///< @copydoc SERD_ERR_OVERFLOW
+	err_invalid    = SERD_ERR_INVALID,    ///< @copydoc SERD_ERR_INVALID
+	err_no_data    = SERD_ERR_NO_DATA,    ///< @copydoc SERD_ERR_NO_DATA
+	err_bad_write  = SERD_ERR_BAD_WRITE,  ///< @copydoc SERD_ERR_BAD_WRITE
+	err_bad_call   = SERD_ERR_BAD_CALL    ///< @copydoc SERD_ERR_BAD_CALL
+};
+
+/// @copydoc SerdSyntax
+enum class Syntax {
+	empty    = SERD_SYNTAX_EMPTY, ///< @copydoc SERD_SYNTAX_EMPTY
+	Turtle   = SERD_TURTLE,       ///< @copydoc SERD_TURTLE
+	NTriples = SERD_NTRIPLES,     ///< @copydoc SERD_NTRIPLES
+	NQuads   = SERD_NQUADS,       ///< @copydoc SERD_NQUADS
+	TriG     = SERD_TRIG          ///< @copydoc SERD_TRIG
+};
+
+/// @copydoc SerdStatementFlag
+enum class StatementFlag {
+	empty_S = SERD_EMPTY_S, ///< @copydoc SERD_EMPTY_S
+	anon_S  = SERD_ANON_S,  ///< @copydoc SERD_ANON_S
+	anon_O  = SERD_ANON_O,  ///< @copydoc SERD_ANON_O
+	list_S  = SERD_LIST_S,  ///< @copydoc SERD_LIST_S
+	list_O  = SERD_LIST_O,  ///< @copydoc SERD_LIST_O
+	terse_S = SERD_TERSE_S, ///< @copydoc SERD_TERSE_S
+	terse_O = SERD_TERSE_O  ///< @copydoc SERD_TERSE_O
+};
+
+/// Bitwise OR of #StatementFlag values
+using StatementFlags = detail::Flags<StatementFlag>;
+
+/// @copydoc SerdSerialisationFlag
+enum class SerialisationFlag {
+	no_inline_objects = SERD_NO_INLINE_OBJECTS ///< Disable object inlining
+};
+
+/// Bitwise OR of #SerialisationFlag values
+using SerialisationFlags = detail::Flags<SerialisationFlag>;
+
+/// @copydoc SerdNodeType
+enum class NodeType {
+	literal = SERD_LITERAL, ///< @copydoc SERD_LITERAL
+	URI     = SERD_URI,     ///< @copydoc SERD_URI
+	CURIE   = SERD_CURIE,   ///< @copydoc SERD_CURIE
+	blank   = SERD_BLANK    ///< @copydoc SERD_BLANK
+};
+
+/// @copydoc SerdNodeFlag
+enum class NodeFlag {
+	has_newline  = SERD_HAS_NEWLINE,  ///< @copydoc SERD_HAS_NEWLINE
+	has_quote    = SERD_HAS_QUOTE,    ///< @copydoc SERD_HAS_QUOTE
+	has_datatype = SERD_HAS_DATATYPE, ///< @copydoc SERD_HAS_DATATYPE
+	has_language = SERD_HAS_LANGUAGE  ///< @copydoc SERD_HAS_LANGUAGE
+};
+
+/// Bitwise OR of #NodeFlag values
+using NodeFlags = detail::Flags<NodeFlag>;
+
+/// @copydoc SerdField
+enum class Field {
+	subject   = SERD_SUBJECT,   ///< @copydoc SERD_SUBJECT
+	predicate = SERD_PREDICATE, ///< @copydoc SERD_PREDICATE
+	object    = SERD_OBJECT,    ///< @copydoc SERD_OBJECT
+	graph     = SERD_GRAPH      ///< @copydoc SERD_GRAPH
+};
+
+/// @copydoc SerdModelFlag
+enum class ModelFlag {
+	index_SPO     = SERD_INDEX_SPO,    ///< @copydoc SERD_INDEX_SPO
+	index_SOP     = SERD_INDEX_SOP,    ///< @copydoc SERD_INDEX_SOP
+	index_OPS     = SERD_INDEX_OPS,    ///< @copydoc SERD_INDEX_OPS
+	index_OSP     = SERD_INDEX_OSP,    ///< @copydoc SERD_INDEX_OSP
+	index_PSO     = SERD_INDEX_PSO,    ///< @copydoc SERD_INDEX_PSO
+	index_POS     = SERD_INDEX_POS,    ///< @copydoc SERD_INDEX_POS
+	index_graphs  = SERD_INDEX_GRAPHS, ///< @copydoc SERD_INDEX_GRAPHS
+	store_cursors = SERD_STORE_CURSORS ///< @copydoc SERD_STORE_CURSORS
+};
+
+/// Bitwise OR of #ModelFlag values
+using ModelFlags = detail::Flags<ModelFlag>;
+
+/// @copydoc SerdLogLevel
+enum class LogLevel {
+	emerg   = SERD_LOG_LEVEL_EMERG,   ///< @copydoc SERD_LOG_LEVEL_EMERG
+	alert   = SERD_LOG_LEVEL_ALERT,   ///< @copydoc SERD_LOG_LEVEL_ALERT
+	crit    = SERD_LOG_LEVEL_CRIT,    ///< @copydoc SERD_LOG_LEVEL_CRIT
+	err     = SERD_LOG_LEVEL_ERR,     ///< @copydoc SERD_LOG_LEVEL_ERR
+	warning = SERD_LOG_LEVEL_WARNING, ///< @copydoc SERD_LOG_LEVEL_WARNING
+	notice  = SERD_LOG_LEVEL_NOTICE,  ///< @copydoc SERD_LOG_LEVEL_NOTICE
+	info    = SERD_LOG_LEVEL_INFO,    ///< @copydoc SERD_LOG_LEVEL_INFO
+	debug   = SERD_LOG_LEVEL_DEBUG    ///< @copydoc SERD_LOG_LEVEL_DEBUG
+};
+
+/// @copydoc SerdReaderFlag
+enum class ReaderFlag {
+	lax = SERD_READ_LAX ///< @copydoc SERD_READ_LAX
+};
+
+/// @copydoc SerdReaderFlags
+using ReaderFlags = detail::Flags<ReaderFlag>;
+
+/// @copydoc SerdWriterFlag
+enum class WriterFlag {
+	ascii = SERD_WRITE_ASCII, ///< @copydoc SERD_WRITE_ASCII
+	terse = SERD_WRITE_TERSE, ///< @copydoc SERD_WRITE_TERSE
+	lax   = SERD_WRITE_LAX    ///< @copydoc SERD_WRITE_LAX
+};
+
+/// @copydoc SerdWriterFlags
+using WriterFlags = detail::Flags<WriterFlag>;
+
+/**
+   @name String Utilities
+   @{
+*/
+
+/// @copydoc serd_strerror
+inline const char*
+strerror(const Status status)
+{
+	return serd_strerror(static_cast<SerdStatus>(status));
+}
+
+/// @copydoc serd_strtod
+inline double
+strtod(StringView str, size_t* end = nullptr)
+{
+	return serd_strtod(str.c_str(), end);
+}
+
+/**
+   @}
+   @name Base64
+   @{
+*/
+
+/**
+   Encode `size` bytes of `buf` into `str`, which must be large enough
+
+   @param buf Input binary data (vector-like container of bytes).
+   @param wrap_lines Wrap lines at 76 characters to conform to RFC 2045.
+   @return A base64 encoded representation of the data in `buf`.
+*/
+template <typename Container>
+inline std::string
+base64_encode(const Container& buf, bool wrap_lines = false)
+{
+	const size_t length{serd_base64_encoded_length(buf.size(), wrap_lines)};
+	std::string  str(length + 1, '\0');
+
+	serd_base64_encode(&str.at(0), buf.data(), buf.size(), wrap_lines);
+	return str;
+}
+
+/**
+   Decode a base64 string
+
+   Container must be a vector-like container of bytes.
+
+   @param str Base64 string to decode.
+   @return The decoded data represented in `str`.
+*/
+template <typename Container = std::vector<uint8_t>>
+inline Container
+base64_decode(StringView str)
+{
+	size_t    size{serd_base64_decoded_size(str.length())};
+	Container buf(size, 0);
+
+	serd_base64_decode(&buf.at(0), &size, str.c_str(), str.length());
+	buf.resize(size);
+	return buf;
+}
+
+/**
+   @}
+   @name Byte Source
+   @{
+*/
+
+class ByteSource
+    : public detail::BasicWrapper<SerdByteSource, serd_byte_source_free>
+{
+public:
+	explicit ByteSource(std::istream& stream)
+	    : BasicWrapper(
+	          serd_byte_source_new_function(s_read, s_error, this, nullptr, 1))
+	    , _stream(&stream)
+	{
+	}
+
+	explicit ByteSource(const std::string& string)
+	    : BasicWrapper(serd_byte_source_new_string(string.c_str(), nullptr))
+	    , _stream(nullptr)
+	{
+	}
+
+	ByteSource(const serd::ByteSource&) = delete;
+	ByteSource& operator=(const serd::ByteSource&) = delete;
+
+	ByteSource(serd::ByteSource&&) = delete;
+	ByteSource& operator=(serd::ByteSource&&) = delete;
+
+	~ByteSource() = default;
+
+	static inline size_t
+	s_read(void* buf, size_t size, size_t nmemb, void* source) noexcept
+	{
+		assert(size == 1);
+		auto* self = static_cast<ByteSource*>(source);
+
+		try {
+			self->_stream->read(static_cast<char*>(buf),
+			                    static_cast<std::streamsize>(nmemb));
+			if (self->_stream->fail()) {
+				return 0;
+			}
+		} catch (...) {
+		}
+		return nmemb;
+	}
+
+	static inline int s_error(void* source) noexcept
+	{
+		auto* self = static_cast<ByteSource*>(source);
+
+		return static_cast<int>(self->_stream->fail());
+	}
+
+private:
+	std::istream* _stream;
+};
+
+/**
+   @}
+   @name Byte Sink
+   @{
+*/
+
+/**
+   Sink function for string output
+
+   Similar semantics to `SerdWriteFunc` (and in turn `fwrite`), but takes char*
+   for convenience and may set errno for more informative error reporting than
+   supported by `SerdStreamErrorFunc`.
+
+   @return Number of elements (bytes) written, which is short on error.
+*/
+using WriteFunc = std::function<size_t(const char*, size_t)>;
+
+class ByteSink : public detail::BasicWrapper<SerdByteSink, serd_byte_sink_free>
+{
+public:
+	ByteSink(WriteFunc write_func, const size_t block_size = 1)
+	    : BasicWrapper(serd_byte_sink_new_function(s_write, this, block_size))
+	    , _write_func(std::move(write_func))
+	{
+	}
+
+	explicit ByteSink(std::ostream& stream)
+	    : BasicWrapper(serd_byte_sink_new_function(s_write, this, 1))
+	    , _write_func([&](const char* str, size_t len) {
+		    stream.write(str, std::streamsize(len));
+		    return stream.good() ? len : size_t(0);
+	    })
+	{
+	}
+
+	static inline size_t
+	s_write(const void* buf, size_t size, size_t nmemb, void* sink) noexcept
+	{
+		assert(size == 1);
+		auto* self = static_cast<ByteSink*>(sink);
+
+		try {
+			return self->_write_func(static_cast<const char*>(buf), nmemb);
+		} catch (...) {
+		}
+		return 0;
+	}
+
+private:
+	WriteFunc _write_func;
+};
+
+/**
+   @}
+   @name Syntax Utilities
+   @{
+*/
+
+/// @copydoc serd_syntax_by_name
+inline Syntax
+syntax_by_name(StringView name)
+{
+	return Syntax(serd_syntax_by_name(name.c_str()));
+}
+
+/// @copydoc serd_guess_syntax
+inline Syntax
+guess_syntax(StringView filename)
+{
+	return Syntax(serd_guess_syntax(filename.c_str()));
+}
+
+/// @copydoc serd_syntax_has_graphs
+inline bool
+syntax_has_graphs(const Syntax syntax)
+{
+	return serd_syntax_has_graphs(static_cast<SerdSyntax>(syntax));
+}
+
+/**
+   @}
+   @name Node
+   @{
+*/
+
+template <typename CObj>
+using NodeHandle = detail::
+    BasicCopyable<CObj, serd_node_copy, serd_node_equals, serd_node_free>;
+
+template <typename CObj>
+class NodeWrapper;
+
+using Node     = NodeWrapper<SerdNode>;
+using NodeView = NodeWrapper<const SerdNode>;
+
+template <typename CObj>
+class NodeWrapper : public NodeHandle<CObj>
+{
+public:
+	using Base = NodeHandle<CObj>;
+	using Base::cobj;
+
+	explicit NodeWrapper(CObj* ptr) : Base(ptr) {}
+
+	template <typename C>
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	NodeWrapper(const NodeWrapper<C>& node) : Base{node}
+	{
+	}
+
+	NodeType    type() const { return NodeType(serd_node_type(cobj())); }
+	const char* c_str() const { return serd_node_string(cobj()); }
+	StringView  str() const { return StringView{c_str(), length()}; }
+	size_t      size() const { return serd_node_length(cobj()); }
+	size_t      length() const { return serd_node_length(cobj()); }
+
+	NodeFlags flags() const { return NodeFlags(serd_node_flags(cobj())); }
+
+	Optional<NodeView> datatype() const;
+	Optional<NodeView> language() const;
+
+	Node resolve(NodeView base) const
+	{
+		return Node(serd_node_resolve(cobj(), base.cobj()));
+	}
+
+	bool operator<(NodeView node) const
+	{
+		return serd_node_compare(cobj(), node.cobj()) < 0;
+	}
+
+	explicit operator std::string() const
+	{
+		return std::string(c_str(), length());
+	}
+
+	explicit operator StringView() const
+	{
+		return StringView(c_str(), length());
+	}
+
+	const char* begin() const { return c_str(); }
+	const char* end() const { return c_str() + length(); }
+	bool        empty() const { return length() == 0; }
+};
+
+template <typename CObj>
+Optional<NodeView>
+NodeWrapper<CObj>::datatype() const
+{
+	return NodeView(serd_node_datatype(cobj()));
+}
+
+template <typename CObj>
+Optional<NodeView>
+NodeWrapper<CObj>::language() const
+{
+	return NodeView(serd_node_language(cobj()));
+}
+
+inline std::ostream&
+operator<<(std::ostream& os, const NodeView& node)
+{
+	return os << node.c_str();
+}
+
+/// Create a new plain literal node with no language from `str`
+inline Node
+make_string(StringView str)
+{
+	return Node(serd_new_substring(str.data(), str.length()));
+}
+
+/// @copydoc serd_new_plain_literal
+inline Node
+make_plain_literal(StringView str, StringView lang)
+{
+	return Node(serd_new_plain_literal(str.data(), lang.data()));
+}
+
+/// Create a new typed literal node from `str`
+inline Node
+make_typed_literal(StringView str, const NodeView& datatype)
+{
+	return Node(serd_new_typed_literal(str.data(), datatype.cobj()));
+}
+
+/// @copydoc serd_new_blank
+inline Node
+make_blank(StringView str)
+{
+	return Node(serd_new_simple_node(SERD_BLANK, str.data(), str.length()));
+}
+
+/// @copydoc serd_new_curie
+inline Node
+make_curie(StringView str)
+{
+	return Node(serd_new_simple_node(SERD_CURIE, str.data(), str.length()));
+}
+
+/// @copydoc serd_new_uri
+inline Node
+make_uri(StringView str)
+{
+	return Node(serd_new_simple_node(SERD_URI, str.data(), str.length()));
+}
+
+/// @copydoc serd_new_resolved_uri
+inline Node
+make_resolved_uri(StringView str, const NodeView& base)
+{
+	return Node(serd_new_resolved_uri(str.data(), base.cobj()));
+}
+
+/// Create a new file URI node from a local filesystem path
+inline Node
+make_file_uri(StringView path)
+{
+	return Node(serd_new_file_uri(path.data(), nullptr));
+}
+
+/// @copydoc serd_new_file_uri
+inline Node
+make_file_uri(StringView path, StringView hostname)
+{
+	return Node(serd_new_file_uri(path.data(), hostname.data()));
+}
+
+/// @copydoc serd_new_relative_uri
+inline Node
+make_relative_uri(StringView         str,
+                  const NodeView&    base,
+                  Optional<NodeView> root = {})
+{
+	return Node(serd_new_relative_uri(str.data(), base.cobj(), root.cobj()));
+}
+
+/// @copydoc serd_new_decimal
+inline Node
+make_decimal(double             d,
+             unsigned           max_precision,
+             unsigned           max_frac_digits,
+             Optional<NodeView> datatype = {})
+{
+	return Node(
+	    serd_new_decimal(d, max_precision, max_frac_digits, datatype.cobj()));
+}
+
+/// @copydoc serd_new_double
+inline Node
+make_double(double d)
+{
+	return Node(serd_new_double(d));
+}
+
+/// @copydoc serd_new_float
+inline Node
+make_float(float f)
+{
+	return Node(serd_new_float(f));
+}
+
+/// @copydoc serd_new_integer
+inline Node
+make_integer(int64_t i, Optional<NodeView> datatype = {})
+{
+	return Node(serd_new_integer(i, datatype.cobj()));
+}
+
+/// @copydoc serd_new_boolean
+inline Node
+make_boolean(bool b)
+{
+	return Node(serd_new_boolean(b));
+}
+
+/// @copydoc serd_new_blob
+inline Node
+make_blob(const void*        buf,
+          size_t             size,
+          bool               wrap_lines,
+          Optional<NodeView> datatype = {})
+{
+	return Node(serd_new_blob(buf, size, wrap_lines, datatype.cobj()));
+}
+
+/**
+   @}
+   @name URI
+   @{
+*/
+
+inline std::string
+file_uri_parse(StringView uri, std::string* hostname = nullptr)
+{
+	char* c_hostname = nullptr;
+	char* c_path     = serd_file_uri_parse(uri.data(), &c_hostname);
+	if (hostname && c_hostname) {
+		*hostname = c_hostname;
+	}
+
+	std::string path(c_path);
+	serd_free(c_hostname);
+	serd_free(c_path);
+	return path;
+}
+
+inline bool
+uri_string_has_scheme(StringView uri)
+{
+	return serd_uri_string_has_scheme(uri.c_str());
+}
+
+/**
+   A parsed URI
+
+   This directly refers to slices in other strings, it does not own any memory
+   itself.  Thus, URIs can be parsed and/or resolved against a base URI
+   in-place without allocating memory.
+*/
+class URI
+{
+public:
+	/**
+	   Component of a URI.
+
+	   Note that there is a distinction between a component being non-present
+	   and present but empty.  For example, "file:///path" has an empty
+	   authority, while "file:/path" has no authority.  A non-present component
+	   has its `data()` pointer set to null, while an empty component has a
+	   data pointer, but length zero.
+	*/
+	using Component = StringView;
+
+	explicit URI(StringView str) : _uri(SERD_URI_NULL)
+	{
+		serd_uri_parse(str.data(), &_uri);
+	}
+
+	explicit URI(const NodeView& node) : _uri(SERD_URI_NULL)
+	{
+		serd_uri_parse(node.c_str(), &_uri);
+	}
+
+	explicit URI(const SerdURI& uri) : _uri(uri) {}
+
+	Component scheme() const { return make_component(_uri.scheme); }
+	Component authority() const { return make_component(_uri.authority); }
+	Component path_base() const { return make_component(_uri.path_base); }
+	Component path() const { return make_component(_uri.path); }
+	Component query() const { return make_component(_uri.query); }
+	Component fragment() const { return make_component(_uri.fragment); }
+
+	/// Return this URI resolved against `base`
+	URI resolve(const URI& base) const
+	{
+		SerdURI resolved = SERD_URI_NULL;
+		serd_uri_resolve(&_uri, &base._uri, &resolved);
+		return URI{resolved};
+	}
+
+	/// Return URI as a string
+	std::string string() const { return serialise(nullptr, nullptr); }
+
+	/// Return URI as a string relative to `base`
+	std::string relative_string(const URI& base) const
+	{
+		return serialise(base.cobj(), nullptr);
+	}
+
+	/**
+	   Return URI as a string relative to `base` but constrained to `root`
+
+	   The returned URI string is relative iff this URI is a child of `base`
+	   and `root`.  The `root` must be a prefix of `base` and can be used keep
+	   up-references ("../") within a certain namespace.
+	*/
+	std::string relative_string(const URI& base, const URI& root) const
+	{
+		return serialise(base.cobj(), root.cobj());
+	}
+
+	const SerdURI* cobj() const { return &_uri; }
+
+private:
+	static Component make_component(const SerdStringView slice)
+	{
+		return slice.buf ? Component{slice.buf, slice.len} : Component{};
+	}
+
+	std::string serialise(const SerdURI* base, const SerdURI* root) const
+	{
+		std::ostringstream ss;
+		ByteSink           byte_sink{ss};
+
+		serd_uri_serialise_relative(
+		    cobj(), base, root, ByteSink::s_write, &byte_sink);
+
+		return ss.str();
+	}
+
+	SerdURI _uri;
+};
+
+inline std::ostream&
+operator<<(std::ostream& os, const URI& uri)
+{
+	ByteSink byte_sink{os};
+	serd_uri_serialise(uri.cobj(), ByteSink::s_write, &byte_sink);
+	return os;
+}
+
+/**
+   @}
+   @name Cursor
+   @{
+*/
+
+template <typename CObj>
+using CursorHandle = detail::
+    BasicCopyable<CObj, serd_cursor_copy, serd_cursor_equals, serd_cursor_free>;
+
+template <typename CObj>
+class CursorWrapper : public CursorHandle<CObj>
+{
+public:
+	using Base = CursorHandle<CObj>;
+	using Base::cobj;
+
+	explicit CursorWrapper(CObj* cursor) : Base(cursor) {}
+
+	template <typename C>
+	CursorWrapper(const CursorWrapper<C>& cursor) : Base{cursor.cobj()}
+	{
+	}
+
+	NodeView name() const { return NodeView(serd_cursor_name(cobj())); }
+	unsigned line() const { return serd_cursor_line(cobj()); }
+	unsigned column() const { return serd_cursor_column(cobj()); }
+};
+
+using CursorView = CursorWrapper<const SerdCursor>;
+
+/// Extra data managed by mutable (user created) Cursor
+struct CursorData
+{
+	Node name_node;
+};
+
+class Cursor : private CursorData, public CursorWrapper<SerdCursor>
+{
+public:
+	Cursor(NodeView name, const unsigned line, const unsigned col)
+	    : CursorData{Node{name}}
+	    , CursorWrapper{serd_cursor_new(name_node.cobj(), line, col)}
+	{
+	}
+
+	Cursor(StringView name, const unsigned line, const unsigned col)
+	    : Cursor(make_string(name), line, col)
+	{
+	}
+
+	Cursor(const CursorView& cursor)
+	    : Cursor(cursor.name(), cursor.line(), cursor.column())
+	{
+	}
+
+private:
+	friend class detail::Optional<Cursor>;
+	friend class Statement;
+	explicit Cursor(std::nullptr_t)
+	    : CursorData{Node{nullptr}}, CursorWrapper{nullptr}
+	{
+	}
+};
+
+/**
+   @}
+   @name Logging
+   @{
+*/
+
+/**
+   @}
+   @name World
+   @{
+*/
+
+using LogFields = std::map<StringView, StringView>;
+
+using LogFunc =
+    std::function<Status(StringView, LogLevel, LogFields, std::string)>;
+
+class World : public detail::BasicWrapper<SerdWorld, serd_world_free>
+{
+public:
+	World() : BasicWrapper(serd_world_new()) {}
+
+	NodeView get_blank() { return NodeView(serd_world_get_blank(cobj())); }
+
+	void set_message_func(LogFunc log_func)
+	{
+		_log_func = std::move(log_func);
+		serd_world_set_log_func(cobj(), s_log_func, this);
+	}
+
+	SERD_LOG_FUNC(5, 6)
+	Status log(StringView        domain,
+	           const LogLevel    level,
+	           const LogFields&  fields,
+	           const char* const fmt,
+	           ...)
+	{
+		va_list args;
+		va_start(args, fmt);
+
+		std::vector<SerdLogField> c_fields(fields.size());
+		size_t                    index = 0;
+		for (const auto& f : fields) {
+			c_fields[index].key   = f.first.c_str();
+			c_fields[index].value = f.second.c_str();
+			++index;
+		}
+
+		const SerdStatus st =
+		    serd_world_vlogf(cobj(),
+		                     domain.c_str(),
+		                     static_cast<SerdLogLevel>(level),
+		                     fields.size(),
+		                     c_fields.data(),
+		                     fmt,
+		                     args);
+
+		va_end(args);
+		return static_cast<Status>(st);
+	}
+
+private:
+	SERD_LOG_FUNC(1, 0)
+	static std::string format(const char* fmt, va_list args) noexcept
+	{
+		va_list args_copy;
+		va_copy(args_copy, args);
+
+		const auto n_bytes =
+		    static_cast<unsigned>(vsnprintf(nullptr, 0, fmt, args_copy));
+
+		va_end(args_copy);
+
+#if __cplusplus >= 201703L
+		std::string result(n_bytes, '\0');
+		vsnprintf(result.data(), n_bytes + 1u, fmt, args);
+#else
+		std::vector<char> str(n_bytes + 1u, '\0');
+		vsnprintf(str.data(), n_bytes + 1u, fmt, args);
+		std::string result(str.data(), size_t(n_bytes));
+#endif
+		return result;
+	}
+
+	static SerdStatus
+	s_log_func(void* handle, const SerdLogEntry* entry) noexcept
+	{
+		const auto* const self = static_cast<const World*>(handle);
+		try {
+			LogFields cxx_fields;
+			for (size_t i = 0; i < entry->n_fields; ++i) {
+				cxx_fields.emplace(entry->fields[i].key,
+				                   entry->fields[i].value);
+			}
+
+			return static_cast<SerdStatus>(
+			    self->_log_func(entry->domain,
+			                    static_cast<LogLevel>(entry->level),
+			                    cxx_fields,
+			                    format(entry->fmt, *entry->args)));
+		} catch (...) {
+			return SERD_ERR_INTERNAL;
+		}
+	}
+
+	LogFunc _log_func{};
+};
+
+/**
+   @}
+   @name Statement
+   @{
+*/
+
+template <typename CObj>
+using StatementHandle = detail::BasicCopyable<CObj,
+                                              serd_statement_copy,
+                                              serd_statement_equals,
+                                              serd_statement_free>;
+
+template <typename CObj>
+class StatementWrapper;
+
+using StatementView = StatementWrapper<const SerdStatement>;
+
+/// Extra data managed by mutable (user created) Statement
+struct StatementData
+{
+	Node             _subject;
+	Node             _predicate;
+	Node             _object;
+	Optional<Node>   _graph;
+	Optional<Cursor> _cursor;
+};
+
+template <typename CObj>
+class IterWrapper;
+
+template <typename CObj>
+class StatementWrapper : public StatementHandle<CObj>
+{
+public:
+	using Base = StatementHandle<CObj>;
+	using Base::cobj;
+
+	explicit StatementWrapper(CObj* statement) : Base{statement} {}
+
+	template <typename C>
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	StatementWrapper(const StatementWrapper<C>& statement) : Base{statement}
+	{
+	}
+
+	/// @copydoc serd_statement_node
+	NodeView node(Field field) const
+	{
+		return NodeView(
+		    serd_statement_node(cobj(), static_cast<SerdField>(field)));
+	}
+
+	/// @copydoc serd_statement_subject
+	NodeView subject() const
+	{
+		return NodeView(serd_statement_subject(cobj()));
+	}
+
+	/// @copydoc serd_statement_predicate
+	NodeView predicate() const
+	{
+		return NodeView(serd_statement_predicate(cobj()));
+	}
+
+	/// @copydoc serd_statement_object
+	NodeView object() const
+	{
+		return NodeView(serd_statement_object(cobj()));
+	}
+
+	/// @copydoc serd_statement_graph
+	Optional<NodeView> graph() const
+	{
+		return NodeView{serd_statement_graph(cobj())};
+	}
+
+	/// @copydoc serd_statement_cursor
+	Optional<CursorView> cursor() const
+	{
+		return CursorView(serd_statement_cursor(cobj()));
+	}
+
+private:
+	template <typename CIter>
+	friend class IterWrapper;
+
+	StatementWrapper() : Base{nullptr} {}
+};
+
+class Statement : public StatementData, public StatementWrapper<SerdStatement>
+{
+public:
+	Statement(const NodeView&      s,
+	          const NodeView&      p,
+	          const NodeView&      o,
+	          const NodeView&      g,
+	          Optional<CursorView> cursor = {})
+	    : StatementData{s, p, o, g, cursor ? *cursor : Optional<Cursor>{}}
+	    , StatementWrapper{serd_statement_new(_subject.cobj(),
+	                                          _predicate.cobj(),
+	                                          _object.cobj(),
+	                                          _graph.cobj(),
+	                                          _cursor.cobj())}
+	{
+	}
+
+	Statement(const NodeView&      s,
+	          const NodeView&      p,
+	          const NodeView&      o,
+	          Optional<CursorView> cursor = {})
+	    : StatementData{s, p, o, {}, cursor ? *cursor : Optional<Cursor>{}}
+	    , StatementWrapper{serd_statement_new(_subject.cobj(),
+	                                          _predicate.cobj(),
+	                                          _object.cobj(),
+	                                          nullptr,
+	                                          _cursor.cobj())}
+	{
+	}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	Statement(const StatementView& statement)
+	    : StatementData{statement.subject(),
+	                    statement.predicate(),
+	                    statement.object(),
+	                    statement.graph() ? *statement.graph()
+	                                      : Optional<Node>{},
+	                    statement.cursor() ? *statement.cursor()
+	                                       : Optional<Cursor>{}}
+	    , StatementWrapper{statement}
+	{
+	}
+};
+
+/**
+   @}
+   @name Sink
+   @{
+*/
+
+/// @copydoc SerdBaseFunc
+using BaseFunc = std::function<Status(NodeView)>;
+
+/// @copydoc SerdPrefixFunc
+using PrefixFunc = std::function<Status(NodeView name, NodeView uri)>;
+
+/// @copydoc SerdStatementFunc
+using StatementFunc = std::function<Status(StatementFlags, StatementView)>;
+
+/// @copydoc SerdEndFunc
+using EndFunc = std::function<Status(NodeView)>;
+
+template <typename CSink>
+class SinkWrapper
+    : public detail::Wrapper<CSink, detail::BasicDeleter<CSink, serd_sink_free>>
+{
+public:
+	explicit SinkWrapper(CSink* ptr)
+	    : detail::Wrapper<CSink, detail::BasicDeleter<CSink, serd_sink_free>>(
+	          ptr)
+	{
+	}
+
+	/// @copydoc serd_sink_write_base
+	Status base(const NodeView& uri) const
+	{
+		return Status(serd_sink_write_base(this->cobj(), uri.cobj()));
+	}
+
+	/// @copydoc serd_sink_write_prefix
+	Status prefix(NodeView name, const NodeView& uri) const
+	{
+		return Status(
+		    serd_sink_write_prefix(this->cobj(), name.cobj(), uri.cobj()));
+	}
+
+	/// @copydoc serd_sink_write_statement
+	Status statement(StatementFlags flags, StatementView statement) const
+	{
+		return Status(
+		    serd_sink_write_statement(this->cobj(), flags, statement.cobj()));
+	}
+
+	/// @copydoc serd_sink_write
+	Status write(StatementFlags     flags,
+	             const NodeView&    subject,
+	             const NodeView&    predicate,
+	             const NodeView&    object,
+	             Optional<NodeView> graph = {}) const
+	{
+		return Status(serd_sink_write(this->cobj(),
+		                              flags,
+		                              subject.cobj(),
+		                              predicate.cobj(),
+		                              object.cobj(),
+		                              graph.cobj()));
+	}
+
+	/// @copydoc serd_sink_write_end
+	Status end(const NodeView& node) const
+	{
+		return Status(serd_sink_write_end(this->cobj(), node.cobj()));
+	}
+};
+
+class SinkView : public SinkWrapper<const SerdSink>
+{
+public:
+	explicit SinkView(const SerdSink* ptr) : SinkWrapper<const SerdSink>(ptr) {}
+
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	SinkView(const SinkWrapper<SerdSink>& sink)
+	    : SinkWrapper<const SerdSink>(sink.cobj())
+	{
+	}
+};
+
+class Sink : public SinkWrapper<SerdSink>
+{
+public:
+	Sink() : SinkWrapper(serd_sink_new(this, nullptr))
+	{
+		serd_sink_set_event_func(cobj(), s_event);
+	}
+
+	// EnvView env() const { return serd_sink_get_env(cobj()); }
+
+	void set_base_func(BaseFunc base_func)
+	{
+		_base_func = std::move(base_func);
+	}
+
+	void set_prefix_func(PrefixFunc prefix_func)
+	{
+		_prefix_func = std::move(prefix_func);
+	}
+
+	void set_statement_func(StatementFunc statement_func)
+	{
+		_statement_func = std::move(statement_func);
+	}
+
+	void set_end_func(EndFunc end_func) { _end_func = std::move(end_func); }
+
+private:
+	static SerdStatus s_base(void* handle, const SerdNode* uri) noexcept
+	{
+		const auto* const sink = static_cast<const Sink*>(handle);
+		return sink->_base_func ? SerdStatus(sink->_base_func(NodeView(uri)))
+		                        : SERD_SUCCESS;
+	}
+
+	static SerdStatus
+	s_prefix(void* handle, const SerdNode* name, const SerdNode* uri) noexcept
+	{
+		const auto* const sink = static_cast<const Sink*>(handle);
+		return sink->_prefix_func
+		           ? SerdStatus(
+		                 sink->_prefix_func(NodeView(name), NodeView(uri)))
+		           : SERD_SUCCESS;
+	}
+
+	static SerdStatus s_statement(void*                handle,
+	                              SerdStatementFlags   flags,
+	                              const SerdStatement* statement) noexcept
+	{
+		const auto* const sink = static_cast<const Sink*>(handle);
+		return sink->_statement_func
+		           ? SerdStatus(sink->_statement_func(StatementFlags(flags),
+		                                              StatementView(statement)))
+		           : SERD_SUCCESS;
+	}
+
+	static SerdStatus s_end(void* handle, const SerdNode* node) noexcept
+	{
+		const auto* const sink = static_cast<const Sink*>(handle);
+		return sink->_end_func ? SerdStatus(sink->_end_func(NodeView(node)))
+		                       : SERD_SUCCESS;
+	}
+
+	static SerdStatus s_event(void* handle, const SerdEvent* event) noexcept
+	{
+		const auto* const sink = static_cast<const Sink*>(handle);
+
+		switch (event->type) {
+		case SERD_BASE:
+			return sink->_base_func
+			           ? SerdStatus(sink->_base_func(NodeView(event->base.uri)))
+			           : SERD_SUCCESS;
+		case SERD_PREFIX:
+			return sink->_prefix_func
+			           ? SerdStatus(
+			                 sink->_prefix_func(NodeView(event->prefix.name),
+			                                    NodeView(event->prefix.uri)))
+			           : SERD_SUCCESS;
+		case SERD_STATEMENT:
+			return sink->_statement_func
+			           ? SerdStatus(sink->_statement_func(
+			                 StatementFlags(event->statement.flags),
+			                 StatementView(event->statement.statement)))
+			           : SERD_SUCCESS;
+		case SERD_END:
+			return sink->_end_func
+			           ? SerdStatus(sink->_end_func(NodeView(event->end.node)))
+			           : SERD_SUCCESS;
+		}
+
+		return SERD_SUCCESS;
+	}
+
+	BaseFunc      _base_func{};
+	PrefixFunc    _prefix_func{};
+	StatementFunc _statement_func{};
+	EndFunc       _end_func{};
+};
+
+/**
+   @}
+   @name Environment
+   @{
+*/
+
+template <typename CObj>
+using EnvHandle = detail::
+    DynamicCopyable<CObj, serd_env_copy, serd_env_equals, serd_env_free>;
+
+template <typename CObj>
+class EnvWrapper : public EnvHandle<CObj>
+{
+public:
+	using Base = EnvHandle<CObj>;
+	using UPtr = typename Base::UPtr;
+
+	using Base::cobj;
+
+	explicit EnvWrapper(UPtr ptr) : Base(std::move(ptr)) {}
+
+	/// Return the base URI
+	NodeView base_uri() const
+	{
+		return NodeView(serd_env_base_uri(cobj()));
+	}
+
+	/// Set the base URI
+	Status set_base_uri(const NodeView& uri)
+	{
+		return Status(serd_env_set_base_uri(cobj(), uri.cobj()));
+	}
+
+	/// Set a namespace prefix
+	Status set_prefix(const NodeView& name, const NodeView& uri)
+	{
+		return Status(serd_env_set_prefix(cobj(), name.cobj(), uri.cobj()));
+	}
+
+	/// Set a namespace prefix
+	Status set_prefix(StringView name, const NodeView& uri)
+	{
+		return Status(serd_env_set_prefix_from_strings(cobj(),
+		                                               name.c_str(),
+		                                               uri.c_str()));
+	}
+
+	/// Set a namespace prefix
+	Status set_prefix(StringView name, StringView uri)
+	{
+		return Status(serd_env_set_prefix_from_strings(cobj(),
+		                                               name.c_str(),
+		                                               uri.c_str()));
+	}
+
+	/// Qualify `uri` into a CURIE if possible
+	Optional<Node> qualify(const NodeView& uri) const
+	{
+		return Node(serd_env_qualify(cobj(), uri.cobj()));
+	}
+
+	/// Expand `node` into an absolute URI if possible
+	Optional<Node> expand(const NodeView& node) const
+	{
+		return Node(serd_env_expand(cobj(), node.cobj()));
+	}
+
+	/// Send all prefixes to `sink`
+	void write_prefixes(SinkView sink) const
+	{
+		serd_env_write_prefixes(cobj(), sink.cobj());
+	}
+};
+
+using EnvView = EnvWrapper<const SerdEnv>;
+
+class Env : public EnvWrapper<SerdEnv>
+{
+public:
+	Env()
+	    : EnvWrapper(
+	          EnvWrapper::UPtr{serd_env_new(nullptr), detail::Ownership::owned})
+	{
+	}
+
+	explicit Env(const NodeView& base)
+	    : EnvWrapper(EnvWrapper::UPtr{serd_env_new(base.cobj()),
+	                                  detail::Ownership::owned})
+	{
+	}
+};
+
+/**
+   @}
+   @name Reader
+   @{
+*/
+
+class Reader : public detail::BasicWrapper<SerdReader, serd_reader_free>
+{
+public:
+	Reader(World&      world,
+	       Syntax      syntax,
+	       ReaderFlags flags,
+	       SinkView    sink,
+	       size_t      stack_size)
+	    : BasicWrapper(serd_reader_new(world.cobj(),
+	                                   SerdSyntax(syntax),
+	                                   SerdReaderFlags(flags),
+	                                   sink.cobj(),
+	                                   stack_size))
+	{
+	}
+
+	void add_blank_prefix(StringView prefix)
+	{
+		serd_reader_add_blank_prefix(cobj(), prefix.data());
+	}
+
+	Status start(ByteSource& byte_source)
+	{
+		return Status(serd_reader_start(cobj(), byte_source.cobj()));
+	}
+
+	Status read_chunk() { return Status(serd_reader_read_chunk(cobj())); }
+
+	Status read_document() { return Status(serd_reader_read_document(cobj())); }
+
+	Status finish() { return Status(serd_reader_finish(cobj())); }
+
+private:
+	static inline size_t
+	s_stream_read(void* buf, size_t size, size_t nmemb, void* stream) noexcept
+	{
+		assert(size == 1);
+		try {
+			auto* const s = static_cast<std::istream*>(stream);
+			s->read(static_cast<char*>(buf), std::streamsize(nmemb));
+			if (s->good()) {
+				return nmemb;
+			}
+		} catch (...) {
+		}
+		return 0;
+	}
+
+	static inline int s_stream_error(void* stream) noexcept
+	{
+		try {
+			auto* const s = static_cast<std::istream*>(stream);
+			return (!(s->good()));
+		} catch (...) {
+		}
+		return 1;
+	}
+};
+
+/**
+   @}
+   @name Byte Streams
+   @{
+*/
+
+/**
+   @}
+   @name Writer
+   @{
+*/
+
+struct WriterData
+{
+	ByteSink _byte_sink;
+};
+
+class Writer : public WriterData,
+               public detail::BasicWrapper<SerdWriter, serd_writer_free>
+{
+public:
+	Writer(World&            world,
+	       const Syntax      syntax,
+	       const WriterFlags flags,
+	       Env&              env,
+	       WriteFunc         sink)
+	    : WriterData{sink}
+	    , BasicWrapper(serd_writer_new(world.cobj(),
+	                                   SerdSyntax(syntax),
+	                                   flags,
+	                                   env.cobj(),
+	                                   _byte_sink.cobj()))
+	{
+	}
+
+	Writer(World&            world,
+	       const Syntax      syntax,
+	       const WriterFlags flags,
+	       Env&              env,
+	       std::ostream&     stream)
+	    : WriterData{ByteSink{stream}}
+	    , BasicWrapper(serd_writer_new(world.cobj(),
+	                                   SerdSyntax(syntax),
+	                                   flags,
+	                                   env.cobj(),
+	                                   _byte_sink.cobj()))
+	{
+	}
+
+	SinkView sink() { return SinkView{serd_writer_get_sink(cobj())}; }
+
+	Status set_root_uri(const NodeView& uri)
+	{
+		return Status(serd_writer_set_root_uri(cobj(), uri.cobj()));
+	}
+
+	Status finish() { return Status(serd_writer_finish(cobj())); }
+};
+
+/**
+   @}
+*/
+
+template <typename CObj>
+using IterHandle = detail::
+    DynamicCopyable<CObj, serd_iter_copy, serd_iter_equals, serd_iter_free>;
+
+template <typename CObj>
+class IterWrapper : public IterHandle<CObj>
+{
+public:
+	using Base = IterHandle<CObj>;
+	using UPtr = typename Base::UPtr;
+	using Base::cobj;
+
+	explicit IterWrapper(CObj* ptr, detail::Ownership ownership)
+	    : Base(UPtr{ptr, ownership})
+	{
+	}
+
+	IterWrapper(IterWrapper&&) noexcept = default;
+	IterWrapper(const IterWrapper&)     = default;
+
+	IterWrapper& operator=(IterWrapper&&) noexcept = default;
+	IterWrapper& operator=(const IterWrapper&) = default;
+
+	~IterWrapper() = default;
+
+	const StatementView& operator*() const
+	{
+		_statement = StatementView{serd_iter_get(cobj())};
+		return _statement;
+	}
+
+	const StatementView* operator->() const
+	{
+		_statement = StatementView{serd_iter_get(cobj())};
+		return &_statement;
+	}
+
+protected:
+	mutable StatementView _statement{};
+};
+
+using IterView = IterWrapper<const SerdIter>;
+
+class Iter : public IterWrapper<SerdIter>
+{
+public:
+	explicit Iter(SerdIter* ptr, detail::Ownership ownership)
+	    : IterWrapper(ptr, ownership)
+	{
+	}
+
+	Iter(Iter&&)      = default;
+	Iter(const Iter&) = default;
+
+	Iter& operator=(Iter&&) = default;
+	Iter& operator=(const Iter&) = default;
+
+	~Iter() = default;
+
+	Iter& operator++()
+	{
+		serd_iter_next(this->cobj());
+		return *this;
+	}
+};
+
+class Range : public detail::BasicCopyable<SerdRange,
+                                           serd_range_copy,
+                                           serd_range_equals,
+                                           serd_range_free>
+{
+public:
+	using Base = detail::BasicCopyable<SerdRange,
+	                                   serd_range_copy,
+	                                   serd_range_equals,
+	                                   serd_range_free>;
+
+	explicit Range(SerdRange* r)
+	    : BasicCopyable(r)
+	    , _begin{serd_range_begin(r), detail::Ownership::view}
+	    , _end{serd_range_end(r), detail::Ownership::view}
+	{
+	}
+
+	const Iter& begin() const { return _begin; }
+	Iter&       begin() { return _begin; }
+	const Iter& end() const { return _end; }
+
+	Status serialise(SinkView sink, SerialisationFlags flags = {})
+	{
+		return Status(serd_range_serialise(cobj(), sink.cobj(), flags));
+	}
+
+private:
+	Iter _begin;
+	Iter _end;
+};
+
+using ModelHandle = detail::BasicCopyable<SerdModel,
+                                          serd_model_copy,
+                                          serd_model_equals,
+                                          serd_model_free>;
+
+class Model : public ModelHandle
+{
+public:
+	using Base           = ModelHandle;
+	using value_type     = Statement;
+	using iterator       = Iter;
+	using const_iterator = Iter;
+
+	Model(World& world, ModelFlags flags)
+	    : Base(serd_model_new(world.cobj(), flags))
+	{
+	}
+
+	Model(World& world, ModelFlag flag)
+	    : Base(serd_model_new(world.cobj(), ModelFlags(flag)))
+	{
+	}
+
+	size_t size() const { return serd_model_size(cobj()); }
+
+	bool empty() const { return serd_model_empty(cobj()); }
+
+	void insert(StatementView s) { serd_model_insert(cobj(), s.cobj()); }
+
+	void insert(const NodeView&    s,
+	            const NodeView&    p,
+	            const NodeView&    o,
+	            Optional<NodeView> g = {})
+	{
+		serd_model_add(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj());
+	}
+
+	Iter find(Optional<NodeView> s,
+	          Optional<NodeView> p,
+	          Optional<NodeView> o,
+	          Optional<NodeView> g = {}) const
+	{
+		return Iter(
+		    serd_model_find(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj()),
+		    detail::Ownership::owned);
+	}
+
+	Range range(Optional<NodeView> s,
+	            Optional<NodeView> p,
+	            Optional<NodeView> o,
+	            Optional<NodeView> g = {}) const
+	{
+		return Range(
+		    serd_model_range(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj()));
+	}
+
+	Optional<NodeView> get(Optional<NodeView> s,
+	                       Optional<NodeView> p,
+	                       Optional<NodeView> o,
+	                       Optional<NodeView> g = {}) const
+	{
+		return NodeView(
+		    serd_model_get(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj()));
+	}
+
+	Optional<StatementView> get_statement(Optional<NodeView> s,
+	                                      Optional<NodeView> p,
+	                                      Optional<NodeView> o,
+	                                      Optional<NodeView> g = {}) const
+	{
+		return StatementView(serd_model_get_statement(
+		    cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj()));
+	}
+
+	bool ask(Optional<NodeView> s,
+	         Optional<NodeView> p,
+	         Optional<NodeView> o,
+	         Optional<NodeView> g = {}) const
+	{
+		return serd_model_ask(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj());
+	}
+
+	size_t count(Optional<NodeView> s,
+	             Optional<NodeView> p,
+	             Optional<NodeView> o,
+	             Optional<NodeView> g = {}) const
+	{
+		return serd_model_count(cobj(), s.cobj(), p.cobj(), o.cobj(), g.cobj());
+	}
+
+	Range all() const { return Range(serd_model_all(cobj())); }
+
+	iterator begin() const
+	{
+		return iterator(serd_model_begin(cobj()), detail::Ownership::owned);
+	}
+
+	iterator end() const
+	{
+		return iterator(serd_iter_copy(serd_model_end(cobj())),
+		                detail::Ownership::owned);
+	}
+
+private:
+	friend class detail::Optional<Model>;
+	explicit Model(std::nullptr_t) : BasicCopyable(nullptr) {}
+};
+
+class Inserter : public SinkWrapper<SerdSink>
+{
+public:
+	Inserter(Model& model, Env& env, Optional<NodeView> default_graph = {})
+	    : SinkWrapper(
+	          serd_inserter_new(model.cobj(), env.cobj(), default_graph.cobj()))
+	{
+	}
+};
+
+} // namespace serd
+
+/**
+   @}
+*/
+
+#endif // SERD_SERD_HPP
diff --git a/tests/serd_cxx_test.cpp b/tests/serd_cxx_test.cpp
new file mode 100644
index 00000000..ae346e01
--- /dev/null
+++ b/tests/serd_cxx_test.cpp
@@ -0,0 +1,828 @@
+/*
+  Copyright 2018-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#undef NDEBUG
+
+#include "serd/serd.h"
+#include "serd/serd.hpp"
+
+// TODO: Figure out how to make iwyu not suggest adding these
+#include "serd/detail/Copyable.hpp"
+#include "serd/detail/Flags.hpp"
+#include "serd/detail/Optional.hpp"
+#include "serd/detail/StringView.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <fstream> // IWYU pragma: keep
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+template <typename T>
+static int
+test_move_only(T&& obj)
+{
+	static_assert(!std::is_copy_constructible<T>::value, "");
+	static_assert(!std::is_copy_assignable<T>::value, "");
+
+	const auto* const ptr = obj.cobj();
+
+	// Move construct
+	T moved{std::forward<T>(obj)};
+	assert(moved.cobj() == ptr);
+	assert(!obj.cobj()); // NOLINT
+
+	// Move assign
+	obj = std::move(moved);
+	assert(obj.cobj() == ptr);
+	assert(!moved.cobj()); // NOLINT
+
+	return 0;
+}
+
+template <typename T>
+static int
+test_copy_move(const T& obj)
+{
+	T copy{obj};
+	assert(copy == obj);
+
+	T moved{std::move(copy)};
+	assert(moved == obj);
+	assert(copy != obj); // NOLINT
+
+	T copy_assigned{obj};
+	copy_assigned = obj;
+	assert(copy_assigned == obj);
+
+	T move_assigned{obj};
+	move_assigned = std::move(copy_assigned);
+	assert(move_assigned == obj);
+	assert(copy_assigned != obj); // NOLINT
+
+	return 0;
+}
+
+static int
+test_operators()
+{
+	int st = 0;
+
+	serd::World world;
+
+	serd::Model model(world,
+	                  serd::ModelFlag::index_SPO |
+	                      serd::ModelFlag::store_cursors);
+	model.insert(serd::Statement{serd::make_uri("http://example.org/s"),
+	                             serd::make_uri("http://example.org/p"),
+	                             serd::make_uri("http://example.org/o"),
+	                             serd::Cursor{"test.ttl", 1, 1}});
+
+	serd::Sink sink;
+	serd::Env  env;
+
+	std::ostringstream stream;
+
+	// st |= test_move_only(serd::World{});
+	st |= test_copy_move(serd::Statement{*model.begin()});
+	st |= test_copy_move(
+	    serd::Cursor{serd::make_uri("http://example.org/doc"), 1, 2});
+	st |= test_copy_move(model.begin()->cursor());
+	st |= test_copy_move(serd::Env{});
+	st |= test_move_only(
+	    serd::Reader{world, serd::Syntax::Turtle, {}, sink, 4096});
+	st |= test_copy_move(model.begin());
+	st |= test_copy_move(model.all());
+	// Sink
+	st |= test_copy_move(model);
+	// st |= test_move_only(serd::Inserter{model, env});
+	// st |= test_move_only(serd::Sink{});
+
+	st |= test_copy_move(serd::Env{});
+
+	return st;
+}
+
+template <typename Value>
+static int
+test_optional(const Value& value, const Value& other)
+{
+	test_copy_move(value);
+
+	// Truthiness
+	assert(!serd::Optional<Value>());
+	// assert(!serd::Optional<Value>(nullptr));
+	assert(serd::Optional<Value>(value));
+
+	// Comparison and general sanity
+	serd::Optional<Value> optional{value};
+	assert(optional);
+	assert(optional == value);
+	assert(optional != other);
+	assert(*optional == value);
+	assert(optional.cobj() != value.cobj()); // non-const, must be a copy
+
+	// Reset
+	optional.reset();
+	assert(!optional);
+	assert(!optional.cobj());
+
+	// Copying and moving
+	Value       nonconst = value;
+	const auto* c_ptr    = nonconst.cobj();
+
+	optional = nonconst;
+	serd::Optional<Value> copied{optional};
+	assert(copied == nonconst);
+	assert(copied.cobj() != c_ptr);
+
+	optional = std::move(nonconst);
+	serd::Optional<Value> moved{std::move(optional)};
+	assert(moved.cobj() == c_ptr);
+	assert(!optional); // NOLINT
+
+	serd::Optional<Value> copy_assigned;
+	copy_assigned = optional;
+	assert(copy_assigned == optional);
+	assert(copy_assigned.cobj() != c_ptr);
+
+	serd::Optional<Value> move_assigned;
+	move_assigned = std::move(moved);
+	assert(move_assigned.cobj() == c_ptr);
+	assert(!optional);
+
+	serd::Optional<Value> nullopt_assigned;
+	nullopt_assigned = {};
+	assert(!nullopt_assigned.cobj());
+
+	return 0;
+}
+
+static int
+test_optional()
+{
+	test_optional(serd::make_string("value"), serd::make_string("other"));
+
+	{
+		serd::World world;
+
+		serd::Model value(world, serd::ModelFlag::index_SPO);
+		value.insert(serd::make_uri("http://example.org/s1"),
+		             serd::make_uri("http://example.org/p1"),
+		             serd::make_uri("http://example.org/o1"));
+
+		serd::Model other(world, serd::ModelFlag::index_SPO);
+		value.insert(serd::make_uri("http://example.org/s2"),
+		             serd::make_uri("http://example.org/p2"),
+		             serd::make_uri("http://example.org/o2"));
+
+		test_optional(value, other);
+	}
+
+	return 0;
+}
+
+static int
+test_node(const serd::Node& node)
+{
+	test_copy_move(node);
+
+	if (node.datatype()) {
+		return test_node(*node.datatype());
+	} else if (node.language()) {
+		return test_node(*node.language());
+	}
+	return 0;
+}
+
+static int
+test_string()
+{
+	assert(!strcmp(serd::strerror(serd::Status::err_unknown), "Unknown error"));
+	assert(serd::strtod("4.0") == 4.0);
+
+	static const char* const buf = "36.0";
+	size_t                   end = 0;
+	const double             num = serd::strtod(buf, &end);
+
+	assert(num == 36.0);
+	assert(end == 4);
+
+	return 0;
+}
+
+static int
+test_stringview()
+{
+	const serd::StringView hello{"hello"};
+
+	assert(hello.front() == 'h');
+	assert(hello.back() == 'o');
+
+	assert(*hello.begin() == 'h');
+	assert(*hello.end() == '\0');
+	assert(*(hello.end() - 1) == 'o');
+	assert(*hello.cbegin() == 'h');
+	assert(*hello.cend() == '\0');
+	assert(*(hello.cend() - 1) == 'o');
+
+	assert(hello[0] == 'h');
+	assert(hello[1] == 'e');
+	assert(hello.at(0) == 'h');
+	assert(hello.at(1) == 'e');
+	assert(hello.substr(2) == "llo");
+
+	assert(hello.str() == "hello");
+	assert(std::string(hello) == "hello");
+	assert(!strcmp(static_cast<const char*>(hello), "hello"));
+
+	std::stringstream ss;
+	ss << hello;
+	assert(ss.str() == "hello");
+
+	bool threw = false;
+	try {
+		hello.at(6);
+	} catch (const std::out_of_range&) {
+		threw = true;
+	}
+	assert(threw);
+
+	try {
+		hello.substr(6);
+	} catch (const std::out_of_range&) {
+		threw = true;
+	}
+	assert(threw);
+
+	assert(serd::StringView{} == serd::StringView{}); // NOLINT
+	assert(hello == "hello");
+	assert(hello == std::string{"hello"});
+	assert(hello == serd::StringView{"hello"});
+
+	assert(hello != "world");
+	assert(hello != std::string{"world"});
+	assert(hello != serd::StringView{"world"});
+
+	assert(serd::StringView{"a"}.compare(serd::StringView{"ab"}) < 0);
+	assert(serd::StringView{"ab"}.compare(serd::StringView{"a"}) > 0);
+	assert(serd::StringView{"ab"}.compare(serd::StringView{"ab"}) == 0);
+
+	assert(hello < serd::StringView{"world"});
+	assert(hello < std::string{"world"});
+	assert(hello < "world");
+
+	assert(!(hello < serd::StringView{"apple"}));
+	assert(!(hello < std::string{"apple"}));
+	assert(!(hello < "apple"));
+
+	return 0;
+}
+
+static int
+test_base64()
+{
+	const std::vector<uint8_t> data{1, 1, 2, 3, 5};
+
+	const auto encoded = serd::base64_encode(data);
+	const auto decoded = serd::base64_decode(encoded);
+
+	assert(decoded == data);
+
+	return 0;
+}
+
+static int
+test_syntax()
+{
+	assert(serd::syntax_by_name("Turtle") == serd::Syntax::Turtle);
+	assert(serd::guess_syntax("foo.trig") == serd::Syntax::TriG);
+	assert(!serd::syntax_has_graphs(serd::Syntax::NTriples));
+	return 0;
+}
+
+static int
+test_nodes()
+{
+	const auto type = serd::make_uri("http://example.org/Type");
+	const auto base = serd::make_uri("http://example.org/");
+	const auto root = serd::make_uri("http://example.org/");
+
+	assert(base.type() == serd::NodeType::URI);
+	assert(base.str() == "http://example.org/");
+	assert(base.size() == strlen("http://example.org/"));
+	assert(base == root);
+	assert(base < type);
+	assert(!base.empty());
+	assert(std::count(base.begin(), base.end(), '/') == 3);
+
+	const auto relative = serd::make_uri("rel/uri");
+	const auto resolved = relative.resolve(base);
+	assert(static_cast<std::string>(resolved) == "http://example.org/rel/uri");
+	assert(static_cast<serd::StringView>(resolved) ==
+	       "http://example.org/rel/uri");
+
+	const auto string = serd::make_string("hello\n\"world\"");
+	assert(string.flags() ==
+	       (serd::NodeFlag::has_newline | serd::NodeFlag::has_quote));
+
+	const auto number = serd::make_integer(42);
+	assert(number.flags() == serd::NodeFlag::has_datatype);
+	assert(number.datatype() ==
+	       serd::make_uri("http://www.w3.org/2001/XMLSchema#integer"));
+
+	const auto tagged = serd::make_plain_literal("hallo", "de");
+	assert(tagged.flags() == serd::NodeFlag::has_language);
+	assert(tagged.language() == serd::make_string("de"));
+
+	assert(!test_node(serd::make_string("hello")));
+	assert(!test_node(serd::make_plain_literal("hello", "en")));
+	assert(!test_node(serd::make_typed_literal("hello", type)));
+	assert(!test_node(serd::make_blank("blank")));
+	assert(!test_node(serd::make_curie("eg:curie")));
+	assert(!test_node(serd::make_uri("http://example.org/thing")));
+	assert(!test_node(serd::make_resolved_uri("thing", base)));
+	assert(!test_node(serd::make_file_uri("/foo/bar", "host")));
+	assert(!test_node(serd::make_file_uri("/foo/bar")));
+	assert(!test_node(serd::make_file_uri("/foo/bar", "host")));
+	assert(!test_node(serd::make_file_uri("/foo/bar")));
+	assert(!test_node(serd::make_relative_uri("http://example.org/a", base)));
+	assert(!test_node(
+	    serd::make_relative_uri("http://example.org/a", base, root)));
+	assert(!test_node(serd::make_decimal(1.2, 17, 7)));
+	assert(!test_node(serd::make_decimal(3.4, 17, 7, type)));
+	assert(!test_node(serd::make_integer(56)));
+	assert(!test_node(serd::make_integer(78, type)));
+	assert(!test_node(serd::make_blob("blob", 4, true)));
+	assert(!test_node(serd::make_blob("blob", 4, true, type)));
+
+	return 0;
+}
+
+static int
+test_uri()
+{
+	const auto uri          = serd::make_uri("file:/path");
+	const auto no_authority = serd::URI(uri);
+	assert(no_authority.scheme() == "file");
+	assert(!no_authority.authority().data());
+	assert(no_authority.path() == "/path");
+
+	const auto empty_authority = serd::URI("file:///path");
+	assert(empty_authority.scheme() == "file");
+	assert(empty_authority.authority().data());
+	assert(empty_authority.authority().empty());
+	assert(empty_authority.path() == "/path");
+
+	const auto base = serd::URI("http://example.org/base/");
+	assert(base.scheme() == "http");
+	assert(base.authority() == "example.org");
+	assert(!base.path_base().data());
+	assert(base.path() == "/base/");
+	assert(!base.query().data());
+	assert(!base.fragment().data());
+
+	const auto rel = serd::URI("relative/path?query#fragment");
+	assert(!rel.scheme().data());
+	assert(!rel.authority().data());
+	assert(!rel.path_base().data());
+	assert(rel.path() == "relative/path");
+	assert(rel.query() == "query");
+	assert(rel.fragment() == "#fragment");
+
+	const auto resolved = rel.resolve(base);
+	assert(resolved.scheme() == "http");
+	assert(resolved.authority() == "example.org");
+	assert(resolved.path_base() == "/base/");
+	assert(resolved.path() == "relative/path");
+	assert(resolved.query() == "query");
+	assert(resolved.fragment() == "#fragment");
+
+	assert(resolved.string() ==
+	       "http://example.org/base/relative/path?query#fragment");
+	assert(resolved.relative_string(base) == "relative/path?query#fragment");
+
+	const auto domain = serd::URI("http://example.org/");
+	assert(domain.relative_string(resolved) == "../../");
+	assert(domain.relative_string(resolved, base) == domain.string());
+
+	auto local_file_uri = serd::file_uri_parse("file:///foo/%20bar");
+	assert(local_file_uri == "/foo/ bar");
+
+	auto hostname      = std::string();
+	auto host_file_uri = serd::file_uri_parse("file://host/foo", &hostname);
+	assert(hostname == "host");
+	assert(host_file_uri == "/foo");
+
+	assert(serd::uri_string_has_scheme("http://example.org/"));
+	assert(!serd::uri_string_has_scheme("foo/bar"));
+
+	std::ostringstream ss;
+	ss << resolved;
+	assert(ss.str() == "http://example.org/base/relative/path?query#fragment");
+
+	return 0;
+}
+
+static int
+test_reader()
+{
+	serd::Optional<serd::Node> base_uri;
+	serd::Optional<serd::Node> ns_name;
+	serd::Optional<serd::Node> ns_uri;
+	serd::Optional<serd::Node> ended_node;
+	size_t                     n_statements{};
+	std::stringstream          stream{};
+	serd::Sink                 sink;
+
+	sink.set_base_func([&](serd::NodeView uri) {
+		base_uri = uri;
+		return serd::Status::success;
+	});
+
+	sink.set_prefix_func([&](serd::NodeView name, serd::NodeView uri) {
+		ns_name = name;
+		ns_uri  = uri;
+		return serd::Status::success;
+	});
+
+	sink.set_statement_func(
+	    [&](const serd::StatementFlags, const serd::Statement& statement) {
+		    ++n_statements;
+		    stream << statement.subject() << " " << statement.predicate() << " "
+		           << statement.object() << std::endl;
+		    return serd::Status::success;
+	    });
+
+	sink.set_end_func([&](serd::NodeView node) {
+		ended_node = node;
+		return serd::Status::success;
+	});
+
+	serd::World  world;
+	serd::Reader reader(world, serd::Syntax::Turtle, {}, sink, 4096);
+
+	const std::string input("@base <http://example.org/base> ."
+	                        "@prefix eg: <http://example.org/> ."
+	                        "eg:s eg:p [ eg:p2 eg:o2 ] .");
+
+	// Read from string
+	serd::ByteSource string_source(input);
+	reader.start(string_source);
+	reader.read_document();
+
+	assert(n_statements == 2);
+	assert(stream.str() == "eg:s eg:p b1\n"
+	                       "b1 eg:p2 eg:o2\n");
+
+	assert(base_uri == serd::make_uri("http://example.org/base"));
+	assert(ns_name == serd::make_string("eg"));
+	assert(ns_uri == serd::make_uri("http://example.org/"));
+
+	// Read from C++ stream
+	std::stringstream ss("eg:s eg:p eg:o3 , _:blank .");
+	serd::ByteSource  byte_source(ss);
+	stream.str("");
+	reader.add_blank_prefix("prefix_");
+	reader.start(byte_source);
+	assert(reader.read_chunk() == serd::Status::success);
+	assert(reader.read_chunk() != serd::Status::success);
+
+	assert(n_statements == 4);
+	assert(stream.str() == "eg:s eg:p eg:o3\n"
+	                       "eg:s eg:p prefix_blank\n");
+
+	assert(reader.finish() == serd::Status::success);
+
+	return 0;
+}
+
+static serd::Status
+write_test_doc(serd::Writer& writer)
+{
+	const auto& sink = writer.sink();
+
+	const auto blank = serd::make_blank("b1");
+	sink.base(serd::make_uri("http://drobilla.net/base/"));
+	sink.prefix(serd::make_string("eg"), serd::make_uri("http://example.org/"));
+	sink.write(serd::StatementFlag::anon_O,
+	           serd::make_uri("http://drobilla.net/base/s"),
+	           serd::make_uri("http://example.org/p"),
+	           blank);
+	sink.statement({},
+	               serd::Statement(blank,
+	                               serd::make_uri("http://example.org/p2"),
+	                               serd::make_uri("http://drobilla.net/o")));
+	sink.end(blank);
+
+	return writer.finish();
+}
+
+static const char* writer_test_doc = "@base <http://drobilla.net/base/> .\n"
+                                     "@prefix eg: <http://example.org/> .\n"
+                                     "\n"
+                                     "<s>\n"
+                                     "\teg:p [\n"
+                                     "\t\teg:p2 <../o>\n"
+                                     "\t] .\n";
+
+static int
+test_writer_ostream()
+{
+	serd::World        world;
+	serd::Env          env;
+	std::ostringstream stream;
+	serd::Writer       writer(world, serd::Syntax::Turtle, {}, env, stream);
+
+	write_test_doc(writer);
+	assert(stream.str() == writer_test_doc);
+
+	{
+		std::ofstream bad_file("/does/not/exist");
+		bad_file.clear();
+		bad_file.exceptions(std::ofstream::badbit);
+		writer = serd::Writer(world, serd::Syntax::Turtle, {}, env, bad_file);
+		const serd::Status st =
+		    writer.sink().base(serd::make_uri("http://drobilla.net/base/"));
+		assert(st == serd::Status::err_bad_write);
+	}
+
+	return 0;
+}
+
+static int
+test_writer_string_sink()
+{
+	serd::World  world;
+	serd::Env    env;
+	std::string  output;
+	serd::Writer writer(world,
+	                    serd::Syntax::Turtle,
+	                    {},
+	                    env,
+	                    [&output](const char* str, size_t len) {
+		                    output += str;
+		                    return len;
+	                    });
+
+	write_test_doc(writer);
+	assert(output == writer_test_doc);
+
+	return 0;
+}
+
+static int
+test_env()
+{
+	serd::Env env{serd::make_uri("http://example.org/")};
+	assert(env.base_uri() == serd::make_uri("http://example.org/"));
+
+	env = serd::Env{};
+
+	const auto base = serd::make_uri("http://drobilla.net/");
+	env.set_base_uri(base);
+	assert(env.base_uri() == base);
+
+	env.set_prefix(serd::make_string("eg"),
+	               serd::make_uri("http://drobilla.net/"));
+	env.set_prefix("eg", serd::make_uri("http://example.org/"));
+
+	assert(env.qualify(serd::make_uri("http://example.org/foo")) ==
+	       serd::make_curie("eg:foo"));
+
+	assert(env.expand(serd::make_uri("foo")) ==
+	       serd::make_uri("http://drobilla.net/foo"));
+
+	serd::Env copied{env};
+	assert(copied.qualify(serd::make_uri("http://example.org/foo")) ==
+	       serd::make_curie("eg:foo"));
+
+	assert(copied.expand(serd::make_uri("foo")) ==
+	       serd::make_uri("http://drobilla.net/foo"));
+
+	serd::Env assigned;
+	assigned   = env;
+	auto curie = env.qualify(serd::make_uri("http://example.org/foo"));
+
+	assert(assigned.qualify(serd::make_uri("http://example.org/foo")) ==
+	       serd::make_curie("eg:foo"));
+
+	assert(assigned.expand(serd::make_uri("foo")) ==
+	       serd::make_uri("http://drobilla.net/foo"));
+
+	serd::Sink                 sink;
+	serd::Optional<serd::Node> ns_name;
+	serd::Optional<serd::Node> ns_uri;
+
+	sink.set_prefix_func([&](serd::NodeView name, serd::NodeView uri) {
+		ns_name = name;
+		ns_uri  = uri;
+		return serd::Status::success;
+	});
+
+	env.write_prefixes(sink);
+	assert(ns_name == serd::make_string("eg"));
+	assert(ns_uri == serd::make_uri("http://example.org/"));
+
+	return 0;
+}
+
+static int
+test_statement()
+{
+	const auto s   = serd::make_uri("http://example.org/s");
+	const auto p   = serd::make_uri("http://example.org/p");
+	const auto o   = serd::make_uri("http://example.org/o");
+	const auto g   = serd::make_uri("http://example.org/g");
+	const auto cur = serd::Cursor{"test", 42, 53};
+
+	const auto t_statement = serd::Statement{s, p, o};
+
+	assert(t_statement.subject() == s);
+	assert(t_statement.predicate() == p);
+	assert(t_statement.object() == o);
+	assert(!t_statement.graph());
+	assert(!t_statement.cursor());
+
+	const auto q_statement = serd::Statement{s, p, o, g, cur};
+	assert(q_statement.subject() == s);
+	assert(q_statement.predicate() == p);
+	assert(q_statement.object() == o);
+	assert(q_statement.graph() == g);
+	assert(q_statement.cursor() == cur);
+
+	assert(q_statement.node(serd::Field::subject) == s);
+	assert(q_statement.node(serd::Field::predicate) == p);
+	assert(q_statement.node(serd::Field::object) == o);
+	assert(q_statement.node(serd::Field::graph) == g);
+
+	return 0;
+}
+
+static int
+test_model()
+{
+	serd::World world;
+	serd::Model model(world,
+	                  serd::ModelFlag::index_SPO | serd::ModelFlag::index_OPS);
+
+	assert(model.empty());
+
+	const auto s  = serd::make_uri("http://example.org/s");
+	const auto p  = serd::make_uri("http://example.org/p");
+	const auto o1 = serd::make_uri("http://example.org/o1");
+	const auto o2 = serd::make_uri("http://example.org/o2");
+
+	serd::NodeView b = world.get_blank();
+	auto           r = b.resolve(s);
+
+	model.insert(s, p, o1);
+	model.insert(serd::Statement{s, p, o2});
+
+	assert(!model.empty());
+	assert(model.size() == 2);
+	assert(model.ask(s, p, o1));
+	assert(model.count(s, p, o1) == 1);
+	assert(!model.ask(s, p, s));
+
+	size_t total_count = 0;
+	for (const auto& statement : model) {
+		assert(statement.subject() == s);
+		assert(statement.predicate() == p);
+		assert(statement.object() == o1 || statement.object() == o2);
+		++total_count;
+	}
+	assert(total_count == 2);
+
+	size_t o1_count = 0;
+	for (const auto& statement : model.range({}, {}, o1)) {
+		assert(statement.subject() == s);
+		assert(statement.predicate() == p);
+		assert(statement.object() == o1);
+		++o1_count;
+	}
+	assert(o1_count == 1);
+
+	size_t o2_count = 0;
+	for (const auto& statement : model.range({}, {}, o2)) {
+		assert(statement.subject() == s);
+		assert(statement.predicate() == p);
+		assert(statement.object() == o2);
+		++o2_count;
+	}
+	assert(o2_count == 1);
+
+	assert(model.get({}, p, o1) == s);
+
+	const auto statement = model.get_statement(s, p, {});
+	assert(statement);
+	assert(statement->subject() == s);
+	assert(statement->predicate() == p);
+	assert(statement->object() == o1);
+
+	const auto iter = model.find(s, p, {});
+	assert(iter->subject() == s);
+	assert(iter->predicate() == p);
+	assert(iter->object() == o1);
+
+	serd::Model copy(model);
+	assert(copy == model);
+
+	copy.insert(s, p, s);
+	assert(copy != model);
+
+	return 0;
+}
+
+static int
+test_log()
+{
+	serd::World world;
+	bool        called = false;
+	world.set_message_func([&called](const serd::StringView domain,
+	                                 const serd::LogLevel   level,
+	                                 const serd::LogFields& fields,
+	                                 const std::string&     msg) {
+		assert(domain == "test");
+		assert(fields.at("TEST_EXTRA") == "extra field");
+		assert(level == serd::LogLevel::err);
+		assert(msg == "bad argument to something: 42\n");
+		called = true;
+		return serd::Status::success;
+	});
+
+	const auto success = world.log("test",
+	                               serd::LogLevel::err,
+	                               {{"TEST_EXTRA", "extra field"}},
+	                               "bad argument to %s: %d\n",
+	                               "something",
+	                               42);
+
+	assert(called);
+	assert(success == serd::Status::success);
+
+	world.set_message_func([](const serd::StringView,
+	                          const serd::LogLevel,
+	                          const serd::LogFields&,
+	                          const std::string&) -> serd::Status {
+		throw std::runtime_error("error");
+	});
+
+	const auto failure = world.log("test", serd::LogLevel::err, {}, "failure");
+	assert(failure == serd::Status::err_internal);
+
+	return 0;
+}
+
+int
+main()
+{
+	using TestFunc = int (*)();
+
+	constexpr std::array<TestFunc, 15> tests{{test_operators,
+	                                          test_optional,
+	                                          test_nodes,
+	                                          test_string,
+	                                          test_stringview,
+	                                          test_base64,
+	                                          test_syntax,
+	                                          test_uri,
+	                                          test_env,
+	                                          test_reader,
+	                                          test_writer_ostream,
+	                                          test_writer_string_sink,
+	                                          test_statement,
+	                                          test_model,
+	                                          test_log}};
+
+	int failed = 0;
+	for (const auto& test : tests) {
+		failed += test();
+	}
+
+	std::cerr << "Failed " << failed << " tests" << std::endl;
+
+	return failed;
+}
diff --git a/wscript b/wscript
index 2d10f77c..8a9e98e4 100644
--- a/wscript
+++ b/wscript
@@ -28,10 +28,12 @@ post_tags    = ['Hacking', 'RDF', 'Serd']
 
 def options(ctx):
     ctx.load('compiler_c')
+    ctx.load('compiler_cxx')
     opt = ctx.configuration_options()
     ctx.add_flags(
         opt,
         {'no-utils':     'do not build command line utilities',
+         'no-cxx':       'do not build C++ bindings',
          'stack-check':  'include runtime stack sanity checks',
          'static':       'build static library',
          'no-shared':    'do not build shared library',
@@ -43,11 +45,18 @@ def options(ctx):
 
 def configure(conf):
     conf.load('compiler_c', cache=True)
+
+    if not Options.options.no_cxx:
+        conf.load('compiler_cxx', cache=True)
+
     conf.load('autowaf', cache=True)
 
     if not autowaf.set_c_lang(conf, 'c11', mandatory=False):
         autowaf.set_c_lang(conf, 'c99')
 
+    if 'COMPILER_CXX' in conf.env:
+        autowaf.set_cxx_lang(conf, 'c++11')
+
     if Options.options.strict:
         # Check for programs used by lint target
         conf.find_program("flake8", var="FLAKE8", mandatory=False)
@@ -94,6 +103,26 @@ def configure(conf):
             ],
         })
 
+        autowaf.add_compiler_flags(conf.env, 'cxx', {
+            'clang': [
+                '-Wno-documentation-unknown-command',
+            ],
+            'gcc': [
+                '-Wno-multiple-inheritance',
+            ],
+            'msvc': [
+                '/wd4355',  # 'this' used in base member initializer list
+                '/wd4571',  # structured exceptions are no longer caught
+                '/wd4623',  # default constructor implicitly deleted
+                '/wd4625',  # copy constructor implicitly deleted
+                '/wd4626',  # assignment operator implicitly deleted
+                '/wd4710',  # function not inlined
+                '/wd4868',  # may not enforce left-to-right evaluation order
+                '/wd5026',  # move constructor implicitly deleted
+                '/wd5027',  # move assignment operator implicitly deleted
+            ]
+        })
+
     conf.env.update({
         'BUILD_UTILS': not Options.options.no_utils,
         'BUILD_SHARED': not Options.options.no_shared,
@@ -198,9 +227,14 @@ lib_source = ['src/base64.c',
 
 
 def build(bld):
-    # C Headers
+    # Main C and C++ headers
     includedir = '${INCLUDEDIR}/serd-%s/serd' % SERD_MAJOR_VERSION
-    bld.install_files(includedir, bld.path.ant_glob('serd/*.h'))
+    bld.install_files(includedir, bld.path.ant_glob('serd/*.h*'))
+
+    # C++ detail headers
+    includedir = '${INCLUDEDIR}/serd-%s/serd' % SERD_MAJOR_VERSION
+    bld.install_files(includedir + '/detail',
+                      bld.path.ant_glob('serd/detail/*.hpp'))
 
     # Pkgconfig file
     autowaf.build_pc(bld, 'SERD', SERD_VERSION, SERD_MAJOR_VERSION, [],
@@ -243,6 +277,7 @@ def build(bld):
         coverage_flags = [''] if bld.env.NO_COVERAGE else ['--coverage']
         test_args = {'includes':     ['.', './src'],
                      'cflags':       coverage_flags,
+                     'cxxflags':     coverage_flags,
                      'linkflags':    coverage_flags,
                      'lib':          lib_args['lib'],
                      'install_path': ''}
@@ -283,6 +318,15 @@ def build(bld):
                 defines      = defines,
                 **test_args)
 
+        # C++ API test
+        if 'COMPILER_CXX' in bld.env:
+            bld(features     = 'cxx cxxprogram',
+                source       = 'tests/serd_cxx_test.cpp',
+                use          = 'libserd_profiled',
+                target       = 'serd_cxx_test',
+                defines      = defines,
+                **test_args)
+
     # Utilities
     if bld.env.BUILD_UTILS:
         obj = bld(features     = 'c cprogram',
@@ -348,7 +392,7 @@ def lint(ctx):
 
     if "CLANG_TIDY" in ctx.env and "clang" in ctx.env.CC[0]:
         Logs.info("Running clang-tidy")
-        sources = glob.glob('src/*.c') + glob.glob('tests/*.c')
+        sources = glob.glob('src/*.c') + glob.glob('tests/*.c*')
         sources = list(map(os.path.abspath, sources))
         procs = []
         for source in sources:
@@ -720,6 +764,9 @@ def test(tst):
         check(['./statement_test'])
         check(['./terse_write_test'])
 
+        if 'COMPILER_CXX' in tst.env:
+            check(['./serd_cxx_test'])
+
     def test_syntax_io(check, in_name, check_name, lang):
         in_path = 'tests/good/%s' % in_name
         out_path = in_path + '.io'