Code style and clarity.

12 files changed, 512 insertions, 447 deletions

diff --git a/examples/example1.cpp b/examples/example1.cpp
index b80fe636..c698fa7f 100644
--- a/examples/example1.cpp
+++ b/examples/example1.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,23 +39,20 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	std::cout << std::endl;
 
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	try
-	{
+	try {
+
 		vmime::messageBuilder mb;
 
 		// Fill in the basic fields
@@ -74,9 +71,12 @@ int main()
 		mb.setSubject(vmime::text("My first message generated with vmime::messageBuilder"));
 
 		// Message body
-		mb.getTextPart()->setText(vmime::make_shared <vmime::stringContentHandler>(
-			"I'm writing this short text to test message construction " \
-			"using the vmime::messageBuilder component."));
+		mb.getTextPart()->setText(
+			vmime::make_shared <vmime::stringContentHandler>(
+				"I'm writing this short text to test message construction " \
+				"using the vmime::messageBuilder component."
+			)
+		);
 
 		// Construction
 		vmime::shared_ptr <vmime::message> msg = mb.construct();
@@ -87,20 +87,21 @@ int main()
 
 		vmime::utility::outputStreamAdapter out(std::cout);
 		msg->generate(out);
-	}
+
 	// VMime exception
-	catch (vmime::exception& e)
-	{
+	} catch (vmime::exception& e) {
+
 		std::cout << "vmime::exception: " << e.what() << std::endl;
 		throw;
-	}
+
 	// Standard exception
-	catch (std::exception& e)
-	{
+	} catch (std::exception& e) {
+
 		std::cout << "std::exception: " << e.what() << std::endl;
-		//throw;
+		throw;
 	}
 
 	std::cout << std::endl;
-}
 
+	return 0;
+}
diff --git a/examples/example2.cpp b/examples/example2.cpp
index 67b8d844..da01d756 100644
--- a/examples/example2.cpp
+++ b/examples/example2.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,23 +39,20 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	std::cout << std::endl;
 
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	try
-	{
+	try {
+
 		vmime::messageBuilder mb;
 
 		// Fill in the basic fields
@@ -74,17 +71,20 @@ int main()
 		mb.setSubject(vmime::text("My first message generated with vmime::messageBuilder"));
 
 		// Message body
-		mb.getTextPart()->setText(vmime::make_shared <vmime::stringContentHandler>(
-			"I'm writing this short text to test message construction " \
-			"with attachment, using the vmime::messageBuilder component."));
+		mb.getTextPart()->setText(
+			vmime::make_shared <vmime::stringContentHandler>(
+				"I'm writing this short text to test message construction " \
+				"with attachment, using the vmime::messageBuilder component."
+			)
+		);
 
 		// Adding an attachment
-		vmime::shared_ptr <vmime::fileAttachment> a = vmime::make_shared <vmime::fileAttachment>
-		(
-			__FILE__,                                       // full path to file
-			vmime::mediaType("application/octet-stream"),   // content type
-			vmime::text("My first attachment")              // description
-		);
+		vmime::shared_ptr <vmime::fileAttachment> a =
+			vmime::make_shared <vmime::fileAttachment>(
+				__FILE__,                                       // full path to file
+				vmime::mediaType("application/octet-stream"),   // content type
+				vmime::text("My first attachment")              // description
+			);
 
 		a->getFileInfo().setFilename("example2.cpp");
 		a->getFileInfo().setCreationDate(vmime::datetime("30 Apr 2003 14:30:00 +0200"));
@@ -101,20 +101,21 @@ int main()
 		std::cout << "==================" << std::endl;
 		std::cout << std::endl;
 		std::cout << dataToSend << std::endl;
-	}
+
 	// VMime exception
-	catch (vmime::exception& e)
-	{
+	} catch (vmime::exception& e) {
+
 		std::cout << "vmime::exception: " << e.what() << std::endl;
 		throw;
-	}
+
 	// Standard exception
-	catch (std::exception& e)
-	{
+	} catch (std::exception& e) {
+
 		std::cout << "std::exception: " << e.what() << std::endl;
 		throw;
 	}
 
 	std::cout << std::endl;
-}
 
+	return 0;
+}
diff --git a/examples/example3.cpp b/examples/example3.cpp
index a472e05c..b4522256 100644
--- a/examples/example3.cpp
+++ b/examples/example3.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,23 +39,20 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	std::cout << std::endl;
 
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	try
-	{
+	try {
+
 		vmime::messageBuilder mb;
 
 		// Fill in the basic fields
@@ -74,12 +71,17 @@ int main()
 		mb.setSubject(vmime::text("My first message generated with vmime::messageBuilder"));
 
 		// Set the content-type to "text/html"
-		mb.constructTextPart(vmime::mediaType
-			(vmime::mediaTypes::TEXT, vmime::mediaTypes::TEXT_HTML));
+		mb.constructTextPart(
+			vmime::mediaType(
+				vmime::mediaTypes::TEXT,
+				vmime::mediaTypes::TEXT_HTML
+			)
+		);
 
 		// Fill in the text part: the message is available in two formats: HTML and plain text.
 		// HTML text part also includes an inline image (embedded into the message).
-		vmime::htmlTextPart& textPart = *vmime::dynamicCast <vmime::htmlTextPart>(mb.getTextPart());
+		vmime::htmlTextPart& textPart =
+			*vmime::dynamicCast <vmime::htmlTextPart>(mb.getTextPart());
 
 		// -- embed an image (the returned "CID" (content identifier) is used to reference
 		// -- the image into HTML content).
@@ -93,18 +95,33 @@ int main()
 			imageFile->getFileReader();
 
 		vmime::shared_ptr <vmime::contentHandler> imageCts =
-			vmime::make_shared <vmime::streamContentHandler>
-				(fileReader->getInputStream(), imageFile->getLength());
-
-		vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj = textPart.addObject
-			(imageCts, vmime::mediaType(vmime::mediaTypes::IMAGE, vmime::mediaTypes::IMAGE_JPEG));
+			vmime::make_shared <vmime::streamContentHandler>(
+				fileReader->getInputStream(),
+				imageFile->getLength()
+			);
+
+		vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj =
+			textPart.addObject(
+				imageCts,
+				vmime::mediaType(
+					vmime::mediaTypes::IMAGE,
+					vmime::mediaTypes::IMAGE_JPEG
+				)
+			);
 
 		// -- message text
-		textPart.setText(vmime::make_shared <vmime::stringContentHandler>
-			(vmime::string("This is the <b>HTML text</b>.<br/>"
-				"<img src=\"") + obj->getReferenceId() + vmime::string("\"/>")));
-		textPart.setPlainText(vmime::make_shared <vmime::stringContentHandler>
-			("This is the plain text (without HTML formatting)."));
+		textPart.setText(
+			vmime::make_shared <vmime::stringContentHandler>(
+				vmime::string("This is the <b>HTML text</b>.<br/>"
+				"<img src=\"") + obj->getReferenceId() + vmime::string("\"/>")
+			)
+		);
+
+		textPart.setPlainText(
+			vmime::make_shared <vmime::stringContentHandler>(
+				"This is the plain text (without HTML formatting)."
+			)
+		);
 
 		// Construction
 		vmime::shared_ptr <vmime::message> msg = mb.construct();
@@ -116,20 +133,21 @@ int main()
 		std::cout << "==================" << std::endl;
 		std::cout << std::endl;
 		std::cout << dataToSend << std::endl;
-	}
+
 	// VMime exception
-	catch (vmime::exception& e)
-	{
+	} catch (vmime::exception& e) {
+
 		std::cout << "vmime::exception: " << e.what() << std::endl;
 		throw;
-	}
+
 	// Standard exception
-	catch (std::exception& e)
-	{
+	} catch (std::exception& e) {
+
 		std::cout << "std::exception: " << e.what() << std::endl;
 		throw;
 	}
 
 	std::cout << std::endl;
-}
 
+	return 0;
+}
diff --git a/examples/example4.cpp b/examples/example4.cpp
index 1e0d6657..4d50c2e4 100644
--- a/examples/example4.cpp
+++ b/examples/example4.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,71 +39,70 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	std::cout << std::endl;
 
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	try
-	{
+	try {
+
 		vmime::messageParser mp("<...MIME message content...>");
 
 		// Enumerate text parts
-		for (size_t i = 0 ; i < mp.getTextPartCount() ; ++i)
-		{
+		for (size_t i = 0 ; i < mp.getTextPartCount() ; ++i) {
+
 			const vmime::textPart& part = *mp.getTextPartAt(i);
 
 			// Output content-type of the part
 			std::cout << part.getType().generate() << std::endl;
 
 			// text/html
-			if (part.getType().getSubType() == vmime::mediaTypes::TEXT_HTML)
-			{
+			if (part.getType().getSubType() == vmime::mediaTypes::TEXT_HTML) {
+
 				const vmime::htmlTextPart& hp = dynamic_cast<const vmime::htmlTextPart&>(part);
 
 				// HTML text is in "hp.getText()"
 				// Corresponding plain text is in "hp.getPlainText()"
 
 				// Enumerate embedded objects (eg. images)
-				for (size_t j = 0 ; j < hp.getObjectCount() ; ++j)
-				{
+				for (size_t j = 0 ; j < hp.getObjectCount() ; ++j) {
+
 					const vmime::htmlTextPart::embeddedObject& obj = *hp.getObjectAt(j);
 
 					// Identifier (content-id or content-location) is in "obj.getId()"
 					// Object data is in "obj.getData()"
 				}
-			}
+
 			// text/plain
-			else
-			{
+			} else {
+
 				const vmime::textPart& tp = dynamic_cast<const vmime::textPart&>(part);
 
 				// Text is in "tp.getText()"
 			}
 		}
-	}
+
 	// VMime exception
-	catch (vmime::exception& e)
-	{
+	} catch (vmime::exception& e) {
+
 		std::cout << "vmime::exception: " << e.what() << std::endl;
 		throw;
-	}
+
 	// Standard exception
-	catch (std::exception& e)
-	{
+	} catch (std::exception& e) {
+
 		std::cout << "std::exception: " << e.what() << std::endl;
 		throw;
 	}
 
 	std::cout << std::endl;
+
+	return 0;
 }
diff --git a/examples/example5.cpp b/examples/example5.cpp
index d33c64f7..24d5cbfc 100644
--- a/examples/example5.cpp
+++ b/examples/example5.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,28 +39,25 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	std::cout << std::endl;
 
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	try
-	{
+	try {
+
 		vmime::messageParser mp("<...MIME message content...>");
 
 		// Enumerate attachments
-		for (size_t i = 0 ; i < mp.getAttachmentCount() ; ++i)
-		{
+		for (size_t i = 0 ; i < mp.getAttachmentCount() ; ++i) {
+
 			const vmime::attachment& att = *mp.getAttachmentAt(i);
 
 			// Media type (content type) is in "att.getType()"
@@ -68,19 +65,21 @@ int main()
 			// Description is in "att.getDescription()"
 			// Data is in "att.getData()"
 		}
-	}
+
 	// VMime exception
-	catch (vmime::exception& e)
-	{
+	} catch (vmime::exception& e) {
+
 		std::cout << "vmime::exception: " << e.what() << std::endl;
 		throw;
-	}
+
 	// Standard exception
-	catch (std::exception& e)
-	{
+	} catch (std::exception& e) {
+
 		std::cout << "std::exception: " << e.what() << std::endl;
 		throw;
 	}
 
 	std::cout << std::endl;
+
+	return 0;
 }
diff --git a/examples/example6.cpp b/examples/example6.cpp
index 91a5ba5d..add24b38 100644
--- a/examples/example6.cpp
+++ b/examples/example6.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -46,22 +46,23 @@ static vmime::shared_ptr <vmime::net::session> g_session = vmime::net::session::
   * @param type service type (vmime::net::service::TYPE_STORE or
   * vmime::net::service::TYPE_TRANSPORT)
   */
-static const std::string findAvailableProtocols(const vmime::net::service::Type type)
-{
+static const std::string findAvailableProtocols(const vmime::net::service::Type type) {
+
 	vmime::shared_ptr <vmime::net::serviceFactory> sf =
 		vmime::net::serviceFactory::getInstance();
 
 	std::ostringstream res;
 	size_t count = 0;
 
-	for (size_t i = 0 ; i < sf->getServiceCount() ; ++i)
-	{
+	for (size_t i = 0 ; i < sf->getServiceCount() ; ++i) {
+
 		const vmime::net::serviceFactory::registeredService& serv = *sf->getServiceAt(i);
 
-		if (serv.getType() == type)
-		{
-			if (count != 0)
+		if (serv.getType() == type) {
+
+			if (count != 0) {
 				res << ", ";
+			}
 
 			res << serv.getName();
 			++count;
@@ -73,14 +74,14 @@ static const std::string findAvailableProtocols(const vmime::net::service::Type
 
 
 // Exception helper
-static std::ostream& operator<<(std::ostream& os, const vmime::exception& e)
-{
+static std::ostream& operator<<(std::ostream& os, const vmime::exception& e) {
+
 	os << "* vmime::exceptions::" << e.name() << std::endl;
 	os << "    what = " << e.what() << std::endl;
 
 	// More information for special exceptions
-	if (dynamic_cast <const vmime::exceptions::command_error*>(&e))
-	{
+	if (dynamic_cast <const vmime::exceptions::command_error*>(&e)) {
+
 		const vmime::exceptions::command_error& cee =
 			dynamic_cast <const vmime::exceptions::command_error&>(e);
 
@@ -88,32 +89,32 @@ static std::ostream& operator<<(std::ostream& os, const vmime::exception& e)
 		os << "    response = " << cee.response() << std::endl;
 	}
 
-	if (dynamic_cast <const vmime::exceptions::invalid_response*>(&e))
-	{
+	if (dynamic_cast <const vmime::exceptions::invalid_response*>(&e)) {
+
 		const vmime::exceptions::invalid_response& ir =
 			dynamic_cast <const vmime::exceptions::invalid_response&>(e);
 
 		os << "    response = " << ir.response() << std::endl;
 	}
 
-	if (dynamic_cast <const vmime::exceptions::connection_greeting_error*>(&e))
-	{
+	if (dynamic_cast <const vmime::exceptions::connection_greeting_error*>(&e)) {
+
 		const vmime::exceptions::connection_greeting_error& cgee =
 			dynamic_cast <const vmime::exceptions::connection_greeting_error&>(e);
 
 		os << "    response = " << cgee.response() << std::endl;
 	}
 
-	if (dynamic_cast <const vmime::exceptions::authentication_error*>(&e))
-	{
+	if (dynamic_cast <const vmime::exceptions::authentication_error*>(&e)) {
+
 		const vmime::exceptions::authentication_error& aee =
 			dynamic_cast <const vmime::exceptions::authentication_error&>(e);
 
 		os << "    response = " << aee.response() << std::endl;
 	}
 
-	if (dynamic_cast <const vmime::exceptions::filesystem_exception*>(&e))
-	{
+	if (dynamic_cast <const vmime::exceptions::filesystem_exception*>(&e)) {
+
 		const vmime::exceptions::filesystem_exception& fse =
 			dynamic_cast <const vmime::exceptions::filesystem_exception&>(e);
 
@@ -121,8 +122,9 @@ static std::ostream& operator<<(std::ostream& os, const vmime::exception& e)
 			getFileSystemFactory()->pathToString(fse.path()) << std::endl;
 	}
 
-	if (e.other() != NULL)
+	if (e.other()) {
 		os << *e.other();
+	}
 
 	return os;
 }
@@ -133,35 +135,40 @@ static std::ostream& operator<<(std::ostream& os, const vmime::exception& e)
   * @param s structure object
   * @param level current depth
   */
-static void printStructure(vmime::shared_ptr <const vmime::net::messageStructure> s, const int level = 0)
-{
-	for (size_t i = 0 ; i < s->getPartCount() ; ++i)
-	{
+static void printStructure(
+	vmime::shared_ptr <const vmime::net::messageStructure> s,
+	const int level = 0
+) {
+
+	for (size_t i = 0 ; i < s->getPartCount() ; ++i) {
+
 		vmime::shared_ptr <const vmime::net::messagePart> part = s->getPartAt(i);
 
-		for (int j = 0 ; j < level * 2 ; ++j)
+		for (int j = 0 ; j < level * 2 ; ++j) {
 			std::cout << " ";
+		}
 
-		std::cout << (part->getNumber() + 1) << ". "
-				<< part->getType().generate()
-				<< " [" << part->getSize() << " byte(s)]"
-				<< std::endl;
+		std::cout
+			<< (part->getNumber() + 1) << ". "
+			<< part->getType().generate()
+			<< " [" << part->getSize() << " byte(s)]"
+			<< std::endl;
 
 		printStructure(part->getStructure(), level + 1);
 	}
 }
 
 
-static const vmime::string getFolderPathString(vmime::shared_ptr <vmime::net::folder> f)
-{
+static const vmime::string getFolderPathString(vmime::shared_ptr <vmime::net::folder> f) {
+
 	const vmime::string n = f->getName().getBuffer();
 
-	if (n.empty()) // root folder
-	{
+	if (n.empty()) {  // root folder
+
 		return "/";
-	}
-	else
-	{
+
+	} else {
+
 		vmime::shared_ptr <vmime::net::folder> p = f->getParent();
 		return getFolderPathString(p) + n + "/";
 	}
@@ -172,38 +179,43 @@ static const vmime::string getFolderPathString(vmime::shared_ptr <vmime::net::fo
   *
   * @param folder current folder
   */
-static void printFolders(vmime::shared_ptr <vmime::net::folder> folder, const int level = 0)
-{
-	for (int j = 0 ; j < level * 2 ; ++j)
+static void printFolders(vmime::shared_ptr <vmime::net::folder> folder, const int level = 0) {
+
+	for (int j = 0 ; j < level * 2 ; ++j) {
 		std::cout << " ";
+	}
 
 	const vmime::net::folderAttributes attr = folder->getAttributes();
 	std::ostringstream attrStr;
 
-	if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_ALL)
+	if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_ALL) {
 		attrStr << " \\use:All";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_ARCHIVE)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_ARCHIVE) {
 		attrStr << " \\use:Archive";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_DRAFTS)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_DRAFTS) {
 		attrStr << " \\use:Drafts";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_FLAGGED)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_FLAGGED) {
 		attrStr << " \\use:Flagged";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_JUNK)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_JUNK) {
 		attrStr << " \\use:Junk";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_SENT)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_SENT) {
 		attrStr << " \\use:Sent";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_TRASH)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_TRASH) {
 		attrStr << " \\use:Trash";
-	else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_IMPORTANT)
+	} else if (attr.getSpecialUse() == vmime::net::folderAttributes::SPECIALUSE_IMPORTANT) {
 		attrStr << " \\use:Important";
+	}
 
-	if (attr.getFlags() & vmime::net::folderAttributes::FLAG_HAS_CHILDREN)
+	if (attr.getFlags() & vmime::net::folderAttributes::FLAG_HAS_CHILDREN) {
 		attrStr << " \\flag:HasChildren";
-	if (attr.getFlags() & vmime::net::folderAttributes::FLAG_NO_OPEN)
+	}
+	if (attr.getFlags() & vmime::net::folderAttributes::FLAG_NO_OPEN) {
 		attrStr << " \\flag:NoOpen";
+	}
 
-	for (size_t i = 0, n = attr.getUserFlags().size() ; i < n ; ++i)
+	for (size_t i = 0, n = attr.getUserFlags().size() ; i < n ; ++i) {
 		attrStr << " \\" << attr.getUserFlags()[i];
+	}
 
 	std::cout << getFolderPathString(folder);
 	std::cout << " " << attrStr.str();
@@ -211,8 +223,9 @@ static void printFolders(vmime::shared_ptr <vmime::net::folder> folder, const in
 
 	std::vector <vmime::shared_ptr <vmime::net::folder> > subFolders = folder->getFolders(false);
 
-	for (unsigned int i = 0 ; i < subFolders.size() ; ++i)
+	for (unsigned int i = 0 ; i < subFolders.size() ; ++i) {
 		printFolders(subFolders[i], level + 1);
+	}
 }
 
 
@@ -220,12 +233,13 @@ static void printFolders(vmime::shared_ptr <vmime::net::folder> folder, const in
   *
   * @param choices menu choices
   */
-static unsigned int printMenu(const std::vector <std::string>& choices)
-{
+static unsigned int printMenu(const std::vector <std::string>& choices) {
+
 	std::cout << std::endl;
 
-	for (unsigned int i = 0 ; i < choices.size() ; ++i)
+	for (unsigned int i = 0 ; i < choices.size() ; ++i) {
 		std::cout << "   " << (i + 1) << ". " << choices[i] << std::endl;
+	}
 
 	std::cout << std::endl;
 	std::cout << "   Your choice? [1-" << choices.size() << "] ";
@@ -241,19 +255,20 @@ static unsigned int printMenu(const std::vector <std::string>& choices)
 
 	std::cout << std::endl;
 
-	if (choice < 1 || choice > choices.size())
+	if (choice < 1 || choice > choices.size()) {
 		return 0;
-	else
+	} else {
 		return choice;
+	}
 }
 
 
 /** Send a message interactively.
   */
-static void sendMessage()
-{
-	try
-	{
+static void sendMessage() {
+
+	try {
+
 		// Request user to enter an URL
 		std::cout << "Enter an URL to connect to transport service." << std::endl;
 		std::cout << "Available protocols: " << findAvailableProtocols(vmime::net::service::TYPE_TRANSPORT) << std::endl;
@@ -268,10 +283,11 @@ static void sendMessage()
 
 		vmime::shared_ptr <vmime::net::transport> tr;
 
-		if (url.getUsername().empty() || url.getPassword().empty())
+		if (url.getUsername().empty() || url.getPassword().empty()) {
 			tr = g_session->getTransport(url, vmime::make_shared <interactiveAuthenticator>());
-		else
+		} else {
 			tr = g_session->getTransport(url);
+		}
 
 #if VMIME_HAVE_TLS_SUPPORT
 
@@ -283,15 +299,17 @@ static void sendMessage()
 
 		// Set the object responsible for verifying certificates, in the
 		// case a secured connection is used (TLS/SSL)
-		tr->setCertificateVerifier
-			(vmime::make_shared <interactiveCertificateVerifier>());
+		tr->setCertificateVerifier(
+			vmime::make_shared <interactiveCertificateVerifier>()
+		);
 
 #endif // VMIME_HAVE_TLS_SUPPORT
 
 		// You can also set some properties (see example7 to know the properties
 		// available for each service). For example, for SMTP:
-		if (!url.getUsername().empty() || !url.getPassword().empty())
+		if (!url.getUsername().empty() || !url.getPassword().empty()) {
 			tr->setProperty("options.need-authentication", true);
+		}
 
 		// Trace communication between client and server
 		vmime::shared_ptr <std::ostringstream> traceStream = vmime::make_shared <std::ostringstream>();
@@ -307,8 +325,8 @@ static void sendMessage()
 		vmime::mailbox from(fromString);
 		vmime::mailboxList to;
 
-		for (bool cont = true ; cont ; )
-		{
+		for (bool cont = true ; cont ; ) {
+
 			std::cout << "Enter email of the recipient (empty to stop): ";
 			std::cout.flush();
 
@@ -317,23 +335,25 @@ static void sendMessage()
 
 			cont = (toString.size() != 0);
 
-			if (cont)
+			if (cont) {
 				to.appendMailbox(vmime::make_shared <vmime::mailbox>(toString));
+			}
 		}
 
 		std::cout << "Enter message data, including headers (end with '.' on a single line):" << std::endl;
 
 		std::ostringstream data;
 
-		for (bool cont = true ; cont ; )
-		{
+		for (bool cont = true ; cont ; ) {
+
 			std::string line;
 			std::getline(std::cin, line);
 
-			if (line == ".")
+			if (line == ".") {
 				cont = false;
-			else
+			} else {
 				data << line << "\r\n";
+			}
 		}
 
 		// Connect to server
@@ -357,15 +377,15 @@ static void sendMessage()
 		std::cout << traceStream->str();
 
 		tr->disconnect();
-	}
-	catch (vmime::exception& e)
-	{
+
+	} catch (vmime::exception& e) {
+
 		std::cerr << std::endl;
 		std::cerr << e << std::endl;
 		throw;
-	}
-	catch (std::exception& e)
-	{
+
+	} catch (std::exception& e) {
+
 		std::cerr << std::endl;
 		std::cerr << "std::exception: " << e.what() << std::endl;
 		throw;
@@ -375,10 +395,10 @@ static void sendMessage()
 
 /** Connect to a message store interactively.
   */
-static void connectStore()
-{
-	try
-	{
+static void connectStore() {
+
+	try {
+
 		// Request user to enter an URL
 		std::cout << "Enter an URL to connect to store service." << std::endl;
 		std::cout << "Available protocols: " << findAvailableProtocols(vmime::net::service::TYPE_STORE) << std::endl;
@@ -396,10 +416,11 @@ static void connectStore()
 		// session properties "auth.username" and "auth.password".
 		vmime::shared_ptr <vmime::net::store> st;
 
-		if (url.getUsername().empty() || url.getPassword().empty())
+		if (url.getUsername().empty() || url.getPassword().empty()) {
 			st = g_session->getStore(url, vmime::make_shared <interactiveAuthenticator>());
-		else
+		} else {
 			st = g_session->getStore(url);
+		}
 
 #if VMIME_HAVE_TLS_SUPPORT
 
@@ -411,8 +432,9 @@ static void connectStore()
 
 		// Set the object responsible for verifying certificates, in the
 		// case a secured connection is used (TLS/SSL)
-		st->setCertificateVerifier
-			(vmime::make_shared <interactiveCertificateVerifier>());
+		st->setCertificateVerifier(
+			vmime::make_shared <interactiveCertificateVerifier>()
+		);
 
 #endif // VMIME_HAVE_TLS_SUPPORT
 
@@ -441,13 +463,13 @@ static void connectStore()
 		std::cout << std::endl;
 		std::cout << count << " message(s) in your inbox" << std::endl;
 
-		for (bool cont = true ; cont ; )
-		{
+		for (bool cont = true ; cont ; ) {
+
 			typedef std::map <vmime::size_t, vmime::shared_ptr <vmime::net::message> > MessageList;
 			MessageList msgList;
 
-			try
-			{
+			try {
+
 				std::vector <std::string> choices;
 
 				choices.push_back("Show message flags");
@@ -470,8 +492,8 @@ static void connectStore()
 				vmime::shared_ptr <vmime::net::message> msg;
 
 				if (choice == 1 || choice == 2 || choice == 3 || choice == 4 ||
-				    choice == 5 || choice == 6 || choice == 11)
-				{
+				    choice == 5 || choice == 6 || choice == 11) {
+
 					std::cout << "Enter message number: ";
 					std::cout.flush();
 
@@ -483,20 +505,20 @@ static void connectStore()
 					vmime::size_t num = 0;
 					iss >> num;
 
-					if (num < 1 || num > f->getMessageCount())
-					{
+					if (num < 1 || num > f->getMessageCount()) {
+
 						std::cerr << "Invalid message number." << std::endl;
 						continue;
 					}
 
 					MessageList::iterator it = msgList.find(num);
 
-					if (it != msgList.end())
-					{
+					if (it != msgList.end()) {
+
 						msg = (*it).second;
-					}
-					else
-					{
+
+					} else {
+
 						msg = f->getMessage(num);
 						msgList.insert(MessageList::value_type(num, msg));
 					}
@@ -504,25 +526,31 @@ static void connectStore()
 					std::cout << std::endl;
 				}
 
-				switch (choice)
-				{
+				switch (choice) {
+
 				// Show message flags
 				case 1:
 
 					f->fetchMessage(msg, vmime::net::fetchAttributes::FLAGS);
 
-					if (msg->getFlags() & vmime::net::message::FLAG_SEEN)
+					if (msg->getFlags() & vmime::net::message::FLAG_SEEN) {
 						std::cout << "FLAG_SEEN" << std::endl;
-					if (msg->getFlags() & vmime::net::message::FLAG_RECENT)
+					}
+					if (msg->getFlags() & vmime::net::message::FLAG_RECENT) {
 						std::cout << "FLAG_RECENT" << std::endl;
-					if (msg->getFlags() & vmime::net::message::FLAG_REPLIED)
+					}
+					if (msg->getFlags() & vmime::net::message::FLAG_REPLIED) {
 						std::cout << "FLAG_REPLIED" << std::endl;
-					if (msg->getFlags() & vmime::net::message::FLAG_DELETED)
+					}
+					if (msg->getFlags() & vmime::net::message::FLAG_DELETED) {
 						std::cout << "FLAG_DELETED" << std::endl;
-					if (msg->getFlags() & vmime::net::message::FLAG_MARKED)
+					}
+					if (msg->getFlags() & vmime::net::message::FLAG_MARKED) {
 						std::cout << "FLAG_MARKED" << std::endl;
-					if (msg->getFlags() & vmime::net::message::FLAG_PASSED)
+					}
+					if (msg->getFlags() & vmime::net::message::FLAG_PASSED) {
 						std::cout << "FLAG_PASSED" << std::endl;
+					}
 
 					break;
 
@@ -541,8 +569,8 @@ static void connectStore()
 					break;
 
 				// Show message envelope
-				case 4:
-				{
+				case 4: {
+
 					vmime::net::fetchAttributes attr(vmime::net::fetchAttributes::ENVELOPE);
 
 					// If you also want to fetch "Received: " fields:
@@ -555,37 +583,38 @@ static void connectStore()
 					break;
 				}
 				// Extract whole message
-				case 5:
-				{
+				case 5: {
+
 					vmime::utility::outputStreamAdapter out(std::cout);
 					msg->extract(out);
 
 					break;
 				}
 				// Extract attachments
-				case 6:
-				{
+				case 6: {
+
 					vmime::shared_ptr <vmime::message> parsedMsg = msg->getParsedMessage();
 
 					std::vector <vmime::shared_ptr <const vmime::attachment> > attchs =
 						vmime::attachmentHelper::findAttachmentsInMessage(parsedMsg);
 
-					if (attchs.size() > 0)
-					{
+					if (attchs.size() > 0) {
+
 						std::cout << attchs.size() << " attachments found." << std::endl;
 
 						for (std::vector <vmime::shared_ptr <const vmime::attachment> >::iterator
-						     it = attchs.begin() ; it != attchs.end() ; ++it)
-						{
+						     it = attchs.begin() ; it != attchs.end() ; ++it) {
+
 							vmime::shared_ptr <const vmime::attachment> att = *it;
 
 							// Get attachment size
 							vmime::size_t size = 0;
 
-							if (att->getData()->isEncoded())
+							if (att->getData()->isEncoded()) {
 								size = att->getData()->getEncoding().getEncoder()->getDecodedSize(att->getData()->getLength());
-							else
+							} else {
 								size = att->getData()->getLength();
+							}
 
 							std::cout << "Found attachment '" << att->getName().getBuffer() << "'"
 							          << ", size is " << size << " bytes:" << std::endl;
@@ -618,17 +647,17 @@ static void connectStore()
 							att->getData()->extract(*output.get());
 							*/
 						}
-					}
-					else
-					{
+
+					} else {
+
 						std::cout << "No attachments found." << std::endl;
 					}
 
 					break;
 				}
 				// Status
-				case 7:
-				{
+				case 7: {
+
 					vmime::size_t count, unseen;
 					f->status(count, unseen);
 
@@ -636,17 +665,16 @@ static void connectStore()
 					break;
 				}
 				// List folders
-				case 8:
-				{
-					vmime::shared_ptr <vmime::net::folder>
-						root = st->getRootFolder();
+				case 8: {
+
+					vmime::shared_ptr <vmime::net::folder> root = st->getRootFolder();
 
 					printFolders(root);
 					break;
 				}
 				// Change folder
-				case 9:
-				{
+				case 9: {
+
 					std::cout << "Enter folder path (eg. /root/subfolder):" << std::endl;
 					std::cout.flush();
 
@@ -655,19 +683,21 @@ static void connectStore()
 
 					vmime::shared_ptr <vmime::net::folder> newFolder = st->getRootFolder();
 
-					for (std::string::size_type s = 0, p = 0 ; ; s = p + 1)
-					{
+					for (std::string::size_type s = 0, p = 0 ; ; s = p + 1) {
+
 						p = path.find_first_of('/', s);
 
 						const std::string x = (p == std::string::npos)
 							? std::string(path.begin() + s, path.end())
 							: std::string(path.begin() + s, path.begin() + p);
 
-						if (!x.empty())
+						if (!x.empty()) {
 							newFolder = newFolder->getFolder(vmime::utility::path::component(x));
+						}
 
-						if (p == std::string::npos)
+						if (p == std::string::npos) {
 							break;
+						}
 					}
 
 					newFolder->open(vmime::net::folder::MODE_READ_WRITE);
@@ -683,8 +713,8 @@ static void connectStore()
 					break;
 				}
 				// Add message
-				case 10:
-				{
+				case 10: {
+
 					vmime::messageBuilder mb;
 
 					mb.setExpeditor(vmime::mailbox("[email protected]"));
@@ -694,32 +724,35 @@ static void connectStore()
 					mb.setRecipients(to);
 
 					mb.setSubject(vmime::text("Test message from VMime example6"));
-					mb.getTextPart()->setText(vmime::make_shared <vmime::stringContentHandler>(
-						"Body of test message from VMime example6."));
+					mb.getTextPart()->setText(
+						vmime::make_shared <vmime::stringContentHandler>(
+							"Body of test message from VMime example6."
+						)
+					);
 
 					vmime::shared_ptr <vmime::message> msg = mb.construct();
 
 					vmime::net::messageSet set = f->addMessage(msg);
 
-					if (set.isEmpty())
-					{
+					if (set.isEmpty()) {
+
 						std::cout << "Message has successfully been added, "
 						          << "but its UID/number is not known." << std::endl;
-					}
-					else
-					{
+
+					} else {
+
 						const vmime::net::messageRange& range = set.getRangeAt(0);
 
-						if (set.isUIDSet())
-						{
+						if (set.isUIDSet()) {
+
 							const vmime::net::message::uid uid =
 								dynamic_cast <const vmime::net::UIDMessageRange&>(range).getFirst();
 
 							std::cout << "Message has successfully been added, "
 							          << "its UID is '" << uid << "'." << std::endl;
-						}
-						else
-						{
+
+						} else {
+
 							const vmime::size_t number =
 								dynamic_cast <const vmime::net::numberMessageRange&>(range).getFirst();
 
@@ -731,30 +764,30 @@ static void connectStore()
 					break;
 				}
 				// Copy message
-				case 11:
-				{
+				case 11: {
+
 					vmime::net::messageSet set = f->copyMessages(f->getFullPath(),
 						vmime::net::messageSet::byNumber(msg->getNumber()));
 
-					if (set.isEmpty())
-					{
+					if (set.isEmpty()) {
+
 						std::cout << "Message has successfully been copied, "
 						          << "but its UID/number is not known." << std::endl;
-					}
-					else
-					{
+
+					} else {
+
 						const vmime::net::messageRange& range = set.getRangeAt(0);
 
-						if (set.isUIDSet())
-						{
+						if (set.isUIDSet()) {
+
 							const vmime::net::message::uid uid =
 								dynamic_cast <const vmime::net::UIDMessageRange&>(range).getFirst();
 
 							std::cout << "Message has successfully been copied, "
 							          << "its UID is '" << uid << "'." << std::endl;
-						}
-						else
-						{
+
+						} else {
+
 							const vmime::size_t number =
 								dynamic_cast <const vmime::net::numberMessageRange&>(range).getFirst();
 
@@ -808,35 +841,37 @@ static void connectStore()
 		{
 			vmime::shared_ptr <vmime::net::folder> g = st->getFolder(vmime::net::folder::path("TEMP"));
 
-			if (!g->exists())
+			if (!g->exists()) {
 				g->create(vmime::net::folder::TYPE_CONTAINS_MESSAGES);
+			}
 
 			f->copyMessages(g->getFullPath());
 		}
 */
-			}
-			catch (vmime::exception& e)
-			{
+
+			} catch (vmime::exception& e) {
+
 				std::cerr << std::endl;
 				std::cerr << e << std::endl;
-			}
-			catch (std::exception& e)
-			{
+
+			} catch (std::exception& e) {
+
 				std::cerr << std::endl;
 				std::cerr << "std::exception: " << e.what() << std::endl;
 			}
+
 		} // for(cont)
 
 		st->disconnect();
-	}
-	catch (vmime::exception& e)
-	{
+
+	} catch (vmime::exception& e) {
+
 		std::cerr << std::endl;
 		std::cerr << e << std::endl;
 		throw;
-	}
-	catch (std::exception& e)
-	{
+
+	} catch (std::exception& e) {
+
 		std::cerr << std::endl;
 		std::cerr << "std::exception: " << e.what() << std::endl;
 		throw;
@@ -848,16 +883,16 @@ static void connectStore()
  *
  * @return true to quit the program, false to continue
  */
-static bool menu()
-{
+static bool menu() {
+
 	std::vector <std::string> items;
 
 	items.push_back("Connect to a message store");
 	items.push_back("Send a message");
 	items.push_back("Quit");
 
-	switch (printMenu(items))
-	{
+	switch (printMenu(items)) {
+
 	// Connect to store
 	case 1:
 
@@ -883,25 +918,21 @@ static bool menu()
 }
 
 
-int main()
-{
+int main() {
+
 	// Set the global C and C++ locale to the user-configured locale.
 	// The locale should use UTF-8 encoding for these tests to run successfully.
-	try
-	{
+	try {
 		std::locale::global(std::locale(""));
-	}
-	catch (std::exception &)
-	{
+	} catch (std::exception &) {
 		std::setlocale(LC_ALL, "");
 	}
 
-	for (bool quit = false ; !quit ; )
-	{
+	for (bool quit = false ; !quit ; ) {
+
 		// Loop on main menu
 		quit = menu();
 	}
 
 	return 0;
 }
-
diff --git a/examples/example6_authenticator.hpp b/examples/example6_authenticator.hpp
index 64336e2a..56f02392 100644
--- a/examples/example6_authenticator.hpp
+++ b/examples/example6_authenticator.hpp
@@ -3,20 +3,23 @@
 #if VMIME_HAVE_SASL_SUPPORT
 
 // SASL authentication handler
-class interactiveAuthenticator : public vmime::security::sasl::defaultSASLAuthenticator
-{
-	const std::vector <vmime::shared_ptr <vmime::security::sasl::SASLMechanism> > getAcceptableMechanisms
-		(const std::vector <vmime::shared_ptr <vmime::security::sasl::SASLMechanism> >& available,
-		 const vmime::shared_ptr <vmime::security::sasl::SASLMechanism>& suggested) const
-	{
+class interactiveAuthenticator : public vmime::security::sasl::defaultSASLAuthenticator {
+
+	const std::vector <vmime::shared_ptr <vmime::security::sasl::SASLMechanism> >
+		getAcceptableMechanisms(
+			const std::vector <vmime::shared_ptr <vmime::security::sasl::SASLMechanism> >& available,
+			const vmime::shared_ptr <vmime::security::sasl::SASLMechanism>& suggested
+		) const {
+
 		std::cout << std::endl << "Available SASL mechanisms:" << std::endl;
 
-		for (unsigned int i = 0 ; i < available.size() ; ++i)
-		{
+		for (unsigned int i = 0 ; i < available.size() ; ++i) {
+
 			std::cout << "  " << available[i]->getName();
 
-			if (suggested && available[i]->getName() == suggested->getName())
+			if (suggested && available[i]->getName() == suggested->getName()) {
 				std::cout << "(suggested)";
+			}
 		}
 
 		std::cout << std::endl << std::endl;
@@ -24,31 +27,33 @@ class interactiveAuthenticator : public vmime::security::sasl::defaultSASLAuthen
 		return defaultSASLAuthenticator::getAcceptableMechanisms(available, suggested);
 	}
 
-	void setSASLMechanism(const vmime::shared_ptr <vmime::security::sasl::SASLMechanism>& mech)
-	{
+	void setSASLMechanism(const vmime::shared_ptr <vmime::security::sasl::SASLMechanism>& mech) {
+
 		std::cout << "Trying '" << mech->getName() << "' authentication mechanism" << std::endl;
 
 		defaultSASLAuthenticator::setSASLMechanism(mech);
 	}
 
-	const vmime::string getUsername() const
-	{
-		if (m_username.empty())
+	const vmime::string getUsername() const {
+
+		if (m_username.empty()) {
 			m_username = getUserInput("Username");
+		}
 
 		return m_username;
 	}
 
-	const vmime::string getPassword() const
-	{
-		if (m_password.empty())
+	const vmime::string getPassword() const {
+
+		if (m_password.empty()) {
 			m_password = getUserInput("Password");
+		}
 
 		return m_password;
 	}
 
-	static const vmime::string getUserInput(const std::string& prompt)
-	{
+	static const vmime::string getUserInput(const std::string& prompt) {
+
 		std::cout << prompt << ": ";
 		std::cout.flush();
 
@@ -67,26 +72,28 @@ private:
 #else // !VMIME_HAVE_SASL_SUPPORT
 
 // Simple authentication handler
-class interactiveAuthenticator : public vmime::security::defaultAuthenticator
-{
-	const vmime::string getUsername() const
-	{
-		if (m_username.empty())
+class interactiveAuthenticator : public vmime::security::defaultAuthenticator {
+
+	const vmime::string getUsername() const {
+
+		if (m_username.empty()) {
 			m_username = getUserInput("Username");
+		}
 
 		return m_username;
 	}
 
-	const vmime::string getPassword() const
-	{
-		if (m_password.empty())
+	const vmime::string getPassword() const {
+
+		if (m_password.empty()) {
 			m_password = getUserInput("Password");
+		}
 
 		return m_password;
 	}
 
-	static const vmime::string getUserInput(const std::string& prompt)
-	{
+	static const vmime::string getUserInput(const std::string& prompt) {
+
 		std::cout << prompt << ": ";
 		std::cout.flush();
 
@@ -103,4 +110,3 @@ private:
 };
 
 #endif // VMIME_HAVE_SASL_SUPPORT
-
diff --git a/examples/example6_certificateVerifier.hpp b/examples/example6_certificateVerifier.hpp
index b4b47a2a..3d8bf82e 100644
--- a/examples/example6_certificateVerifier.hpp
+++ b/examples/example6_certificateVerifier.hpp
@@ -3,20 +3,23 @@
 #if VMIME_HAVE_TLS_SUPPORT
 
 // Certificate verifier (TLS/SSL)
-class interactiveCertificateVerifier : public vmime::security::cert::defaultCertificateVerifier
-{
+class interactiveCertificateVerifier : public vmime::security::cert::defaultCertificateVerifier {
+
 public:
 
-	void verify(const vmime::shared_ptr <vmime::security::cert::certificateChain>& chain, const vmime::string& hostname)
-	{
-		try
-		{
+	void verify(
+		const vmime::shared_ptr <vmime::security::cert::certificateChain>& chain,
+		const vmime::string& hostname
+	) {
+
+		try {
+
 			setX509TrustedCerts(m_trustedCerts);
 
 			defaultCertificateVerifier::verify(chain, hostname);
-		}
-		catch (vmime::security::cert::certificateException&)
-		{
+
+		} catch (vmime::security::cert::certificateException&) {
+
 			// Obtain subject's certificate
 			vmime::shared_ptr <vmime::security::cert::certificate> cert = chain->getAt(0);
 
@@ -29,13 +32,14 @@ public:
 			std::getline(std::cin, answer);
 
 			if (answer.length() != 0 &&
-			    (answer[0] == 'Y' || answer[0] == 'y'))
-			{
+			    (answer[0] == 'Y' || answer[0] == 'y')) {
+
 				// Accept it, and remember user's choice for later
-				if (cert->getType() == "X.509")
-				{
-					m_trustedCerts.push_back(vmime::dynamicCast
-						<vmime::security::cert::X509Certificate>(cert));
+				if (cert->getType() == "X.509") {
+
+					m_trustedCerts.push_back(
+						vmime::dynamicCast <vmime::security::cert::X509Certificate>(cert)
+					);
 
 					setX509TrustedCerts(m_trustedCerts);
 					defaultCertificateVerifier::verify(chain, hostname);
@@ -44,8 +48,7 @@ public:
 				return;
 			}
 
-			throw vmime::security::cert::certificateException
-				("User did not accept the certificate.");
+			throw vmime::security::cert::certificateException("User did not accept the certificate.");
 		}
 	}
 
@@ -59,4 +62,3 @@ std::vector <vmime::shared_ptr <vmime::security::cert::X509Certificate> >
 	interactiveCertificateVerifier::m_trustedCerts;
 
 #endif // VMIME_HAVE_TLS_SUPPORT
-
diff --git a/examples/example6_timeoutHandler.hpp b/examples/example6_timeoutHandler.hpp
index 3e188baf..7999084d 100644
--- a/examples/example6_timeoutHandler.hpp
+++ b/examples/example6_timeoutHandler.hpp
@@ -5,17 +5,17 @@
   * Used to stop the current operation after too much time, or if the user
   * requested cancellation.
   */
-class timeoutHandler : public vmime::net::timeoutHandler
-{
+class timeoutHandler : public vmime::net::timeoutHandler {
+
 public:
 
 	timeoutHandler()
-		: m_start(time(NULL))
-	{
+		: m_start(time(NULL)) {
+
 	}
 
-	bool isTimeOut()
-	{
+	bool isTimeOut() {
+
 		// This is a cancellation point: return true if you want to cancel
 		// the current operation. If you return true, handleTimeOut() will
 		// be called just after this, and before actually cancelling the
@@ -25,15 +25,15 @@ public:
 		return (time(NULL) - m_start) >= 10;  // seconds
 	}
 
-	void resetTimeOut()
-	{
+	void resetTimeOut() {
+
 		// Called at the beginning of an operation (eg. connecting,
 		// a read() or a write() on a socket...)
 		m_start = time(NULL);
 	}
 
-	bool handleTimeOut()
-	{
+	bool handleTimeOut() {
+
 		// If isTimeOut() returned true, this function will be called. This
 		// allows you to interact with the user, ie. display a prompt to
 		// know whether he wants to cancel the operation.
@@ -49,13 +49,12 @@ private:
 };
 
 
-class timeoutHandlerFactory : public vmime::net::timeoutHandlerFactory
-{
+class timeoutHandlerFactory : public vmime::net::timeoutHandlerFactory {
+
 public:
 
-	vmime::shared_ptr <vmime::net::timeoutHandler> create()
-	{
+	vmime::shared_ptr <vmime::net::timeoutHandler> create() {
+
 		return vmime::make_shared <timeoutHandler>();
 	}
 };
-
diff --git a/examples/example6_tracer.hpp b/examples/example6_tracer.hpp
index 8f57f56c..27090cf7 100644
--- a/examples/example6_tracer.hpp
+++ b/examples/example6_tracer.hpp
@@ -1,25 +1,29 @@
 
 /** Tracer used to demonstrate logging communication between client and server.
   */
+class myTracer : public vmime::net::tracer {
 
-class myTracer : public vmime::net::tracer
-{
 public:
 
-	myTracer(const vmime::shared_ptr <std::ostringstream>& stream,
-	         const vmime::shared_ptr <vmime::net::service>& serv, const int connectionId)
-		: m_stream(stream), m_service(serv), m_connectionId(connectionId)
-	{
+	myTracer(
+		const vmime::shared_ptr <std::ostringstream>& stream,
+		const vmime::shared_ptr <vmime::net::service>& serv,
+		const int connectionId
+	)
+		: m_stream(stream),
+		  m_service(serv),
+		  m_connectionId(connectionId) {
+
 	}
 
-	void traceSend(const vmime::string& line)
-	{
+	void traceSend(const vmime::string& line) {
+
 		*m_stream << "[" << m_service->getProtocolName() << ":" << m_connectionId
 		          << "] C: " << line << std::endl;
 	}
 
-	void traceReceive(const vmime::string& line)
-	{
+	void traceReceive(const vmime::string& line) {
+
 		*m_stream << "[" << m_service->getProtocolName() << ":" << m_connectionId
 		          << "] S: " << line << std::endl;
 	}
@@ -31,18 +35,21 @@ private:
 	const int m_connectionId;
 };
 
-class myTracerFactory : public vmime::net::tracerFactory
-{
+
+class myTracerFactory : public vmime::net::tracerFactory {
+
 public:
 
 	myTracerFactory(const vmime::shared_ptr <std::ostringstream>& stream)
-		: m_stream(stream)
-	{
+		: m_stream(stream) {
+
 	}
 
-	vmime::shared_ptr <vmime::net::tracer> create
-		(const vmime::shared_ptr <vmime::net::service>& serv, const int connectionId)
-	{
+	vmime::shared_ptr <vmime::net::tracer> create(
+		const vmime::shared_ptr <vmime::net::service>& serv,
+		const int connectionId
+	) {
+
 		return vmime::make_shared <myTracer>(m_stream, serv, connectionId);
 	}
 
@@ -50,4 +57,3 @@ private:
 
 	vmime::shared_ptr <std::ostringstream> m_stream;
 };
-
diff --git a/examples/example7.cpp b/examples/example7.cpp
index ae508697..db96dbda 100644
--- a/examples/example7.cpp
+++ b/examples/example7.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -39,16 +39,16 @@
 #include "vmime/platforms/posix/posixHandler.hpp"
 
 
-int main()
-{
+int main() {
+
 	// Enumerate encoders
 	vmime::shared_ptr <vmime::utility::encoder::encoderFactory> ef =
 		vmime::utility::encoder::encoderFactory::getInstance();
 
 	std::cout << "Available encoders:" << std::endl;
 
-	for (size_t i = 0 ; i < ef->getEncoderCount() ; ++i)
-	{
+	for (size_t i = 0 ; i < ef->getEncoderCount() ; ++i) {
+
 		vmime::shared_ptr <const vmime::utility::encoder::encoderFactory::registeredEncoder>
 			enc = ef->getEncoderAt(i);
 
@@ -59,8 +59,9 @@ int main()
 
 		std::vector <vmime::string> props = e->getAvailableProperties();
 
-		for (std::vector <vmime::string>::const_iterator it = props.begin() ; it != props.end() ; ++it)
+		for (std::vector <vmime::string>::const_iterator it = props.begin() ; it != props.end() ; ++it) {
 			std::cout << "      - " << *it << std::endl;
+		}
 	}
 
 	std::cout << std::endl;
@@ -71,8 +72,8 @@ int main()
 
 	std::cout << "Available messaging services:" << std::endl;
 
-	for (size_t i = 0 ; i < sf->getServiceCount() ; ++i)
-	{
+	for (size_t i = 0 ; i < sf->getServiceCount() ; ++i) {
+
 		const vmime::net::serviceFactory::registeredService& serv = *sf->getServiceAt(i);
 
 		std::cout << "  * " << serv.getName() << std::endl;
@@ -81,28 +82,29 @@ int main()
 			serv.getInfos().getAvailableProperties();
 
 		for (std::vector <vmime::net::serviceInfos::property>::const_iterator it = props.begin() ;
-		     it != props.end() ; ++it)
-		{
+		     it != props.end() ; ++it) {
+
 			const vmime::net::serviceInfos::property& p = *it;
 
 			const vmime::string name = serv.getInfos().getPropertyPrefix() + p.getName();
 
 			vmime::string type;
 
-			switch (p.getType())
-			{
-			case vmime::net::serviceInfos::property::TYPE_INTEGER: type = "TYPE_INTEGER"; break;
-			case vmime::net::serviceInfos::property::TYPE_STRING: type = "TYPE_STRING"; break;
-			case vmime::net::serviceInfos::property::TYPE_BOOLEAN: type = "TYPE_BOOLEAN"; break;
-			default: type = "(unknown)"; break;
+			switch (p.getType()) {
+				case vmime::net::serviceInfos::property::TYPE_INTEGER: type = "TYPE_INTEGER"; break;
+				case vmime::net::serviceInfos::property::TYPE_STRING: type = "TYPE_STRING"; break;
+				case vmime::net::serviceInfos::property::TYPE_BOOLEAN: type = "TYPE_BOOLEAN"; break;
+				default: type = "(unknown)"; break;
 			}
 
 			vmime::string flags;
 
-			if (p.getFlags() & vmime::net::serviceInfos::property::FLAG_REQUIRED)
+			if (p.getFlags() & vmime::net::serviceInfos::property::FLAG_REQUIRED) {
 				flags += " FLAG_REQUIRED";
-			if (p.getFlags() & vmime::net::serviceInfos::property::FLAG_HIDDEN)
+			}
+			if (p.getFlags() & vmime::net::serviceInfos::property::FLAG_HIDDEN) {
 				flags += " FLAG_HIDDEN";
+			}
 
 			std::cout << "      - " << serv.getInfos().getPropertyPrefix() + p.getName();
 			std::cout << " (type=" << type << ", flags=" << flags;
@@ -111,5 +113,6 @@ int main()
 	}
 
 	std::cout << std::endl;
-}
 
+	return 0;
+}
diff --git a/examples/viewer/viewer.cpp b/examples/viewer/viewer.cpp
index 1d6daa05..a03120ac 100644
--- a/examples/viewer/viewer.cpp
+++ b/examples/viewer/viewer.cpp
@@ -1,6 +1,6 @@
 //
 // VMime library (http://www.vmime.org)
-// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+// Copyright (C) 2002 Vincent Richard <[email protected]>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -53,8 +53,12 @@ vmime::shared_ptr <vmime::message> currentMessage;
 
 
 
-void insertRowInModel(GtkTreeStore* model, vmime::shared_ptr <vmime::component> comp, GtkTreeIter* parent = NULL)
-{
+void insertRowInModel(
+	GtkTreeStore* model,
+	vmime::shared_ptr <vmime::component> comp,
+	GtkTreeIter* parent = NULL
+) {
+
 	GtkTreeIter iter;
 
 	gtk_tree_store_append(model, &iter, parent);
@@ -62,15 +66,14 @@ void insertRowInModel(GtkTreeStore* model, vmime::shared_ptr <vmime::component>
 
 	const std::vector <vmime::shared_ptr <vmime::component> > children = comp->getChildComponents();
 
-	for (int i = 0 ; i < children.size() ; ++i)
-	{
+	for (int i = 0 ; i < children.size() ; ++i) {
 		insertRowInModel(model, children[i], &iter);
 	}
 }
 
 
-void updateTreeView()
-{
+void updateTreeView() {
+
 	GtkTreeStore* model = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeView)));
 
 	g_object_ref(model);
@@ -85,8 +88,8 @@ void updateTreeView()
 }
 
 
-static void treeViewSelChanged(GtkTreeView* treeView, gpointer userData)
-{
+static void treeViewSelChanged(GtkTreeView* treeView, gpointer userData) {
+
 	GtkTreePath* path = NULL;
 	GtkTreeViewColumn* col = NULL;
 
@@ -112,19 +115,18 @@ static void treeViewSelChanged(GtkTreeView* treeView, gpointer userData)
 }
 
 
-static void destroy(GtkWidget* widget, gpointer data)
-{
+static void destroy(GtkWidget* widget, gpointer data) {
+
 	gtk_main_quit();
 }
 
 
-void openFile(const std::string& filename)
-{
+void openFile(const std::string& filename) {
+
 	std::ifstream file;
 	file.open(filename.c_str(), std::ios::in | std::ios::binary);
 
-	if (!file)
-	{
+	if (!file) {
 		std::cerr << "Can't open file '" << filename << "'." << std::endl;
 		return;
 	}
@@ -132,12 +134,10 @@ void openFile(const std::string& filename)
 	vmime::string data;
 	char buffer[16384];
 
-	do
-	{
+	do {
 		file.read(buffer, sizeof(buffer));
 		data += vmime::string(buffer, file.gcount());
-	}
-	while (file.gcount());
+	} while (file.gcount());
 
 	vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 	msg->parse(data);
@@ -147,13 +147,13 @@ void openFile(const std::string& filename)
 	char* convData = g_convert_with_fallback(data.c_str(), data.length(),
 		"UTF-8", "ISO-8859-1", "?", NULL, NULL, NULL);
 
-	if (convData == NULL)
-	{
+	if (!convData) {
+
 		gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textArea)),
 			"GLib UTF-8 conversion error.", -1);
-	}
-	else
-	{
+
+	} else {
+
 		gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textArea)),
 			convData, strlen(convData));
 
@@ -164,16 +164,19 @@ void openFile(const std::string& filename)
 }
 
 
-static void onFileOpen()
-{
-	GtkWidget* dlg = gtk_file_chooser_dialog_new
-		("Open Message File", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN,
-		 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-		 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-		 NULL);
+static void onFileOpen() {
+
+	GtkWidget* dlg = gtk_file_chooser_dialog_new(
+		"Open Message File",
+		GTK_WINDOW(window),
+		GTK_FILE_CHOOSER_ACTION_OPEN,
+		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+		NULL
+	);
+
+	if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_ACCEPT) {
 
-	if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_ACCEPT)
-	{
 		char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dlg));
 
 		openFile(filename);
@@ -187,8 +190,7 @@ static void onFileOpen()
 
 
 // UI definitions
-static const GtkActionEntry uiActions[] =
-{
+static const GtkActionEntry uiActions[] = {
 	{ "FileMenu", NULL, "_File" },
 	{ "FileOpen", GTK_STOCK_OPEN, "_Open...", "<control>O", NULL, G_CALLBACK(onFileOpen) },
 	{ "FileExit", GTK_STOCK_QUIT, "_Exit", "<control>Q", NULL, G_CALLBACK(gtk_main_quit) }
@@ -205,8 +207,8 @@ static const char* uiDefinition =
 	"</ui>";
 
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
+
 	// VMime initialization
 	vmime::platform::setHandler<vmime::platforms::posix::posixHandler>();
 
@@ -290,5 +292,3 @@ int main(int argc, char* argv[])
 
 	return 0;
 }
-
-