5 files changed, 175 insertions, 168 deletions

diff --git a/src/messaging/imap/IMAPConnection.cpp b/src/messaging/imap/IMAPConnection.cpp
index 37a132de..586a1716 100644
--- a/src/messaging/imap/IMAPConnection.cpp
+++ b/src/messaging/imap/IMAPConnection.cpp
@@ -42,7 +42,7 @@ namespace messaging {
 namespace imap {
 
 
-IMAPConnection::IMAPConnection(IMAPStore* store, authenticator* auth)
+IMAPConnection::IMAPConnection(weak_ref <IMAPStore> store, ref <authenticator> auth)
 	: m_store(store), m_auth(auth), m_socket(NULL), m_parser(NULL), m_tag(NULL),
 	  m_hierarchySeparator('\0'), m_state(STATE_NONE), m_timeoutHandler(NULL)
 {
@@ -55,9 +55,6 @@ IMAPConnection::~IMAPConnection()
 		disconnect();
 	else if (m_socket)
 		internalDisconnect();
-
-	delete (m_tag);
-	delete (m_parser);
 }
 
 
@@ -89,11 +86,8 @@ void IMAPConnection::connect()
 	m_socket->connect(address, port);
 
 
-	delete (m_tag);
-	m_tag = new IMAPTag();
-
-	delete (m_parser);
-	m_parser = new IMAPParser(m_tag, m_socket, m_timeoutHandler);
+	m_tag = vmime::create <IMAPTag>();
+	m_parser = vmime::create <IMAPParser>(m_tag, m_socket, m_timeoutHandler);
 
 
 	setState(STATE_NON_AUTHENTICATED);
@@ -164,11 +158,8 @@ void IMAPConnection::internalDisconnect()
 	send(true, "LOGOUT", true);
 
 	m_socket->disconnect();
-
-	delete (m_socket);
 	m_socket = NULL;
 
-	delete (m_timeoutHandler);
 	m_timeoutHandler = NULL;
 
 	m_state = STATE_LOGOUT;
@@ -179,7 +170,7 @@ void IMAPConnection::initHierarchySeparator()
 {
 	send(true, "LIST \"\" \"\"", true);
 
-	utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	vmime::utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -284,31 +275,31 @@ const char IMAPConnection::hierarchySeparator() const
 }
 
 
-const IMAPTag* IMAPConnection::getTag() const
+ref <const IMAPTag> IMAPConnection::getTag() const
 {
 	return (m_tag);
 }
 
 
-const IMAPParser* IMAPConnection::getParser() const
+ref <const IMAPParser> IMAPConnection::getParser() const
 {
 	return (m_parser);
 }
 
 
-const IMAPStore* IMAPConnection::getStore() const
+weak_ref <const IMAPStore> IMAPConnection::getStore() const
 {
 	return (m_store);
 }
 
 
-IMAPStore* IMAPConnection::getStore()
+weak_ref <IMAPStore> IMAPConnection::getStore()
 {
 	return (m_store);
 }
 
 
-session* IMAPConnection::getSession()
+ref <session> IMAPConnection::getSession()
 {
 	return (m_store->getSession());
 }
diff --git a/src/messaging/imap/IMAPFolder.cpp b/src/messaging/imap/IMAPFolder.cpp
index 35f3509b..c567c590 100644
--- a/src/messaging/imap/IMAPFolder.cpp
+++ b/src/messaging/imap/IMAPFolder.cpp
@@ -59,7 +59,7 @@ IMAPFolder::~IMAPFolder()
 	}
 	else if (m_open)
 	{
-		delete (m_connection);
+		m_connection = NULL;
 		onClose();
 	}
 }
@@ -132,8 +132,8 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 		throw exceptions::illegal_state("Store disconnected");
 
 	// Open a connection for this folder
-	IMAPConnection* connection =
-		new IMAPConnection(m_store, m_store->oneTimeAuthenticator());
+	ref <IMAPConnection> connection =
+		vmime::create <IMAPConnection>(m_store, m_store->oneTimeAuthenticator());
 
 	try
 	{
@@ -263,7 +263,6 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 	}
 	catch (std::exception&)
 	{
-		delete (connection);
 		throw;
 	}
 }
@@ -277,7 +276,7 @@ void IMAPFolder::close(const bool expunge)
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
-	IMAPConnection* oldConnection = m_connection;
+	ref <IMAPConnection> oldConnection = m_connection;
 
 	// Emit the "CLOSE" command to expunge messages marked
 	// as deleted (this is fastest than "EXPUNGE")
@@ -301,8 +300,6 @@ void IMAPFolder::close(const bool expunge)
 	m_uidValidity = 0;
 
 	onClose();
-
-	delete (oldConnection);
 }
 
 
@@ -358,7 +355,10 @@ void IMAPFolder::create(const int type)
 	}
 
 	// Notify folder created
-	events::folderEvent event(this, events::folderEvent::TYPE_CREATED, m_path, m_path);
+	events::folderEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::folderEvent::TYPE_CREATED, m_path, m_path);
+
 	notifyFolder(event);
 }
 
@@ -450,7 +450,7 @@ const bool IMAPFolder::isOpen() const
 }
 
 
-message* IMAPFolder::getMessage(const int num)
+ref <message> IMAPFolder::getMessage(const int num)
 {
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
@@ -458,33 +458,33 @@ message* IMAPFolder::getMessage(const int num)
 	if (num < 1 || num > m_messageCount)
 		throw exceptions::message_not_found();
 
-	return new IMAPMessage(this, num);
+	return vmime::create <IMAPMessage>(this, num);
 }
 
 
-std::vector <message*> IMAPFolder::getMessages(const int from, const int to)
+std::vector <ref <message> > IMAPFolder::getMessages(const int from, const int to)
 {
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
-	std::vector <message*> v;
+	std::vector <ref <message> > v;
 
 	for (int i = from ; i <= to ; ++i)
-		v.push_back(new IMAPMessage(this, i));
+		v.push_back(vmime::create <IMAPMessage>(this, i));
 
 	return (v);
 }
 
 
-std::vector <message*> IMAPFolder::getMessages(const std::vector <int>& nums)
+std::vector <ref <message> > IMAPFolder::getMessages(const std::vector <int>& nums)
 {
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
-	std::vector <message*> v;
+	std::vector <ref <message> > v;
 
 	for (std::vector <int>::const_iterator it = nums.begin() ; it != nums.end() ; ++it)
-		v.push_back(new IMAPMessage(this, *it));
+		v.push_back(vmime::create <IMAPMessage>(this, *it));
 
 	return (v);
 }
@@ -499,16 +499,16 @@ const int IMAPFolder::getMessageCount()
 }
 
 
-folder* IMAPFolder::getFolder(const folder::path::component& name)
+ref <folder> IMAPFolder::getFolder(const folder::path::component& name)
 {
 	if (!m_store)
 		throw exceptions::illegal_state("Store disconnected");
 
-	return new IMAPFolder(m_path / name, m_store);
+	return vmime::create <IMAPFolder>(m_path / name, m_store);
 }
 
 
-std::vector <folder*> IMAPFolder::getFolders(const bool recursive)
+std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
 {
 	if (!isOpen() && !m_store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -556,57 +556,47 @@ std::vector <folder*> IMAPFolder::getFolders(const bool recursive)
 		resp->continue_req_or_response_data();
 
 
-	std::vector <folder*> v;
+	std::vector <ref <folder> > v;
 
-	try
+	for (std::vector <IMAPParser::continue_req_or_response_data*>::const_iterator
+	     it = respDataList.begin() ; it != respDataList.end() ; ++it)
 	{
-		for (std::vector <IMAPParser::continue_req_or_response_data*>::const_iterator
-		     it = respDataList.begin() ; it != respDataList.end() ; ++it)
+		if ((*it)->response_data() == NULL)
 		{
-			if ((*it)->response_data() == NULL)
-			{
-				throw exceptions::command_error("LIST",
-					m_connection->getParser()->lastLine(), "invalid response");
-			}
+			throw exceptions::command_error("LIST",
+				m_connection->getParser()->lastLine(), "invalid response");
+		}
 
-			const IMAPParser::mailbox_data* mailboxData =
-				(*it)->response_data()->mailbox_data();
+		const IMAPParser::mailbox_data* mailboxData =
+			(*it)->response_data()->mailbox_data();
 
-			if (mailboxData == NULL || mailboxData->type() != IMAPParser::mailbox_data::LIST)
-				continue;
+		if (mailboxData == NULL || mailboxData->type() != IMAPParser::mailbox_data::LIST)
+			continue;
 
-			// Get folder path
-			const class IMAPParser::mailbox* mailbox =
-				mailboxData->mailbox_list()->mailbox();
+		// Get folder path
+		const class IMAPParser::mailbox* mailbox =
+			mailboxData->mailbox_list()->mailbox();
 
-			folder::path path = IMAPUtils::stringToPath
-				(mailboxData->mailbox_list()->quoted_char(), mailbox->name());
+		folder::path path = IMAPUtils::stringToPath
+			(mailboxData->mailbox_list()->quoted_char(), mailbox->name());
 
-			if (recursive || m_path.isDirectParentOf(path))
-			{
-				// Append folder to list
-				const class IMAPParser::mailbox_flag_list* mailbox_flag_list =
-					mailboxData->mailbox_list()->mailbox_flag_list();
+		if (recursive || m_path.isDirectParentOf(path))
+		{
+			// Append folder to list
+			const class IMAPParser::mailbox_flag_list* mailbox_flag_list =
+				mailboxData->mailbox_list()->mailbox_flag_list();
 
-				v.push_back(new IMAPFolder(path, m_store,
-					IMAPUtils::folderTypeFromFlags(mailbox_flag_list),
-					IMAPUtils::folderFlagsFromFlags(mailbox_flag_list)));
-			}
+			v.push_back(vmime::create <IMAPFolder>(path, m_store,
+				IMAPUtils::folderTypeFromFlags(mailbox_flag_list),
+				IMAPUtils::folderFlagsFromFlags(mailbox_flag_list)));
 		}
 	}
-	catch (std::exception&)
-	{
-		for (std::vector <folder*>::iterator it = v.begin() ; it != v.end() ; ++it)
-			delete (*it);
-
-		throw;
-	}
 
 	return (v);
 }
 
 
-void IMAPFolder::fetchMessages(std::vector <message*>& msg, const int options,
+void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const int options,
                                utility::progressionListener* progress)
 {
 	if (!m_store)
@@ -620,10 +610,10 @@ void IMAPFolder::fetchMessages(std::vector <message*>& msg, const int options,
 	if (progress)
 		progress->start(total);
 
-	for (std::vector <message*>::iterator it = msg.begin() ;
+	for (std::vector <ref <message> >::iterator it = msg.begin() ;
 	     it != msg.end() ; ++it)
 	{
-		dynamic_cast <IMAPMessage*>(*it)->fetch(this, options);
+		(*it).dynamicCast <IMAPMessage>()->fetch(this, options);
 
 		if (progress)
 			progress->progress(++current, total);
@@ -634,14 +624,14 @@ void IMAPFolder::fetchMessages(std::vector <message*>& msg, const int options,
 }
 
 
-void IMAPFolder::fetchMessage(message* msg, const int options)
+void IMAPFolder::fetchMessage(ref <message> msg, const int options)
 {
 	if (!m_store)
 		throw exceptions::illegal_state("Store disconnected");
 	else if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
-	dynamic_cast <IMAPMessage*>(msg)->fetch(this, options);
+	msg.dynamicCast <IMAPMessage>()->fetch(this, options);
 }
 
 
@@ -652,19 +642,22 @@ const int IMAPFolder::getFetchCapabilities() const
 }
 
 
-folder* IMAPFolder::getParent()
+ref <folder> IMAPFolder::getParent()
 {
-	return (m_path.isEmpty() ? NULL : new IMAPFolder(m_path.getParent(), m_store));
+	if (m_path.isEmpty())
+		return NULL;
+	else
+		return vmime::create <IMAPFolder>(m_path.getParent(), m_store);
 }
 
 
-const store* IMAPFolder::getStore() const
+weak_ref <const store> IMAPFolder::getStore() const
 {
 	return (m_store);
 }
 
 
-store* IMAPFolder::getStore()
+weak_ref <store> IMAPFolder::getStore()
 {
 	return (m_store);
 }
@@ -733,7 +726,9 @@ void IMAPFolder::deleteMessage(const int num)
 	std::vector <int> nums;
 	nums.push_back(num);
 
-	events::messageChangedEvent event(this, events::messageChangedEvent::TYPE_FLAGS, nums);
+	events::messageChangedEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageChangedEvent::TYPE_FLAGS, nums);
 
 	notifyMessageChanged(event);
 }
@@ -794,7 +789,9 @@ void IMAPFolder::deleteMessages(const int from, const int to)
 	for (int i = from, j = 0 ; i <= to2 ; ++i, ++j)
 		nums[j] = i;
 
-	events::messageChangedEvent event(this, events::messageChangedEvent::TYPE_FLAGS, nums);
+	events::messageChangedEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageChangedEvent::TYPE_FLAGS, nums);
 
 	notifyMessageChanged(event);
 }
@@ -851,7 +848,9 @@ void IMAPFolder::deleteMessages(const std::vector <int>& nums)
 	}
 
 	// Notify message flags changed
-	events::messageChangedEvent event(this, events::messageChangedEvent::TYPE_FLAGS, list);
+	events::messageChangedEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageChangedEvent::TYPE_FLAGS, list);
 
 	notifyMessageChanged(event);
 }
@@ -937,7 +936,9 @@ void IMAPFolder::setMessageFlags(const int from, const int to, const int flags,
 	for (int i = from, j = 0 ; i <= to2 ; ++i, ++j)
 		nums[j] = i;
 
-	events::messageChangedEvent event(this, events::messageChangedEvent::TYPE_FLAGS, nums);
+	events::messageChangedEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageChangedEvent::TYPE_FLAGS, nums);
 
 	notifyMessageChanged(event);
 }
@@ -1013,7 +1014,9 @@ void IMAPFolder::setMessageFlags(const std::vector <int>& nums, const int flags,
 	}
 
 	// Notify message flags changed
-	events::messageChangedEvent event(this, events::messageChangedEvent::TYPE_FLAGS, nums);
+	events::messageChangedEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageChangedEvent::TYPE_FLAGS, nums);
 
 	notifyMessageChanged(event);
 }
@@ -1055,7 +1058,7 @@ void IMAPFolder::setMessageFlags(const string& set, const int flags, const int m
 }
 
 
-void IMAPFolder::addMessage(vmime::message* msg, const int flags,
+void IMAPFolder::addMessage(ref <vmime::message> msg, const int flags,
                             vmime::datetime* date, utility::progressionListener* progress)
 {
 	std::ostringstream oss;
@@ -1166,7 +1169,9 @@ void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int
 	std::vector <int> nums;
 	nums.push_back(m_messageCount + 1);
 
-	events::messageCountEvent event(this, events::messageCountEvent::TYPE_ADDED, nums);
+	events::messageCountEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageCountEvent::TYPE_ADDED, nums);
 
 	m_messageCount++;
 	notifyMessageCount(event);
@@ -1177,7 +1182,9 @@ void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int
 	{
 		if ((*it) != this && (*it)->getFullPath() == m_path)
 		{
-			events::messageCountEvent event(*it, events::messageCountEvent::TYPE_ADDED, nums);
+			events::messageCountEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_ADDED, nums);
 
 			(*it)->m_messageCount++;
 			(*it)->notifyMessageCount(event);
@@ -1250,7 +1257,9 @@ void IMAPFolder::expunge()
 	m_messageCount -= nums.size();
 
 	// Notify message expunged
-	events::messageCountEvent event(this, events::messageCountEvent::TYPE_REMOVED, nums);
+	events::messageCountEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::messageCountEvent::TYPE_REMOVED, nums);
 
 	notifyMessageCount(event);
 
@@ -1262,7 +1271,9 @@ void IMAPFolder::expunge()
 		{
 			(*it)->m_messageCount = m_messageCount;
 
-			events::messageCountEvent event(*it, events::messageCountEvent::TYPE_REMOVED, nums);
+			events::messageCountEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_REMOVED, nums);
 
 			(*it)->notifyMessageCount(event);
 		}
@@ -1308,7 +1319,10 @@ void IMAPFolder::rename(const folder::path& newPath)
 	m_path = newPath;
 	m_name = newPath.getLastComponent();
 
-	events::folderEvent event(this, events::folderEvent::TYPE_RENAMED, oldPath, newPath);
+	events::folderEvent event
+		(thisRef().dynamicCast <folder>(),
+		 events::folderEvent::TYPE_RENAMED, oldPath, newPath);
+
 	notifyFolder(event);
 
 	// Notify folders with the same path and sub-folders
@@ -1320,7 +1334,10 @@ void IMAPFolder::rename(const folder::path& newPath)
 			(*it)->m_path = newPath;
 			(*it)->m_name = newPath.getLastComponent();
 
-			events::folderEvent event(*it, events::folderEvent::TYPE_RENAMED, oldPath, newPath);
+			events::folderEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::folderEvent::TYPE_RENAMED, oldPath, newPath);
+
 			(*it)->notifyFolder(event);
 		}
 		else if ((*it) != this && oldPath.isParentOf((*it)->getFullPath()))
@@ -1329,7 +1346,10 @@ void IMAPFolder::rename(const folder::path& newPath)
 
 			(*it)->m_path.renameParent(oldPath, newPath);
 
-			events::folderEvent event(*it, events::folderEvent::TYPE_RENAMED, oldPath, (*it)->m_path);
+			events::folderEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::folderEvent::TYPE_RENAMED, oldPath, (*it)->m_path);
+
 			(*it)->notifyFolder(event);
 		}
 	}
@@ -1354,13 +1374,15 @@ void IMAPFolder::copyMessage(const folder::path& dest, const int num)
 	std::vector <int> nums;
 	nums.push_back(num);
 
-	events::messageCountEvent event(this, events::messageCountEvent::TYPE_ADDED, nums);
-
 	for (std::list <IMAPFolder*>::iterator it = m_store->m_folders.begin() ;
 	     it != m_store->m_folders.end() ; ++it)
 	{
 		if ((*it)->getFullPath() == dest)
 		{
+			events::messageCountEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_ADDED, nums);
+
 			(*it)->m_messageCount++;
 			(*it)->notifyMessageCount(event);
 		}
@@ -1398,13 +1420,15 @@ void IMAPFolder::copyMessages(const folder::path& dest, const int from, const in
 	for (int i = from, j = 0 ; i <= to2 ; ++i, ++j)
 		nums[j] = i;
 
-	events::messageCountEvent event(this, events::messageCountEvent::TYPE_ADDED, nums);
-
 	for (std::list <IMAPFolder*>::iterator it = m_store->m_folders.begin() ;
 	     it != m_store->m_folders.end() ; ++it)
 	{
 		if ((*it)->getFullPath() == dest)
 		{
+			events::messageCountEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_ADDED, nums);
+
 			(*it)->m_messageCount += count;
 			(*it)->notifyMessageCount(event);
 		}
@@ -1425,13 +1449,15 @@ void IMAPFolder::copyMessages(const folder::path& dest, const std::vector <int>&
 	// Notify message count changed
 	const int count = nums.size();
 
-	events::messageCountEvent event(this, events::messageCountEvent::TYPE_ADDED, nums);
-
 	for (std::list <IMAPFolder*>::iterator it = m_store->m_folders.begin() ;
 		it != m_store->m_folders.end() ; ++it)
 	{
 		if ((*it)->getFullPath() == dest)
 		{
+			events::messageCountEvent event
+				((*it)->thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_ADDED, nums);
+
 			(*it)->m_messageCount += count;
 			(*it)->notifyMessageCount(event);
 		}
@@ -1545,7 +1571,9 @@ void IMAPFolder::status(int& count, int& unseen)
 			for (int i = oldCount + 1, j = 0 ; i <= count ; ++i, ++j)
 				nums[j] = i;
 
-			events::messageCountEvent event(this, events::messageCountEvent::TYPE_ADDED, nums);
+			events::messageCountEvent event
+				(thisRef().dynamicCast <folder>(),
+				 events::messageCountEvent::TYPE_ADDED, nums);
 
 			notifyMessageCount(event);
 
@@ -1557,7 +1585,9 @@ void IMAPFolder::status(int& count, int& unseen)
 				{
 					(*it)->m_messageCount = count;
 
-					events::messageCountEvent event(*it, events::messageCountEvent::TYPE_ADDED, nums);
+					events::messageCountEvent event
+						((*it)->thisRef().dynamicCast <folder>(),
+						 events::messageCountEvent::TYPE_ADDED, nums);
 
 					(*it)->notifyMessageCount(event);
 				}
diff --git a/src/messaging/imap/IMAPMessage.cpp b/src/messaging/imap/IMAPMessage.cpp
index 03af67c6..97aa2d28 100644
--- a/src/messaging/imap/IMAPMessage.cpp
+++ b/src/messaging/imap/IMAPMessage.cpp
@@ -43,17 +43,17 @@ class IMAPpart : public part
 {
 private:
 
-	IMAPpart(IMAPpart* parent, const int number, const IMAPParser::body_type_mpart* mpart);
-	IMAPpart(IMAPpart* parent, const int number, const IMAPParser::body_type_1part* part);
+	friend class vmime::creator;
 
-public:
+	IMAPpart(weak_ref <IMAPpart> parent, const int number, const IMAPParser::body_type_mpart* mpart);
+	IMAPpart(weak_ref <IMAPpart> parent, const int number, const IMAPParser::body_type_1part* part);
 
-	~IMAPpart();
+public:
 
 	const structure& getStructure() const;
 	structure& getStructure();
 
-	const IMAPpart* getParent() const { return (m_parent); }
+	weak_ref <const IMAPpart> getParent() const { return (m_parent); }
 
 	const mediaType& getType() const { return (m_mediaType); }
 	const int getSize() const { return (m_size); }
@@ -68,12 +68,13 @@ public:
 	}
 
 
-	static IMAPpart* create(IMAPpart* parent, const int number, const IMAPParser::body* body)
+	static ref <IMAPpart> create
+		(weak_ref <IMAPpart> parent, const int number, const IMAPParser::body* body)
 	{
 		if (body->body_type_mpart())
-			return new IMAPpart(parent, number, body->body_type_mpart());
+			return vmime::create <IMAPpart>(parent, number, body->body_type_mpart());
 		else
-			return new IMAPpart(parent, number, body->body_type_1part());
+			return vmime::create <IMAPpart>(parent, number, body->body_type_1part());
 	}
 
 
@@ -82,14 +83,14 @@ public:
 		if (m_header != NULL)
 			return (*m_header);
 		else
-			return (*(m_header = new header()));
+			return (*(m_header = vmime::create <header>()));
 	}
 
 private:
 
-	IMAPstructure* m_structure;
-	IMAPpart* m_parent;
-	header* m_header;
+	ref <IMAPstructure> m_structure;
+	weak_ref <IMAPpart> m_parent;
+	ref <header> m_header;
 
 	int m_number;
 	int m_size;
@@ -117,7 +118,7 @@ public:
 		m_parts.push_back(IMAPpart::create(NULL, 1, body));
 	}
 
-	IMAPstructure(IMAPpart* parent, const std::vector <IMAPParser::body*>& list)
+	IMAPstructure(weak_ref <IMAPpart> parent, const std::vector <IMAPParser::body*>& list)
 	{
 		int number = 1;
 
@@ -128,11 +129,6 @@ public:
 		}
 	}
 
-	~IMAPstructure()
-	{
-		free_container(m_parts);
-	}
-
 
 	const part& operator[](const int x) const
 	{
@@ -159,7 +155,7 @@ private:
 
 	static IMAPstructure m_emptyStructure;
 
-	std::vector <IMAPpart*> m_parts;
+	std::vector <ref <IMAPpart> > m_parts;
 };
 
 
@@ -167,17 +163,18 @@ IMAPstructure IMAPstructure::m_emptyStructure;
 
 
 
-IMAPpart::IMAPpart(IMAPpart* parent, const int number, const IMAPParser::body_type_mpart* mpart)
+IMAPpart::IMAPpart(weak_ref <IMAPpart> parent, const int number, const IMAPParser::body_type_mpart* mpart)
 	: m_parent(parent), m_header(NULL), m_number(number), m_size(0)
 {
 	m_mediaType = vmime::mediaType
 		("multipart", mpart->media_subtype()->value());
 
-	m_structure = new IMAPstructure(this, mpart->list());
+	m_structure = vmime::create <IMAPstructure>
+		(thisWeakRef().dynamicCast <IMAPpart>(), mpart->list());
 }
 
 
-IMAPpart::IMAPpart(IMAPpart* parent, const int number, const IMAPParser::body_type_1part* part)
+IMAPpart::IMAPpart(weak_ref <IMAPpart> parent, const int number, const IMAPParser::body_type_1part* part)
 	: m_parent(parent), m_header(NULL), m_number(number), m_size(0)
 {
 	if (part->body_type_text())
@@ -207,13 +204,6 @@ IMAPpart::IMAPpart(IMAPpart* parent, const int number, const IMAPParser::body_ty
 }
 
 
-IMAPpart::~IMAPpart()
-{
-	delete (m_structure);
-	delete (m_header);
-}
-
-
 const class structure& IMAPpart::getStructure() const
 {
 	if (m_structure != NULL)
@@ -292,8 +282,6 @@ IMAPMessage::~IMAPMessage()
 {
 	if (m_folder)
 		m_folder->unregisterMessage(this);
-
-	delete dynamic_cast <header*>(m_header);
 }
 
 
@@ -597,62 +585,61 @@ void IMAPMessage::processFetchResponse
 				vmime::header& hdr = getOrCreateHeader();
 
 				// Date
-				hdr.Date().setValue(env->env_date()->value());
+				hdr.Date()->setValue(env->env_date()->value());
 
 				// Subject
 				text subject;
 				text::decodeAndUnfold(env->env_subject()->value(), &subject);
 
-				hdr.Subject().setValue(subject);
+				hdr.Subject()->setValue(subject);
 
 				// From
 				mailboxList from;
 				convertAddressList(*(env->env_from()), from);
 
 				if (!from.isEmpty())
-					hdr.From().setValue(*(from.getMailboxAt(0)));
+					hdr.From()->setValue(*(from.getMailboxAt(0)));
 
 				// To
 				mailboxList to;
 				convertAddressList(*(env->env_to()), to);
 
-				hdr.To().setValue(to);
+				hdr.To()->setValue(to);
 
 				// Sender
 				mailboxList sender;
 				convertAddressList(*(env->env_sender()), sender);
 
 				if (!sender.isEmpty())
-					hdr.Sender().setValue(*(sender.getMailboxAt(0)));
+					hdr.Sender()->setValue(*(sender.getMailboxAt(0)));
 
 				// Reply-to
 				mailboxList replyTo;
 				convertAddressList(*(env->env_reply_to()), replyTo);
 
 				if (!replyTo.isEmpty())
-					hdr.ReplyTo().setValue(*(replyTo.getMailboxAt(0)));
+					hdr.ReplyTo()->setValue(*(replyTo.getMailboxAt(0)));
 
 				// Cc
 				mailboxList cc;
 				convertAddressList(*(env->env_cc()), cc);
 
 				if (!cc.isEmpty())
-					hdr.Cc().setValue(cc);
+					hdr.Cc()->setValue(cc);
 
 				// Bcc
 				mailboxList bcc;
 				convertAddressList(*(env->env_bcc()), bcc);
 
 				if (!bcc.isEmpty())
-					hdr.Bcc().setValue(bcc);
+					hdr.Bcc()->setValue(bcc);
 			}
 
 			break;
 		}
 		case IMAPParser::msg_att_item::BODY_STRUCTURE:
 		{
-			delete (m_structure);
-			m_structure = new IMAPstructure((*it)->body());
+			m_structure = vmime::create <IMAPstructure>((*it)->body());
 			break;
 		}
 		case IMAPParser::msg_att_item::RFC822_HEADER:
@@ -677,12 +664,12 @@ void IMAPMessage::processFetchResponse
 					tempHeader.parse((*it)->nstring()->value());
 
 					vmime::header& hdr = getOrCreateHeader();
-					std::vector <headerField*> fields = tempHeader.getFieldList();
+					std::vector <ref <headerField> > fields = tempHeader.getFieldList();
 
-					for (std::vector <headerField*>::const_iterator jt = fields.begin() ;
+					for (std::vector <ref <headerField> >::const_iterator jt = fields.begin() ;
 					     jt != fields.end() ; ++jt)
 					{
-						hdr.appendField((*jt)->clone());
+						hdr.appendField((*jt)->clone().dynamicCast <headerField>());
 					}
 				}
 			}
@@ -710,7 +697,7 @@ header& IMAPMessage::getOrCreateHeader()
 	if (m_header != NULL)
 		return (*m_header);
 	else
-		return (*(m_header = new header()));
+		return (*(m_header = vmime::create <header>()));
 }
 
 
@@ -728,7 +715,7 @@ void IMAPMessage::convertAddressList
 		string email = addr.addr_mailbox()->value()
 			+ "@" + addr.addr_host()->value();
 
-		dest.appendMailbox(new mailbox(name, email));
+		dest.appendMailbox(vmime::create <mailbox>(name, email));
 	}
 }
 
@@ -829,7 +816,9 @@ void IMAPMessage::setFlags(const int flags, const int mode)
 		std::vector <int> nums;
 		nums.push_back(m_num);
 
-		events::messageChangedEvent event(m_folder, events::messageChangedEvent::TYPE_FLAGS, nums);
+		events::messageChangedEvent event
+			(m_folder->thisRef().dynamicCast <folder>(),
+			 events::messageChangedEvent::TYPE_FLAGS, nums);
 
 		for (std::list <IMAPFolder*>::iterator it = m_folder->m_store->m_folders.begin() ;
 		     it != m_folder->m_store->m_folders.end() ; ++it)
diff --git a/src/messaging/imap/IMAPStore.cpp b/src/messaging/imap/IMAPStore.cpp
index 07b22351..00ef98f2 100644
--- a/src/messaging/imap/IMAPStore.cpp
+++ b/src/messaging/imap/IMAPStore.cpp
@@ -45,28 +45,27 @@ class IMAPauthenticator : public authenticator
 {
 public:
 
-	IMAPauthenticator(authenticator* auth)
+	IMAPauthenticator(ref <authenticator> auth)
 		: m_auth(auth), m_infos(NULL)
 	{
 	}
 
 	~IMAPauthenticator()
 	{
-		delete (m_infos);
 	}
 
 	const authenticationInfos requestAuthInfos() const
 	{
 		if (m_infos == NULL)
-			m_infos = new authenticationInfos(m_auth->requestAuthInfos());
+			m_infos = vmime::create <authenticationInfos>(m_auth->requestAuthInfos());
 
 		return (*m_infos);
 	}
 
 private:
 
-	authenticator* m_auth;
-	mutable authenticationInfos* m_infos;
+	ref <authenticator> m_auth;
+	mutable ref <authenticationInfos> m_infos;
 };
 
 #endif // VMIME_BUILDING_DOC
@@ -77,7 +76,7 @@ private:
 // IMAPStore
 //
 
-IMAPStore::IMAPStore(session* sess, authenticator* auth)
+IMAPStore::IMAPStore(ref <session> sess, ref <authenticator> auth)
 	: store(sess, getInfosInstance(), auth),
 	  m_connection(NULL), m_oneTimeAuth(NULL)
 {
@@ -91,7 +90,7 @@ IMAPStore::~IMAPStore()
 }
 
 
-authenticator* IMAPStore::oneTimeAuthenticator()
+ref <authenticator> IMAPStore::oneTimeAuthenticator()
 {
 	return (m_oneTimeAuth);
 }
@@ -103,30 +102,30 @@ const string IMAPStore::getProtocolName() const
 }
 
 
-folder* IMAPStore::getRootFolder()
+ref <folder> IMAPStore::getRootFolder()
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return new IMAPFolder(folder::path(), this);
+	return vmime::create <IMAPFolder>(folder::path(), this);
 }
 
 
-folder* IMAPStore::getDefaultFolder()
+ref <folder> IMAPStore::getDefaultFolder()
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return new IMAPFolder(folder::path::component("INBOX"), this);
+	return vmime::create <IMAPFolder>(folder::path::component("INBOX"), this);
 }
 
 
-folder* IMAPStore::getFolder(const folder::path& path)
+ref <folder> IMAPStore::getFolder(const folder::path& path)
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return new IMAPFolder(path, this);
+	return vmime::create <IMAPFolder>(path, this);
 }
 
 
@@ -141,9 +140,10 @@ void IMAPStore::connect()
 	if (isConnected())
 		throw exceptions::already_connected();
 
-	m_oneTimeAuth = new IMAPauthenticator(getAuthenticator());
+	m_oneTimeAuth = vmime::create <IMAPauthenticator>(getAuthenticator());
 
-	m_connection = new IMAPConnection(this, m_oneTimeAuth);
+	m_connection = vmime::create <IMAPConnection>
+		(thisWeakRef().dynamicCast <IMAPStore>(), m_oneTimeAuth);
 
 	try
 	{
@@ -151,7 +151,6 @@ void IMAPStore::connect()
 	}
 	catch (std::exception&)
 	{
-		delete (m_connection);
 		m_connection = NULL;
 		throw;
 	}
@@ -180,10 +179,8 @@ void IMAPStore::disconnect()
 
 	m_connection->disconnect();
 
-	delete (m_oneTimeAuth);
 	m_oneTimeAuth = NULL;
 
-	delete (m_connection);
 	m_connection = NULL;
 }
 
@@ -205,7 +202,7 @@ void IMAPStore::noop()
 }
 
 
-IMAPConnection* IMAPStore::connection()
+ref <IMAPConnection> IMAPStore::connection()
 {
 	return (m_connection);
 }
diff --git a/src/messaging/imap/IMAPTag.cpp b/src/messaging/imap/IMAPTag.cpp
index bc6b656d..c1cf659d 100644
--- a/src/messaging/imap/IMAPTag.cpp
+++ b/src/messaging/imap/IMAPTag.cpp
@@ -36,7 +36,7 @@ IMAPTag::IMAPTag(const int number)
 
 
 IMAPTag::IMAPTag(const IMAPTag& tag)
-	: m_number(tag.m_number)
+	: object(), m_number(tag.m_number)
 {
 	m_tag.resize(4);
 }