feat(src): use now a LINPHONE_{BEGIN,END}_NAMESPACE macro

src/cpim/header/cpim-core-headers.cpp

@@ -21,11 +21,11 @@
 
 #include "cpim-core-headers.h"
 
+// =============================================================================
+
 using namespace std;
 
-using namespace LinphonePrivate;
-
-// =============================================================================
+LINPHONE_BEGIN_NAMESPACE
 
 Cpim::CoreHeader::CoreHeader () : Header(*new HeaderPrivate) {}
 
@@ -56,7 +56,7 @@ MAKE_CORE_HEADER_IMPL(Require);
 
 // -----------------------------------------------------------------------------
 
-void Cpim::CoreHeader::force (const std::string &value) {
+void Cpim::CoreHeader::force (const string &value) {
 	Header::setValue(value);
 }
 
@@ -103,3 +103,5 @@ void Cpim::SubjectHeader::force (const string &value, const string &language) {
 	CoreHeader::force(value);
 	d->language = language;
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/header/cpim-core-headers.h

@@ -23,6 +23,8 @@
 
 // =============================================================================
 
+LINPHONE_BEGIN_NAMESPACE
+
 #define MAKE_CORE_HEADER(CLASS_PREFIX, NAME) \
 	class LINPHONE_PUBLIC CLASS_PREFIX ## Header : public CoreHeader { \
 	public: \
@@ -35,77 +37,77 @@
 		L_DISABLE_COPY(CLASS_PREFIX ## Header); \
 	};
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class HeaderNode;
+namespace Cpim {
+	class HeaderNode;
 
-		// -------------------------------------------------------------------------
-		// Generic core header.
-		// -------------------------------------------------------------------------
+	// -------------------------------------------------------------------------
+	// Generic core header.
+	// -------------------------------------------------------------------------
 
-		class LINPHONE_PUBLIC CoreHeader : public Header {
-			friend class HeaderNode;
+	class LINPHONE_PUBLIC CoreHeader : public Header {
+		friend class HeaderNode;
 
-		public:
-			CoreHeader ();
+	public:
+		CoreHeader ();
 
-			virtual ~CoreHeader () = 0;
+		virtual ~CoreHeader () = 0;
 
-			bool isValid () const override;
+		bool isValid () const override;
 
-		protected:
-			explicit CoreHeader (HeaderPrivate &p);
+	protected:
+		explicit CoreHeader (HeaderPrivate &p);
 
-			void force (const std::string &value);
+		void force (const std::string &value);
 
-		private:
-			L_DISABLE_COPY(CoreHeader);
-		};
+	private:
+		L_DISABLE_COPY(CoreHeader);
+	};
 
-		// -------------------------------------------------------------------------
-		// Core headers.
-		// -------------------------------------------------------------------------
+	// -------------------------------------------------------------------------
+	// Core headers.
+	// -------------------------------------------------------------------------
 
-		MAKE_CORE_HEADER(From, "From");
-		MAKE_CORE_HEADER(To, "To");
-		MAKE_CORE_HEADER(Cc, "cc");
-		MAKE_CORE_HEADER(DateTime, "DateTime");
-		MAKE_CORE_HEADER(Ns, "NS");
-		MAKE_CORE_HEADER(Require, "Require");
+	MAKE_CORE_HEADER(From, "From");
+	MAKE_CORE_HEADER(To, "To");
+	MAKE_CORE_HEADER(Cc, "cc");
+	MAKE_CORE_HEADER(DateTime, "DateTime");
+	MAKE_CORE_HEADER(Ns, "NS");
+	MAKE_CORE_HEADER(Require, "Require");
 
-		// -------------------------------------------------------------------------
-		// Specific Subject declaration.
-		// -------------------------------------------------------------------------
+	// -------------------------------------------------------------------------
+	// Specific Subject declaration.
+	// -------------------------------------------------------------------------
 
-		class SubjectHeaderPrivate;
+	class SubjectHeaderPrivate;
 
-		class LINPHONE_PUBLIC SubjectHeader : public CoreHeader {
-			friend class HeaderNode;
+	class LINPHONE_PUBLIC SubjectHeader : public CoreHeader {
+		friend class HeaderNode;
 
-		public:
-			SubjectHeader ();
+	public:
+		SubjectHeader ();
 
-			inline std::string getName () const override {
-				return "Subject";
-			}
+		inline std::string getName () const override {
+			return "Subject";
+		}
 
-			bool setValue (const std::string &value) override;
+		bool setValue (const std::string &value) override;
 
-			std::string getLanguage () const;
-			bool setLanguage (const std::string &language);
+		std::string getLanguage () const;
+		bool setLanguage (const std::string &language);
 
-			std::string asString () const override;
+		std::string asString () const override;
 
-		protected:
-			void force (const std::string &value, const std::string &language);
+	protected:
+		void force (const std::string &value, const std::string &language);
 
-		private:
-			L_DECLARE_PRIVATE(SubjectHeader);
-			L_DISABLE_COPY(SubjectHeader);
-		};
-	}
+	private:
+		L_DECLARE_PRIVATE(SubjectHeader);
+		L_DISABLE_COPY(SubjectHeader);
+	};
 }
 
 #undef MAKE_CORE_HEADER
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_CORE_HEADERS_H_

src/cpim/header/cpim-generic-header.cpp

@@ -24,11 +24,11 @@
 
 #include "cpim-generic-header.h"
 
+// =============================================================================
+
 using namespace std;
 
-using namespace LinphonePrivate;
-
-// =============================================================================
+LINPHONE_BEGIN_NAMESPACE
 
 class Cpim::GenericHeaderPrivate : public HeaderPrivate {
 public:
@@ -117,3 +117,5 @@ void Cpim::GenericHeader::force (const string &name, const string &value, const
 			d->parameters->push_back(make_pair(parameter.substr(0, equalIndex), parameter.substr(equalIndex + 1)));
 	}
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/header/cpim-generic-header.h

@@ -26,40 +26,42 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class GenericHeaderPrivate;
-		class HeaderNode;
+LINPHONE_BEGIN_NAMESPACE
 
-		class LINPHONE_PUBLIC GenericHeader : public Header {
-			friend class HeaderNode;
+namespace Cpim {
+	class GenericHeaderPrivate;
+	class HeaderNode;
 
-		public:
-			GenericHeader ();
+	class LINPHONE_PUBLIC GenericHeader : public Header {
+		friend class HeaderNode;
 
-			std::string getName () const override;
-			bool setName (const std::string &name);
+	public:
+		GenericHeader ();
 
-			bool setValue (const std::string &value) override;
+		std::string getName () const override;
+		bool setName (const std::string &name);
 
-			typedef std::shared_ptr<const std::list<std::pair<std::string, std::string> > > ParameterList;
+		bool setValue (const std::string &value) override;
 
-			ParameterList getParameters () const;
-			bool addParameter (const std::string &key, const std::string &value);
-			void removeParameter (const std::string &key, const std::string &value);
+		typedef std::shared_ptr<const std::list<std::pair<std::string, std::string> > > ParameterList;
 
-			bool isValid () const override;
+		ParameterList getParameters () const;
+		bool addParameter (const std::string &key, const std::string &value);
+		void removeParameter (const std::string &key, const std::string &value);
 
-			std::string asString () const override;
+		bool isValid () const override;
 
-		protected:
-			void force (const std::string &name, const std::string &value, const std::string &parameters);
+		std::string asString () const override;
 
-		private:
-			L_DECLARE_PRIVATE(GenericHeader);
-			L_DISABLE_COPY(GenericHeader);
-		};
-	}
+	protected:
+		void force (const std::string &name, const std::string &value, const std::string &parameters);
+
+	private:
+		L_DECLARE_PRIVATE(GenericHeader);
+		L_DISABLE_COPY(GenericHeader);
+	};
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_GENERIC_HEADER_H_

src/cpim/header/cpim-header-p.h

@@ -24,18 +24,20 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class HeaderPrivate : public ObjectPrivate {
-		public:
-			virtual ~HeaderPrivate () = default;
+LINPHONE_BEGIN_NAMESPACE
 
-		private:
-			std::string value;
+namespace Cpim {
+	class HeaderPrivate : public ObjectPrivate {
+	public:
+		virtual ~HeaderPrivate () = default;
 
-			L_DECLARE_PUBLIC(Header);
-		};
-	}
+	private:
+		std::string value;
+
+		L_DECLARE_PUBLIC(Header);
+	};
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_HEADER_P_H_

src/cpim/header/cpim-header.cpp

@@ -20,11 +20,11 @@
 
 #include "cpim-header.h"
 
+// =============================================================================
+
 using namespace std;
 
-using namespace LinphonePrivate;
-
-// =============================================================================
+LINPHONE_BEGIN_NAMESPACE
 
 Cpim::Header::Header (HeaderPrivate &p) : Object(p) {}
 
@@ -43,3 +43,5 @@ string Cpim::Header::asString () const {
 	L_D(const Header);
 	return getName() + ": " + d->value + "\r\n";
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/header/cpim-header.h

@@ -25,31 +25,33 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class HeaderPrivate;
+LINPHONE_BEGIN_NAMESPACE
 
-		class LINPHONE_PUBLIC Header : public Object {
-		public:
-			virtual ~Header () = default;
+namespace Cpim {
+	class HeaderPrivate;
 
-			virtual std::string getName () const = 0;
+	class LINPHONE_PUBLIC Header : public Object {
+	public:
+		virtual ~Header () = default;
 
-			std::string getValue () const;
-			virtual bool setValue (const std::string &value);
+		virtual std::string getName () const = 0;
 
-			virtual bool isValid () const = 0;
+		std::string getValue () const;
+		virtual bool setValue (const std::string &value);
 
-			virtual std::string asString () const;
+		virtual bool isValid () const = 0;
 
-		protected:
-			explicit Header (HeaderPrivate &p);
+		virtual std::string asString () const;
 
-		private:
-			L_DECLARE_PRIVATE(Header);
-			L_DISABLE_COPY(Header);
-		};
-	}
+	protected:
+		explicit Header (HeaderPrivate &p);
+
+	private:
+		L_DECLARE_PRIVATE(Header);
+		L_DISABLE_COPY(Header);
+	};
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_HEADER_H_

src/cpim/message/cpim-message.cpp

@@ -24,11 +24,11 @@
 
 #include "cpim-message.h"
 
+// =============================================================================
+
 using namespace std;
 
-using namespace LinphonePrivate;
-
-// =============================================================================
+LINPHONE_BEGIN_NAMESPACE
 
 class Cpim::MessagePrivate : public ObjectPrivate {
 public:
@@ -139,3 +139,5 @@ string Cpim::Message::asString () const {
 shared_ptr<const Cpim::Message> Cpim::Message::createFromString (const string &str) {
 	return Parser::getInstance()->parseMessage(str);
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/message/cpim-message.h

@@ -24,38 +24,40 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class MessagePrivate;
+LINPHONE_BEGIN_NAMESPACE
 
-		class LINPHONE_PUBLIC Message : public Object {
-		public:
-			Message ();
+namespace Cpim {
+	class MessagePrivate;
 
-			typedef std::shared_ptr<std::list<std::shared_ptr<const Cpim::Header> > > HeaderList;
+	class LINPHONE_PUBLIC Message : public Object {
+	public:
+		Message ();
 
-			HeaderList getCpimHeaders () const;
-			bool addCpimHeader (const Header &cpimHeader);
-			void removeCpimHeader (const Header &cpimHeader);
+		typedef std::shared_ptr<std::list<std::shared_ptr<const Cpim::Header> > > HeaderList;
 
-			HeaderList getMessageHeaders () const;
-			bool addMessageHeader (const Header &messageHeader);
-			void removeMessageHeader (const Header &messageHeader);
+		HeaderList getCpimHeaders () const;
+		bool addCpimHeader (const Header &cpimHeader);
+		void removeCpimHeader (const Header &cpimHeader);
 
-			std::string getContent () const;
-			bool setContent (const std::string &content);
+		HeaderList getMessageHeaders () const;
+		bool addMessageHeader (const Header &messageHeader);
+		void removeMessageHeader (const Header &messageHeader);
 
-			bool isValid () const;
+		std::string getContent () const;
+		bool setContent (const std::string &content);
 
-			std::string asString () const;
+		bool isValid () const;
 
-			static std::shared_ptr<const Message> createFromString (const std::string &str);
+		std::string asString () const;
 
-		private:
-			L_DECLARE_PRIVATE(Message);
-			L_DISABLE_COPY(Message);
-		};
-	}
+		static std::shared_ptr<const Message> createFromString (const std::string &str);
+
+	private:
+		L_DECLARE_PRIVATE(Message);
+		L_DISABLE_COPY(Message);
+	};
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_MESSAGE_H_

src/cpim/parser/cpim-grammar.cpp

@@ -20,8 +20,9 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	static const char *grammar =
+LINPHONE_BEGIN_NAMESPACE
+
+static const char *grammar =
 // See: https://tools.ietf.org/html/rfc3862
 R"==GRAMMAR==(
 Message = Headers CRLF Headers CRLF
@@ -200,8 +201,9 @@ full-time = partial-time time-offset
 
 date-time = full-date "T" full-time
 )==GRAMMAR==";
-}
 
-const char *LinphonePrivate::Cpim::getGrammar () {
+const char *Cpim::getGrammar () {
 	return grammar;
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/parser/cpim-grammar.h

@@ -19,12 +19,16 @@
 #ifndef _CPIM_GRAMMAR_H_
 #define _CPIM_GRAMMAR_H_
 
+#include "utils/general.h"
+
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		const char *getGrammar ();
-	}
+LINPHONE_BEGIN_NAMESPACE
+
+namespace Cpim {
+	const char *getGrammar ();
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_GRAMMAR_H_

src/cpim/parser/cpim-parser.cpp

@@ -28,181 +28,179 @@
 
 #include "cpim-parser.h"
 
-using namespace std;
-
-using namespace LinphonePrivate;
-
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class Node {
-		public:
-			virtual ~Node () = default;
-		};
+using namespace std;
 
-		class HeaderNode : public Node {
-		public:
-			HeaderNode () = default;
+LINPHONE_BEGIN_NAMESPACE
 
-			explicit HeaderNode (const Header &header) {
-				mName = header.getName();
-				mValue = header.getValue();
+namespace Cpim {
+	class Node {
+	public:
+		virtual ~Node () = default;
+	};
 
-				// Generic header.
-				const GenericHeader *genericHeader = dynamic_cast<const GenericHeader *>(&header);
-				if (genericHeader) {
-					for (const auto &parameter : *genericHeader->getParameters())
-						mParameters += ";" + parameter.first + "=" + parameter.second;
-					return;
-				}
+	class HeaderNode : public Node {
+	public:
+		HeaderNode () = default;
 
-				// Subject header.
-				const SubjectHeader *subjectHeader = dynamic_cast<const SubjectHeader *>(&header);
-				if (subjectHeader) {
-					const string language = subjectHeader->getLanguage();
-					if (!language.empty())
-						mParameters = ";lang=" + language;
-				}
+		explicit HeaderNode (const Header &header) {
+			mName = header.getName();
+			mValue = header.getValue();
+
+			// Generic header.
+			const GenericHeader *genericHeader = dynamic_cast<const GenericHeader *>(&header);
+			if (genericHeader) {
+				for (const auto &parameter : *genericHeader->getParameters())
+					mParameters += ";" + parameter.first + "=" + parameter.second;
+				return;
 			}
 
-			string getName () const {
-				return mName;
+			// Subject header.
+			const SubjectHeader *subjectHeader = dynamic_cast<const SubjectHeader *>(&header);
+			if (subjectHeader) {
+				const string language = subjectHeader->getLanguage();
+				if (!language.empty())
+					mParameters = ";lang=" + language;
 			}
+		}
 
-			void setName (const string &name) {
-				mName = name;
-			}
+		string getName () const {
+			return mName;
+		}
 
-			string getParameters () const {
-				return mParameters;
-			}
+		void setName (const string &name) {
+			mName = name;
+		}
 
-			void setParameters (const string &parameters) {
-				mParameters = parameters;
-			}
+		string getParameters () const {
+			return mParameters;
+		}
 
-			string getValue () const {
-				return mValue;
-			}
+		void setParameters (const string &parameters) {
+			mParameters = parameters;
+		}
 
-			void setValue (const string &value) {
-				mValue = value;
-			}
+		string getValue () const {
+			return mValue;
+		}
 
-			shared_ptr<Header> createHeader (bool force) const;
+		void setValue (const string &value) {
+			mValue = value;
+		}
 
-		private:
-			template<typename T>
-			shared_ptr<Header> createCoreHeader (bool force) const {
-				shared_ptr<T> header = make_shared<T>();
-				if (force)
-					header->force(mValue);
-				else if (!header->setValue(mValue)) {
-					lWarning() << "Unable to set value on core header: `" << mName << "` => `" << mValue << "`.";
-					return nullptr;
-				}
-
-				return header;
-			}
-
-			string mValue;
-			string mName;
-			string mParameters;
-		};
-
-		template<>
-		shared_ptr<Header> HeaderNode::createCoreHeader<SubjectHeader>(bool force) const {
-			shared_ptr<SubjectHeader> header = make_shared<SubjectHeader>();
-			const string language = mParameters.length() >= 6 ? mParameters.substr(6) : "";
+		shared_ptr<Header> createHeader (bool force) const;
 
+	private:
+		template<typename T>
+		shared_ptr<Header> createCoreHeader (bool force) const {
+			shared_ptr<T> header = make_shared<T>();
 			if (force)
-				header->force(mValue, language);
-			else if (!header->setValue(mValue) || (!language.empty() && !header->setLanguage(language))) {
-				lWarning() << "Unable to set value on subject header: `" <<
-					mName << "` => `" << mValue << "`, `" << language << "`.";
+				header->force(mValue);
+			else if (!header->setValue(mValue)) {
+				lWarning() << "Unable to set value on core header: `" << mName << "` => `" << mValue << "`.";
 				return nullptr;
 			}
 
 			return header;
 		}
 
-		shared_ptr<Header> HeaderNode::createHeader (bool force = false) const {
-			static const unordered_map<string, shared_ptr<Header>(HeaderNode::*)(bool)const> reservedHandlers = {
-				{ "From", &HeaderNode::createCoreHeader<FromHeader> },
-				{ "To", &HeaderNode::createCoreHeader<ToHeader> },
-				{ "cc", &HeaderNode::createCoreHeader<CcHeader> },
-				{ "DateTime", &HeaderNode::createCoreHeader<DateTimeHeader> },
-				{ "Subject", &HeaderNode::createCoreHeader<SubjectHeader> },
-				{ "NS", &HeaderNode::createCoreHeader<NsHeader> },
-				{ "Require", &HeaderNode::createCoreHeader<RequireHeader> }
-			};
+		string mValue;
+		string mName;
+		string mParameters;
+	};
 
-			// Core Header.
-			const auto it = reservedHandlers.find(mName);
-			if (it != reservedHandlers.cend())
-				return (this->*it->second)(force);
+	template<>
+	shared_ptr<Header> HeaderNode::createCoreHeader<SubjectHeader>(bool force) const {
+		shared_ptr<SubjectHeader> header = make_shared<SubjectHeader>();
+		const string language = mParameters.length() >= 6 ? mParameters.substr(6) : "";
 
-			// Generic Header
-			shared_ptr<GenericHeader> genericHeader = make_shared<GenericHeader>();
-			genericHeader->force(mName, mValue, mParameters);
-			return genericHeader;
+		if (force)
+			header->force(mValue, language);
+		else if (!header->setValue(mValue) || (!language.empty() && !header->setLanguage(language))) {
+			lWarning() << "Unable to set value on subject header: `" <<
+				mName << "` => `" << mValue << "`, `" << language << "`.";
+			return nullptr;
 		}
 
-		// -------------------------------------------------------------------------
-
-		class ListHeaderNode :
-			public Node,
-			public list<shared_ptr<HeaderNode> > {};
-
-		// -------------------------------------------------------------------------
-
-		class MessageNode : public Node {
-		public:
-			void addHeaders (const shared_ptr<ListHeaderNode> &headers) {
-				mHeaders->push_back(headers);
-			}
-
-			// Warning: Call this function one time!
-			shared_ptr<Message> createMessage () const {
-				size_t size = mHeaders->size();
-				if (size != 2) {
-					lWarning() << "Bad headers lists size.";
-					return nullptr;
-				}
-
-				const shared_ptr<Message> message = make_shared<Message>();
-				const shared_ptr<ListHeaderNode> cpimHeaders = mHeaders->front();
-
-				if (find_if(cpimHeaders->cbegin(), cpimHeaders->cend(),
-							[](const shared_ptr<const HeaderNode> &headerNode) {
-								return Utils::iequals(headerNode->getName(), "content-type") && headerNode->getValue() == "Message/CPIM";
-							}) == cpimHeaders->cend()) {
-					lWarning() << "No MIME `Content-Type` found!";
-					return nullptr;
-				}
-
-				// Add MIME headers.
-				for (const auto &headerNode : *cpimHeaders) {
-					const shared_ptr<const Header> header = headerNode->createHeader();
-					if (!header || !message->addCpimHeader(*header))
-						return nullptr;
-				}
-
-				// Add message headers.
-				for (const auto &headerNode : *mHeaders->back()) {
-					const shared_ptr<const Header> header = headerNode->createHeader();
-					if (!header || !message->addMessageHeader(*header))
-						return nullptr;
-				}
-
-				return message;
-			}
-
-		private:
-			shared_ptr<list<shared_ptr<ListHeaderNode> > > mHeaders = make_shared<list<shared_ptr<ListHeaderNode> > >();
-		};
+		return header;
 	}
+
+	shared_ptr<Header> HeaderNode::createHeader (bool force = false) const {
+		static const unordered_map<string, shared_ptr<Header>(HeaderNode::*)(bool)const> reservedHandlers = {
+			{ "From", &HeaderNode::createCoreHeader<FromHeader> },
+			{ "To", &HeaderNode::createCoreHeader<ToHeader> },
+			{ "cc", &HeaderNode::createCoreHeader<CcHeader> },
+			{ "DateTime", &HeaderNode::createCoreHeader<DateTimeHeader> },
+			{ "Subject", &HeaderNode::createCoreHeader<SubjectHeader> },
+			{ "NS", &HeaderNode::createCoreHeader<NsHeader> },
+			{ "Require", &HeaderNode::createCoreHeader<RequireHeader> }
+		};
+
+		// Core Header.
+		const auto it = reservedHandlers.find(mName);
+		if (it != reservedHandlers.cend())
+			return (this->*it->second)(force);
+
+		// Generic Header
+		shared_ptr<GenericHeader> genericHeader = make_shared<GenericHeader>();
+		genericHeader->force(mName, mValue, mParameters);
+		return genericHeader;
+	}
+
+	// -------------------------------------------------------------------------
+
+	class ListHeaderNode :
+		public Node,
+		public list<shared_ptr<HeaderNode> > {};
+
+	// -------------------------------------------------------------------------
+
+	class MessageNode : public Node {
+	public:
+		void addHeaders (const shared_ptr<ListHeaderNode> &headers) {
+			mHeaders->push_back(headers);
+		}
+
+		// Warning: Call this function one time!
+		shared_ptr<Message> createMessage () const {
+			size_t size = mHeaders->size();
+			if (size != 2) {
+				lWarning() << "Bad headers lists size.";
+				return nullptr;
+			}
+
+			const shared_ptr<Message> message = make_shared<Message>();
+			const shared_ptr<ListHeaderNode> cpimHeaders = mHeaders->front();
+
+			if (find_if(cpimHeaders->cbegin(), cpimHeaders->cend(),
+						[](const shared_ptr<const HeaderNode> &headerNode) {
+							return Utils::iequals(headerNode->getName(), "content-type") && headerNode->getValue() == "Message/CPIM";
+						}) == cpimHeaders->cend()) {
+				lWarning() << "No MIME `Content-Type` found!";
+				return nullptr;
+			}
+
+			// Add MIME headers.
+			for (const auto &headerNode : *cpimHeaders) {
+				const shared_ptr<const Header> header = headerNode->createHeader();
+				if (!header || !message->addCpimHeader(*header))
+					return nullptr;
+			}
+
+			// Add message headers.
+			for (const auto &headerNode : *mHeaders->back()) {
+				const shared_ptr<const Header> header = headerNode->createHeader();
+				if (!header || !message->addMessageHeader(*header))
+					return nullptr;
+			}
+
+			return message;
+		}
+
+	private:
+		shared_ptr<list<shared_ptr<ListHeaderNode> > > mHeaders = make_shared<list<shared_ptr<ListHeaderNode> > >();
+	};
 }
 
 // -----------------------------------------------------------------------------
@@ -294,17 +292,17 @@ inline bool headerIsValid (const shared_ptr<belr::Grammar> &grammar, const strin
 
 bool Cpim::Parser::headerNameIsValid (const string &headerName) const {
 	L_D(const Parser);
-	return ::headerIsValid(d->grammar, headerName + ": value\r\n");
+	return headerIsValid(d->grammar, headerName + ": value\r\n");
 }
 
 bool Cpim::Parser::headerValueIsValid (const string &headerValue) const {
 	L_D(const Parser);
-	return ::headerIsValid(d->grammar, "key: " + headerValue + "\r\n");
+	return headerIsValid(d->grammar, "key: " + headerValue + "\r\n");
 }
 
-bool Cpim::Parser::headerParameterIsValid (const std::string &headerParameter) const {
+bool Cpim::Parser::headerParameterIsValid (const string &headerParameter) const {
 	L_D(const Parser);
-	return ::headerIsValid(d->grammar, "key:;" + headerParameter + " value\r\n");
+	return headerIsValid(d->grammar, "key:;" + headerParameter + " value\r\n");
 }
 
 // -----------------------------------------------------------------------------
@@ -332,19 +330,19 @@ inline bool coreHeaderIsValid (
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::FromHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "From", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "From", headerValue);
 }
 
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::ToHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "To", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "To", headerValue);
 }
 
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::CcHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "cc", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "cc", headerValue);
 }
 
 template<>
@@ -352,7 +350,7 @@ bool Cpim::Parser::coreHeaderIsValid<Cpim::DateTimeHeader>(const string &headerV
 	static const int daysInMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
 	L_D(const Parser);
-	if (!::coreHeaderIsValid(d->grammar, "DateTime", headerValue))
+	if (!LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "DateTime", headerValue))
 		return false;
 
 	// Check date.
@@ -391,24 +389,26 @@ bool Cpim::Parser::coreHeaderIsValid<Cpim::DateTimeHeader>(const string &headerV
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::SubjectHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "Subject", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "Subject", headerValue);
 }
 
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::NsHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "NS", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "NS", headerValue);
 }
 
 template<>
 bool Cpim::Parser::coreHeaderIsValid<Cpim::RequireHeader>(const string &headerValue) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "Require", headerValue);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "Require", headerValue);
 }
 
 // -----------------------------------------------------------------------------
 
 bool Cpim::Parser::subjectHeaderLanguageIsValid (const string &language) const {
 	L_D(const Parser);
-	return ::coreHeaderIsValid(d->grammar, "Subject", "SubjectValue", ";lang=" + language);
+	return LINPHONE_NAMESPACE::coreHeaderIsValid(d->grammar, "Subject", "SubjectValue", ";lang=" + language);
 }
+
+LINPHONE_END_NAMESPACE

src/cpim/parser/cpim-parser.h

@@ -24,59 +24,61 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Cpim {
-		class ParserPrivate;
+LINPHONE_BEGIN_NAMESPACE
 
-		class Parser : public Singleton<Parser> {
-			friend class Singleton<Parser>;
+namespace Cpim {
+	class ParserPrivate;
 
-		public:
-			std::shared_ptr<Message> parseMessage (const std::string &input);
+	class Parser : public Singleton<Parser> {
+		friend class Singleton<Parser>;
 
-			std::shared_ptr<Header> cloneHeader (const Header &header);
+	public:
+		std::shared_ptr<Message> parseMessage (const std::string &input);
 
-			bool headerNameIsValid (const std::string &headerName) const;
-			bool headerValueIsValid (const std::string &headerValue) const;
-			bool headerParameterIsValid (const std::string &headerParameter) const;
+		std::shared_ptr<Header> cloneHeader (const Header &header);
 
-			template<typename>
-			bool coreHeaderIsValid (const std::string &headerValue) const {
-				return false;
-			}
+		bool headerNameIsValid (const std::string &headerName) const;
+		bool headerValueIsValid (const std::string &headerValue) const;
+		bool headerParameterIsValid (const std::string &headerParameter) const;
 
-			bool subjectHeaderLanguageIsValid (const std::string &language) const;
+		template<typename>
+		bool coreHeaderIsValid (const std::string &headerValue) const {
+			return false;
+		}
 
-		private:
-			Parser ();
+		bool subjectHeaderLanguageIsValid (const std::string &language) const;
 
-			L_DECLARE_PRIVATE(Parser);
-			L_DISABLE_COPY(Parser);
-		};
+	private:
+		Parser ();
 
-		// -------------------------------------------------------------------------
+		L_DECLARE_PRIVATE(Parser);
+		L_DISABLE_COPY(Parser);
+	};
 
-		template<>
-		bool Parser::coreHeaderIsValid<FromHeader>(const std::string &headerValue) const;
+	// ---------------------------------------------------------------------------
 
-		template<>
-		bool Parser::coreHeaderIsValid<ToHeader>(const std::string &headerValue) const;
+	template<>
+	bool Parser::coreHeaderIsValid<FromHeader>(const std::string &headerValue) const;
 
-		template<>
-		bool Parser::coreHeaderIsValid<CcHeader>(const std::string &headerValue) const;
+	template<>
+	bool Parser::coreHeaderIsValid<ToHeader>(const std::string &headerValue) const;
 
-		template<>
-		bool Parser::coreHeaderIsValid<DateTimeHeader>(const std::string &headerValue) const;
+	template<>
+	bool Parser::coreHeaderIsValid<CcHeader>(const std::string &headerValue) const;
 
-		template<>
-		bool Parser::coreHeaderIsValid<SubjectHeader>(const std::string &headerValue) const;
+	template<>
+	bool Parser::coreHeaderIsValid<DateTimeHeader>(const std::string &headerValue) const;
 
-		template<>
-		bool Parser::coreHeaderIsValid<NsHeader>(const std::string &headerValue) const;
+	template<>
+	bool Parser::coreHeaderIsValid<SubjectHeader>(const std::string &headerValue) const;
 
-		template<>
-		bool Parser::coreHeaderIsValid<RequireHeader>(const std::string &headerValue) const;
-	}
+	template<>
+	bool Parser::coreHeaderIsValid<NsHeader>(const std::string &headerValue) const;
+
+	template<>
+	bool Parser::coreHeaderIsValid<RequireHeader>(const std::string &headerValue) const;
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _CPIM_PARSER_H_

src/logger/logger.cpp

@@ -22,19 +22,17 @@
 
 #include "logger.h"
 
-using namespace std;
-
-using namespace LinphonePrivate;
-
 // =============================================================================
 
-namespace LinphonePrivate {
-	class LoggerPrivate : public ObjectPrivate {
-	public:
-		Logger::Level level;
-		ostringstream os;
-	};
-}
+using namespace std;
+
+LINPHONE_BEGIN_NAMESPACE
+
+class LoggerPrivate : public ObjectPrivate {
+public:
+	Logger::Level level;
+	ostringstream os;
+};
 
 // -----------------------------------------------------------------------------
 
@@ -72,3 +70,5 @@ ostringstream &Logger::getOutput () {
 	L_D(Logger);
 	return d->os;
 }
+
+LINPHONE_END_NAMESPACE

src/logger/logger.h

@@ -25,34 +25,36 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	class LoggerPrivate;
+LINPHONE_BEGIN_NAMESPACE
 
-	class LINPHONE_PUBLIC Logger : public Object {
-	public:
-		enum Level {
-			Debug,
-			Info,
-			Warning,
-			Error,
-			Fatal
-		};
+class LoggerPrivate;
 
-		Logger (Level level);
-		~Logger ();
-
-		std::ostringstream &getOutput ();
-
-	private:
-		L_DECLARE_PRIVATE(Logger);
-		L_DISABLE_COPY(Logger);
+class LINPHONE_PUBLIC Logger : public Object {
+public:
+	enum Level {
+		Debug,
+		Info,
+		Warning,
+		Error,
+		Fatal
 	};
-}
 
-#define lDebug() LinphonePrivate::Logger(Logger::Debug).getOutput()
-#define lInfo() LinphonePrivate::Logger(Logger::Info).getOutput()
-#define lWarning() LinphonePrivate::Logger(Logger::Warning).getOutput()
-#define lError() LinphonePrivate::Logger(Logger::Error).getOutput()
-#define lFatal() LinphonePrivate::Logger(Logger::Fatal).getOutput()
+	Logger (Level level);
+	~Logger ();
+
+	std::ostringstream &getOutput ();
+
+private:
+	L_DECLARE_PRIVATE(Logger);
+	L_DISABLE_COPY(Logger);
+};
+
+LINPHONE_END_NAMESPACE
+
+#define lDebug() LINPHONE_NAMESPACE::Logger(Logger::Debug).getOutput()
+#define lInfo() LINPHONE_NAMESPACE::Logger(Logger::Info).getOutput()
+#define lWarning() LINPHONE_NAMESPACE::Logger(Logger::Warning).getOutput()
+#define lError() LINPHONE_NAMESPACE::Logger(Logger::Error).getOutput()
+#define lFatal() LINPHONE_NAMESPACE::Logger(Logger::Fatal).getOutput()
 
 #endif // ifndef _LOGGER_H_

src/object/object-p.h

@@ -23,19 +23,21 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	class Object;
+LINPHONE_BEGIN_NAMESPACE
 
-	class ObjectPrivate {
-	public:
-		virtual ~ObjectPrivate () = default;
+class Object;
 
-	protected:
-		Object *mPublic = nullptr;
+class ObjectPrivate {
+public:
+	virtual ~ObjectPrivate () = default;
 
-	private:
-		L_DECLARE_PUBLIC(Object);
-	};
-}
+protected:
+	Object *mPublic = nullptr;
+
+private:
+	L_DECLARE_PUBLIC(Object);
+};
+
+LINPHONE_END_NAMESPACE
 
 #endif // ifndef _OBJECT_P_H_

src/object/object.cpp

@@ -20,10 +20,10 @@
 
 #include "object.h"
 
-using namespace LinphonePrivate;
-
 // =============================================================================
 
+LINPHONE_BEGIN_NAMESPACE
+
 Object::~Object () {
 	delete mPrivate;
 }
@@ -31,3 +31,5 @@ Object::~Object () {
 Object::Object (ObjectPrivate &p) : mPrivate(&p) {
 	mPrivate->mPublic = this;
 }
+
+LINPHONE_END_NAMESPACE

src/object/object.h

@@ -23,22 +23,24 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	class ObjectPrivate;
+LINPHONE_BEGIN_NAMESPACE
 
-	class LINPHONE_PUBLIC Object {
-	public:
-		virtual ~Object ();
+class ObjectPrivate;
 
-	protected:
-		explicit Object (ObjectPrivate &p);
+class LINPHONE_PUBLIC Object {
+public:
+	virtual ~Object ();
 
-		ObjectPrivate *mPrivate = nullptr;
+protected:
+	explicit Object (ObjectPrivate &p);
 
-	private:
-		L_DECLARE_PRIVATE(Object);
-		L_DISABLE_COPY(Object);
-	};
-}
+	ObjectPrivate *mPrivate = nullptr;
+
+private:
+	L_DECLARE_PRIVATE(Object);
+	L_DISABLE_COPY(Object);
+};
+
+LINPHONE_END_NAMESPACE
 
 #endif // ifndef _OBJECT_H_

src/object/singleton.h

@@ -23,37 +23,39 @@
 
 // =============================================================================
 
-namespace LinphonePrivate {
-	template<class T>
-	class Singleton : public Object {
-	public:
-		virtual ~Singleton () = default;
+LINPHONE_BEGIN_NAMESPACE
 
-		static T *getInstance () {
-			if (!mInstance) {
-				mInstance = new T();
-				static SingletonDeleter deleter;
-			}
-			return mInstance;
+template<class T>
+class Singleton : public Object {
+public:
+	virtual ~Singleton () = default;
+
+	static T *getInstance () {
+		if (!mInstance) {
+			mInstance = new T();
+			static SingletonDeleter deleter;
 		}
+		return mInstance;
+	}
 
-	protected:
-		explicit Singleton (ObjectPrivate &p) : Object(p) {}
+protected:
+	explicit Singleton (ObjectPrivate &p) : Object(p) {}
 
-	private:
-		struct SingletonDeleter {
-			~SingletonDeleter () {
-				delete mInstance;
-			}
-		};
-
-		static T *mInstance;
-
-		L_DISABLE_COPY(Singleton);
+private:
+	struct SingletonDeleter {
+		~SingletonDeleter () {
+			delete mInstance;
+		}
 	};
 
-	template<class T>
-	T *Singleton<T>::mInstance = nullptr;
-}
+	static T *mInstance;
+
+	L_DISABLE_COPY(Singleton);
+};
+
+template<class T>
+T *Singleton<T>::mInstance = nullptr;
+
+LINPHONE_END_NAMESPACE
 
 #endif // ifndef _SINGLETON_H_

src/utils/general.h

@@ -39,6 +39,12 @@
 
 // -----------------------------------------------------------------------------
 
+#define LINPHONE_NAMESPACE LinphonePrivate
+#define LINPHONE_BEGIN_NAMESPACE namespace LINPHONE_NAMESPACE {
+#define LINPHONE_END_NAMESPACE }
+
+// -----------------------------------------------------------------------------
+
 #define L_DECLARE_PRIVATE(CLASS) \
 	inline CLASS ## Private * getPrivate() { \
 		return reinterpret_cast<CLASS ## Private *>(mPrivate); \

src/utils/utils.cpp

@@ -20,11 +20,11 @@
 
 #include "utils.h"
 
+// =============================================================================
+
 using namespace std;
 
-using namespace LinphonePrivate;
-
-// =============================================================================
+LINPHONE_BEGIN_NAMESPACE
 
 bool Utils::iequals (const string &a, const string &b) {
 	size_t size = a.size();
@@ -59,3 +59,5 @@ int Utils::stoi (const string &str, size_t *idx, int base) {
 
 	return v;
 }
+
+LINPHONE_END_NAMESPACE

src/utils/utils.h

@@ -22,20 +22,24 @@
 #include <string>
 #include <vector>
 
+#include "general.h"
+
 // =============================================================================
 
-namespace LinphonePrivate {
-	namespace Utils {
-		bool iequals (const std::string &a, const std::string &b);
+LINPHONE_BEGIN_NAMESPACE
 
-		std::vector<std::string> split (const std::string &str, const std::string &delimiter);
+namespace Utils {
+	bool iequals (const std::string &a, const std::string &b);
 
-		inline std::vector<std::string> split (const std::string &str, char delimiter) {
-			return split(str, std::string(1, delimiter));
-		}
+	std::vector<std::string> split (const std::string &str, const std::string &delimiter);
 
-		int stoi (const std::string &str, size_t *idx = 0, int base = 10);
+	inline std::vector<std::string> split (const std::string &str, char delimiter) {
+		return split(str, std::string(1, delimiter));
 	}
+
+	int stoi (const std::string &str, size_t *idx = 0, int base = 10);
 }
 
+LINPHONE_END_NAMESPACE
+
 #endif // ifndef _UTILS_H_