statically link libstdc++ on Linux and remove std::variant

this will hopefully fix #1610

cmake/ConfigureCompiler.cmake

@@ -1,5 +1,4 @@
 set(USE_GPERFTOOLS OFF CACHE BOOL "Use gperfools for profiling")
-set(PORTABLE_BINARY OFF CACHE BOOL "Create a binary that runs on older OS versions")
 set(USE_VALGRIND OFF CACHE BOOL "Compile for valgrind usage")
 set(ALLOC_INSTRUMENTATION OFF CACHE BOOL "Instrument alloc")
 set(WITH_UNDODB OFF CACHE BOOL "Use rr or undodb")
@@ -9,6 +8,7 @@ set(USE_LD "LD" CACHE STRING "The linker to use for building: can be LD (system
 set(USE_LIBCXX OFF CACHE BOOL "Use libc++")
 set(USE_CCACHE OFF CACHE BOOL "Use ccache for compilation if available")
 set(RELATIVE_DEBUG_PATHS OFF CACHE BOOL "Use relative file paths in debug info")
+set(STATIC_LINK_LIBCXX ON CACHE BOOL "Statically link libstdcpp/libc++")
 
 set(rel_debug_paths OFF)
 if(RELATIVE_DEBUG_PATHS)
@@ -131,6 +131,11 @@ else()
     set(CMAKE_SHARED_LINKER_FLAGS "-static-libstdc++ -static-libgcc ${CMAKE_SHARED_LINKER_FLAGS}")
     set(CMAKE_EXE_LINKER_FLAGS    "-static-libstdc++ -static-libgcc ${CMAKE_EXE_LINKER_FLAGS}")
   endif()
+  if(STATIC_LINK_LIBCXX)
+    if (NOT USE_LIBCXX AND NOT APPLE)
+      add_link_options(-static-libstdc++ -static-libgcc)
+    endif()
+  endif()
   # Instruction sets we require to be supported by the CPU
   add_compile_options(
     -maes

flow/ObjectSerializerTraits.h

@@ -27,6 +27,7 @@
 #include <functional>
 #include <vector>
 #include <variant>
+#include <boost/variant.hpp>
 
 template <class T, typename = void>
 struct is_fb_function_t : std::false_type {};
@@ -151,15 +152,15 @@ struct struct_like_traits : std::false_type {
 };
 
 template <class... Alternatives>
-struct union_like_traits<std::variant<Alternatives...>> : std::true_type {
-	using Member = std::variant<Alternatives...>;
+struct union_like_traits<boost::variant<Alternatives...>> : std::true_type {
+	using Member = boost::variant<Alternatives...>;
 	using alternatives = pack<Alternatives...>;
-	static uint8_t index(const Member& variant) { return variant.index(); }
+	static uint8_t index(const Member& variant) { return variant.which(); }
 	static bool empty(const Member& variant) { return false; }
 
 	template <int i>
 	static const index_t<i, alternatives>& get(const Member& variant) {
-		return std::get<index_t<i, alternatives>>(variant);
+		return boost::get<index_t<i, alternatives>>(variant);
 	}
 
 	template <size_t i, class Alternative>

flow/flat_buffers.cpp

@@ -286,7 +286,7 @@ TEST_CASE("flow/FlatBuffers/serializeDeserializeMembers") {
 namespace unit_tests {
 
 TEST_CASE("flow/FlatBuffers/variant") {
-	using V = std::variant<int, double, Nested2>;
+	using V = boost::variant<int, double, Nested2>;
 	V v1;
 	V v2;
 	Arena arena;
@@ -297,21 +297,21 @@ TEST_CASE("flow/FlatBuffers/variant") {
 	out = save_members(arena, FileIdentifier{}, v1);
 	// print_buffer(out, arena.get_size(out));
 	load_members(out, context, v2);
-	ASSERT(std::get<int>(v1) == std::get<int>(v2));
+	ASSERT(boost::get<int>(v1) == boost::get<int>(v2));
 
 	v1 = 1.0;
 	out = save_members(arena, FileIdentifier{}, v1);
 	// print_buffer(out, arena.get_size(out));
 	load_members(out, context, v2);
-	ASSERT(std::get<double>(v1) == std::get<double>(v2));
+	ASSERT(boost::get<double>(v1) == boost::get<double>(v2));
 
 	v1 = Nested2{ 1, { "abc", "def" }, 2 };
 	out = save_members(arena, FileIdentifier{}, v1);
 	// print_buffer(out, arena.get_size(out));
 	load_members(out, context, v2);
-	ASSERT(std::get<Nested2>(v1).a == std::get<Nested2>(v2).a);
-	ASSERT(std::get<Nested2>(v1).b == std::get<Nested2>(v2).b);
-	ASSERT(std::get<Nested2>(v1).c == std::get<Nested2>(v2).c);
+	ASSERT(boost::get<Nested2>(v1).a == boost::get<Nested2>(v2).a);
+	ASSERT(boost::get<Nested2>(v1).b == boost::get<Nested2>(v2).b);
+	ASSERT(boost::get<Nested2>(v1).c == boost::get<Nested2>(v2).c);
 	return Void();
 }
 
@@ -344,7 +344,7 @@ struct Y1 {
 
 struct Y2 {
 	int a;
-	std::variant<int> b;
+	boost::variant<int> b;
 
 	template <class Archiver>
 	void serialize(Archiver& ar) {

flow/network.cpp

@@ -38,9 +38,9 @@ bool IPAddress::operator<(const IPAddress& rhs) const {
 
 std::string IPAddress::toString() const {
 	if (isV6()) {
-		return boost::asio::ip::address_v6(std::get<IPAddressStore>(addr)).to_string();
+		return boost::asio::ip::address_v6(boost::get<IPAddressStore>(addr)).to_string();
 	} else {
-		auto ip = std::get<uint32_t>(addr);
+		auto ip = boost::get<uint32_t>(addr);
 		return format("%d.%d.%d.%d", (ip >> 24) & 0xff, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
 	}
 }
@@ -56,10 +56,10 @@ Optional<IPAddress> IPAddress::parse(std::string str) {
 
 bool IPAddress::isValid() const {
 	if (isV6()) {
-		const auto& ip = std::get<IPAddressStore>(addr);
+		const auto& ip = boost::get<IPAddressStore>(addr);
 		return std::any_of(ip.begin(), ip.end(), [](uint8_t part) { return part != 0; });
 	}
-	return std::get<uint32_t>(addr) != 0;
+	return boost::get<uint32_t>(addr) != 0;
 }
 
 NetworkAddress NetworkAddress::parse( std::string const& s ) {

flow/network.h

@@ -99,25 +99,36 @@ class Void;
 template<class T> class Optional;
 
 struct IPAddress {
-	// Represents both IPv4 and IPv6 address. For IPv4 addresses,
-	// only the first 32bits are relevant and rest are initialized to
-	// 0.
 	typedef boost::asio::ip::address_v6::bytes_type IPAddressStore;
 	static_assert(std::is_same<IPAddressStore, std::array<uint8_t, 16>>::value,
 	              "IPAddressStore must be std::array<uint8_t, 16>");
 
+private:
+	struct IsV6Visitor : boost::static_visitor<> {
+		bool result = false;
+		void operator() (const IPAddressStore&) { result = true; }
+		void operator() (const uint32_t&) { result = true; }
+	};
+public:
+	// Represents both IPv4 and IPv6 address. For IPv4 addresses,
+	// only the first 32bits are relevant and rest are initialized to
+	// 0.
 	IPAddress() : addr(uint32_t(0)) {}
 	explicit IPAddress(const IPAddressStore& v6addr) : addr(v6addr) {}
 	explicit IPAddress(uint32_t v4addr) : addr(v4addr) {}
 
-	bool isV6() const { return std::holds_alternative<IPAddressStore>(addr); }
+	bool isV6() const {
+		IsV6Visitor visitor;
+		boost::apply_visitor(visitor, addr);
+		return visitor.result;
+	}
 	bool isV4() const { return !isV6(); }
 	bool isValid() const;
 
 	// Returns raw v4/v6 representation of address. Caller is responsible
 	// to call these functions safely.
-	uint32_t toV4() const { return std::get<uint32_t>(addr); }
-	const IPAddressStore& toV6() const { return std::get<IPAddressStore>(addr); }
+	uint32_t toV4() const { return boost::get<uint32_t>(addr); }
+	const IPAddressStore& toV6() const { return boost::get<IPAddressStore>(addr); }
 
 	std::string toString() const;
 	static Optional<IPAddress> parse(std::string str);
@@ -158,7 +169,7 @@ struct IPAddress {
 	}
 
 private:
-	std::variant<uint32_t, IPAddressStore> addr;
+	boost::variant<uint32_t, IPAddressStore> addr;
 };
 
 template<>