X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FShareContainer.h;h=084b044095668c1f7dbf5a307476240c52a137d0;hb=501f1dd61b6c0beb927151ecf331f78848261b59;hp=a4aa23fa828a34b86aa7323522ab907d7d4134a8;hpb=c7aeeae2cbd4fb1cca6ffdf65d70d736bd43daf4;p=lyx.git

diff --git a/src/ShareContainer.h b/src/ShareContainer.h
index a4aa23fa82..084b044095 100644
--- a/src/ShareContainer.h
+++ b/src/ShareContainer.h
@@ -3,31 +3,36 @@
 #ifndef SHARECONTAINER_H
 #define SHARECONTAINER_H
 
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+
 #include <vector>
 #include <algorithm>
-#include <boost/utility.hpp>
-#include <boost/smart_ptr.hpp>
+#include <functional>
 
-///
+/// Share objects between several users.
+/**
+   This class can be used to reduce memory consuption when you have a lot
+   of equal objects used all over your code.
+
+   \author Lars Gullik Bjønnes
+*/
 template<class Share>
-class ShareContainer : public noncopyable {
+class ShareContainer : boost::noncopyable {
 public:
 	///
 	typedef std::vector<boost::shared_ptr<Share> > Params;
 	///
 	typedef typename Params::value_type value_type;
-	///
+	/// Return a shared_ptr that points to a element equal to ps.
 	value_type
 	get(Share const & ps) const {
 		// First see if we already have this ps in the container
-		Params::iterator it = params.begin();
-		Params::iterator end = params.end();
-		for (; it != end; ++it) {
-			if (ps == *(*it).get())
-				break;
-		}
+		typename Params::iterator it = std::find_if(params.begin(),
+							    params.end(),
+							    isEqual(ps));
 		value_type tmp;
-		if (it == end) {
+		if (it == params.end()) {
 			// ok we don't have it so we should
 			// insert it.
 			tmp.reset(new Share(ps));
@@ -36,40 +41,46 @@ public:
 			// some (one) unique elemements some times
 			// but we should gain a lot in speed.
 			clean();
-			std::sort(params.rbegin(), params.rend(), comp());
 		} else {
 			// yes we have it already
 			tmp = *it;
+			// move it forward - optimization
+			// makes the next find faster.
+			if (it != params.begin())
+				std::swap(*it, *(it - 1));
 		}
 		return tmp;
 	}
 private:
-	///
-	struct comp {
-		int operator()(value_type const & p1,
-			       value_type const & p2) {
-			return p1.use_count() < p2.use_count();
+	/// A functor returning true if the elements are equal.
+	struct isEqual {
+		isEqual(Share const & s) : p_(s) {}
+		bool operator()(value_type const & p1) const {
+			return *p1.get() == p_;
 		}
+	private:
+		Share const & p_;
 	};
-	///
+	/// A functor returning true if the element is unique.
 	struct isUnique {
 		bool operator()(value_type const & p) const {
 			return p.unique();
 		}
 	};
 
-	///
+	/** Remove all unique items.
+	    This removes all elements from params that is only referenced
+	    from the private container. This can be considered a memory
+	    optimizaton.
+	*/
 	void clean() const {
-		// Remove all unique items. (i.e. entries that only
-		// exists in the conatainer and does not have a
-		// corresponding paragrah.
-		Params::iterator it = std::remove_if(params.begin(),
-						     params.end(),
-						     isUnique());
+		typename Params::iterator it = std::remove_if(params.begin(),
+							      params.end(),
+							      isUnique());
 		params.erase(it, params.end());
 	}
-	
-	///
+
+	/// The actual container.
 	mutable Params params;
 };
 #endif