3 files changed, 40 insertions, 15 deletions
diff --git a/Swiften/Elements/Message.h b/Swiften/Elements/Message.h
index f6c16e4..0f0d380 100644
--- a/Swiften/Elements/Message.h
+++ b/Swiften/Elements/Message.h
@@ -1,71 +1,82 @@
 /*
- * Copyright (c) 2010-2015 Isode Limited.
+ * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
+#include <string>
+
 #include <boost/optional.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
-#include <string>
 #include <Swiften/Base/API.h>
 #include <Swiften/Elements/Body.h>
-#include <Swiften/Elements/Subject.h>
 #include <Swiften/Elements/ErrorPayload.h>
-#include <Swiften/Elements/Stanza.h>
 #include <Swiften/Elements/Replace.h>
+#include <Swiften/Elements/Stanza.h>
+#include <Swiften/Elements/Subject.h>
 
 namespace Swift {
 	class SWIFTEN_API Message : public Stanza {
 	  public:
 			typedef boost::shared_ptr<Message> ref;
 
 			enum Type { Normal, Chat, Error, Groupchat, Headline };
 
 			Message() : type_(Chat) { }
 
 			std::string getSubject() const { 
 				boost::shared_ptr<Subject> subject(getPayload<Subject>());
 				if (subject) {
 					return subject->getText();
 				}
 				return "";
 			}
 
 			void setSubject(const std::string& subject) { 
 				updatePayload(boost::make_shared<Subject>(subject));
 			}
 
 			// Explicitly convert to bool. In C++11, it would be cleaner to
 			// compare to nullptr.
 			bool hasSubject() {
 				return static_cast<bool>(getPayload<Subject>());
 			}
 
-			std::string getBody() const { 
+			boost::optional<std::string> getBody() const {
 				boost::shared_ptr<Body> body(getPayload<Body>());
+				boost::optional<std::string> bodyData;
 				if (body) {
-					return body->getText();
+					bodyData = body->getText();
 				}
-				return "";
+				return bodyData;
+			}
+
+			void setBody(const std::string& body) {
+				setBody(boost::optional<std::string>(body));
 			}
 
-			void setBody(const std::string& body) { 
-				updatePayload(boost::make_shared<Body>(body));
+			void setBody(const boost::optional<std::string>& body) {
+				if (body) {
+					updatePayload(boost::make_shared<Body>(body.get()));
+				}
+				else {
+					removePayloadOfSameType(boost::make_shared<Body>());
+				}
 			}
 
 			bool isError() {
 				boost::shared_ptr<Swift::ErrorPayload> error(getPayload<Swift::ErrorPayload>());
 				return getType() == Message::Error || error;
 			}
 
 			Type getType() const { return type_; }
 			void setType(Type type) { type_ = type; }
 
 		private:
 			Type type_;
 	};
 }
diff --git a/Swiften/Elements/Stanza.cpp b/Swiften/Elements/Stanza.cpp
index 234878c..f385e1c 100644
--- a/Swiften/Elements/Stanza.cpp
+++ b/Swiften/Elements/Stanza.cpp
@@ -1,58 +1,70 @@
 /*
- * Copyright (c) 2010 Isode Limited.
+ * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/Elements/Stanza.h>
-#include <Swiften/Elements/Delay.h>
 
 #include <typeinfo>
 
+#include <boost/bind.hpp>
+
 #include <Swiften/Base/foreach.h>
+#include <Swiften/Elements/Delay.h>
 
 namespace Swift {
 
 Stanza::Stanza() {
 }
 	
 Stanza::~Stanza() {
 	payloads_.clear();
 }
 
 void Stanza::updatePayload(boost::shared_ptr<Payload> payload) {
 	foreach (boost::shared_ptr<Payload>& i, payloads_) {
 		if (typeid(*i.get()) == typeid(*payload.get())) {
 			i = payload;
 			return;
 		}
 	}
 	addPayload(payload);
 }
 
+static bool sameType(boost::shared_ptr<Payload> a, boost::shared_ptr<Payload> b) {
+	return typeid(*a.get()) == typeid(*b.get());
+}
+
+void Stanza::removePayloadOfSameType(boost::shared_ptr<Payload> payload) {
+	payloads_.erase(std::remove_if(payloads_.begin(), payloads_.end(),
+		boost::bind<bool>(&sameType, payload, _1)),
+		payloads_.end());
+}
+
 boost::shared_ptr<Payload> Stanza::getPayloadOfSameType(boost::shared_ptr<Payload> payload) const {
 	foreach (const boost::shared_ptr<Payload>& i, payloads_) {
 		if (typeid(*i.get()) == typeid(*payload.get())) {
 			return i;
 		}
 	}
 	return boost::shared_ptr<Payload>();
 }
 
 boost::optional<boost::posix_time::ptime> Stanza::getTimestamp() const {
 	boost::shared_ptr<Delay> delay = getPayload<Delay>();
 	return delay ? delay->getStamp() : boost::optional<boost::posix_time::ptime>();
 }
 
 boost::optional<boost::posix_time::ptime> Stanza::getTimestampFrom(const JID& jid) const {
 	std::vector< boost::shared_ptr<Delay> > delays = getPayloads<Delay>();
 	for (size_t i = 0; i < delays.size(); ++i) {
 		if (delays[i]->getFrom() == jid) {
 			return delays[i]->getStamp();
 		}
 	}
 	return getTimestamp();
 }
 
 
 }
diff --git a/Swiften/Elements/Stanza.h b/Swiften/Elements/Stanza.h
index 41df894..8da6280 100644
--- a/Swiften/Elements/Stanza.h
+++ b/Swiften/Elements/Stanza.h
@@ -1,94 +1,96 @@
 /*
- * Copyright (c) 2010-2014 Isode Limited.
+ * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <vector>
 #include <string>
-#include <boost/shared_ptr.hpp>
-#include <boost/optional/optional_fwd.hpp>
+#include <vector>
+
 #include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/optional/optional_fwd.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include <Swiften/Base/API.h>
 #include <Swiften/Elements/ToplevelElement.h>
 #include <Swiften/JID/JID.h>
 
 namespace Swift {
 	class Payload;
 
 	class SWIFTEN_API Stanza : public ToplevelElement {
 		public:
 			typedef boost::shared_ptr<Stanza> ref;
 
 		protected:
 			Stanza();
 
 		public:
 			virtual ~Stanza();
 			SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Stanza)
 
 			template<typename T> 
 			boost::shared_ptr<T> getPayload() const {
 				for (size_t i = 0; i < payloads_.size(); ++i) {
 					boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));
 					if (result) {
 						return result;
 					}
 				}
 				return boost::shared_ptr<T>();
 			}
 
 			template<typename T> 
 			std::vector< boost::shared_ptr<T> > getPayloads() const {
 				std::vector< boost::shared_ptr<T> > results;
 				for (size_t i = 0; i < payloads_.size(); ++i) {
 					boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));
 					if (result) {
 						results.push_back(result);
 					}
 				}
 				return results;
 			}
 
 
 			const std::vector< boost::shared_ptr<Payload> >& getPayloads() const {
 				return payloads_;
 			}
 
 			void addPayload(boost::shared_ptr<Payload> payload) {
 				payloads_.push_back(payload);
 			}
 
 			template<typename InputIterator>
 			void addPayloads(InputIterator begin, InputIterator end) {
 				payloads_.insert(payloads_.end(), begin, end);
 			}
 
 			void updatePayload(boost::shared_ptr<Payload> payload);
 
+			void removePayloadOfSameType(boost::shared_ptr<Payload>);
 			boost::shared_ptr<Payload> getPayloadOfSameType(boost::shared_ptr<Payload>) const;
 
 			const JID& getFrom() const { return from_; }
 			void setFrom(const JID& from) { from_ = from; }
 
 			const JID& getTo() const { return to_; }
 			void setTo(const JID& to) { to_ = to; }
 
 			const std::string& getID() const { return id_; }
 			void setID(const std::string& id) { id_ = id; }
 
 			boost::optional<boost::posix_time::ptime> getTimestamp() const;
 
 			// Falls back to any timestamp if no specific timestamp for the given JID is found.
 			boost::optional<boost::posix_time::ptime> getTimestampFrom(const JID& jid) const;
 	
 		private:
 			std::string id_;
 			JID from_;
 			JID to_;
 			std::vector< boost::shared_ptr<Payload> > payloads_;
 	};
 }