logger: use Logger* instead of Logger& to propagate signature using swig

See the comment in IfcLogger.h explaining this.

src/ifcconvert/IfcConvert.cpp

@@ -675,7 +675,7 @@ int main(int argc, char** argv) {
 				time_t start, end;
 				time(&start);
                 if (output_extension == XML) {
-                    XmlSerializer s(ifc_file, IfcUtil::path::to_utf8(output_temp_filename), logger);
+                    XmlSerializer s(ifc_file, IfcUtil::path::to_utf8(output_temp_filename), &logger);
                     logger.Status("Writing XML output...");
                     s.finalize();
                 } else {
@@ -834,14 +834,14 @@ int main(int argc, char** argv) {
 	if (output_extension == OBJ) {
         // Do not use temp file for MTL as it's such a small file.
         const path_t mtl_filename = change_extension(output_filename, MTL);
-		serializer = boost::make_shared<WaveFrontOBJSerializer>(IfcUtil::path::to_utf8(output_temp_filename), IfcUtil::path::to_utf8(mtl_filename), geometry_settings, serializer_settings, logger);
+		serializer = boost::make_shared<WaveFrontOBJSerializer>(IfcUtil::path::to_utf8(output_temp_filename), IfcUtil::path::to_utf8(mtl_filename), geometry_settings, serializer_settings, &logger);
 #ifdef WITH_OPENCOLLADA
 	} else if (output_extension == DAE) {
-		serializer = boost::make_shared<ColladaSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, logger);
+		serializer = boost::make_shared<ColladaSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, &logger);
 #endif
 #ifdef WITH_GLTF
 	} else if (output_extension == GLB) {
-		serializer = boost::make_shared<GltfSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, logger);
+		serializer = boost::make_shared<GltfSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, &logger);
 #endif
 #ifdef WITH_USD
 	} else if (output_extension == USD || output_extension == USDA || output_extension == USDC) {
@@ -858,15 +858,15 @@ int main(int argc, char** argv) {
 		serializer = boost::make_shared<IgesSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, logger);
 	} else if (output_extension == SVG) {
 		geometry_settings.get<ifcopenshell::geometry::settings::IteratorOutput>().value = ifcopenshell::geometry::settings::NATIVE;
-		serializer = boost::make_shared<SvgSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, logger);
+		serializer = boost::make_shared<SvgSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, &logger);
 #ifdef WITH_HDF5
 	} else if (output_extension == HDF) {
 		geometry_settings.get<ifcopenshell::geometry::settings::IteratorOutput>().value = ifcopenshell::geometry::settings::NATIVE;
-		serializer = boost::make_shared<HdfSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, false, logger);
+		serializer = boost::make_shared<HdfSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, false, &logger);
+#endif
 #endif
-#endif	
 	} else if (output_extension == TTL) {
-		serializer = boost::make_shared<TtlWktSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, logger);
+		serializer = boost::make_shared<TtlWktSerializer>(IfcUtil::path::to_utf8(output_temp_filename), geometry_settings, serializer_settings, &logger);
 	} else {
         cerr_ << "[Error] Unknown output filename extension '" << output_extension << "'\n";
 		write_log(!quiet);
@@ -1011,7 +1011,7 @@ int main(int argc, char** argv) {
 		if (!vmap.count("cache-file")) {
 			cache_file = input_filename + CACHE + HDF;
 		}
-		cache.reset(new HdfSerializer(IfcUtil::path::to_utf8(cache_file), geometry_settings, serializer_settings, false, logger));
+		cache.reset(new HdfSerializer(IfcUtil::path::to_utf8(cache_file), geometry_settings, serializer_settings, false, &logger));
 		context_iterator->set_cache(cache.get());
 	}
 #endif
@@ -1290,7 +1290,7 @@ bool init_input_file(const std::string& filename, IfcParse::IfcFile*& ifc_file,
 
 #ifdef WITH_IFCXML
 	if (boost::ends_with(boost::to_lower_copy(filename), ".ifcxml")) {
-		ifc_file = IfcParse::parse_ifcxml(filename, logger);
+		ifc_file = IfcParse::parse_ifcxml(filename, &logger);
     } else
 #endif
     {

src/ifcopenshell-python/ifcopenshell/ifcopenshell_wrapper.pyi

@@ -138,7 +138,7 @@ class BRepElement(Element):
     def volume(self): ...
 
 class ColladaSerializer(WriteOnlyGeometrySerializer):
-    def __init__(self, dae_filename, geometry_settings, settings): ...
+    def __init__(self, dae_filename, geometry_settings, settings, logger=None): ...
     def finalize(self): ...
     def isTesselated(self): ...
     def object_id(self, o): ...
@@ -284,7 +284,7 @@ class GeometrySerializer:
     def write(self, *args): ...
 
 class GltfSerializer(WriteOnlyGeometrySerializer):
-    def __init__(self, filename, geometry_settings, settings): ...
+    def __init__(self, filename, geometry_settings, settings, logger=None): ...
     def finalize(self): ...
     def isTesselated(self): ...
     def ready(self): ...
@@ -294,7 +294,7 @@ class GltfSerializer(WriteOnlyGeometrySerializer):
     def writeHeader(self): ...
 
 class HdfSerializer(GeometrySerializer):
-    def __init__(self, hdf_filename, geometry_settings, settings, read_only=False): ...
+    def __init__(self, hdf_filename, geometry_settings, settings, read_only=False, logger=None): ...
     def finalize(self): ...
     def isTesselated(self): ...
     def read(self, *args): ...
@@ -466,7 +466,7 @@ class Settings:
     def setting_names(self): ...
 
 class SvgSerializer(WriteOnlyGeometrySerializer):
-    def __init__(self, out_filename, geometry_settings, settings): ...
+    def __init__(self, out_filename, geometry_settings, settings, logger=None): ...
     SH_NONE: Any
     SH_FULL: Any
     SH_LEFT: Any
@@ -609,7 +609,7 @@ class TriangulationElement(Element):
     def geometry_pointer(self): ...
 
 class TtlWktSerializer(WriteOnlyGeometrySerializer):
-    def __init__(self, filename, geometry_settings, settings): ...
+    def __init__(self, filename, geometry_settings, settings, logger=None): ...
     def finalize(self): ...
     def isTesselated(self): ...
     def ready(self): ...
@@ -620,7 +620,7 @@ class TtlWktSerializer(WriteOnlyGeometrySerializer):
     def writeHeader(self): ...
 
 class WaveFrontOBJSerializer(WriteOnlyGeometrySerializer):
-    def __init__(self, obj_filename, mtl_filename, geometry_settings, settings): ...
+    def __init__(self, obj_filename, mtl_filename, geometry_settings, settings, logger=None): ...
     def finalize(self): ...
     def isTesselated(self): ...
     def ready(self): ...
@@ -635,7 +635,7 @@ class WriteOnlyGeometrySerializer(GeometrySerializer):
     def read(self, *args): ...
 
 class XmlSerializer:
-    def __init__(self, file, xml_filename): ...
+    def __init__(self, file, xml_filename, logger=None): ...
     def finalize(self): ...
     def ready(self): ...
     def setFile(self, arg2): ...
@@ -1695,17 +1695,17 @@ class type_declaration(declaration):
 
 class uninitialized_tag: ...
 
-def arrange_polygons(settings, polygons): ...
+def arrange_polygons(settings, polygons, logger=None): ...
 def clear_schemas(): ...
-def construct_iterator(geometry_library, settings, file, num_threads, logger=...): ...
+def construct_iterator(geometry_library, settings, file, num_threads, logger=None): ...
 def construct_iterator_with_include_exclude(
-    geometry_library, settings, file, elems, include, num_threads, logger=...
+    geometry_library, settings, file, elems, include, num_threads, logger=None
 ): ...
 def construct_iterator_with_include_exclude_globalid(
-    geometry_library, settings, file, elems, include, num_threads, logger=...
+    geometry_library, settings, file, elems, include, num_threads, logger=None
 ): ...
 def construct_iterator_with_include_exclude_id(
-    geometry_library, settings, file, elems, include, num_threads, logger=...
+    geometry_library, settings, file, elems, include, num_threads, logger=None
 ): ...
 def convert_loop_to_function_item(loop): ...
 def create_box(*args): ...
@@ -1721,10 +1721,11 @@ def kind_to_string(k): ...
 def less(arg1, arg2): ...
 def line_segments_to_polygons(s, eps, segments): ...
 def map_shape(settings, instance): ...
+def logger_or_root(logger): ...
 def nary_union(sequence): ...
 def new_IfcBaseClass(schema_identifier: str, name: str) -> entity_instance: ...
-def open(fn: str, readonly: bool = False, logger=...) -> file: ...
+def open(fn: str, readonly: bool = False, logger=None) -> file: ...
-def parse_ifcxml(filename, logger=...): ...
+def parse_ifcxml(filename, logger=None): ...
 def polygons_to_svg(*args): ...
 def read(data): ...
 def register_schema(arg1): ...

src/ifcparse/IfcFile.h

@@ -447,7 +447,7 @@ public:
 };
 
 #ifdef WITH_IFCXML
-IFC_PARSE_API IfcFile* parse_ifcxml(const std::string& filename, Logger& logger = Logger::Root());
+IFC_PARSE_API IfcFile* parse_ifcxml(const std::string& filename, Logger* logger = nullptr);
 #endif
 
 namespace impl {

src/ifcparse/IfcLogger.h

@@ -142,6 +142,13 @@ class IFC_PARSE_API Logger {
     const std::vector<log_message>& log_messages() const { return log_messages_; }
 };
 
+// SWIG couldn't represent `Logger::Root()` default value using Python,
+// so when translating signature it represents it just as `fn(*args)`, losing information about args.
+// Using `Logger * = nullptr` instead of `&Logger = Logger::Root` helps,
+// since `nullptr` is convertable Python's `None`.
+// `logger_or_root` is just covering the boilerplate for this pattern.
+inline Logger& logger_or_root(Logger* logger) { return logger ? *logger : Logger::Root(); }
+
 #define PERF(x)                                                      \
                                                                      \
     Logger::Root().Message(Logger::LOG_PERF, "SYS", 1, x);            \

src/ifcparse/parse_ifcxml.cpp

@@ -695,10 +695,10 @@ end:
     return;
 }
 
-IFC_PARSE_API IfcParse::IfcFile* IfcParse::parse_ifcxml(const std::string& filename, Logger& logger) {
+IFC_PARSE_API IfcParse::IfcFile* IfcParse::parse_ifcxml(const std::string& filename, Logger* logger) {
     throw std::runtime_error("IFC-XML import temporarily disabled");
 
-    ifcxml_parse_state state(logger);
+    ifcxml_parse_state state(logger_or_root(logger));
 
     xmlSAXHandler handler;
     memset(&handler, 0, sizeof(xmlSAXHandler));

src/ifcwrap/IfcGeomWrapper.i

@@ -630,29 +630,33 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 // I couldn't get the vector<string> typemap to be applied when %extending Iterator constructor.
 // anyway it does not matter as SWIG generates C code without actual constructors
 %inline %{
-	IfcGeom::Iterator* construct_iterator(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, int num_threads, Logger& logger = Logger::Root()) {
+	IfcGeom::Iterator* construct_iterator(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, int num_threads, Logger* logger = nullptr) {
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger), settings, file, num_threads, logger);
+		Logger& logger_ = logger_or_root(logger);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger_), settings, file, num_threads, logger_);
 	}
 
-	IfcGeom::Iterator* construct_iterator_with_include_exclude(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<std::string> elems, bool include, int num_threads, Logger& logger = Logger::Root()) {
+	IfcGeom::Iterator* construct_iterator_with_include_exclude(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<std::string> elems, bool include, int num_threads, Logger* logger = nullptr) {
+		Logger& logger_ = logger_or_root(logger);
 		std::set<std::string> elems_set(elems.begin(), elems.end());
 		IfcGeom::entity_filter ef{ include, false, elems_set };
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger), settings, file, {ef}, num_threads, logger);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger_), settings, file, {ef}, num_threads, logger_);
 	}
 
-	IfcGeom::Iterator* construct_iterator_with_include_exclude_globalid(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<std::string> elems, bool include, int num_threads, Logger& logger = Logger::Root()) {
+	IfcGeom::Iterator* construct_iterator_with_include_exclude_globalid(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<std::string> elems, bool include, int num_threads, Logger* logger = nullptr) {
+		Logger& logger_ = logger_or_root(logger);
 		std::set<std::string> elems_set(elems.begin(), elems.end());
 		IfcGeom::attribute_filter af;
 		af.attribute_name = "GlobalId";
 		af.populate(elems_set);
 		af.include = include;
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger), settings, file, {af}, num_threads, logger);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger_), settings, file, {af}, num_threads, logger_);
 	}
 
-	IfcGeom::Iterator* construct_iterator_with_include_exclude_id(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<int> elems, bool include, int num_threads, Logger& logger = Logger::Root()) {
+	IfcGeom::Iterator* construct_iterator_with_include_exclude_id(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, IfcParse::IfcFile* file, std::vector<int> elems, bool include, int num_threads, Logger* logger = nullptr) {
+		Logger& logger_ = logger_or_root(logger);
 		std::set<int> elems_set(elems.begin(), elems.end());
 		IfcGeom::instance_id_filter af(include, false, elems_set);
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger), settings, file, {af}, num_threads, logger);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings, logger_), settings, file, {af}, num_threads, logger_);
 	}
 %}
 
@@ -1295,9 +1299,9 @@ ifcopenshell::geometry::taxonomy::item::ptr try_upcast(PyObject* obj0, swig_type
 		}	
 	}
 
-	std::vector<svgfill::polygon_2> arrange_polygons(svgfill::arrange_polygon_settings settings, const std::vector<svgfill::polygon_2>& polygons, Logger& logger = Logger::Root()) {
+	std::vector<svgfill::polygon_2> arrange_polygons(svgfill::arrange_polygon_settings settings, const std::vector<svgfill::polygon_2>& polygons, Logger* logger = nullptr) {
 		std::vector<svgfill::polygon_2> r;
-		if (svgfill::arrange_polygons(settings, polygons, r, logger)) {
+		if (svgfill::arrange_polygons(settings, polygons, r, logger_or_root(logger))) {
 			return r;
 		} else {
 			throw std::runtime_error("Failed to arrange polygons");

src/ifcwrap/IfcParseWrapper.i

@@ -752,10 +752,10 @@ private:
 %newobject stream_from_string;
 
 %inline %{
-	IfcParse::IfcFile* open(const std::string& fn, bool readonly=false, Logger& logger=Logger::Root()) {
+	IfcParse::IfcFile* open(const std::string& fn, bool readonly=false, Logger* logger=nullptr) {
 		IfcParse::IfcFile* f;
 		Py_BEGIN_ALLOW_THREADS;
-		f = new IfcParse::IfcFile(fn, IfcParse::FT_AUTODETECT, readonly, logger);
+		f = new IfcParse::IfcFile(fn, IfcParse::FT_AUTODETECT, readonly, logger_or_root(logger));
 		Py_END_ALLOW_THREADS;
 		return f;
 	}

src/serializers/ColladaSerializer.h

@@ -219,8 +219,8 @@ private:
 	std::string unit_name;
 	float unit_magnitude;
 public:
-    ColladaSerializer(const std::string& dae_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger = Logger::Root())
+    ColladaSerializer(const std::string& dae_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger = nullptr)
-        : WriteOnlyGeometrySerializer(geometry_settings, settings, logger)
+        : WriteOnlyGeometrySerializer(geometry_settings, settings, logger_or_root(logger))
 		, exporter("IfcOpenShell", dae_filename, this, settings.get<ifcopenshell::geometry::settings::FloatingPointDigits>().get() >= 15)
     {
         exporter.serializer = this;

src/serializers/GltfSerializer.cpp

@@ -53,8 +53,8 @@ static const uint32_t PRIM_TRIANGLE_FAN = 6;
 static const uint32_t ELEMENT_ARRAY_BUFFER = 34963;
 static const uint32_t ARRAY_BUFFER = 34962;
 
-GltfSerializer::GltfSerializer(const std::string& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger)
+GltfSerializer::GltfSerializer(const std::string& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger)
-	: WriteOnlyGeometrySerializer(geometry_settings, settings, logger)
+	: WriteOnlyGeometrySerializer(geometry_settings, settings, logger_or_root(logger))
 	, filename_(filename)
 	, tmp_filename1_(filename + ".indices.tmp")
 	, tmp_filename2_(filename + ".vertices.tmp")

src/serializers/GltfSerializer.h

@@ -43,7 +43,7 @@ private:
 
 	int writeMaterial(const ifcopenshell::geometry::taxonomy::style::ptr style);
 public:
-	GltfSerializer(const std::string& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger = Logger::Root());
+	GltfSerializer(const std::string& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger = nullptr);
 	virtual ~GltfSerializer();
 	bool ready();
 	void writeHeader();

src/serializers/HdfSerializer.cpp

@@ -55,8 +55,8 @@ herr_t print_stack(hid_t /*estack*/, void*) {
 	return 0;
 }
 
-HdfSerializer::HdfSerializer(const std::string& hdf_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, bool read_only, Logger& logger)
+HdfSerializer::HdfSerializer(const std::string& hdf_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, bool read_only, Logger* logger)
-	: GeometrySerializer(geometry_settings, settings, logger)
+	: GeometrySerializer(geometry_settings, settings, logger_or_root(logger))
 	, hdf_filename(hdf_filename)
 	, settings_(settings)
 {

src/serializers/HdfSerializer.h

@@ -96,7 +96,7 @@ private:
 	void write_style(surface_style_serialization& data, const ifcopenshell::geometry::taxonomy::style::ptr& s);
 
 public:
-	HdfSerializer(const std::string& hdf_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, bool read_only=false, Logger& logger = Logger::Root());
+	HdfSerializer(const std::string& hdf_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, bool read_only=false, Logger* logger = nullptr);
 	virtual ~HdfSerializer() {}
 	bool ready();
 	void writeHeader();

src/serializers/SvgSerializer.h

@@ -596,8 +596,8 @@ protected:
 	subtract_before_project subtraction_settings_;
 
 public:
-	SvgSerializer(const stream_or_filename& out_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger = Logger::Root())
+	SvgSerializer(const stream_or_filename& out_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger = nullptr)
-		: WriteOnlyGeometrySerializer(geometry_settings, settings, logger)
+		: WriteOnlyGeometrySerializer(geometry_settings, settings, logger_or_root(logger))
 		, svg_file(out_filename)
 		, xmin(+std::numeric_limits<double>::infinity())
 		, ymin(+std::numeric_limits<double>::infinity())

src/serializers/TtlWktSerializer.cpp

@@ -233,8 +233,8 @@ namespace {
     }
 }
 
-TtlWktSerializer::TtlWktSerializer(const stream_or_filename& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger)
+TtlWktSerializer::TtlWktSerializer(const stream_or_filename& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger)
-    : WriteOnlyGeometrySerializer(geometry_settings, settings, logger)
+    : WriteOnlyGeometrySerializer(geometry_settings, settings, logger_or_root(logger))
     , filename_(filename)
 {
     const auto& tri_setting = geometry_settings.get<ifcopenshell::geometry::settings::TriangulationType>().get();

src/serializers/TtlWktSerializer.h

@@ -32,7 +32,7 @@ class SERIALIZERS_API TtlWktSerializer : public WriteOnlyGeometrySerializer {
 private:
 	stream_or_filename filename_;
 public:
-	TtlWktSerializer(const stream_or_filename& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger = Logger::Root());
+	TtlWktSerializer(const stream_or_filename& filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger = nullptr);
 	virtual ~TtlWktSerializer() {}
 	bool ready();
 	void writeHeader();

src/serializers/WavefrontObjSerializer.cpp

@@ -27,8 +27,8 @@
 #include <boost/lexical_cast.hpp>
 #include <iomanip>
 
-WaveFrontOBJSerializer::WaveFrontOBJSerializer(const stream_or_filename& obj_filename, const stream_or_filename& mtl_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger)
+WaveFrontOBJSerializer::WaveFrontOBJSerializer(const stream_or_filename& obj_filename, const stream_or_filename& mtl_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger)
-	: WriteOnlyGeometrySerializer(geometry_settings, settings, logger)
+	: WriteOnlyGeometrySerializer(geometry_settings, settings, logger_or_root(logger))
 	, obj_stream(obj_filename)
 	, mtl_stream(mtl_filename)
 	, vcount_total(1)

src/serializers/WavefrontObjSerializer.h

@@ -35,7 +35,7 @@ private:
 	size_t vcount_total, ncount_total;
 	std::set<std::string> materials;
 public:
-	WaveFrontOBJSerializer(const stream_or_filename& obj_filename, const stream_or_filename& mtl_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger& logger = Logger::Root());
+	WaveFrontOBJSerializer(const stream_or_filename& obj_filename, const stream_or_filename& mtl_filename, const ifcopenshell::geometry::Settings& geometry_settings, const ifcopenshell::geometry::SerializerSettings& settings, Logger* logger = nullptr);
 	virtual ~WaveFrontOBJSerializer() {}
 	bool ready();
 	void writeHeader();

src/serializers/XmlSerializer.cpp

@@ -31,8 +31,8 @@ XmlSerializer* XmlSerializerFactory::Factory::construct(const std::string& schem
 	return it->second(file, xml_filename, logger);
 }
 
-XmlSerializer::XmlSerializer(IfcParse::IfcFile* file, const std::string& xml_filename, Logger& logger)
+XmlSerializer::XmlSerializer(IfcParse::IfcFile* file, const std::string& xml_filename, Logger* logger)
-	: Serializer(logger) {
+	: Serializer(logger_or_root(logger)) {
 	if (file) {
 		implementation_ = XmlSerializerFactory::implementations().construct(file->schema()->name(), file, xml_filename, logger_);
 	}

src/serializers/XmlSerializer.h

@@ -16,7 +16,7 @@ protected:
 	std::string xml_filename;
 
 public:
-	XmlSerializer(IfcParse::IfcFile* file, const std::string& xml_filename, Logger& logger = Logger::Root());
+	XmlSerializer(IfcParse::IfcFile* file, const std::string& xml_filename, Logger* logger = nullptr);
 
 	virtual ~XmlSerializer() {}
 

src/serializers/schema_dependent/XmlSerializer.h

@@ -40,7 +40,7 @@ private:
 
 public:
 	POSTFIX_SCHEMA(XmlSerializer)(IfcParse::IfcFile* file, const std::string& xml_filename, Logger& logger = Logger::Root())
-		: XmlSerializer(0, "", logger)
+		: XmlSerializer(0, "", &logger)
 		, mapping_(ifcopenshell::geometry::impl::mapping_implementations().construct(file, settings_, logger))
 	{
 		this->file = file;