Simplify WriterAppender interface in the next ABI version (#508)

swebb2066 · stephen-webb · web-flow · commit 39854585dbca · 2025-07-05T11:02:45.000+10:00
Co-authored-by: Stephen Webb &lt;swebb2066@gmail.com&gt;
diff --git a/src/main/cpp/fileappender.cpp b/src/main/cpp/fileappender.cpp
@@ -323,7 +323,7 @@ void FileAppender::setFileInternal(
 
 	try
 	{
-		outStream = FileOutputStreamPtr(new FileOutputStream(filename, append1));
+		outStream = std::make_shared<FileOutputStream>(filename, append1);
 	}
 	catch (IOException&)
 	{
@@ -336,7 +336,7 @@ void FileAppender::setFileInternal(
 
 			if (!parentDir.exists(p) && parentDir.mkdirs(p))
 			{
-				outStream = OutputStreamPtr(new FileOutputStream(filename, append1));
+				outStream = std::make_shared<FileOutputStream>(filename, append1);
 			}
 			else
 			{
diff --git a/src/main/cpp/multiprocessrollingfileappender.cpp b/src/main/cpp/multiprocessrollingfileappender.cpp
@@ -428,7 +428,7 @@ void MultiprocessRollingFileAppender::subAppend(const LoggingEventPtr& event, Po
  @param os output stream, may not be null.
  @return new writer.
  */
-WriterPtr MultiprocessRollingFileAppender::createWriter(OutputStreamPtr& os)
+WriterPtr MultiprocessRollingFileAppender::createWriter(LOG4CXX_16_CONST OutputStreamPtr& os)
 {
 	auto fos = LOG4CXX_NS::cast<FileOutputStream>(os);
 	if( fos )
diff --git a/src/main/cpp/outputstreamwriter.cpp b/src/main/cpp/outputstreamwriter.cpp
@@ -27,38 +27,43 @@ using namespace LOG4CXX_NS::helpers;
 
 IMPLEMENT_LOG4CXX_OBJECT(OutputStreamWriter)
 
-struct OutputStreamWriter::OutputStreamWriterPrivate{
-	OutputStreamWriterPrivate(OutputStreamPtr& out1) : out(out1), enc(CharsetEncoder::getDefaultEncoder()){}
-
-	OutputStreamWriterPrivate(OutputStreamPtr& out1,
-							  CharsetEncoderPtr& enc1)
-		: out(out1), enc(enc1){}
+struct OutputStreamWriter::OutputStreamWriterPrivate
+{
+	OutputStreamWriterPrivate
+		( const OutputStreamPtr& out1
+		, const CharsetEncoderPtr& enc1 = CharsetEncoder::getDefaultEncoder()
+		)
+		: out(out1)
+		, enc(enc1)
+		{}
 
 	OutputStreamPtr out;
 	CharsetEncoderPtr enc;
 };
 
-OutputStreamWriter::OutputStreamWriter(OutputStreamPtr& out1)
-	: m_priv(std::make_unique<OutputStreamWriterPrivate>(out1))
+OutputStreamWriter::OutputStreamWriter(LOG4CXX_16_CONST OutputStreamPtr& out)
+	: m_priv(std::make_unique<OutputStreamWriterPrivate>(out))
 {
-	if (out1 == 0)
+	if (!out)
 	{
-		throw NullPointerException(LOG4CXX_STR("out parameter may not be null."));
+		throw NullPointerException(LOG4CXX_STR("OutputStream parameter may not be null."));
 	}
 }
 
-OutputStreamWriter::OutputStreamWriter(OutputStreamPtr& out1,
-	CharsetEncoderPtr& enc1)
-	: m_priv(std::make_unique<OutputStreamWriterPrivate>(out1, enc1))
+OutputStreamWriter::OutputStreamWriter
+	( LOG4CXX_16_CONST OutputStreamPtr& out
+	, LOG4CXX_16_CONST CharsetEncoderPtr& enc
+	)
+	: m_priv(std::make_unique<OutputStreamWriterPrivate>(out, enc))
 {
-	if (out1 == 0)
+	if (!out)
 	{
-		throw NullPointerException(LOG4CXX_STR("out parameter may not be null."));
+		throw NullPointerException(LOG4CXX_STR("OutputStream parameter may not be null."));
 	}
 
-	if (enc1 == 0)
+	if (!enc)
 	{
-		throw NullPointerException(LOG4CXX_STR("enc parameter may not be null."));
+		throw NullPointerException(LOG4CXX_STR("CharsetEncoder parameter may not be null."));
 	}
 }
 
diff --git a/src/main/cpp/rollingfileappender.cpp b/src/main/cpp/rollingfileappender.cpp
@@ -357,10 +357,11 @@ bool RollingFileAppender::rolloverInternal(Pool& p)
 							setFileInternal(rollover1->getActiveFileName());
 							// Call activateOptions to create any intermediate directories(if required)
 							FileAppender::activateOptionsInternal(p);
-							OutputStreamPtr os(new FileOutputStream(
-									rollover1->getActiveFileName(), rollover1->getAppend()));
-							WriterPtr newWriter(createWriter(os));
-							setWriterInternal(newWriter);
+							OutputStreamPtr os = std::make_shared<FileOutputStream>
+									( rollover1->getActiveFileName()
+									, rollover1->getAppend()
+									);
+							setWriterInternal(createWriter(os));
 
 							bool success = true;
 
@@ -518,16 +519,19 @@ class CountingOutputStream : public OutputStream
 		 * @param os output stream to wrap.
 		 * @param rfa rolling file appender to inform.
 		 */
-		CountingOutputStream(
-			OutputStreamPtr& os1, RollingFileAppender* rfa1) :
-			os(os1), rfa(rfa1)
+		CountingOutputStream
+			( const OutputStreamPtr& os1
+			, RollingFileAppender* rfa1
+			)
+			: os(os1)
+			, rfa(rfa1)
 		{
 		}
 
 		/**
 		 * {@inheritDoc}
 		 */
-		void close(Pool& p)
+		void close(Pool& p) override
 		{
 			os->close(p);
 			rfa = 0;
@@ -536,15 +540,15 @@ class CountingOutputStream : public OutputStream
 		/**
 		 * {@inheritDoc}
 		 */
-		void flush(Pool& p)
+		void flush(Pool& p) override
 		{
 			os->flush(p);
 		}
 
 		/**
 		 * {@inheritDoc}
 		 */
-		void write(ByteBuffer& buf, Pool& p)
+		void write(ByteBuffer& buf, Pool& p) override
 		{
 			os->write(buf, p);
 
@@ -566,7 +570,7 @@ class CountingOutputStream : public OutputStream
  @param os output stream, may not be null.
  @return new writer.
  */
-WriterPtr RollingFileAppender::createWriter(OutputStreamPtr& os)
+WriterPtr RollingFileAppender::createWriter(LOG4CXX_16_CONST OutputStreamPtr& os)
 {
 	OutputStreamPtr cos = std::make_shared<CountingOutputStream>(os, this);
 	return FileAppender::createWriter(cos);
diff --git a/src/main/cpp/writerappender.cpp b/src/main/cpp/writerappender.cpp
@@ -36,18 +36,26 @@ WriterAppender::WriterAppender() :
 {
 }
 
-WriterAppender::WriterAppender(const LayoutPtr& layout1,
-	LOG4CXX_NS::helpers::WriterPtr& writer1)
-	: AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout1, writer1))
+#if LOG4CXX_ABI_VERSION <= 15
+WriterAppender::WriterAppender(const LayoutPtr& layout, helpers::WriterPtr& writer)
+	: AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout, writer))
 {
 	Pool p;
 	activateOptions(p);
 }
 
-WriterAppender::WriterAppender(const LayoutPtr& layout1)
-	: AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout1))
+WriterAppender::WriterAppender(const LayoutPtr& layout)
+	: AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout))
 {
 }
+#else
+WriterAppender::WriterAppender(const LayoutPtr& layout, const helpers::WriterPtr& writer)
+	: AppenderSkeleton(std::make_unique<WriterAppenderPriv>(layout, writer))
+{
+	Pool p;
+	activateOptions(p);
+}
+#endif
 
 WriterAppender::WriterAppender(std::unique_ptr<WriterAppenderPriv> priv)
 	: AppenderSkeleton (std::move(priv))
@@ -182,7 +190,7 @@ void WriterAppender::closeWriter()
    <code>encoding</code> property.  If the encoding value is
    specified incorrectly the writer will be opened using the default
    system encoding (an error message will be printed to the loglog.  */
-WriterPtr WriterAppender::createWriter(OutputStreamPtr& os)
+WriterPtr WriterAppender::createWriter(LOG4CXX_16_CONST OutputStreamPtr& os)
 {
 
 	LogString enc(getEncoding());
@@ -213,7 +221,7 @@ WriterPtr WriterAppender::createWriter(OutputStreamPtr& os)
 		}
 	}
 
-	return WriterPtr(new OutputStreamWriter(os, encoder));
+	return std::make_shared<OutputStreamWriter>(os, encoder);
 }
 
 LogString WriterAppender::getEncoding() const
diff --git a/src/main/include/log4cxx/fileappender.h b/src/main/include/log4cxx/fileappender.h
@@ -219,7 +219,7 @@ class LOG4CXX_EXPORT FileAppender : public WriterAppender
 		static LogString stripDuplicateBackslashes(const LogString& name);
 
 	protected:
-		void activateOptionsInternal(LOG4CXX_NS::helpers::Pool& p);
+		void activateOptionsInternal(helpers::Pool& p);
 
 		/**
 		Sets and <i>opens</i> the file where the log output will
@@ -243,7 +243,7 @@ class LOG4CXX_EXPORT FileAppender : public WriterAppender
 		*/
 		void setFileInternal(const LogString& file, bool append,
 			bool bufferedIO, size_t bufferSize,
-			LOG4CXX_NS::helpers::Pool& p);
+			helpers::Pool& p);
 
 		void setFileInternal(const LogString& file);
 
diff --git a/src/main/include/log4cxx/helpers/outputstreamwriter.h b/src/main/include/log4cxx/helpers/outputstreamwriter.h
@@ -22,6 +22,12 @@
 #include <log4cxx/helpers/outputstream.h>
 #include <log4cxx/helpers/charsetencoder.h>
 
+#if 15 < LOG4CXX_ABI_VERSION
+#define LOG4CXX_16_CONST const
+#else
+#define LOG4CXX_16_CONST 
+#endif
+
 namespace LOG4CXX_NS
 {
 
@@ -43,8 +49,8 @@ class LOG4CXX_EXPORT OutputStreamWriter : public Writer
 		LOG4CXX_CAST_ENTRY_CHAIN(Writer)
 		END_LOG4CXX_CAST_MAP()
 
-		OutputStreamWriter(OutputStreamPtr& out);
-		OutputStreamWriter(OutputStreamPtr& out, CharsetEncoderPtr& enc);
+		OutputStreamWriter(LOG4CXX_16_CONST OutputStreamPtr& out);
+		OutputStreamWriter(LOG4CXX_16_CONST OutputStreamPtr& out, LOG4CXX_16_CONST CharsetEncoderPtr& enc);
 		~OutputStreamWriter();
 
 		void close(Pool& p) override;
diff --git a/src/main/include/log4cxx/private/writerappender_priv.h b/src/main/include/log4cxx/private/writerappender_priv.h
@@ -42,24 +42,11 @@ struct WriterAppender::WriterAppenderPriv : public AppenderSkeleton::AppenderSke
 	{
 	}
 
-	WriterAppenderPriv(const LayoutPtr& layout1,
-		LOG4CXX_NS::helpers::WriterPtr& writer1) :
-		AppenderSkeletonPrivate(layout1),
-		immediateFlush(true),
-		writer(writer1)
-#if LOG4CXX_EVENTS_AT_EXIT
-		, atExitRegistryRaii{ [this]{flush();} }
-#endif
-	{
-	}
-
-	WriterAppenderPriv(const LayoutPtr& layout1) :
-		AppenderSkeletonPrivate(layout1),
-		immediateFlush(true)
-#if LOG4CXX_EVENTS_AT_EXIT
-		, atExitRegistryRaii{ [this]{flush();} }
-#endif
+	WriterAppenderPriv(const LayoutPtr& layout1, const helpers::WriterPtr& writer1 = helpers::WriterPtr())
+		: WriterAppenderPriv()
 	{
+		this->layout = layout1;
+		this->writer = writer1;
 	}
 
 	void flush()
@@ -94,7 +81,7 @@ struct WriterAppender::WriterAppenderPriv : public AppenderSkeleton::AppenderSke
 	/**
 	*  This is the {@link Writer Writer} where we will write to.
 	*/
-	LOG4CXX_NS::helpers::WriterPtr writer;
+	helpers::WriterPtr writer;
 
 #if LOG4CXX_EVENTS_AT_EXIT
 	helpers::AtExitRegistry::Raii atExitRegistryRaii;
diff --git a/src/main/include/log4cxx/rolling/multiprocessrollingfileappender.h b/src/main/include/log4cxx/rolling/multiprocessrollingfileappender.h
@@ -91,7 +91,7 @@ class LOG4CXX_EXPORT MultiprocessRollingFileAppender : public RollingFileAppende
 		 @param os output stream, may not be null.
 		 @return new writer.
 		 */
-		helpers::WriterPtr createWriter(helpers::OutputStreamPtr& os) override;
+		helpers::WriterPtr createWriter(LOG4CXX_16_CONST helpers::OutputStreamPtr& os) override;
 
 	private:
 		/**
diff --git a/src/main/include/log4cxx/rolling/rollingfileappender.h b/src/main/include/log4cxx/rolling/rollingfileappender.h
@@ -220,7 +220,7 @@ class LOG4CXX_EXPORT RollingFileAppender : public FileAppender
 		 @param os output stream, may not be null.
 		 @return new writer.
 		 */
-		helpers::WriterPtr createWriter(helpers::OutputStreamPtr& os) override;
+		helpers::WriterPtr createWriter(LOG4CXX_16_CONST helpers::OutputStreamPtr& os) override;
 
 	public:
 		/**
diff --git a/src/main/include/log4cxx/writerappender.h b/src/main/include/log4cxx/writerappender.h
@@ -25,11 +25,6 @@
 namespace LOG4CXX_NS
 {
 
-namespace helpers
-{
-class Transcoder;
-}
-
 /**
 WriterAppender appends log events to a standard output stream
 */
@@ -48,9 +43,12 @@ class LOG4CXX_EXPORT WriterAppender : public AppenderSkeleton
 		This default constructor does nothing.*/
 		WriterAppender();
 	protected:
-		WriterAppender(const LayoutPtr& layout,
-			LOG4CXX_NS::helpers::WriterPtr& writer);
+#if LOG4CXX_ABI_VERSION <= 15
+		WriterAppender(const LayoutPtr& layout, helpers::WriterPtr& writer);
 		WriterAppender(const LayoutPtr& layout);
+#else
+		WriterAppender(const LayoutPtr& layout, const helpers::WriterPtr& writer = helpers::WriterPtr());
+#endif
 		WriterAppender(std::unique_ptr<WriterAppenderPriv> priv);
 
 	public:
@@ -128,7 +126,7 @@ class LOG4CXX_EXPORT WriterAppender : public AppenderSkeleton
 		    <code>encoding</code> property.  If the encoding value is
 		    specified incorrectly the writer will be opened using the default
 		    system encoding (an error message will be printed to the loglog.  */
-		virtual helpers::WriterPtr createWriter(helpers::OutputStreamPtr& os);
+		virtual helpers::WriterPtr createWriter(LOG4CXX_16_CONST helpers::OutputStreamPtr& os);
 
 	public:
 		/**
@@ -165,33 +163,33 @@ class LOG4CXX_EXPORT WriterAppender : public AppenderSkeleton
 
 		  @param writer An already opened Writer.
 		*/
-		void setWriter(const LOG4CXX_NS::helpers::WriterPtr& writer);
+		void setWriter(const helpers::WriterPtr& writer);
 
-		const LOG4CXX_NS::helpers::WriterPtr getWriter() const;
+		const helpers::WriterPtr getWriter() const;
 
 		bool requiresLayout() const override;
 
 	protected:
 		/**
 		 Actual writing occurs here.
 		*/
-		virtual void subAppend(const spi::LoggingEventPtr& event, LOG4CXX_NS::helpers::Pool& p);
+		virtual void subAppend(const spi::LoggingEventPtr& event, helpers::Pool& p);
 
 
 		/**
 		Write a footer as produced by the embedded layout's
 		Layout#appendFooter method.  */
-		virtual void writeFooter(LOG4CXX_NS::helpers::Pool& p);
+		virtual void writeFooter(helpers::Pool& p);
 
 		/**
 		Write a header as produced by the embedded layout's
 		Layout#appendHeader method.  */
-		virtual void writeHeader(LOG4CXX_NS::helpers::Pool& p);
+		virtual void writeHeader(helpers::Pool& p);
 
 		/**
 		 * Set the writer.  Mutex must already be held.
 		 */
-		void setWriterInternal(const LOG4CXX_NS::helpers::WriterPtr& writer);
+		void setWriterInternal(const helpers::WriterPtr& writer);
 
 	private:
 		//

Original file line number	Diff line number	Diff line change
`@@ -323,7 +323,7 @@ void FileAppender::setFileInternal(`
`323`	`323`
`324`	`324`	`try`
`325`	`325`	`{`
`326`		`- outStream = FileOutputStreamPtr(new FileOutputStream(filename, append1));`
	`326`	`+ outStream = std::make_shared<FileOutputStream>(filename, append1);`
`327`	`327`	`}`
`328`	`328`	`catch (IOException&)`
`329`	`329`	`{`
`@@ -336,7 +336,7 @@ void FileAppender::setFileInternal(`
`336`	`336`
`337`	`337`	`if (!parentDir.exists(p) && parentDir.mkdirs(p))`
`338`	`338`	`{`
`339`		`- outStream = OutputStreamPtr(new FileOutputStream(filename, append1));`
	`339`	`+ outStream = std::make_shared<FileOutputStream>(filename, append1);`
`340`	`340`	`}`
`341`	`341`	`else`
`342`	`342`	`{`
Original file line number	Diff line number	Diff line change
`@@ -428,7 +428,7 @@ void MultiprocessRollingFileAppender::subAppend(const LoggingEventPtr& event, Po`
`428`	`428`	`@param os output stream, may not be null.`
`429`	`429`	`@return new writer.`
`430`	`430`	`*/`
`431`		`-WriterPtr MultiprocessRollingFileAppender::createWriter(OutputStreamPtr& os)`
	`431`	`+WriterPtr MultiprocessRollingFileAppender::createWriter(LOG4CXX_16_CONST OutputStreamPtr& os)`
`432`	`432`	`{`
`433`	`433`	`auto fos = LOG4CXX_NS::cast<FileOutputStream>(os);`
`434`	`434`	`if( fos )`
Original file line number	Diff line number	Diff line change
`@@ -27,38 +27,43 @@ using namespace LOG4CXX_NS::helpers;`
`27`	`27`
`28`	`28`	`IMPLEMENT_LOG4CXX_OBJECT(OutputStreamWriter)`
`29`	`29`
`30`		`-struct OutputStreamWriter::OutputStreamWriterPrivate{`
`31`		`- OutputStreamWriterPrivate(OutputStreamPtr& out1) : out(out1), enc(CharsetEncoder::getDefaultEncoder()){}`
`32`		`-`
`33`		`- OutputStreamWriterPrivate(OutputStreamPtr& out1,`
`34`		`- CharsetEncoderPtr& enc1)`
`35`		`- : out(out1), enc(enc1){}`
	`30`	`+struct OutputStreamWriter::OutputStreamWriterPrivate`
	`31`	`+{`
	`32`	`+ OutputStreamWriterPrivate`
	`33`	`+ ( const OutputStreamPtr& out1`
	`34`	`+ , const CharsetEncoderPtr& enc1 = CharsetEncoder::getDefaultEncoder()`
	`35`	`+ )`
	`36`	`+ : out(out1)`
	`37`	`+ , enc(enc1)`
	`38`	`+ {}`
`36`	`39`
`37`	`40`	`OutputStreamPtr out;`
`38`	`41`	`CharsetEncoderPtr enc;`
`39`	`42`	`};`
`40`	`43`
`41`		`-OutputStreamWriter::OutputStreamWriter(OutputStreamPtr& out1)`
`42`		`- : m_priv(std::make_unique<OutputStreamWriterPrivate>(out1))`
	`44`	`+OutputStreamWriter::OutputStreamWriter(LOG4CXX_16_CONST OutputStreamPtr& out)`
	`45`	`+ : m_priv(std::make_unique<OutputStreamWriterPrivate>(out))`
`43`	`46`	`{`
`44`		`- if (out1 == 0)`
	`47`	`+ if (!out)`
`45`	`48`	`{`
`46`		`- throw NullPointerException(LOG4CXX_STR("out parameter may not be null."));`
	`49`	`+ throw NullPointerException(LOG4CXX_STR("OutputStream parameter may not be null."));`
`47`	`50`	`}`
`48`	`51`	`}`
`49`	`52`
`50`		`-OutputStreamWriter::OutputStreamWriter(OutputStreamPtr& out1,`
`51`		`- CharsetEncoderPtr& enc1)`
`52`		`- : m_priv(std::make_unique<OutputStreamWriterPrivate>(out1, enc1))`
	`53`	`+OutputStreamWriter::OutputStreamWriter`
	`54`	`+ ( LOG4CXX_16_CONST OutputStreamPtr& out`
	`55`	`+ , LOG4CXX_16_CONST CharsetEncoderPtr& enc`
	`56`	`+ )`
	`57`	`+ : m_priv(std::make_unique<OutputStreamWriterPrivate>(out, enc))`
`53`	`58`	`{`
`54`		`- if (out1 == 0)`
	`59`	`+ if (!out)`
`55`	`60`	`{`
`56`		`- throw NullPointerException(LOG4CXX_STR("out parameter may not be null."));`
	`61`	`+ throw NullPointerException(LOG4CXX_STR("OutputStream parameter may not be null."));`
`57`	`62`	`}`
`58`	`63`
`59`		`- if (enc1 == 0)`
	`64`	`+ if (!enc)`
`60`	`65`	`{`
`61`		`- throw NullPointerException(LOG4CXX_STR("enc parameter may not be null."));`
	`66`	`+ throw NullPointerException(LOG4CXX_STR("CharsetEncoder parameter may not be null."));`
`62`	`67`	`}`
`63`	`68`	`}`
`64`	`69`
Original file line number	Diff line number	Diff line change
`@@ -36,18 +36,26 @@ WriterAppender::WriterAppender() :`
`36`	`36`	`{`
`37`	`37`	`}`
`38`	`38`
`39`		`-WriterAppender::WriterAppender(const LayoutPtr& layout1,`
`40`		`- LOG4CXX_NS::helpers::WriterPtr& writer1)`
`41`		`- : AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout1, writer1))`
	`39`	`+#if LOG4CXX_ABI_VERSION <= 15`
	`40`	`+WriterAppender::WriterAppender(const LayoutPtr& layout, helpers::WriterPtr& writer)`
	`41`	`+ : AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout, writer))`
`42`	`42`	`{`
`43`	`43`	`Pool p;`
`44`	`44`	`activateOptions(p);`
`45`	`45`	`}`
`46`	`46`
`47`		`-WriterAppender::WriterAppender(const LayoutPtr& layout1)`
`48`		`- : AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout1))`
	`47`	`+WriterAppender::WriterAppender(const LayoutPtr& layout)`
	`48`	`+ : AppenderSkeleton (std::make_unique<WriterAppenderPriv>(layout))`
`49`	`49`	`{`
`50`	`50`	`}`
	`51`	`+#else`
	`52`	`+WriterAppender::WriterAppender(const LayoutPtr& layout, const helpers::WriterPtr& writer)`
	`53`	`+ : AppenderSkeleton(std::make_unique<WriterAppenderPriv>(layout, writer))`
	`54`	`+{`
	`55`	`+ Pool p;`
	`56`	`+ activateOptions(p);`
	`57`	`+}`
	`58`	`+#endif`
`51`	`59`
`52`	`60`	`WriterAppender::WriterAppender(std::unique_ptr<WriterAppenderPriv> priv)`
`53`	`61`	`: AppenderSkeleton (std::move(priv))`
`@@ -182,7 +190,7 @@ void WriterAppender::closeWriter()`
`182`	`190`	`<code>encoding</code> property. If the encoding value is`
`183`	`191`	`specified incorrectly the writer will be opened using the default`
`184`	`192`	`system encoding (an error message will be printed to the loglog. */`
`185`		`-WriterPtr WriterAppender::createWriter(OutputStreamPtr& os)`
	`193`	`+WriterPtr WriterAppender::createWriter(LOG4CXX_16_CONST OutputStreamPtr& os)`
`186`	`194`	`{`
`187`	`195`
`188`	`196`	`LogString enc(getEncoding());`
`@@ -213,7 +221,7 @@ WriterPtr WriterAppender::createWriter(OutputStreamPtr& os)`
`213`	`221`	`}`
`214`	`222`	`}`
`215`	`223`
`216`		`- return WriterPtr(new OutputStreamWriter(os, encoder));`
	`224`	`+ return std::make_shared<OutputStreamWriter>(os, encoder);`
`217`	`225`	`}`
`218`	`226`
`219`	`227`	`LogString WriterAppender::getEncoding() const`