merge trunk@116587 skinning-7@119389 -> viewer-2.0.0-skinning-7

40 files changed, 2477 insertions, 567 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index 3f14be6e18..c4663cc145 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -4,6 +4,7 @@ project(llcommon)
 
 include(00-Common)
 include(LLCommon)
+include(Boost)
 
 include_directories(
     ${EXPAT_INCLUDE_DIRS}
@@ -11,6 +12,11 @@ include_directories(
     ${ZLIB_INCLUDE_DIRS}
     )
 
+# add_executable(lltreeiterators lltreeiterators.cpp)
+# 
+# target_link_libraries(lltreeiterators
+#     ${LLCOMMON_LIBRARIES})
+
 set(llcommon_SOURCE_FILES
     llapp.cpp
     llapr.cpp
@@ -44,6 +50,7 @@ set(llcommon_SOURCE_FILES
     llprocessor.cpp
     llqueuedthread.cpp
     llrand.cpp
+    llrefcount.cpp
     llrun.cpp
     llsd.cpp
     llsdserialize.cpp
@@ -98,6 +105,7 @@ set(llcommon_HEADER_FILES
     lldefs.h
     lldepthstack.h
     lldlinked.h
+    lldoubledispatch.h
     lldqueueptr.h
     llendianswizzle.h
     llenum.h
@@ -119,6 +127,7 @@ set(llcommon_HEADER_FILES
     llhttpstatuscodes.h
     llindexedqueue.h
     llindraconfigfile.h
+    llinstancetracker.h
     llkeythrottle.h
     lllinkedqueue.h
     llliveappconfig.h
@@ -134,20 +143,26 @@ set(llcommon_HEADER_FILES
     llmetrics.h
     llmortician.h
     llnametable.h
+    llpointer.h
     llpreprocessor.h
     llpriqueuemap.h
     llprocessor.h
     llptrskiplist.h
     llptrskipmap.h
+    llptrto.h
     llqueuedthread.h
     llrand.h
+    llrefcount.h
     llrun.h
+    llrefcount.h
+    llsafehandle.h
     llsd.h
     llsdserialize.h
     llsdserialize_xml.h
     llsdutil.h
     llsecondlifeurls.h
     llsimplehash.h
+    llsingleton.h
     llskiplist.h
     llskipmap.h
     llstack.h
@@ -161,6 +176,7 @@ set(llcommon_HEADER_FILES
     llsys.h
     llthread.h
     lltimer.h
+    lltreeiterators.h
     lluri.h
     lluuid.h
     lluuidhashmap.h
@@ -195,4 +211,6 @@ target_link_libraries(
     ${APR_LIBRARIES}
     ${EXPAT_LIBRARIES}
     ${ZLIB_LIBRARIES}
+    ${BOOST_PROGRAM_OPTIONS_LIBRARY}
+    ${BOOST_REGEX_LIBRARY}
     )
diff --git a/indra/llcommon/is_approx_equal_fraction.h b/indra/llcommon/is_approx_equal_fraction.h
index f95b148590..d369fbc5b3 100644
--- a/indra/llcommon/is_approx_equal_fraction.h
+++ b/indra/llcommon/is_approx_equal_fraction.h
@@ -7,7 +7,30 @@
  *         making llcommon depend on llmath.
  * 
  * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
  * Copyright (c) 2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 
diff --git a/indra/llcommon/linden_common.h b/indra/llcommon/linden_common.h
index f9d5877ab2..9adf24a492 100644
--- a/indra/llcommon/linden_common.h
+++ b/indra/llcommon/linden_common.h
@@ -33,6 +33,11 @@
 #ifndef LL_LINDEN_COMMON_H
 #define LL_LINDEN_COMMON_H
 
+// *NOTE:  Please keep includes here to a minimum!
+//
+// Files included here are included in every library .cpp file and
+// are not precompiled.
+
 #if defined(LL_WINDOWS) && defined(_DEBUG)
 # if _MSC_VER >= 1400 // Visual C++ 2005 or later
 #  define _CRTDBG_MAP_ALLOC
@@ -51,23 +56,22 @@
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include <iostream>
-#include <fstream>
+#include <iosfwd>
 
-// Work Microsoft compiler warnings
+// Work around Microsoft compiler warnings in STL headers
 #ifdef LL_WINDOWS
 #pragma warning (disable : 4702) // unreachable code
 #pragma warning (disable : 4244) // conversion from time_t to S32
 #endif	//	LL_WINDOWS
 
-#include <algorithm>
 #include <list>
 #include <map>
 #include <vector>
 #include <string>
 
 #ifdef LL_WINDOWS
-#pragma warning (3 : 4702) // we like level 3, not 4
+// Reenable warnings we disabled above
+#pragma warning (3 : 4702) // unreachable code, we like level 3, not 4
 // level 4 warnings that we need to disable:
 #pragma warning (disable : 4100) // unreferenced formal parameter
 #pragma warning (disable : 4127) // conditional expression is constant (e.g. while(1) )
@@ -78,6 +82,7 @@
 #endif	//	LL_WINDOWS
 
 // Linden only libs in alpha-order other than stdtypes.h
+// *NOTE: Please keep includes here to a minimum, see above.
 #include "stdtypes.h"
 #include "lldefs.h"
 #include "llerror.h"
@@ -85,8 +90,5 @@
 #include "llfasttimer.h"
 #include "llfile.h"
 #include "llformat.h"
-#include "llstring.h"
-#include "llsys.h"
-#include "lltimer.h"
 
 #endif
diff --git a/indra/llcommon/llassettype.cpp b/indra/llcommon/llassettype.cpp
index cf3bf89b4f..fc2ac9dcbc 100644
--- a/indra/llcommon/llassettype.cpp
+++ b/indra/llcommon/llassettype.cpp
@@ -70,6 +70,7 @@ asset_info_t asset_types[] =
 	{ LLAssetType::AT_ANIMATION, "ANIMATION" },
 	{ LLAssetType::AT_GESTURE, "GESTURE" },
 	{ LLAssetType::AT_SIMSTATE, "SIMSTATE" },
+	{ LLAssetType::AT_FAVORITE, "FAVORITE" },
 	{ LLAssetType::AT_NONE, "NONE" },
 };
 
@@ -129,7 +130,8 @@ const char* LLAssetType::mAssetTypeNames[LLAssetType::AT_COUNT] =
 	"jpeg",
 	"animatn",
 	"gesture",
-	"simstate"
+	"simstate",
+	"favorite"
 };
 
 // This table is meant for decoding to human readable form. Put any
@@ -160,6 +162,7 @@ const char* LLAssetType::mAssetTypeHumanNames[LLAssetType::AT_COUNT] =
 	"animation",
 	"gesture",
 	"simstate"
+	"favorite"
 };
 
 ///----------------------------------------------------------------------------
diff --git a/indra/llcommon/llassettype.h b/indra/llcommon/llassettype.h
index 4077b8d2c1..0ee4ae2821 100644
--- a/indra/llcommon/llassettype.h
+++ b/indra/llcommon/llassettype.h
@@ -131,6 +131,9 @@ public:
 		// simstate file
 		AT_SIMSTATE = 22,
 
+		// favorite items
+		AT_FAVORITE = 23,
+
 		// +*********************************************+
 		// |  TO ADD AN ELEMENT TO THIS ENUM:            |
 		// +*********************************************+
@@ -140,7 +143,7 @@ public:
 		// | 4. ADD TO LLAssetType::mAssetTypeHumanNames |
 		// +*********************************************+
 
-		AT_COUNT = 23,
+		AT_COUNT = 24,
 
 		AT_NONE = -1
 	};
diff --git a/indra/llcommon/llboost.h b/indra/llcommon/llboost.h
index 4df9dbf3bd..f4bfc2bfa2 100644
--- a/indra/llcommon/llboost.h
+++ b/indra/llcommon/llboost.h
@@ -46,4 +46,19 @@
 */
 typedef boost::tokenizer<boost::char_separator<char> > boost_tokenizer;
 
+// Useful combiner for boost signals that retturn a vool (e.g. validation)
+//  returns false if any of the callbacks return false
+struct boost_boolean_combiner
+{
+	typedef bool result_type;
+	template<typename InputIterator>
+	bool operator()(InputIterator first, InputIterator last) const
+	{
+		bool res = true;
+		while (first != last)
+			res &= *first++;
+		return res;
+	}
+};
+
 #endif // LL_LLBOOST_H
diff --git a/indra/llcommon/llcommon.cpp b/indra/llcommon/llcommon.cpp
index 2cbb71855f..36a0018995 100644
--- a/indra/llcommon/llcommon.cpp
+++ b/indra/llcommon/llcommon.cpp
@@ -32,6 +32,8 @@
 #include "linden_common.h"
 
 #include "llcommon.h"
+
+#include "llmemory.h"
 #include "llthread.h"
 
 //static
diff --git a/indra/llcommon/llcommon.h b/indra/llcommon/llcommon.h
index 5f77988336..a1808e8a6c 100644
--- a/indra/llcommon/llcommon.h
+++ b/indra/llcommon/llcommon.h
@@ -32,9 +32,8 @@
 #ifndef LL_COMMON_H
 #define LL_COMMON_H
 
-#include "llmemory.h"
+// *TODO: remove these?
 #include "llapr.h"
-// #include "llframecallbackmanager.h"
 #include "lltimer.h"
 #include "llfile.h"
 
diff --git a/indra/llcommon/lldate.cpp b/indra/llcommon/lldate.cpp
index 41a3af398f..7bc9e16bc9 100644
--- a/indra/llcommon/lldate.cpp
+++ b/indra/llcommon/lldate.cpp
@@ -38,10 +38,13 @@
 #include "apr_time.h"
 
 #include <time.h>
+#include <locale>
+#include <string>
 #include <iomanip>
 #include <sstream>
 
 #include "lltimer.h"
+#include "llstring.h"
 
 static const F64 DATE_EPOCH = 0.0;
 
@@ -88,45 +91,36 @@ std::string LLDate::asString() const
 //        is one of the standards used and the prefered format
 std::string LLDate::asRFC1123() const
 {
-    std::ostringstream stream;
-    toHTTPDateStream(stream);
-    return stream.str();
+	return toHTTPDateString (std::string ("%A, %d %b %Y %H:%M:%S GMT"));
 }
 
-void LLDate::toHTTPDateStream(std::ostream& s) const
+std::string LLDate::toHTTPDateString (std::string fmt) const
 {
-    // http://apr.apache.org/docs/apr/0.9/group__apr__time.html
-    apr_time_t time = (apr_time_t)(mSecondsSinceEpoch * LL_APR_USEC_PER_SEC);
+	std::ostringstream stream;
+	time_t locSeconds = (time_t) mSecondsSinceEpoch;
+	struct tm * gmt = gmtime (&locSeconds);
 
-    apr_time_exp_t exp_time ; //Apache time module
+	stream.imbue (std::locale(LLStringUtil::getLocale().c_str()));
+	toHTTPDateStream (stream, gmt, fmt);
+	return stream.str();
+}
 
-    if (apr_time_exp_gmt(&exp_time, time) != APR_SUCCESS)
-    {
-        // Return Epoch UTC date
-        s << "Thursday, 01 Jan 1970 00:00:00 GMT" ;
-        return;
-    }
+std::string LLDate::toHTTPDateString (tm * gmt, std::string fmt)
+{
+	std::ostringstream stream;
+	stream.imbue (std::locale(LLStringUtil::getLocale().c_str()));
+	toHTTPDateStream (stream, gmt, fmt);
+	return stream.str();
+}
 
-    s << std::dec << std::setfill('0');
-#if( LL_WINDOWS || __GNUC__ > 2)
-    s << std::right ;
-#else
-    s.setf(ios::right);
-#endif    
-    std::string day = weekdays[exp_time.tm_wday];
-    std::string month = months[exp_time.tm_mon];
-
-    s << std::setw(day.length()) << (day)
-      << ", " << std::setw(2) << (exp_time.tm_mday)
-      << ' ' << std::setw(month.length()) << (month)
-      << ' ' << std::setw(4) << (exp_time.tm_year + 1900)
-	  << ' ' << std::setw(2) << (exp_time.tm_hour)
-	  << ':' << std::setw(2) << (exp_time.tm_min)
-	  << ':' << std::setw(2) << (exp_time.tm_sec)
-      << " GMT";
+void LLDate::toHTTPDateStream(std::ostream& s, tm * gmt, std::string fmt)
+{
+	using namespace std;
 
-    // RFC 1123 date does not use microseconds
-    //llinfos << "Date in RFC 1123 format is " << s << llendl;
+	const char * pBeg = fmt.c_str();
+	const char * pEnd = pBeg + fmt.length();
+	const time_put<char>& tp = use_facet<time_put<char> >(s.getloc());
+	tp.put (s, s, s.fill(), gmt, pBeg, pEnd);
 }
 
 void LLDate::toStream(std::ostream& s) const
diff --git a/indra/llcommon/lldate.h b/indra/llcommon/lldate.h
index 32825b18dc..29a9030b6d 100644
--- a/indra/llcommon/lldate.h
+++ b/indra/llcommon/lldate.h
@@ -84,7 +84,9 @@ public:
 	std::string asString() const;
 	std::string asRFC1123() const;
 	void toStream(std::ostream&) const;
-	void toHTTPDateStream(std::ostream&) const;
+	std::string toHTTPDateString (std::string fmt) const;
+	static std::string toHTTPDateString (tm * gmt, std::string fmt);
+	static void toHTTPDateStream(std::ostream&, tm *, std::string);
 	/** 
 	 * @brief Set the date from an ISO-8601 string.
 	 *
diff --git a/indra/llcommon/lldoubledispatch.h b/indra/llcommon/lldoubledispatch.h
new file mode 100755
index 0000000000..60678d44fb
--- /dev/null
+++ b/indra/llcommon/lldoubledispatch.h
@@ -0,0 +1,332 @@
+/**
+ * @file   lldoubledispatch.h
+ * @author Nat Goodspeed
+ * @date   2008-11-11
+ * @brief  function calls virtual on more than one parameter
+ * 
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLDOUBLEDISPATCH_H)
+#define LL_LLDOUBLEDISPATCH_H
+
+#include <list>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+
+/**
+ * This class supports function calls which are virtual on the dynamic type of
+ * more than one parameter. Specifically, we address a limited but useful
+ * subset of that problem: function calls which accept two parameters, and
+ * select which particular function to call depending on the dynamic type of
+ * both.
+ * 
+ * Scott Meyers, in More Effective C++ (Item 31), talks about some of the perils
+ * and pitfalls lurking down this pathway.  He discusses and dismisses the
+ * straightforward approaches of using single-dispatch virtual functions twice,
+ * and of using a family of single-dispatch virtual functions which each examine
+ * RTTI for their other parameter.  He advocates using a registry in which you
+ * look up the actual types of both parameters (he uses the classes' string names,
+ * via typeid(param).name()) to obtain a pointer to a free (non-member) function
+ * that will accept this pair of parameters.
+ * 
+ * He does point out that his approach doesn't handle inheritance.  If you have a
+ * registry entry for SpaceShip, and you have in hand a MilitaryShip (subclass of
+ * SpaceShip) and an Asteroid, you'd like to call the function appropriate for
+ * SpaceShips and Asteroids -- but alas, his lookup fails because the class name
+ * for your MilitaryShip subclass isn't in the registry.
+ * 
+ * This class extends his idea to build a registry whose entries can examine the
+ * dynamic type of the parameter in a more flexible way -- using dynamic_cast<>
+ * -- thereby supporting inheritance relationships.
+ * 
+ * Of course we must allow for the ambiguity this permits. We choose to use a
+ * sequence container rather than a map, and require that the client code
+ * specify the order in which dispatch-table entries should be searched. The
+ * result resembles the semantics of the catch clauses for a try/catch block:
+ * you must code catch clauses in decreasing order of specificity, because if
+ * you catch ErrorBaseClass before you catch ErrorSubclass, then any
+ * ErrorSubclass exceptions thrown by the protected code will always match
+ * ErrorBaseClass, and you will never reach your catch(ErrorSubclass) clause.
+ * 
+ * So, in a similar way, if you have a specific routine to process
+ * MilitaryShip and Asteroid, you'd better place that in the table @em before
+ * your more general routine that processes SpaceShip and Asteroid, or else
+ * the MilitaryShip variant will never be called.
+ *
+ * @todo This implementation doesn't attempt to deal with
+ * <tt>const</tt>-correctness of arguments. Our container stores templated
+ * objects into which the specific parameter types have been "frozen." But to
+ * store all these in the same container, they are all instances of a base
+ * class with a virtual invocation method. Naturally the base-class virtual
+ * method definition cannot know the <tt>const</tt>-ness of the particular
+ * types with which its template subclass is instantiated.
+ *
+ * One is tempted to suggest four different virtual methods, one for each
+ * combination of @c const and non-<tt>const</tt> arguments. Then the client
+ * will select the particular virtual method that best fits the
+ * <tt>const</tt>-ness of the arguments in hand. The trouble with that idea is
+ * that in order to instantiate the subclass instance, we must compile all
+ * four of its virtual method overrides, which means we must be prepared to
+ * pass all four combinations of @c const and non-<tt>const</tt> arguments to
+ * the registered callable. That only works when the registered callable
+ * accepts both parameters as @c const.
+ *
+ * Of course the virtual method overrides could use @c const_cast to force
+ * them to compile correctly regardless of the <tt>const</tt>-ness of the
+ * registered callable's parameter declarations. But if we're going to force
+ * the issue with @c const_cast anyway, why bother with the four different
+ * virtual methods? Why not just require canonical parameter
+ * <tt>const</tt>-ness for any callables used with this mechanism?
+ *
+ * We therefore require that your callable accept both params as
+ * non-<tt>const</tt>. (This is more general than @c const: you can perform @c
+ * const operations on a non-<tt>const</tt> parameter, but you can't perform
+ * non-<tt>const</tt> operations on a @c const parameter.)
+ *
+ * For ease of use, though, our invocation method accepts both params as @c
+ * const. Again, you can pass a non-<tt>const</tt> object to a @c const param,
+ * but not the other way around. We take care of the @c const_cast for you.
+ */
+// LLDoubleDispatch is a template because we have to assume that all parameter
+// types are subclasses of some common base class -- but we don't have to
+// impose that base class on client code.  Instead, we let IT tell US the
+// common parameter base class.
+template<class ReturnType, class ParamBaseType>
+class LLDoubleDispatch
+{
+    typedef LLDoubleDispatch<ReturnType, ParamBaseType> self_type;
+
+public:
+    LLDoubleDispatch() {}
+
+    /**
+     * Call the first matching entry.  If there's no registered Functor
+     * appropriate for this pair of parameter types, this call will do
+     * @em nothing!  (If you want notification in this case, simply add a new
+     * Functor for (ParamBaseType&, ParamBaseType&) at the end of the table.
+     * The two base-class entries should match anything that isn't matched by
+     * any more specific entry.)
+     *
+     * See note in class documentation about <tt>const</tt>-correctness.
+     */
+    inline
+    ReturnType operator()(const ParamBaseType& param1, const ParamBaseType& param2) const;
+
+    // Borrow a trick from Alexandrescu:  use a Type class to "wrap" a type
+    // for purposes of passing the type itself into a template method.
+    template<typename T>
+    struct Type {};
+
+    /**
+     * Add a new Entry for a given @a Functor. As mentioned above, the order
+     * in which you add these entries is very important.
+     *
+     * If you want symmetrical entries -- that is, if a B and an A can call
+     * the same Functor as an A and a B -- then pass @c true for the last
+     * parameter, and we'll add a (B, A) entry as well as an (A, B) entry. But
+     * your @a Functor can still be written to expect exactly the pair of types
+     * you've explicitly specified, because the Entry with the reversed params
+     * will call a special thunk that swaps params before calling your @a
+     * Functor.
+     */
+    template<typename Type1, typename Type2, class Functor>
+    void add(const Type<Type1>& t1, const Type<Type2>& t2, Functor func, bool symmetrical=false)
+    {
+        insert(t1, t2, func);
+        if (symmetrical)
+        {
+            // Use boost::bind() to construct a param-swapping thunk. Don't
+            // forget to reverse the parameters too.
+            insert(t2, t1, boost::bind(func, _2, _1));
+        }
+    }
+
+    /**
+     * Add a new Entry for a given @a Functor, explicitly passing instances of
+     * the Functor's leaf param types to help us figure out where to insert.
+     * Because it can use RTTI, this add() method isn't order-sensitive like
+     * the other one.
+     *
+     * If you want symmetrical entries -- that is, if a B and an A can call
+     * the same Functor as an A and a B -- then pass @c true for the last
+     * parameter, and we'll add a (B, A) entry as well as an (A, B) entry. But
+     * your @a Functor can still be written to expect exactly the pair of types
+     * you've explicitly specified, because the Entry with the reversed params
+     * will call a special thunk that swaps params before calling your @a
+     * Functor.
+     */
+    template <typename Type1, typename Type2, class Functor>
+    void add(const Type1& prototype1, const Type2& prototype2, Functor func, bool symmetrical=false)
+    {
+        // Because we expect our caller to pass leaf param types, we can just
+        // perform an ordinary search to find the first matching iterator. If
+        // we find an existing Entry that matches both params, either the
+        // param types are the same, or the existing Entry uses the base class
+        // for one or both params, and the new Entry must precede that. Assume
+        // our client won't register two callables with exactly the SAME set
+        // of types; in that case we'll insert the new one before any earlier
+        // ones, meaning the last one registered will "win." Note that if
+        // find() doesn't find any matching Entry, it will return end(),
+        // meaning the new Entry will be last, which is fine.
+        typename DispatchTable::iterator insertion = find(prototype1, prototype2);
+        insert(Type<Type1>(), Type<Type2>(), func, insertion);
+        if (symmetrical)
+        {
+            insert(Type<Type2>(), Type<Type1>(), boost::bind(func, _2, _1), insertion);
+        }
+    }
+
+    /**
+     * Add a new Entry for a given @a Functor, specifying the Functor's leaf
+     * param types as explicit template arguments. This will instantiate
+     * temporary objects of each of these types, which requires that they have
+     * a lightweight default constructor.
+     *
+     * If you want symmetrical entries -- that is, if a B and an A can call
+     * the same Functor as an A and a B -- then pass @c true for the last
+     * parameter, and we'll add a (B, A) entry as well as an (A, B) entry. But
+     * your @a Functor can still be written to expect exactly the pair of types
+     * you've explicitly specified, because the Entry with the reversed params
+     * will call a special thunk that swaps params before calling your @a
+     * Functor.
+     */
+    template <typename Type1, typename Type2, class Functor>
+    void add(Functor func, bool symmetrical=false)
+    {
+        // This is a convenience wrapper for the add() variant taking explicit
+        // instances.
+        add(Type1(), Type2(), func, symmetrical);
+    }
+
+private:
+    /// This is the base class for each entry in our dispatch table.
+    struct EntryBase
+    {
+        virtual ~EntryBase() {}
+        virtual bool matches(const ParamBaseType& param1, const ParamBaseType& param2) const = 0;
+        virtual ReturnType operator()(ParamBaseType& param1, ParamBaseType& param2) const = 0;
+    };
+
+    /// Here's the template subclass that actually creates each entry.
+    template<typename Type1, typename Type2, class Functor>
+    class Entry: public EntryBase
+    {
+    public:
+        Entry(Functor func): mFunc(func) {}
+        /// Is this entry appropriate for these arguments?
+        virtual bool matches(const ParamBaseType& param1, const ParamBaseType& param2) const
+        {
+            return (dynamic_cast<const Type1*>(&param1) &&
+                    dynamic_cast<const Type2*>(&param2));
+        }
+        /// invocation
+        virtual ReturnType operator()(ParamBaseType& param1, ParamBaseType& param2) const
+        {
+            // We perform the downcast so callable can accept leaf param
+            // types, instead of accepting ParamBaseType and downcasting
+            // explicitly.
+            return mFunc(dynamic_cast<Type1&>(param1), dynamic_cast<Type2&>(param2));
+        }
+    private:
+        /// Bind whatever function or function object the instantiator passed.
+        Functor mFunc;
+    };
+
+    /// shared_ptr manages Entry lifespan for us
+    typedef boost::shared_ptr<EntryBase> EntryPtr;
+    /// use a @c list to make it easy to insert
+    typedef std::list<EntryPtr> DispatchTable;
+    DispatchTable mDispatch;
+
+    /// Look up the location of the first matching entry.
+    typename DispatchTable::const_iterator find(const ParamBaseType& param1, const ParamBaseType& param2) const
+    {
+        // We assert that it's safe to call the non-const find() method on a
+        // const LLDoubleDispatch instance. Cast away the const-ness of 'this'.
+        return const_cast<self_type*>(this)->find(param1, param2);
+    }
+
+    /// Look up the location of the first matching entry.
+    typename DispatchTable::iterator find(const ParamBaseType& param1, const ParamBaseType& param2)
+    {
+        return std::find_if(mDispatch.begin(), mDispatch.end(),
+                            boost::bind(&EntryBase::matches, _1,
+                                        boost::ref(param1), boost::ref(param2)));
+    }
+
+    /// Look up the first matching entry.
+    EntryPtr lookup(const ParamBaseType& param1, const ParamBaseType& param2) const
+    {
+        typename DispatchTable::const_iterator found = find(param1, param2);            
+        if (found != mDispatch.end())
+        {
+            // Dereferencing the list iterator gets us an EntryPtr
+            return *found;
+        }
+        // not found
+        return EntryPtr();
+    }
+
+    // Break out the actual insert operation so the public add() template
+    // function can avoid calling itself recursively.  See add() comments.
+    template<typename Type1, typename Type2, class Functor>
+    void insert(const Type<Type1>& param1, const Type<Type2>& param2, Functor func)
+    {
+        insert(param1, param2, func, mDispatch.end());
+    }
+
+    // Break out the actual insert operation so the public add() template
+    // function can avoid calling itself recursively.  See add() comments.
+    template<typename Type1, typename Type2, class Functor>
+    void insert(const Type<Type1>&, const Type<Type2>&, Functor func,
+                typename DispatchTable::iterator where)
+    {
+        mDispatch.insert(where, EntryPtr(new Entry<Type1, Type2, Functor>(func)));
+    }
+
+    /// Don't implement the copy ctor.  Everyone will be happier if the
+    /// LLDoubleDispatch object isn't copied.
+    LLDoubleDispatch(const LLDoubleDispatch& src);
+};
+
+template <class ReturnType, class ParamBaseType>
+ReturnType LLDoubleDispatch<ReturnType, ParamBaseType>::operator()(const ParamBaseType& param1,
+                                                                   const ParamBaseType& param2) const
+{
+    EntryPtr found = lookup(param1, param2);
+    if (found.get() == 0)
+        return ReturnType();    // bogus return value
+
+    // otherwise, call the Functor we found
+    return (*found)(const_cast<ParamBaseType&>(param1), const_cast<ParamBaseType&>(param2));
+}
+
+#endif /* ! defined(LL_LLDOUBLEDISPATCH_H) */
diff --git a/indra/llcommon/llerrorthread.cpp b/indra/llcommon/llerrorthread.cpp
index 4c779c58c8..f0e46ae78d 100644
--- a/indra/llcommon/llerrorthread.cpp
+++ b/indra/llcommon/llerrorthread.cpp
@@ -31,7 +31,9 @@
 
 #include "linden_common.h"
 #include "llerrorthread.h"
+
 #include "llapp.h"
+#include "lltimer.h"	// ms_sleep()
 
 LLErrorThread::LLErrorThread()
 	: LLThread("Error"),
diff --git a/indra/llcommon/llevent.h b/indra/llcommon/llevent.h
index 60887a060a..2b8f276df1 100644
--- a/indra/llcommon/llevent.h
+++ b/indra/llcommon/llevent.h
@@ -35,7 +35,7 @@
 #define LL_EVENT_H
 
 #include "llsd.h"
-#include "llmemory.h"
+#include "llpointer.h"
 #include "llthread.h"
 
 class LLEventListener;
diff --git a/indra/llcommon/llinstancetracker.h b/indra/llcommon/llinstancetracker.h
new file mode 100644
index 0000000000..11f4063a1d
--- /dev/null
+++ b/indra/llcommon/llinstancetracker.h
@@ -0,0 +1,100 @@
+/** 
+ * @file llinstancetracker.h
+ * @brief LLInstanceTracker is a mixin class that automatically tracks object
+ *        instances with or without an associated key
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLINSTANCETRACKER_H
+#define LL_LLINSTANCETRACKER_H
+
+#include <map>
+
+#include "string_table.h"
+#include <boost/utility.hpp>
+
+// This mix-in class adds support for tracking all instances of the specificed class parameter T
+// The (optional) key associates a value of type KEY with a given instance of T, for quick lookup
+// If KEY is not provided, then instances are stored in a simple list
+template<typename T, typename KEY = T*>
+class LLInstanceTracker : boost::noncopyable
+{
+public:
+	typedef typename std::map<KEY, T*>::iterator instance_iter;
+	typedef typename std::map<KEY, T*>::const_iterator instance_const_iter;
+
+	static T* getInstance(const KEY& k) { instance_iter found = sInstances.find(k); return (found == sInstances.end()) ? NULL : found->second; }
+
+	static instance_iter beginInstances() { return sInstances.begin(); }
+	static instance_iter endInstances() { return sInstances.end(); }
+	static S32 instanceCount() { return sInstances.size(); }
+protected:
+	LLInstanceTracker(KEY key) { add(key); }
+	virtual ~LLInstanceTracker() { remove(); }
+	virtual void setKey(KEY key) { remove(); add(key); }
+	virtual const KEY& getKey() const { return mKey; }
+
+private:
+	void add(KEY key) 
+	{ 
+		mKey = key; 
+		sInstances[key] = static_cast<T*>(this); 
+	}
+	void remove() { sInstances.erase(mKey); }
+
+private:
+
+	KEY mKey;
+	static std::map<KEY, T*> sInstances;
+};
+
+template<typename T>
+class LLInstanceTracker<T, T*>
+{
+public:
+	typedef typename std::set<T*>::iterator instance_iter;
+	typedef typename std::set<T*>::const_iterator instance_const_iter;
+
+	static instance_iter instancesBegin() { return sInstances.begin(); }
+	static instance_iter instancesEnd() { return sInstances.end(); }
+	static S32 instanceCount() { return sInstances.size(); }
+
+protected:
+	LLInstanceTracker() { sInstances.insert(static_cast<T*>(this)); }
+	virtual ~LLInstanceTracker() { sInstances.erase(static_cast<T*>(this)); }
+
+	LLInstanceTracker(const LLInstanceTracker& other) { sInstances.insert(static_cast<T*>(this)); }
+
+	static std::set<T*> sInstances;
+};
+
+template <typename T, typename KEY> std::map<KEY, T*> LLInstanceTracker<T, KEY>::sInstances;
+template <typename T> std::set<T*> LLInstanceTracker<T, T*>::sInstances;
+
+#endif
diff --git a/indra/llcommon/llmd5.cpp b/indra/llcommon/llmd5.cpp
index 14b4f9f4b0..da9cb94e13 100644
--- a/indra/llcommon/llmd5.cpp
+++ b/indra/llcommon/llmd5.cpp
@@ -83,6 +83,7 @@ documentation and/or software.
 #include "llmd5.h"
 
 #include <cassert>
+#include <iostream>		// cerr
 
 // how many bytes to grab at a time when checking files
 const int LLMD5::BLOCK_LEN = 4096;
diff --git a/indra/llcommon/llmemory.cpp b/indra/llcommon/llmemory.cpp
index a6de3d2d69..5d54cfcade 100644
--- a/indra/llcommon/llmemory.cpp
+++ b/indra/llcommon/llmemory.cpp
@@ -275,27 +275,12 @@ void operator delete[] (void *p)
 }
 
 #endif
-
-//----------------------------------------------------------------------------
-
-LLRefCount::LLRefCount() :
-	mRef(0)
-{
-}
-
-LLRefCount::~LLRefCount()
-{ 
-	if (mRef != 0)
-	{
-		llerrs << "deleting non-zero reference" << llendl;
-	}
-}
 	
 //----------------------------------------------------------------------------
 
 #if defined(LL_WINDOWS)
 
-U64 getCurrentRSS()
+U64 LLMemory::getCurrentRSS()
 {
 	HANDLE self = GetCurrentProcess();
 	PROCESS_MEMORY_COUNTERS counters;
@@ -333,7 +318,7 @@ U64 getCurrentRSS()
 // 	}
 // }
 
-U64 getCurrentRSS()
+U64 LLMemory::getCurrentRSS()
 {
 	U64 residentSize = 0;
 	task_basic_info_data_t basicInfo;
@@ -357,7 +342,7 @@ U64 getCurrentRSS()
 
 #elif defined(LL_LINUX)
 
-U64 getCurrentRSS()
+U64 LLMemory::getCurrentRSS()
 {
 	static const char statPath[] = "/proc/self/stat";
 	LLFILE *fp = LLFile::fopen(statPath, "r");
@@ -396,7 +381,7 @@ bail:
 #define _STRUCTURED_PROC 1
 #include <sys/procfs.h>
 
-U64 getCurrentRSS()
+U64 LLMemory::getCurrentRSS()
 {
 	char path [LL_MAX_PATH];	/* Flawfinder: ignore */ 
 
@@ -419,7 +404,7 @@ U64 getCurrentRSS()
 }
 #else
 
-U64 getCurrentRSS()
+U64 LLMemory::getCurrentRSS()
 {
 	return 0;
 }
diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index b5c0711484..a72e58034b 100644
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -29,444 +29,34 @@
  * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
-#ifndef LL_MEMORY_H
-#define LL_MEMORY_H
+#ifndef LLMEMORY_H
+#define LLMEMORY_H
 
-#include <new>
-#include <cstdlib>
 
-#include "llerror.h"
 
 extern S32 gTotalDAlloc;
 extern S32 gTotalDAUse;
 extern S32 gDACount;
 
-const U32 LLREFCOUNT_SENTINEL_VALUE = 0xAAAAAAAA;
-
-//----------------------------------------------------------------------------
-
 class LLMemory
 {
 public:
 	static void initClass();
 	static void cleanupClass();
 	static void freeReserve();
+	// Return the resident set size of the current process, in bytes.
+	// Return value is zero if not known.
+	static U64 getCurrentRSS();
 private:
 	static char* reserveMem;
 };
 
-//----------------------------------------------------------------------------
-// RefCount objects should generally only be accessed by way of LLPointer<>'s
-// NOTE: LLPointer<LLFoo> x = new LLFoo(); MAY NOT BE THREAD SAFE
-//   if LLFoo::LLFoo() does anything like put itself in an update queue.
-//   The queue may get accessed before it gets assigned to x.
-// The correct implementation is:
-//   LLPointer<LLFoo> x = new LLFoo; // constructor does not do anything interesting
-//   x->instantiate(); // does stuff like place x into an update queue
-
-// see llthread.h for LLThreadSafeRefCount
-
-//----------------------------------------------------------------------------
-
-class LLRefCount
-{
-protected:
-	LLRefCount(const LLRefCount&); // not implemented
-private:
-	LLRefCount&operator=(const LLRefCount&); // not implemented
-
-protected:
-	virtual ~LLRefCount(); // use unref()
-	
-public:
-	LLRefCount();
-
-	void ref()
-	{ 
-		mRef++; 
-	} 
-
-	S32 unref()
-	{
-		llassert(mRef >= 1);
-		if (0 == --mRef) 
-		{
-			delete this; 
-			return 0;
-		}
-		return mRef;
-	}	
-
-	S32 getNumRefs() const
-	{
-		return mRef;
-	}
-
-private: 
-	S32	mRef; 
-};
-
-//----------------------------------------------------------------------------
-
-// Note: relies on Type having ref() and unref() methods
-template <class Type> class LLPointer
-{
-public:
-
-	LLPointer() : 
-		mPointer(NULL)
-	{
-	}
-
-	LLPointer(Type* ptr) : 
-		mPointer(ptr)
-	{
-		ref();
-	}
-
-	LLPointer(const LLPointer<Type>& ptr) : 
-		mPointer(ptr.mPointer)
-	{
-		ref();
-	}
-
-	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLPointer(const LLPointer<Subclass>& ptr) : 
-		mPointer(ptr.get())
-	{
-		ref();
-	}
-
-	~LLPointer()								
-	{
-		unref();
-	}
-
-	Type*	get() const							{ return mPointer; }
-	const Type*	operator->() const				{ return mPointer; }
-	Type*	operator->()						{ return mPointer; }
-	const Type&	operator*() const				{ return *mPointer; }
-	Type&	operator*()							{ return *mPointer; }
-
-	operator BOOL()  const						{ return (mPointer != NULL); }
-	operator bool()  const						{ return (mPointer != NULL); }
-	bool operator!() const						{ return (mPointer == NULL); }
-	bool isNull() const							{ return (mPointer == NULL); }
-	bool notNull() const						{ return (mPointer != NULL); }
-
-	operator Type*()       const				{ return mPointer; }
-	operator const Type*() const				{ return mPointer; }
-	bool operator !=(Type* ptr) const           { return (mPointer != ptr); 	}
-	bool operator ==(Type* ptr) const           { return (mPointer == ptr); 	}
-	bool operator ==(const LLPointer<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
-	bool operator < (const LLPointer<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
-	bool operator > (const LLPointer<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
-
-	LLPointer<Type>& operator =(Type* ptr)                   
-	{ 
-		if( mPointer != ptr )
-		{
-			unref(); 
-			mPointer = ptr; 
-			ref();
-		}
-
-		return *this; 
-	}
-
-	LLPointer<Type>& operator =(const LLPointer<Type>& ptr)  
-	{ 
-		if( mPointer != ptr.mPointer )
-		{
-			unref(); 
-			mPointer = ptr.mPointer;
-			ref();
-		}
-		return *this; 
-	}
-
-	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)  
-	{ 
-		if( mPointer != ptr.get() )
-		{
-			unref(); 
-			mPointer = ptr.get();
-			ref();
-		}
-		return *this; 
-	}
-	
-	// Just exchange the pointers, which will not change the reference counts.
-	static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
-	{
-		Type* temp = a.mPointer;
-		a.mPointer = b.mPointer;
-		b.mPointer = temp;
-	}
-
-protected:
-	void ref()                             
-	{ 
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
-	{
-		if (mPointer)
-		{
-			Type *tempp = mPointer;
-			mPointer = NULL;
-			tempp->unref();
-			if (mPointer != NULL)
-			{
-				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
-				unref();
-			}
-		}
-	}
-
-protected:
-	Type*	mPointer;
-};
-
-//template <class Type> 
-//class LLPointerTraits
-//{
-//	static Type* null();
-//};
-//
-// Expands LLPointer to return a pointer to a special instance of class Type instead of NULL.
-// This is useful in instances where operations on NULL pointers are semantically safe and/or
-// when error checking occurs at a different granularity or in a different part of the code
-// than when referencing an object via a LLSafeHandle.
-// 
+// LLRefCount moved to llrefcount.h
 
-template <class Type> 
-class LLSafeHandle
-{
-public:
-	LLSafeHandle() :
-		mPointer(NULL)
-	{
-	}
-
-	LLSafeHandle(Type* ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr);
-	}
-
-	LLSafeHandle(const LLSafeHandle<Type>& ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr.mPointer);
-	}
-
-	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLSafeHandle(const LLSafeHandle<Subclass>& ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr.get());
-	}
-
-	~LLSafeHandle()								
-	{
-		unref();
-	}
-
-	const Type*	operator->() const				{ return nonNull(mPointer); }
-	Type*	operator->()						{ return nonNull(mPointer); }
-
-	Type*	get() const							{ return mPointer; }
-	// we disallow these operations as they expose our null objects to direct manipulation
-	// and bypass the reference counting semantics
-	//const Type&	operator*() const			{ return *nonNull(mPointer); }
-	//Type&	operator*()							{ return *nonNull(mPointer); }
-
-	operator BOOL()  const						{ return mPointer != NULL; }
-	operator bool()  const						{ return mPointer != NULL; }
-	bool operator!() const						{ return mPointer == NULL; }
-	bool isNull() const							{ return mPointer == NULL; }
-	bool notNull() const						{ return mPointer != NULL; }
-
-
-	operator Type*()       const				{ return mPointer; }
-	operator const Type*() const				{ return mPointer; }
-	bool operator !=(Type* ptr) const           { return (mPointer != ptr); 	}
-	bool operator ==(Type* ptr) const           { return (mPointer == ptr); 	}
-	bool operator ==(const LLSafeHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
-	bool operator < (const LLSafeHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
-	bool operator > (const LLSafeHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
-
-	LLSafeHandle<Type>& operator =(Type* ptr)                   
-	{ 
-		assign(ptr);
-		return *this; 
-	}
-
-	LLSafeHandle<Type>& operator =(const LLSafeHandle<Type>& ptr)  
-	{ 
-		assign(ptr.mPointer);
-		return *this; 
-	}
-
-	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLSafeHandle<Type>& operator =(const LLSafeHandle<Subclass>& ptr)  
-	{ 
-		assign(ptr.get());
-		return *this; 
-	}
-
-public:
-	typedef Type* (*NullFunc)();
-	static const NullFunc sNullFunc;
-
-protected:
-	void ref()                             
-	{ 
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
-	{
-		if (mPointer)
-		{
-			Type *tempp = mPointer;
-			mPointer = NULL;
-			tempp->unref();
-			if (mPointer != NULL)
-			{
-				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
-				unref();
-			}
-		}
-	}
-
-	void assign(Type* ptr)
-	{
-		if( mPointer != ptr )
-		{
-			unref(); 
-			mPointer = ptr; 
-			ref();
-		}
-	}
-
-	static Type* nonNull(Type* ptr)
-	{
-		return ptr == NULL ? sNullFunc() : ptr;
-	}
-
-protected:
-	Type*	mPointer;
-};
-
-// LLInitializedPointer is just a pointer with a default constructor that initializes it to NULL
-// NOT a smart pointer like LLPointer<>
-// Useful for example in std::map<int,LLInitializedPointer<LLFoo> >
-//  (std::map uses the default constructor for creating new entries)
-template <typename T> class LLInitializedPointer
-{
-public:
-	LLInitializedPointer() : mPointer(NULL) {}
-	~LLInitializedPointer() { delete mPointer; }
-	
-	const T* operator->() const { return mPointer; }
-	T* operator->() 			{ return mPointer; }
-	const T& operator*() const 	{ return *mPointer; }
-	T& operator*() 				{ return *mPointer; }
-	operator const T*() const	{ return mPointer; }
-	operator T*()				{ return mPointer; }
-	T* operator=(T* x)				{ return (mPointer = x); }
-	operator bool() const		{ return mPointer != NULL; }
-	bool operator!() const		{ return mPointer == NULL; }
-	bool operator==(T* rhs)		{ return mPointer == rhs; }
-	bool operator==(const LLInitializedPointer<T>* rhs) { return mPointer == rhs.mPointer; }
-
-protected:
-	T* mPointer;
-};	
-
-//----------------------------------------------------------------------------
-
-// LLSingleton implements the getInstance() method part of the Singleton
-// pattern. It can't make the derived class constructors protected, though, so
-// you have to do that yourself.
-//
-// There are two ways to use LLSingleton. The first way is to inherit from it
-// while using the typename that you'd like to be static as the template
-// parameter, like so:
-//
-//   class Foo: public LLSingleton<Foo>{};
-//
-//   Foo& instance = Foo::instance();
-//
-// The second way is to use the singleton class directly, without inheritance:
-//
-//   typedef LLSingleton<Foo> FooSingleton;
-//
-//   Foo& instance = FooSingleton::instance();
-//
-// In this case, the class being managed as a singleton needs to provide an
-// initSingleton() method since the LLSingleton virtual method won't be
-// available
-//
-// As currently written, it is not thread-safe.
-template <typename T>
-class LLSingleton
-{
-public:
-	virtual ~LLSingleton() {}
-#ifdef  LL_MSVC7
-// workaround for VC7 compiler bug
-// adapted from http://www.codeproject.com/KB/tips/VC2003MeyersSingletonBug.aspx
-// our version doesn't introduce a nested struct so that you can still declare LLSingleton<MyClass>
-// a friend and hide your constructor
-	static T* getInstance()
-    {
-        LLSingleton<T> singleton;
-        return singleton.vsHack();
-    }
-
-	T* vsHack()
-#else
-	static T* getInstance()
-#endif
-	{
-		static T instance;
-		static bool needs_init = true;
-		if (needs_init)
-		{
-			needs_init = false;
-			instance.initSingleton();
-		}
-		return &instance;
-	}
-
-	static T& instance()
-	{
-		return *getInstance();
-	}
-
-private:
-	virtual void initSingleton() {}
-};
+// LLPointer moved to llpointer.h
 
-//----------------------------------------------------------------------------
+// LLSafeHandle moved to llsafehandle.h
 
-// Return the resident set size of the current process, in bytes.
-// Return value is zero if not known.
-U64 getCurrentRSS();
+// LLSingleton moved to llsingleton.h
 
 #endif
diff --git a/indra/llcommon/llmemtype.h b/indra/llcommon/llmemtype.h
index a9ebc2062f..b7cef4de4a 100644
--- a/indra/llcommon/llmemtype.h
+++ b/indra/llcommon/llmemtype.h
@@ -41,7 +41,10 @@ class LLMemType;
 extern void* ll_allocate (size_t size);
 extern void ll_release (void *p);
 
-#define MEM_TRACK_MEM 0
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// WARNING: Never commit with MEM_TRACK_MEM == 1
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+#define MEM_TRACK_MEM (0 && LL_WINDOWS)
 #define MEM_TRACK_TYPE (1 && MEM_TRACK_MEM)
 
 #if MEM_TRACK_TYPE
diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
new file mode 100644
index 0000000000..2c37eadcc6
--- /dev/null
+++ b/indra/llcommon/llpointer.h
@@ -0,0 +1,177 @@
+/** 
+ * @file llpointer.h
+ * @brief A reference-counted pointer for objects derived from LLRefCount
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#ifndef LLPOINTER_H
+#define LLPOINTER_H
+
+#include "llerror.h"	// *TODO: consider eliminating this
+
+//----------------------------------------------------------------------------
+// RefCount objects should generally only be accessed by way of LLPointer<>'s
+// NOTE: LLPointer<LLFoo> x = new LLFoo(); MAY NOT BE THREAD SAFE
+//   if LLFoo::LLFoo() does anything like put itself in an update queue.
+//   The queue may get accessed before it gets assigned to x.
+// The correct implementation is:
+//   LLPointer<LLFoo> x = new LLFoo; // constructor does not do anything interesting
+//   x->instantiate(); // does stuff like place x into an update queue
+
+// see llthread.h for LLThreadSafeRefCount
+
+//----------------------------------------------------------------------------
+
+// Note: relies on Type having ref() and unref() methods
+template <class Type> class LLPointer
+{
+public:
+
+	LLPointer() : 
+		mPointer(NULL)
+	{
+	}
+
+	LLPointer(Type* ptr) : 
+		mPointer(ptr)
+	{
+		ref();
+	}
+
+	LLPointer(const LLPointer<Type>& ptr) : 
+		mPointer(ptr.mPointer)
+	{
+		ref();
+	}
+
+	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
+	template<typename Subclass>
+	LLPointer(const LLPointer<Subclass>& ptr) : 
+		mPointer(ptr.get())
+	{
+		ref();
+	}
+
+	~LLPointer()								
+	{
+		unref();
+	}
+
+	Type*	get() const							{ return mPointer; }
+	const Type*	operator->() const				{ return mPointer; }
+	Type*	operator->()						{ return mPointer; }
+	const Type&	operator*() const				{ return *mPointer; }
+	Type&	operator*()							{ return *mPointer; }
+
+	operator BOOL()  const						{ return (mPointer != NULL); }
+	operator bool()  const						{ return (mPointer != NULL); }
+	bool operator!() const						{ return (mPointer == NULL); }
+	bool isNull() const							{ return (mPointer == NULL); }
+	bool notNull() const						{ return (mPointer != NULL); }
+
+	operator Type*()       const				{ return mPointer; }
+	operator const Type*() const				{ return mPointer; }
+	bool operator !=(Type* ptr) const           { return (mPointer != ptr); 	}
+	bool operator ==(Type* ptr) const           { return (mPointer == ptr); 	}
+	bool operator ==(const LLPointer<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
+	bool operator < (const LLPointer<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
+	bool operator > (const LLPointer<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
+
+	LLPointer<Type>& operator =(Type* ptr)                   
+	{ 
+		if( mPointer != ptr )
+		{
+			unref(); 
+			mPointer = ptr; 
+			ref();
+		}
+
+		return *this; 
+	}
+
+	LLPointer<Type>& operator =(const LLPointer<Type>& ptr)  
+	{ 
+		if( mPointer != ptr.mPointer )
+		{
+			unref(); 
+			mPointer = ptr.mPointer;
+			ref();
+		}
+		return *this; 
+	}
+
+	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
+	template<typename Subclass>
+	LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)  
+	{ 
+		if( mPointer != ptr.get() )
+		{
+			unref(); 
+			mPointer = ptr.get();
+			ref();
+		}
+		return *this; 
+	}
+	
+	// Just exchange the pointers, which will not change the reference counts.
+	static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
+	{
+		Type* temp = a.mPointer;
+		a.mPointer = b.mPointer;
+		b.mPointer = temp;
+	}
+
+protected:
+	void ref()                             
+	{ 
+		if (mPointer)
+		{
+			mPointer->ref();
+		}
+	}
+
+	void unref()
+	{
+		if (mPointer)
+		{
+			Type *tempp = mPointer;
+			mPointer = NULL;
+			tempp->unref();
+			if (mPointer != NULL)
+			{
+				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
+				unref();
+			}
+		}
+	}
+
+protected:
+	Type*	mPointer;
+};
+
+#endif
diff --git a/indra/llcommon/llptrto.cpp b/indra/llcommon/llptrto.cpp
new file mode 100644
index 0000000000..ce93f09489
--- /dev/null
+++ b/indra/llcommon/llptrto.cpp
@@ -0,0 +1,108 @@
+/**
+ * @file   llptrto.cpp
+ * @author Nat Goodspeed
+ * @date   2008-08-20
+ * @brief  Test for llptrto.h
+ * 
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "linden_common.h"
+// associated header
+#include "llptrto.h"
+// STL headers
+// std headers
+// external library headers
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+// other Linden headers
+#include "llmemory.h"
+
+// a refcounted class
+class RCFoo: public LLRefCount
+{
+public:
+    RCFoo() {}
+};
+
+// a refcounted subclass
+class RCSubFoo: public RCFoo
+{
+public:
+    RCSubFoo() {}
+};
+
+// a refcounted class using the other refcount base class
+class TSRCFoo: public LLThreadSafeRefCount
+{
+public:
+    TSRCFoo() {}
+};
+
+// a non-refcounted class
+class Bar
+{
+public:
+    Bar() {}
+};
+
+// a non-refcounted subclass
+class SubBar: public Bar
+{
+public:
+    SubBar() {}
+};
+
+int main(int argc, char *argv[])
+{
+    // test LLPtrTo<>
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<RCFoo>::type, LLPointer<RCFoo> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<RCSubFoo>::type, LLPointer<RCSubFoo> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<TSRCFoo>::type, LLPointer<TSRCFoo> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<Bar>::type, Bar*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<SubBar>::type, SubBar*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLPtrTo<int>::type, int*>::value));
+
+    // Test LLRemovePointer<>. Note that we remove both pointer variants from
+    // each kind of type, regardless of whether the variant makes sense.
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<RCFoo*>::type, RCFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<RCFoo> >::type, RCFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<RCSubFoo*>::type, RCSubFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<RCSubFoo> >::type, RCSubFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<TSRCFoo*>::type, TSRCFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<TSRCFoo> >::type, TSRCFoo>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<Bar*>::type, Bar>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<Bar> >::type, Bar>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<SubBar*>::type, SubBar>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<SubBar> >::type, SubBar>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer<int*>::type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<LLRemovePointer< LLPointer<int> >::type, int>::value));
+
+    return 0;
+}
diff --git a/indra/llcommon/llptrto.h b/indra/llcommon/llptrto.h
new file mode 100644
index 0000000000..74c117a7f6
--- /dev/null
+++ b/indra/llcommon/llptrto.h
@@ -0,0 +1,93 @@
+/**
+ * @file   llptrto.h
+ * @author Nat Goodspeed
+ * @date   2008-08-19
+ * @brief  LLPtrTo<TARGET> is a template helper to pick either TARGET* or -- when
+ *         TARGET is a subclass of LLRefCount or LLThreadSafeRefCount --
+ *         LLPointer<TARGET>. LLPtrTo<> chooses whichever pointer type is best.
+ * 
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLPTRTO_H)
+#define LL_LLPTRTO_H
+
+#include "llpointer.h"
+#include "llrefcount.h"             // LLRefCount
+#include "llthread.h"               // LLThreadSafeRefCount
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/utility/enable_if.hpp>
+
+/**
+ * LLPtrTo<TARGET>::type is either of two things:
+ *
+ * * When TARGET is a subclass of either LLRefCount or LLThreadSafeRefCount,
+ *   LLPtrTo<TARGET>::type is LLPointer<TARGET>.
+ * * Otherwise, LLPtrTo<TARGET>::type is TARGET*.
+ *
+ * This way, a class template can use LLPtrTo<TARGET>::type to select an
+ * appropriate pointer type to store.
+ */
+template <class T, class ENABLE=void>
+struct LLPtrTo
+{
+    typedef T* type;
+};
+
+/// specialize for subclasses of LLRefCount
+template <class T>
+struct LLPtrTo<T, typename boost::enable_if< boost::is_base_of<LLRefCount, T> >::type>
+{
+    typedef LLPointer<T> type;
+};
+
+/// specialize for subclasses of LLThreadSafeRefCount
+template <class T>
+struct LLPtrTo<T, typename boost::enable_if< boost::is_base_of<LLThreadSafeRefCount, T> >::type>
+{
+    typedef LLPointer<T> type;
+};
+
+/**
+ * LLRemovePointer<PTRTYPE>::type gets you the underlying (pointee) type.
+ */
+template <typename PTRTYPE>
+struct LLRemovePointer
+{
+    typedef typename boost::remove_pointer<PTRTYPE>::type type;
+};
+
+/// specialize for LLPointer<SOMECLASS>
+template <typename SOMECLASS>
+struct LLRemovePointer< LLPointer<SOMECLASS> >
+{
+    typedef SOMECLASS type;
+};
+
+#endif /* ! defined(LL_LLPTRTO_H) */
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index cd53e701d2..3db5c36545 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -31,7 +31,9 @@
 
 #include "linden_common.h"
 #include "llqueuedthread.h"
+
 #include "llstl.h"
+#include "lltimer.h"	// ms_sleep()
 
 //============================================================================
 
diff --git a/indra/llcommon/llrefcount.cpp b/indra/llcommon/llrefcount.cpp
new file mode 100644
index 0000000000..33b6875fb0
--- /dev/null
+++ b/indra/llcommon/llrefcount.cpp
@@ -0,0 +1,49 @@
+/** 
+ * @file llrefcount.cpp
+ * @brief Base class for reference counted objects for use with LLPointer
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#include "linden_common.h"
+
+#include "llrefcount.h"
+
+#include "llerror.h"
+
+LLRefCount::LLRefCount() :
+	mRef(0)
+{
+}
+
+LLRefCount::~LLRefCount()
+{ 
+	if (mRef != 0)
+	{
+		llerrs << "deleting non-zero reference" << llendl;
+	}
+}
diff --git a/indra/llcommon/llrefcount.h b/indra/llcommon/llrefcount.h
new file mode 100644
index 0000000000..540a18b8a0
--- /dev/null
+++ b/indra/llcommon/llrefcount.h
@@ -0,0 +1,78 @@
+/** 
+ * @file llrefcount.h
+ * @brief Base class for reference counted objects for use with LLPointer
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#ifndef LLREFCOUNT_H
+#define LLREFCOUNT_H
+
+//----------------------------------------------------------------------------
+// RefCount objects should generally only be accessed by way of LLPointer<>'s
+// see llthread.h for LLThreadSafeRefCount
+//----------------------------------------------------------------------------
+
+class LLRefCount
+{
+protected:
+	LLRefCount(const LLRefCount&); // not implemented
+private:
+	LLRefCount&operator=(const LLRefCount&); // not implemented
+
+protected:
+	virtual ~LLRefCount(); // use unref()
+	
+public:
+	LLRefCount();
+
+	void ref()
+	{ 
+		mRef++; 
+	} 
+
+	S32 unref()
+	{
+		llassert(mRef >= 1);
+		if (0 == --mRef) 
+		{
+			delete this; 
+			return 0;
+		}
+		return mRef;
+	}	
+
+	S32 getNumRefs() const
+	{
+		return mRef;
+	}
+
+private: 
+	S32	mRef; 
+};
+
+#endif
diff --git a/indra/llcommon/llsafehandle.h b/indra/llcommon/llsafehandle.h
new file mode 100644
index 0000000000..1f7c682fd1
--- /dev/null
+++ b/indra/llcommon/llsafehandle.h
@@ -0,0 +1,167 @@
+/** 
+ * @file llsafehandle.h
+ * @brief Reference-counted object where Object() is valid, not NULL.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#ifndef LLSAFEHANDLE_H
+#define LLSAFEHANDLE_H
+
+#include "llerror.h"	// *TODO: consider eliminating this
+
+// Expands LLPointer to return a pointer to a special instance of class Type instead of NULL.
+// This is useful in instances where operations on NULL pointers are semantically safe and/or
+// when error checking occurs at a different granularity or in a different part of the code
+// than when referencing an object via a LLSafeHandle.
+
+template <class Type> 
+class LLSafeHandle
+{
+public:
+	LLSafeHandle() :
+		mPointer(NULL)
+	{
+	}
+
+	LLSafeHandle(Type* ptr) : 
+		mPointer(NULL)
+	{
+		assign(ptr);
+	}
+
+	LLSafeHandle(const LLSafeHandle<Type>& ptr) : 
+		mPointer(NULL)
+	{
+		assign(ptr.mPointer);
+	}
+
+	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
+	template<typename Subclass>
+	LLSafeHandle(const LLSafeHandle<Subclass>& ptr) : 
+		mPointer(NULL)
+	{
+		assign(ptr.get());
+	}
+
+	~LLSafeHandle()								
+	{
+		unref();
+	}
+
+	const Type*	operator->() const				{ return nonNull(mPointer); }
+	Type*	operator->()						{ return nonNull(mPointer); }
+
+	Type*	get() const							{ return mPointer; }
+	// we disallow these operations as they expose our null objects to direct manipulation
+	// and bypass the reference counting semantics
+	//const Type&	operator*() const			{ return *nonNull(mPointer); }
+	//Type&	operator*()							{ return *nonNull(mPointer); }
+
+	operator BOOL()  const						{ return mPointer != NULL; }
+	operator bool()  const						{ return mPointer != NULL; }
+	bool operator!() const						{ return mPointer == NULL; }
+	bool isNull() const							{ return mPointer == NULL; }
+	bool notNull() const						{ return mPointer != NULL; }
+
+
+	operator Type*()       const				{ return mPointer; }
+	operator const Type*() const				{ return mPointer; }
+	bool operator !=(Type* ptr) const           { return (mPointer != ptr); 	}
+	bool operator ==(Type* ptr) const           { return (mPointer == ptr); 	}
+	bool operator ==(const LLSafeHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
+	bool operator < (const LLSafeHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
+	bool operator > (const LLSafeHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
+
+	LLSafeHandle<Type>& operator =(Type* ptr)                   
+	{ 
+		assign(ptr);
+		return *this; 
+	}
+
+	LLSafeHandle<Type>& operator =(const LLSafeHandle<Type>& ptr)  
+	{ 
+		assign(ptr.mPointer);
+		return *this; 
+	}
+
+	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
+	template<typename Subclass>
+	LLSafeHandle<Type>& operator =(const LLSafeHandle<Subclass>& ptr)  
+	{ 
+		assign(ptr.get());
+		return *this; 
+	}
+
+public:
+	typedef Type* (*NullFunc)();
+	static const NullFunc sNullFunc;
+
+protected:
+	void ref()                             
+	{ 
+		if (mPointer)
+		{
+			mPointer->ref();
+		}
+	}
+
+	void unref()
+	{
+		if (mPointer)
+		{
+			Type *tempp = mPointer;
+			mPointer = NULL;
+			tempp->unref();
+			if (mPointer != NULL)
+			{
+				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
+				unref();
+			}
+		}
+	}
+
+	void assign(Type* ptr)
+	{
+		if( mPointer != ptr )
+		{
+			unref(); 
+			mPointer = ptr; 
+			ref();
+		}
+	}
+
+	static Type* nonNull(Type* ptr)
+	{
+		return ptr == NULL ? sNullFunc() : ptr;
+	}
+
+protected:
+	Type*	mPointer;
+};
+
+#endif
diff --git a/indra/llcommon/llsdserialize.cpp b/indra/llcommon/llsdserialize.cpp
index 7a66d70d3f..cf337be161 100644
--- a/indra/llcommon/llsdserialize.cpp
+++ b/indra/llcommon/llsdserialize.cpp
@@ -34,7 +34,7 @@
 
 #include "linden_common.h"
 #include "llsdserialize.h"
-#include "llmemory.h"
+#include "llpointer.h"
 #include "llstreamtools.h" // for fullread
 
 #include <iostream>
diff --git a/indra/llcommon/llsdserialize.h b/indra/llcommon/llsdserialize.h
index bb38b75d8f..7463d1e5dd 100644
--- a/indra/llcommon/llsdserialize.h
+++ b/indra/llcommon/llsdserialize.h
@@ -36,8 +36,9 @@
 #define LL_LLSDSERIALIZE_H
 
 #include <iosfwd>
+#include "llpointer.h"
+#include "llrefcount.h"
 #include "llsd.h"
-#include "llmemory.h"
 
 /** 
  * @class LLSDParser
diff --git a/indra/llcommon/llsdutil.cpp b/indra/llcommon/llsdutil.cpp
index aa0e0f3696..0202a033c3 100644
--- a/indra/llcommon/llsdutil.cpp
+++ b/indra/llcommon/llsdutil.cpp
@@ -171,6 +171,15 @@ char* ll_print_sd(const LLSD& sd)
 	return buffer;
 }
 
+char* ll_pretty_print_sd_ptr(const LLSD* sd)
+{
+	if (sd)
+	{
+		return ll_pretty_print_sd(*sd);
+	}
+	return NULL;
+}
+
 char* ll_pretty_print_sd(const LLSD& sd)
 {
 	const U32 bufferSize = 10 * 1024;
diff --git a/indra/llcommon/llsdutil.h b/indra/llcommon/llsdutil.h
index b67ad521ea..501600f1d9 100644
--- a/indra/llcommon/llsdutil.h
+++ b/indra/llcommon/llsdutil.h
@@ -89,6 +89,7 @@ LLSD ll_binary_from_string(const LLSD& sd);
 char* ll_print_sd(const LLSD& sd);
 
 // Serializes sd to static buffer and returns pointer, using "pretty printing" mode.
+char* ll_pretty_print_sd_ptr(const LLSD* sd);
 char* ll_pretty_print_sd(const LLSD& sd);
 
 //compares the structure of an LLSD to a template LLSD and stores the
diff --git a/indra/llcommon/llsecondlifeurls.cpp b/indra/llcommon/llsecondlifeurls.cpp
index 36d8e8870f..6323d9d36b 100644
--- a/indra/llcommon/llsecondlifeurls.cpp
+++ b/indra/llcommon/llsecondlifeurls.cpp
@@ -32,57 +32,59 @@
 
 #include "linden_common.h"
 #include "llsecondlifeurls.h"
-
+/*
 const std::string CREATE_ACCOUNT_URL ( 
 	"http://secondlife.com/registration/");
 
 const std::string MANAGE_ACCOUNT ( 
-	"http://secondlife.com/account/");
+	"http://secondlife.com/account/");  // *TODO: NOT USED
 
 const std::string AUCTION_URL ( 
 	"http://secondlife.com/auctions/auction-detail.php?id=");
 
 const std::string EVENTS_URL ( 
 	"http://secondlife.com/events/");
-
+*/
 const std::string TIER_UP_URL ( 
-	"http://secondlife.com/app/landtier");
+	"http://secondlife.com/app/landtier"); // *TODO: Translate (simulator)
 
+const std::string DIRECTX_9_URL ( 
+								 "http://secondlife.com/support/"); // *TODO: NOT USED
+/*
 const std::string LAND_URL ( 
-	"http://secondlife.com/app/landtier");
+	"http://secondlife.com/app/landtier"); // *TODO: NOT USED
 
 const std::string UPGRADE_TO_PREMIUM_URL (
-	"http://secondlife.com/app/upgrade/");
-
-const std::string DIRECTX_9_URL ( 
-	"http://secondlife.com/support/");
+	"http://secondlife.com/app/upgrade/"); // *TODO: NOT USED
 
 const std::string AMD_AGP_URL ( 
-	"http://secondlife.com/support/");
+	"http://secondlife.com/support/"); // *TODO: NOT USED
 
 const std::string VIA_URL ( 
-	"http://secondlife.com/support/");
+	"http://secondlife.com/support/"); // *TODO: NOT USED
 
 const std::string SUPPORT_URL ( 
     "http://secondlife.com/support/");
 
 const std::string INTEL_CHIPSET_URL ( 
-	"http://secondlife.com/support/");
+	"http://secondlife.com/support/"); // *TODO: NOT USED
 
 const std::string SIS_CHIPSET_URL ( 
-	"http://secondlife.com/support/");
+	"http://secondlife.com/support/"); // *TODO: NOT USED
 
 const std::string BLOGS_URL ( 
-	"http://blog.secondlife.com/");
+	"http://blog.secondlife.com/"); // *TODO: NOT USED
 
 const std::string BUY_CURRENCY_URL (
 	"http://secondlife.com/app/currency/");
 
 const std::string LSL_DOC_URL (
-	"http://secondlife.com/app/lsldoc/");
+	"http://secondlife.com/app/lsldoc/");  // *TODO: NOT USED
 
 const std::string SL_KB_URL (
-	"http://secondlife.com/knowledgebase/");
+	"http://secondlife.com/knowledgebase/"); // *TODO: NOT USED
 
 const std::string RELEASE_NOTES_BASE_URL (
 	"http://secondlife.com/app/releasenotes/");
+*/
+
diff --git a/indra/llcommon/llsecondlifeurls.h b/indra/llcommon/llsecondlifeurls.h
index 9fd75c363b..a2e5f0b9c6 100644
--- a/indra/llcommon/llsecondlifeurls.h
+++ b/indra/llcommon/llsecondlifeurls.h
@@ -32,7 +32,7 @@
 
 #ifndef LL_LLSECONDLIFEURLS_H
 #define LL_LLSECONDLIFEURLS_H
-
+/*
 // Account registration web page
 extern const std::string CREATE_ACCOUNT_URL;
 
@@ -42,18 +42,21 @@ extern const std::string MANAGE_ACCOUNT;
 extern const std::string AUCTION_URL; 
 
 extern const std::string EVENTS_URL;
-
+*/
 // Tier up to a new land level.
 extern const std::string TIER_UP_URL;
 
+
 // Tier up to a new land level.
 extern const std::string LAND_URL;
 
+// How to get DirectX 9
+extern const std::string DIRECTX_9_URL;
+
+/*
 // Upgrade from basic membership to premium membership
 extern const std::string UPGRADE_TO_PREMIUM_URL;
 
-// How to get DirectX 9
-extern const std::string DIRECTX_9_URL;
 
 // Out of date VIA chipset
 extern const std::string VIA_URL;
@@ -75,5 +78,5 @@ extern const std::string SL_KB_URL;
 
 // Release Notes Redirect URL for Server and Viewer
 extern const std::string RELEASE_NOTES_BASE_URL;
-
+*/
 #endif
diff --git a/indra/llcommon/llsingleton.h b/indra/llcommon/llsingleton.h
new file mode 100644
index 0000000000..dc1457e4f7
--- /dev/null
+++ b/indra/llcommon/llsingleton.h
@@ -0,0 +1,158 @@
+/** 
+ * @file llsingleton.h
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#ifndef LLSINGLETON_H
+#define LLSINGLETON_H
+
+#include "llerror.h"	// *TODO: eliminate this
+
+#include <boost/noncopyable.hpp>
+
+// LLSingleton implements the getInstance() method part of the Singleton
+// pattern. It can't make the derived class constructors protected, though, so
+// you have to do that yourself.
+//
+// There are two ways to use LLSingleton. The first way is to inherit from it
+// while using the typename that you'd like to be static as the template
+// parameter, like so:
+//
+//   class Foo: public LLSingleton<Foo>{};
+//
+//   Foo& instance = Foo::instance();
+//
+// The second way is to use the singleton class directly, without inheritance:
+//
+//   typedef LLSingleton<Foo> FooSingleton;
+//
+//   Foo& instance = FooSingleton::instance();
+//
+// In this case, the class being managed as a singleton needs to provide an
+// initSingleton() method since the LLSingleton virtual method won't be
+// available
+//
+// As currently written, it is not thread-safe.
+
+template <typename DERIVED_TYPE>
+class LLSingleton : private boost::noncopyable
+{
+	
+private:
+	typedef enum e_init_state
+	{
+		UNINITIALIZED,
+		CONSTRUCTING,
+		INITIALIZING,
+		INITIALIZED,
+		DELETED
+	} EInitState;
+	
+	static void deleteSingleton()
+	{
+		delete getData().mSingletonInstance;
+		getData().mSingletonInstance = NULL;
+	}
+	
+	// stores pointer to singleton instance
+	// and tracks initialization state of singleton
+	struct SingletonInstanceData
+	{
+		EInitState		mInitState;
+		DERIVED_TYPE*	mSingletonInstance;
+		
+		SingletonInstanceData()
+		:	mSingletonInstance(NULL),
+			mInitState(UNINITIALIZED)
+		{}
+
+		~SingletonInstanceData()
+		{
+			deleteSingleton();
+		}
+	};
+	
+public:
+	virtual ~LLSingleton()
+	{
+		SingletonInstanceData& data = getData();
+		data.mSingletonInstance = NULL;
+		data.mInitState = DELETED;
+	}
+
+	static SingletonInstanceData& getData()
+	{
+		static SingletonInstanceData data;
+		return data;
+	}
+
+	static DERIVED_TYPE* getInstance()
+	{
+		SingletonInstanceData& data = getData();
+
+		if (data.mInitState == CONSTRUCTING)
+		{
+			llerrs << "Tried to access singleton " << typeid(DERIVED_TYPE).name() << " from singleton constructor!" << llendl;
+		}
+
+		if (data.mInitState == DELETED)
+		{
+			llwarns << "Trying to access deleted singleton " << typeid(DERIVED_TYPE).name() << " creating new instance" << llendl;
+		}
+		
+		if (!data.mSingletonInstance) 
+		{
+			data.mInitState = CONSTRUCTING;
+			data.mSingletonInstance = new DERIVED_TYPE(); 
+			data.mInitState = INITIALIZING;
+			data.mSingletonInstance->initSingleton(); 
+			data.mInitState = INITIALIZED;	
+		}
+		
+		return data.mSingletonInstance;
+	}
+
+	// Reference version of getInstance()
+	// Preferred over getInstance() as it disallows checking for NULL
+	static DERIVED_TYPE& instance()
+	{
+		return *getInstance();
+	}
+
+	// Has this singleton already been deleted?
+	// Use this to avoid accessing singletons from a static object's destructor
+	static bool destroyed()
+	{
+		return getData().mInitState == DELETED;
+	}
+
+private:
+	virtual void initSingleton() {}
+};
+
+#endif
diff --git a/indra/llcommon/llstat.cpp b/indra/llcommon/llstat.cpp
index e411a1c798..eab1241b5c 100644
--- a/indra/llcommon/llstat.cpp
+++ b/indra/llcommon/llstat.cpp
@@ -46,6 +46,7 @@
 BOOL            LLPerfBlock::sStatsEnabled = FALSE;    // Flag for detailed information
 LLPerfBlock::stat_map_t    LLPerfBlock::sStatMap;    // Map full path string to LLStatTime objects, tracks all active objects
 std::string        LLPerfBlock::sCurrentStatPath = "";    // Something like "/total_time/physics/physics step"
+LLStat::stat_map_t LLStat::sStatList;
 
 //------------------------------------------------------------------------
 // Live config file to trigger stats logging
@@ -724,28 +725,48 @@ void LLPerfBlock::addStatsToLLSDandReset( LLSD & stats,
 LLTimer LLStat::sTimer;
 LLFrameTimer LLStat::sFrameTimer;
 
-LLStat::LLStat(const U32 num_bins, const BOOL use_frame_timer)
+void LLStat::init()
 {
-	llassert(num_bins > 0);
-	U32 i;
-	mUseFrameTimer = use_frame_timer;
+	llassert(mNumBins > 0);
 	mNumValues = 0;
 	mLastValue = 0.f;
 	mLastTime = 0.f;
-	mNumBins = num_bins;
 	mCurBin = (mNumBins-1);
 	mNextBin = 0;
 	mBins      = new F32[mNumBins];
 	mBeginTime = new F64[mNumBins];
 	mTime      = new F64[mNumBins];
 	mDT        = new F32[mNumBins];
-	for (i = 0; i < mNumBins; i++)
+	for (U32 i = 0; i < mNumBins; i++)
 	{
 		mBins[i]      = 0.f;
 		mBeginTime[i] = 0.0;
 		mTime[i]      = 0.0;
 		mDT[i]        = 0.f;
 	}
+
+	if (!mName.empty())
+	{
+		stat_map_t::iterator iter = sStatList.find(mName);
+		if (iter != sStatList.end())
+			llwarns << "LLStat with duplicate name: " << mName << llendl;
+		sStatList.insert(std::make_pair(mName, this));
+	}
+}
+
+LLStat::LLStat(const U32 num_bins, const BOOL use_frame_timer)
+	: mUseFrameTimer(use_frame_timer),
+	  mNumBins(num_bins)
+{
+	init();
+}
+
+LLStat::LLStat(std::string name, U32 num_bins, BOOL use_frame_timer)
+	: mUseFrameTimer(use_frame_timer),
+	  mNumBins(num_bins),
+	  mName(name)
+{
+	init();
 }
 
 LLStat::~LLStat()
@@ -754,6 +775,15 @@ LLStat::~LLStat()
 	delete[] mBeginTime;
 	delete[] mTime;
 	delete[] mDT;
+
+	if (!mName.empty())
+	{
+		// handle multiple entries with the same name
+		stat_map_t::iterator iter = sStatList.find(mName);
+		while (iter != sStatList.end() && iter->second != this)
+			++iter;
+		sStatList.erase(iter);
+	}
 }
 
 void LLStat::reset()
diff --git a/indra/llcommon/llstat.h b/indra/llcommon/llstat.h
index 61aaac45bf..bad18f46a0 100644
--- a/indra/llcommon/llstat.h
+++ b/indra/llcommon/llstat.h
@@ -258,8 +258,15 @@ private:
 // ----------------------------------------------------------------------------
 class LLStat
 {
+private:
+	typedef std::multimap<std::string, LLStat*> stat_map_t;
+	static stat_map_t sStatList;
+
+	void init();
+
 public:
-	LLStat(const U32 num_bins = 32, BOOL use_frame_timer = FALSE);
+	LLStat(U32 num_bins = 32, BOOL use_frame_timer = FALSE);
+	LLStat(std::string name, U32 num_bins = 32, BOOL use_frame_timer = FALSE);
 	~LLStat();
 
 	void reset();
@@ -322,8 +329,22 @@ private:
 	F32 *mDT;
 	S32 mCurBin;
 	S32 mNextBin;
+	
+	std::string mName;
+
 	static LLTimer sTimer;
 	static LLFrameTimer sFrameTimer;
+	
+public:
+	static LLStat* getStat(const std::string& name)
+	{
+		// return the first stat that matches 'name'
+		stat_map_t::iterator iter = sStatList.find(name);
+		if (iter != sStatList.end())
+			return iter->second;
+		else
+			return NULL;
+	}
 };
-
+	
 #endif // LL_STAT_
diff --git a/indra/llcommon/llstring.cpp b/indra/llcommon/llstring.cpp
index 1f653c159c..ec1718a8cb 100644
--- a/indra/llcommon/llstring.cpp
+++ b/indra/llcommon/llstring.cpp
@@ -71,6 +71,24 @@ U8 hex_as_nybble(char hex)
 	return 0; // uh - oh, not hex any more...
 }
 
+bool iswindividual(llwchar elem)
+{   
+	U32 cur_char = (U32)elem;
+	bool result = false;
+	if (0x2E80<= cur_char && cur_char <= 0x9FFF)
+	{
+		result = true;
+	}
+	else if (0xAC00<= cur_char && cur_char <= 0xD7A0 )
+	{
+		result = true;
+	}
+	else if (0xF900<= cur_char && cur_char <= 0xFA60 )
+	{
+		result = true;
+	}
+	return result;
+}
 
 bool _read_file_into_string(std::string& str, const std::string& filename)
 {
@@ -650,6 +668,11 @@ std::string ll_convert_wide_to_string(const wchar_t* in)
 }
 #endif // LL_WINDOWS
 
+long LLStringOps::sltOffset;
+long LLStringOps::localTimeOffset;
+bool LLStringOps::daylightSavings;
+std::map<std::string, std::string> LLStringOps::datetimeToCodes;
+
 S32	LLStringOps::collate(const llwchar* a, const llwchar* b)
 { 
 	#if LL_WINDOWS
@@ -661,6 +684,59 @@ S32	LLStringOps::collate(const llwchar* a, const llwchar* b)
 	#endif
 }
 
+void LLStringOps::setupDatetimeInfo (bool daylight)
+{
+	time_t nowT, localT, gmtT;
+	struct tm * tmpT;
+
+	nowT = time (NULL);
+
+	tmpT = localtime (&nowT);
+	localT = mktime (tmpT);
+
+	tmpT = gmtime (&nowT);
+	gmtT = mktime (tmpT);
+
+	localTimeOffset = (long) (gmtT - localT);
+
+
+	daylightSavings = daylight;
+	sltOffset = (daylightSavings? 7 : 8 ) * 60 * 60;
+
+	datetimeToCodes["wkday"]	= "%a";		// Thu
+	datetimeToCodes["weekday"]	= "%A";		// Thursday
+	datetimeToCodes["year4"]	= "%Y";		// 2009
+	datetimeToCodes["year"]		= "%Y";		// 2009
+	datetimeToCodes["year2"]	= "%y";		// 09
+	datetimeToCodes["mth"]		= "%b";		// Aug
+	datetimeToCodes["month"]	= "%B";		// August
+	datetimeToCodes["mthnum"]	= "%m";		// 08
+	datetimeToCodes["day"]		= "%d";		// 31
+	datetimeToCodes["hour24"]	= "%H";		// 14
+	datetimeToCodes["hour"]		= "%H";		// 14
+	datetimeToCodes["hour12"]	= "%I";		// 02
+	datetimeToCodes["min"]		= "%M";		// 59
+	datetimeToCodes["ampm"]		= "%p";		// AM
+	datetimeToCodes["second"]	= "%S";		// 59
+	datetimeToCodes["timezone"]	= "%Z";		// PST
+}
+
+std::string LLStringOps::getDatetimeCode (std::string key)
+{
+	std::map<std::string, std::string>::iterator iter;
+
+	iter = datetimeToCodes.find (key);
+	if (iter != datetimeToCodes.end())
+	{
+		return iter->second;
+	}
+	else
+	{
+		return std::string("");
+	}
+}
+
+
 namespace LLStringFn
 {
 	// NOTE - this restricts output to ascii
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 99a9b9e269..1aba001353 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -34,6 +34,10 @@
 #define LL_LLSTRING_H
 
 #include <string>
+#include <locale>
+#include <iomanip>
+#include <boost/regex.hpp>
+#include "llsd.h"
 
 #if LL_LINUX || LL_SOLARIS
 #include <wctype.h>
@@ -145,6 +149,12 @@ struct char_traits<U16>
 
 class LLStringOps
 {
+private:
+	static long sltOffset;
+	static long localTimeOffset;
+	static bool daylightSavings;
+	static std::map<std::string, std::string> datetimeToCodes;
+
 public:
 	static char toUpper(char elem) { return toupper((unsigned char)elem); }
 	static llwchar toUpper(llwchar elem) { return towupper(elem); }
@@ -172,6 +182,12 @@ public:
 
 	static S32	collate(const char* a, const char* b) { return strcoll(a, b); }
 	static S32	collate(const llwchar* a, const llwchar* b);
+
+	static void setupDatetimeInfo (bool daylight);
+	static long getSltOffset (void) {return sltOffset;}
+	static long getLocalTimeOffset (void) {return localTimeOffset;}
+	static bool getDaylightSavings (void) {return daylightSavings;}
+	static std::string getDatetimeCode (std::string key);
 };
 
 /**
@@ -201,6 +217,9 @@ private:
 template <class T>
 class LLStringUtilBase
 {
+private:
+	static std::string sLocale;
+
 public:
 	typedef typename std::basic_string<T>::size_type size_type;
 	
@@ -211,7 +230,14 @@ public:
 	static std::basic_string<T> null;
 	
 	typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
+	static void getTokens (std::basic_string<T> input, std::vector<std::basic_string<T> >& tokens);
+	static void formatNumber(std::basic_string<T>& numStr, std::basic_string<T> decimals);
+	static bool formatDatetime(std::basic_string<T>& replacement, std::basic_string<T> token, std::basic_string<T> param, const LLSD& substitutions);
+	static S32 format(std::basic_string<T>& s, const LLSD& substitutions);
 	static S32 format(std::basic_string<T>& s, const format_map_t& fmt_map);
+	static bool simpleReplacement(std::basic_string<T>& replacement, std::basic_string<T> token, const LLSD& substitutions);
+	static void setLocale (std::string inLocale) {sLocale = inLocale;};
+	static std::string getLocale (void) {return sLocale;};
 	
 	static bool isValidIndex(const std::basic_string<T>& string, size_type i)
 	{
@@ -299,6 +325,7 @@ public:
 };
 
 template<class T> std::basic_string<T> LLStringUtilBase<T>::null;
+template<class T> std::string LLStringUtilBase<T>::sLocale;
 
 typedef LLStringUtilBase<char> LLStringUtil;
 typedef LLStringUtilBase<llwchar> LLWStringUtil;
@@ -360,6 +387,7 @@ U8 hex_as_nybble(char hex);
  * @return Returns true on success. If false, str is unmodified.
  */
 bool _read_file_into_string(std::string& str, const std::string& filename);
+bool iswindividual(llwchar elem);
 
 /**
  * Unicode support
@@ -546,64 +574,215 @@ namespace LLStringFn
 
 ////////////////////////////////////////////////////////////
 
-// LLStringBase::format()
-//
-// This function takes a string 's' and a map 'fmt_map' of strings-to-strings.
-// All occurances of strings in 's' from the left-hand side of 'fmt_map' are
-// then replaced with the corresponding right-hand side of 'fmt_map', non-
-// recursively.  The function returns the number of substitutions made.
+//static
+template<class T>
+void LLStringUtilBase<T>::getTokens (std::basic_string<T> input, std::vector<std::basic_string<T> >& tokens)
+{
+	const std::basic_string<T> delims (",");
+	std::basic_string<T> currToken;
+	size_type begIdx, endIdx;
+
+	begIdx = input.find_first_not_of (delims);
+	while (begIdx != std::basic_string<T>::npos)
+	{
+		endIdx = input.find_first_of (delims, begIdx);
+		if (endIdx == std::basic_string<T>::npos)
+		{
+			endIdx = input.length();
+		}
+
+		currToken = input.substr(begIdx, endIdx - begIdx);
+		trim (currToken);
+		tokens.push_back(currToken);
+		begIdx = input.find_first_not_of (delims, endIdx);
+	}
+}
 
 // static
 template<class T> 
 S32 LLStringUtilBase<T>::format(std::basic_string<T>& s, const format_map_t& fmt_map)
 {
-	typedef typename std::basic_string<T>::size_type string_size_type_t;
-	string_size_type_t scanstart = 0;
+	LLSD llsdMap;
+
+	for (format_map_t::const_iterator iter = fmt_map.begin();
+		 iter != fmt_map.end();
+		 ++iter)
+	{
+		llsdMap[iter->first] = iter->second;
+	}
+
+	return format (s, llsdMap);
+}
+
+//static
+template<class T>
+S32 LLStringUtilBase<T>::format(std::basic_string<T>& s, const LLSD& substitutions)
+{
 	S32 res = 0;
 
-	// Look for the first match of any keyword, replace that keyword,
-	// repeat from the end of the replacement string.  This avoids
-	// accidentally performing substitution on a substituted string.
-	while (1)
+	if (!substitutions.isMap()) 
+	{
+		return res;
+	}
+
+	std::basic_ostringstream<T> output;
+	// match strings like [NAME,number,3]
+	const boost::regex key("\\[((\\s)*([0-9_A-Za-z]+)((\\s)*,(\\s)*[0-9_A-Za-z\\s]*){0,2}(\\s)*)]");
+
+
+	typename std::basic_string<T>::const_iterator start = s.begin();
+	typename std::basic_string<T>::const_iterator end = s.end();
+	boost::smatch match;
+	
+
+	while (boost::regex_search(start, end, match, key, boost::match_default))
 	{
-		string_size_type_t first_match_pos = scanstart;
-		string_size_type_t first_match_str_length = 0;
-		std::basic_string<T> first_match_str_replacement;
+		bool found_replacement = false;
+		std::vector<std::basic_string<T> > tokens;
+		std::basic_string<T> replacement;
 
-		for (format_map_t::const_iterator iter = fmt_map.begin();
-		     iter != fmt_map.end();
-		     ++iter)
+		getTokens (std::basic_string<T>(match[1].first, match[1].second), tokens);
+
+		if (tokens.size() == 1)
 		{
-			string_size_type_t n = s.find(iter->first, scanstart);
-			if (n != std::basic_string<T>::npos &&
-			    (n < first_match_pos ||
-			     0 == first_match_str_length))
-			{
-				first_match_pos = n;
-				first_match_str_length = iter->first.length();
-				first_match_str_replacement = iter->second;
-			}
+			found_replacement = simpleReplacement (replacement, tokens[0], substitutions);
 		}
+		else if (tokens[1] == "number")
+		{
+			std::basic_string<T> param = "0";
 
-		if (0 == first_match_str_length)
+			if (tokens.size() > 2) param = tokens[2];
+			found_replacement = simpleReplacement (replacement, tokens[0], substitutions);
+			if (found_replacement) formatNumber (replacement, param);
+		}
+		else if (tokens[1] == "datetime")
 		{
-			// no more keys found to substitute from this point
-			// in the string forward.
-			break;
+			std::basic_string<T> param;
+			if (tokens.size() > 2) param = tokens[2];
+
+			found_replacement = formatDatetime (replacement, tokens[0], param, substitutions);
+		}
+
+		if (found_replacement)
+		{
+			output << std::basic_string<T>(start, match[0].first) << replacement;
+			res++;
 		}
 		else
 		{
-			s.erase(first_match_pos, first_match_str_length);
-			s.insert(first_match_pos, first_match_str_replacement);
-			scanstart = first_match_pos +
-				first_match_str_replacement.length();
-			++res;
+			// we had no replacement, so leave the string we searched for so that it gets noticed by QA
+			// "hello [NAME_NOT_FOUND]" is output
+			output << std::basic_string<T>(start, match[0].second);
 		}
+		
+		// update search position 
+		start = match[0].second; 
 	}
+	// send the remainder of the string (with no further matches for bracketed names)
+	output << std::basic_string<T>(start, end);
+	s = output.str();
 	return res;
 }
 
 // static
+template<class T>
+bool LLStringUtilBase<T>::simpleReplacement(std::basic_string<T> &replacement, std::basic_string<T> token, const LLSD &substitutions)
+{
+	// see if we have a replacement for the bracketed string (without the brackets)
+	// test first using has() because if we just look up with operator[] we get back an
+	// empty string even if the value is missing. We want to distinguish between 
+	// missing replacements and deliberately empty replacement strings.
+	if (substitutions.has(token))
+	{
+		replacement = substitutions[token].asString();
+		return true;
+	}
+	// if not, see if there's one WITH brackets
+	else if (substitutions.has(std::basic_string<T>("[" + token + "]")))
+	{
+		replacement = substitutions[std::basic_string<T>("[" + token + "]")].asString();
+		return true;
+	}
+
+	return false;
+}
+
+// static
+template<class T>
+void LLStringUtilBase<T>::formatNumber(std::basic_string<T>& numStr, std::basic_string<T> decimals)
+{
+	typedef typename std::basic_string<T>::size_type string_size_type_t;
+	std::basic_stringstream<T> strStream;
+	S32 intDecimals = 0;
+
+	convertToS32 (decimals, intDecimals);
+	if (!sLocale.empty())
+	{
+		strStream.imbue (std::locale(sLocale.c_str()));
+	}
+
+	if (!intDecimals)
+	{
+		S32 intStr;
+
+		if (convertToS32(numStr, intStr))
+		{
+			strStream << intStr;
+			numStr = strStream.str();
+		}
+	}
+	else
+	{
+		F32 floatStr;
+
+		if (convertToF32(numStr, floatStr))
+		{
+			strStream << std::fixed << std::showpoint << std::setprecision(intDecimals) << floatStr;
+			numStr = strStream.str();
+		}
+	}
+}
+
+// static
+template<class T>
+bool LLStringUtilBase<T>::formatDatetime(std::basic_string<T>& replacement, std::basic_string<T> token,
+										 std::basic_string<T> param, const LLSD& substitutions)
+{
+	S32 secFromEpoch = (long) substitutions["datetime"].asInteger();
+
+	if (param == "local")
+	{
+		secFromEpoch -= LLStringOps::getLocalTimeOffset();
+	}
+	else if (param != "utc")
+	{
+		secFromEpoch -= LLStringOps::getSltOffset();
+	}
+
+	if (secFromEpoch < 0) secFromEpoch = 0;
+
+	LLDate * datetime = new LLDate((F64)secFromEpoch);
+	std::string code = LLStringOps::getDatetimeCode (token);
+
+	// special case to handle timezone
+	if (code == "%Z") {
+		if (param == "utc") replacement = "GMT";
+		else if (param != "local") replacement = LLStringOps::getDaylightSavings()? "PDT" : "PST";
+		return true;
+	}
+
+	replacement = datetime->toHTTPDateString(code);
+	if (code.empty())
+	{
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+// static
 template<class T> 
 S32 LLStringUtilBase<T>::compareStrings(const T* lhs, const T* rhs)
 {	
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index c8c9fd4eec..f25339f48d 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -35,7 +35,6 @@
 
 #include "llapr.h"
 #include "llapp.h"
-#include "llmemory.h"
 
 #include "apr_thread_cond.h"
 
diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index fa6efaf38e..f8066d56ed 100644
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -561,32 +561,27 @@ void secondsToTimecodeString(F32 current_time, std::string& tcstring)
 //
 //////////////////////////////////////////////////////////////////////////////
 
-std::list<LLEventTimer*> LLEventTimer::sActiveList;
-
 LLEventTimer::LLEventTimer(F32 period)
 : mEventTimer()
 {
 	mPeriod = period;
-	sActiveList.push_back(this);
 }
 
 LLEventTimer::LLEventTimer(const LLDate& time)
 : mEventTimer()
 {
 	mPeriod = (F32)(time.secondsSinceEpoch() - LLDate::now().secondsSinceEpoch());
-	sActiveList.push_back(this);
 }
 
 
-LLEventTimer::~LLEventTimer() 
+LLEventTimer::~LLEventTimer()
 {
-	sActiveList.remove(this);
 }
 
 void LLEventTimer::updateClass() 
 {
 	std::list<LLEventTimer*> completed_timers;
-	for (std::list<LLEventTimer*>::iterator iter = sActiveList.begin(); iter != sActiveList.end(); ) 
+	for (instance_iter iter = instancesBegin(); iter != instancesEnd(); ) 
 	{
 		LLEventTimer* timer = *iter++;
 		F32 et = timer->mEventTimer.getElapsedTimeF32();
diff --git a/indra/llcommon/lltimer.h b/indra/llcommon/lltimer.h
index e2cf1c7689..0319bec45b 100644
--- a/indra/llcommon/lltimer.h
+++ b/indra/llcommon/lltimer.h
@@ -40,6 +40,7 @@
 
 #include "stdtypes.h"
 #include "lldate.h"
+#include "llinstancetracker.h"
 
 #include <string>
 #include <list>
@@ -171,13 +172,13 @@ void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
 void secondsToTimecodeString(F32 current_time, std::string& tcstring);
 
 // class for scheduling a function to be called at a given frequency (approximate, inprecise)
-class LLEventTimer 
+class LLEventTimer : protected LLInstanceTracker<LLEventTimer>
 {
 public:
 	LLEventTimer(F32 period);	// period is the amount of time between each call to tick() in seconds
 	LLEventTimer(const LLDate& time);
 	virtual ~LLEventTimer();
-
+	
 	//function to be called at the supplied frequency
 	// Normally return FALSE; TRUE will delete the timer after the function returns.
 	virtual BOOL tick() = 0;
@@ -187,10 +188,6 @@ public:
 protected:
 	LLTimer mEventTimer;
 	F32 mPeriod;
-
-private:
-	//list of active timers
-	static std::list<LLEventTimer*> sActiveList; // TODO should this be a vector
 };
 
 #endif
diff --git a/indra/llcommon/lltreeiterators.h b/indra/llcommon/lltreeiterators.h
new file mode 100644
index 0000000000..7ab94b0e6d
--- /dev/null
+++ b/indra/llcommon/lltreeiterators.h
@@ -0,0 +1,691 @@
+/**
+ * @file   lltreeiterators.h
+ * @author Nat Goodspeed
+ * @date   2008-08-19
+ * @brief  This file defines iterators useful for traversing arbitrary node
+ *         classes, potentially polymorphic, linked into strict tree
+ *         structures.
+ *
+ *         Dereferencing any one of these iterators actually yields a @em
+ *         pointer to the node in question. For example, given an
+ *         LLLinkedIter<MyNode> <tt>li</tt>, <tt>*li</tt> gets you a pointer
+ *         to MyNode, and <tt>**li</tt> gets you the MyNode instance itself.
+ *         More commonly, instead of writing <tt>li->member</tt>, you write
+ *         <tt>(*li)->member</tt> -- as you would if you were traversing an
+ *         STL container of MyNode pointers.
+ *
+ *         It would certainly be possible to build these iterators so that
+ *         <tt>*iterator</tt> would return a reference to the node itself
+ *         rather than a pointer to the node, and for many purposes it would
+ *         even be more convenient. However, that would be insufficiently
+ *         flexible. If you want to use an iterator range to (e.g.) initialize
+ *         a std::vector collecting results -- you rarely want to actually @em
+ *         copy the nodes in question. You're much more likely to want to copy
+ *         <i>pointers to</i> the traversed nodes. Hence these iterators
+ *         produce pointers.
+ *
+ *         Though you specify the actual NODE class as the template parameter,
+ *         these iterators internally use LLPtrTo<> to discover whether to
+ *         store and return an LLPointer<NODE> or a simple NODE*.
+ *
+ *         By strict tree structures, we mean that each child must have
+ *         exactly one parent. This forbids a child claiming any ancestor as a
+ *         child of its own. Child nodes with multiple parents will be visited
+ *         once for each parent. Cycles in the graph will result in either an
+ *         infinite loop or an out-of-memory crash. You Have Been Warned.
+ * 
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLTREEITERATORS_H)
+#define LL_LLTREEITERATORS_H
+
+#include "llptrto.h"
+#include <vector>
+#include <deque>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/function.hpp>
+#include <boost/static_assert.hpp>
+
+namespace LLTreeIter
+{
+    /// Discriminator between LLTreeUpIter and LLTreeDownIter
+    enum RootIter { UP, DOWN };
+    /// Discriminator between LLTreeDFSIter, LLTreeDFSPostIter and LLTreeBFSIter
+    enum WalkIter { DFS_PRE, DFS_POST, BFS };
+}
+
+/**
+ * LLBaseIter defines some machinery common to all these iterators. We use
+ * boost::iterator_facade to define the iterator boilerplate: the conventional
+ * operators and methods necessary to implement a standards-conforming
+ * iterator. That allows us to specify the actual iterator semantics in terms
+ * of equal(), dereference() and increment() methods.
+ */
+template <class SELFTYPE, class NODE>
+class LLBaseIter: public boost::iterator_facade<SELFTYPE,
+                                                // use pointer type as the
+                                                // reference type
+                                                typename LLPtrTo<NODE>::type,
+                                                boost::forward_traversal_tag>
+{
+protected:
+    /// LLPtrTo<NODE>::type is either NODE* or LLPointer<NODE>, as appropriate
+    typedef typename LLPtrTo<NODE>::type ptr_type;
+    /// function that advances from this node to next accepts a node pointer
+    /// and returns another
+    typedef boost::function<ptr_type(const ptr_type&)> func_type;
+    typedef SELFTYPE self_type;
+};
+
+/// Functor returning NULL, suitable for an end-iterator's 'next' functor
+template <class NODE>
+typename LLPtrTo<NODE>::type LLNullNextFunctor(const typename LLPtrTo<NODE>::type&)
+{
+    return typename LLPtrTo<NODE>::type();
+}
+
+/**
+ * LLLinkedIter is an iterator over an intrusive singly-linked list. The
+ * beginning of the list is represented by LLLinkedIter(list head); the end is
+ * represented by LLLinkedIter().
+ *
+ * The begin LLLinkedIter must be instantiated with a functor to extract the
+ * 'next' pointer from the current node. Supposing that the link pointer is @c
+ * public, something like:
+ *
+ * @code
+ * NODE* mNext;
+ * @endcode
+ *
+ * you can use (e.g.) <tt>boost::bind(&NODE::mNext, _1)</tt> for the purpose.
+ * Alternatively, you can bind whatever accessor method is normally used to
+ * advance to the next node, e.g. for:
+ *
+ * @code
+ * NODE* next() const;
+ * @endcode
+ *
+ * you can use <tt>boost::bind(&NODE::next, _1)</tt>.
+ */
+template <class NODE>
+class LLLinkedIter: public LLBaseIter<LLLinkedIter<NODE>, NODE>
+{
+    typedef LLBaseIter<LLLinkedIter<NODE>, NODE> super;
+protected:
+    /// some methods need to return a reference to self
+    typedef typename super::self_type self_type;
+    typedef typename super::ptr_type ptr_type;
+    typedef typename super::func_type func_type;
+public:
+    /// Instantiate an LLLinkedIter to start a range, or to end a range before
+    /// a particular list entry. Pass a functor to extract the 'next' pointer
+    /// from the current node.
+    LLLinkedIter(const ptr_type& entry, const func_type& nextfunc):
+        mCurrent(entry),
+        mNextFunc(nextfunc)
+    {}
+    /// Instantiate an LLLinkedIter to end a range at the end of the list
+    LLLinkedIter():
+        mCurrent(),
+        mNextFunc(LLNullNextFunctor<NODE>)
+    {}
+
+private:
+    /// leverage boost::iterator_facade
+    friend class boost::iterator_core_access;
+
+    /// advance
+    void increment()
+    {
+        mCurrent = mNextFunc(mCurrent);
+    }
+    /// equality
+    bool equal(const self_type& that) const { return this->mCurrent == that.mCurrent; }
+    /// dereference
+    ptr_type& dereference() const { return const_cast<ptr_type&>(mCurrent); }
+
+    ptr_type mCurrent;
+    func_type mNextFunc;
+};
+
+/**
+ * LLTreeUpIter walks from the node in hand to the root of the tree. The term
+ * "up" is applied to a tree visualized with the root at the top.
+ *
+ * LLTreeUpIter is an alias for LLLinkedIter, since any linked tree that you
+ * can navigate that way at all contains parent pointers.
+ */
+template <class NODE>
+class LLTreeUpIter: public LLLinkedIter<NODE>
+{
+    typedef LLLinkedIter<NODE> super;
+public:
+    /// Instantiate an LLTreeUpIter to start from a particular tree node, or
+    /// to end a parent traversal before reaching a particular ancestor. Pass
+    /// a functor to extract the 'parent' pointer from the current node.
+    LLTreeUpIter(const typename super::ptr_type& node,
+                 const typename super::func_type& parentfunc):
+        super(node, parentfunc)
+    {}
+    /// Instantiate an LLTreeUpIter to end a range at the root of the tree
+    LLTreeUpIter():
+        super()
+    {}
+};
+
+/**
+ * LLTreeDownIter walks from the root of the tree to the node in hand. The
+ * term "down" is applied to a tree visualized with the root at the top.
+ *
+ * Though you instantiate the begin() LLTreeDownIter with a pointer to some
+ * node at an arbitrary location in the tree, the root will be the first node
+ * you dereference and the passed node will be the last node you dereference.
+ *
+ * On construction, LLTreeDownIter walks from the current node to the root,
+ * capturing the path. Then in use, it replays that walk in reverse. As with
+ * all traversals of interesting data structures, it is actively dangerous to
+ * modify the tree during an LLTreeDownIter walk.
+ */
+template <class NODE>
+class LLTreeDownIter: public LLBaseIter<LLTreeDownIter<NODE>, NODE>
+{
+    typedef LLBaseIter<LLTreeDownIter<NODE>, NODE> super;
+    typedef typename super::self_type self_type;
+protected:
+    typedef typename super::ptr_type ptr_type;
+    typedef typename super::func_type func_type;
+private:
+    typedef std::vector<ptr_type> list_type;
+public:
+    /// Instantiate an LLTreeDownIter to end at a particular tree node. Pass a
+    /// functor to extract the 'parent' pointer from the current node.
+    LLTreeDownIter(const ptr_type& node,
+                   const func_type& parentfunc)
+    {
+        for (ptr_type n = node; n; n = parentfunc(n))
+            mParents.push_back(n);
+    }
+    /// Instantiate an LLTreeDownIter representing "here", the end of the loop
+    LLTreeDownIter() {}
+
+private:
+    /// leverage boost::iterator_facade
+    friend class boost::iterator_core_access;
+
+    /// advance
+    void increment()
+    {
+        mParents.pop_back();
+    }
+    /// equality
+    bool equal(const self_type& that) const { return this->mParents == that.mParents; }
+    /// implement dereference/indirection operators
+    ptr_type& dereference() const { return const_cast<ptr_type&>(mParents.back()); }
+
+    list_type mParents;
+};
+
+/**
+ * When you want to select between LLTreeUpIter and LLTreeDownIter with a
+ * compile-time discriminator, use LLTreeRootIter with an LLTreeIter::RootIter
+ * template arg.
+ */
+template <LLTreeIter::RootIter DISCRIM, class NODE>
+class LLTreeRootIter
+{
+    enum { use_a_valid_LLTreeIter_RootIter_value = false };
+public:
+    /// Bogus constructors for default (unrecognized discriminator) case
+    template <typename TYPE1, typename TYPE2>
+    LLTreeRootIter(TYPE1, TYPE2)
+    {
+        BOOST_STATIC_ASSERT(use_a_valid_LLTreeIter_RootIter_value);
+    }
+    LLTreeRootIter()
+    {
+        BOOST_STATIC_ASSERT(use_a_valid_LLTreeIter_RootIter_value);
+    }
+};
+
+/// Specialize for LLTreeIter::UP
+template <class NODE>
+class LLTreeRootIter<LLTreeIter::UP, NODE>: public LLTreeUpIter<NODE>
+{
+    typedef LLTreeUpIter<NODE> super;
+public:
+    /// forward begin ctor
+    LLTreeRootIter(const typename super::ptr_type& node,
+                   const typename super::func_type& parentfunc):
+        super(node, parentfunc)
+    {}
+    /// forward end ctor
+    LLTreeRootIter():
+        super()
+    {}
+};
+
+/// Specialize for LLTreeIter::DOWN
+template <class NODE>
+class LLTreeRootIter<LLTreeIter::DOWN, NODE>: public LLTreeDownIter<NODE>
+{
+    typedef LLTreeDownIter<NODE> super;
+public:
+    /// forward begin ctor
+    LLTreeRootIter(const typename super::ptr_type& node,
+                   const typename super::func_type& parentfunc):
+        super(node, parentfunc)
+    {}
+    /// forward end ctor
+    LLTreeRootIter():
+        super()
+    {}
+};
+
+/**
+ * Instantiated with a tree node, typically the root, LLTreeDFSIter "flattens"
+ * a depth-first tree walk through that node and all its descendants.
+ *
+ * The begin() LLTreeDFSIter must be instantiated with functors to obtain from
+ * a given node begin() and end() iterators for that node's children. For this
+ * reason, you must specify the type of the node's child iterator as an
+ * additional template parameter.
+ *
+ * Specifically, the begin functor must return an iterator whose dereferenced
+ * value is a @em pointer to a child tree node. For instance, if each node
+ * tracks its children in an STL container of node* pointers, you can simply
+ * return that container's begin() iterator.
+ *
+ * Alternatively, if a node tracks its children with a classic linked list,
+ * write a functor returning LLLinkedIter<NODE>.
+ *
+ * The end() LLTreeDFSIter must, of course, match the begin() iterator's
+ * template parameters, but is constructed without runtime parameters.
+ */
+template <class NODE, typename CHILDITER>
+class LLTreeDFSIter: public LLBaseIter<LLTreeDFSIter<NODE, CHILDITER>, NODE>
+{
+    typedef LLBaseIter<LLTreeDFSIter<NODE, CHILDITER>, NODE> super;
+    typedef typename super::self_type self_type;
+protected:
+    typedef typename super::ptr_type ptr_type;
+    // The func_type is different for this: from a NODE pointer, we must
+    // obtain a CHILDITER.
+    typedef boost::function<CHILDITER(const ptr_type&)> func_type;
+private:
+    typedef std::vector<ptr_type> list_type;
+public:
+    /// Instantiate an LLTreeDFSIter to start a depth-first walk. Pass
+    /// functors to extract the 'child begin' and 'child end' iterators from
+    /// each node.
+    LLTreeDFSIter(const ptr_type& node, const func_type& beginfunc, const func_type& endfunc):
+        mBeginFunc(beginfunc),
+        mEndFunc(endfunc),
+		mSkipChildren(false)
+    {
+        // Only push back this node if it's non-NULL!
+        if (node)
+            mPending.push_back(node);
+    }
+    /// Instantiate an LLTreeDFSIter to mark the end of the walk
+    LLTreeDFSIter() {}
+
+	/// flags iterator logic to skip traversing children of current node on next increment
+	void skipChildren(bool skip = true) { mSkipChildren = skip; }
+
+private:
+    /// leverage boost::iterator_facade
+    friend class boost::iterator_core_access;
+
+    /// advance
+    /// This implementation is due to http://en.wikipedia.org/wiki/Depth-first_search
+    void increment()
+    {
+        // Capture the node we were just looking at
+        ptr_type current = mPending.back();
+        // Remove it from mPending so we don't process it again later
+        mPending.pop_back();
+		if (!mSkipChildren)
+		{
+			// Add all its children to mPending
+			addChildren(current);
+		}
+		// reset flag after each step
+		mSkipChildren = false;
+    }
+    /// equality
+    bool equal(const self_type& that) const { return this->mPending == that.mPending; }
+    /// implement dereference/indirection operators
+    ptr_type& dereference() const { return const_cast<ptr_type&>(mPending.back()); }
+
+    /// Add the direct children of the specified node to mPending
+    void addChildren(const ptr_type& node)
+    {
+        // If we just use push_back() for each child in turn, we'll end up
+        // processing children in reverse order. We don't want to assume
+        // CHILDITER is reversible: some of the linked trees we'll be
+        // processing manage their children using singly-linked lists. So
+        // figure out how many children there are, grow mPending by that size
+        // and reverse-copy the children into the new space.
+        CHILDITER chi = mBeginFunc(node), chend = mEndFunc(node);
+        // grow mPending by the number of children
+        mPending.resize(mPending.size() + std::distance(chi, chend));
+        // reverse-copy the children into the newly-expanded space
+        std::copy(chi, chend, mPending.rbegin());
+    }
+
+    /// list of the nodes yet to be processed
+    list_type mPending;
+    /// functor to extract begin() child iterator
+    func_type mBeginFunc;
+    /// functor to extract end() child iterator
+    func_type mEndFunc;
+	/// flag which controls traversal of children (skip children of current node if true)
+	bool	mSkipChildren;
+};
+
+/**
+ * Instantiated with a tree node, typically the root, LLTreeDFSPostIter
+ * "flattens" a depth-first tree walk through that node and all its
+ * descendants. Whereas LLTreeDFSIter visits each node before visiting any of
+ * its children, LLTreeDFSPostIter visits all of a node's children before
+ * visiting the node itself.
+ *
+ * The begin() LLTreeDFSPostIter must be instantiated with functors to obtain
+ * from a given node begin() and end() iterators for that node's children. For
+ * this reason, you must specify the type of the node's child iterator as an
+ * additional template parameter.
+ *
+ * Specifically, the begin functor must return an iterator whose dereferenced
+ * value is a @em pointer to a child tree node. For instance, if each node
+ * tracks its children in an STL container of node* pointers, you can simply
+ * return that container's begin() iterator.
+ *
+ * Alternatively, if a node tracks its children with a classic linked list,
+ * write a functor returning LLLinkedIter<NODE>.
+ *
+ * The end() LLTreeDFSPostIter must, of course, match the begin() iterator's
+ * template parameters, but is constructed without runtime parameters.
+ */
+template <class NODE, typename CHILDITER>
+class LLTreeDFSPostIter: public LLBaseIter<LLTreeDFSPostIter<NODE, CHILDITER>, NODE>
+{
+    typedef LLBaseIter<LLTreeDFSPostIter<NODE, CHILDITER>, NODE> super;
+    typedef typename super::self_type self_type;
+protected:
+    typedef typename super::ptr_type ptr_type;
+    // The func_type is different for this: from a NODE pointer, we must
+    // obtain a CHILDITER.
+    typedef boost::function<CHILDITER(const ptr_type&)> func_type;
+private:
+    // Upon reaching a given node in our pending list, we need to know whether
+    // we've already pushed that node's children, so we must associate a bool
+    // with each node pointer.
+    typedef std::vector< std::pair<ptr_type, bool> > list_type;
+public:
+    /// Instantiate an LLTreeDFSPostIter to start a depth-first walk. Pass
+    /// functors to extract the 'child begin' and 'child end' iterators from
+    /// each node.
+    LLTreeDFSPostIter(const ptr_type& node, const func_type& beginfunc, const func_type& endfunc):
+        mBeginFunc(beginfunc),
+        mEndFunc(endfunc)
+    {
+        if (! node)
+            return;
+        mPending.push_back(typename list_type::value_type(node, false));
+        makeCurrent();
+    }
+    /// Instantiate an LLTreeDFSPostIter to mark the end of the walk
+    LLTreeDFSPostIter() {}
+
+private:
+    /// leverage boost::iterator_facade
+    friend class boost::iterator_core_access;
+
+    /// advance
+    /// This implementation is due to http://en.wikipedia.org/wiki/Depth-first_search
+    void increment()
+    {
+        // Pop the previous current node
+        mPending.pop_back();
+        makeCurrent();
+    }
+    /// equality
+    bool equal(const self_type& that) const { return this->mPending == that.mPending; }
+    /// implement dereference/indirection operators
+    ptr_type& dereference() const { return const_cast<ptr_type&>(mPending.back().first); }
+
+    /// Call this each time we change mPending.back() -- that is, every time
+    /// we're about to change the value returned by dereference(). If we
+    /// haven't yet pushed the new node's children, do so now.
+    void makeCurrent()
+    {
+        // Once we've popped the last node, this becomes a no-op.
+        if (mPending.empty())
+            return;
+        // Here mPending.back() holds the node pointer we're proposing to
+        // dereference next. Have we pushed that node's children yet?
+        if (mPending.back().second)
+            return;                 // if so, it's okay to visit this node now
+        // We haven't yet pushed this node's children. Do so now. Remember
+        // that we did -- while the node in question is still back().
+        mPending.back().second = true;
+        addChildren(mPending.back().first);
+        // Now, because we've just changed mPending.back(), make that new node
+        // current.
+        makeCurrent();
+    }
+
+    /// Add the direct children of the specified node to mPending
+    void addChildren(const ptr_type& node)
+    {
+        // If we just use push_back() for each child in turn, we'll end up
+        // processing children in reverse order. We don't want to assume
+        // CHILDITER is reversible: some of the linked trees we'll be
+        // processing manage their children using singly-linked lists. So
+        // figure out how many children there are, grow mPending by that size
+        // and reverse-copy the children into the new space.
+        CHILDITER chi = mBeginFunc(node), chend = mEndFunc(node);
+        // grow mPending by the number of children
+        mPending.resize(mPending.size() + std::distance(chi, chend));
+        // Reverse-copy the children into the newly-expanded space. We can't
+        // just use std::copy() because the source is a ptr_type, whereas the
+        // dest is a pair of (ptr_type, bool).
+        for (typename list_type::reverse_iterator pi = mPending.rbegin(); chi != chend; ++chi, ++pi)
+        {
+            pi->first = *chi;       // copy the child pointer
+            pi->second = false;     // we haven't yet pushed this child's chldren
+        }
+    }
+
+    /// list of the nodes yet to be processed
+    list_type mPending;
+    /// functor to extract begin() child iterator
+    func_type mBeginFunc;
+    /// functor to extract end() child iterator
+    func_type mEndFunc;
+};
+
+/**
+ * Instantiated with a tree node, typically the root, LLTreeBFSIter "flattens"
+ * a breadth-first tree walk through that node and all its descendants.
+ *
+ * The begin() LLTreeBFSIter must be instantiated with functors to obtain from
+ * a given node the begin() and end() iterators of that node's children. For
+ * this reason, you must specify the type of the node's child iterator as an
+ * additional template parameter.
+ *
+ * Specifically, the begin functor must return an iterator whose dereferenced
+ * value is a @em pointer to a child tree node. For instance, if each node
+ * tracks its children in an STL container of node* pointers, you can simply
+ * return that container's begin() iterator.
+ *
+ * Alternatively, if a node tracks its children with a classic linked list,
+ * write a functor returning LLLinkedIter<NODE>.
+ *
+ * The end() LLTreeBFSIter must, of course, match the begin() iterator's
+ * template parameters, but is constructed without runtime parameters.
+ */
+template <class NODE, typename CHILDITER>
+class LLTreeBFSIter: public LLBaseIter<LLTreeBFSIter<NODE, CHILDITER>, NODE>
+{
+    typedef LLBaseIter<LLTreeBFSIter<NODE, CHILDITER>, NODE> super;
+    typedef typename super::self_type self_type;
+protected:
+    typedef typename super::ptr_type ptr_type;
+    // The func_type is different for this: from a NODE pointer, we must
+    // obtain a CHILDITER.
+    typedef boost::function<CHILDITER(const ptr_type&)> func_type;
+private:
+    // We need a FIFO queue rather than a LIFO stack. Use a deque rather than
+    // a vector, since vector can't implement pop_front() efficiently.
+    typedef std::deque<ptr_type> list_type;
+public:
+    /// Instantiate an LLTreeBFSIter to start a depth-first walk. Pass
+    /// functors to extract the 'child begin' and 'child end' iterators from
+    /// each node.
+    LLTreeBFSIter(const ptr_type& node, const func_type& beginfunc, const func_type& endfunc):
+        mBeginFunc(beginfunc),
+        mEndFunc(endfunc)
+    {
+        if (node)
+            mPending.push_back(node);
+    }
+    /// Instantiate an LLTreeBFSIter to mark the end of the walk
+    LLTreeBFSIter() {}
+
+private:
+    /// leverage boost::iterator_facade
+    friend class boost::iterator_core_access;
+
+    /// advance
+    /// This implementation is due to http://en.wikipedia.org/wiki/Breadth-first_search
+    void increment()
+    {
+        // Capture the node we were just looking at
+        ptr_type current = mPending.front();
+        // Remove it from mPending so we don't process it again later
+        mPending.pop_front();
+        // Add all its children to mPending
+        CHILDITER chend = mEndFunc(current);
+        for (CHILDITER chi = mBeginFunc(current); chi != chend; ++chi)
+            mPending.push_back(*chi);
+    }
+    /// equality
+    bool equal(const self_type& that) const { return this->mPending == that.mPending; }
+    /// implement dereference/indirection operators
+    ptr_type& dereference() const { return const_cast<ptr_type&>(mPending.front()); }
+
+    /// list of the nodes yet to be processed
+    list_type mPending;
+    /// functor to extract begin() child iterator
+    func_type mBeginFunc;
+    /// functor to extract end() child iterator
+    func_type mEndFunc;
+};
+
+/**
+ * When you want to select between LLTreeDFSIter, LLTreeDFSPostIter and
+ * LLTreeBFSIter with a compile-time discriminator, use LLTreeWalkIter with an
+ * LLTreeIter::WalkIter template arg.
+ */
+template <LLTreeIter::WalkIter DISCRIM, class NODE, typename CHILDITER>
+class LLTreeWalkIter
+{
+    enum { use_a_valid_LLTreeIter_WalkIter_value = false };
+public:
+    /// Bogus constructors for default (unrecognized discriminator) case
+    template <typename TYPE1, typename TYPE2>
+    LLTreeWalkIter(TYPE1, TYPE2)
+    {
+        BOOST_STATIC_ASSERT(use_a_valid_LLTreeIter_WalkIter_value);
+    }
+    LLTreeWalkIter()
+    {
+        BOOST_STATIC_ASSERT(use_a_valid_LLTreeIter_WalkIter_value);
+    }
+};
+
+/// Specialize for LLTreeIter::DFS_PRE
+template <class NODE, typename CHILDITER>
+class LLTreeWalkIter<LLTreeIter::DFS_PRE, NODE, CHILDITER>:
+    public LLTreeDFSIter<NODE, CHILDITER>
+{
+    typedef LLTreeDFSIter<NODE, CHILDITER> super;
+public:
+    /// forward begin ctor
+    LLTreeWalkIter(const typename super::ptr_type& node,
+                   const typename super::func_type& beginfunc,
+                   const typename super::func_type& endfunc):
+        super(node, beginfunc, endfunc)
+    {}
+    /// forward end ctor
+    LLTreeWalkIter():
+        super()
+    {}
+};
+
+/// Specialize for LLTreeIter::DFS_POST
+template <class NODE, typename CHILDITER>
+class LLTreeWalkIter<LLTreeIter::DFS_POST, NODE, CHILDITER>:
+    public LLTreeDFSPostIter<NODE, CHILDITER>
+{
+    typedef LLTreeDFSPostIter<NODE, CHILDITER> super;
+public:
+    /// forward begin ctor
+    LLTreeWalkIter(const typename super::ptr_type& node,
+                   const typename super::func_type& beginfunc,
+                   const typename super::func_type& endfunc):
+        super(node, beginfunc, endfunc)
+    {}
+    /// forward end ctor
+    LLTreeWalkIter():
+        super()
+    {}
+};
+
+/// Specialize for LLTreeIter::BFS
+template <class NODE, typename CHILDITER>
+class LLTreeWalkIter<LLTreeIter::BFS, NODE, CHILDITER>:
+    public LLTreeBFSIter<NODE, CHILDITER>
+{
+    typedef LLTreeBFSIter<NODE, CHILDITER> super;
+public:
+    /// forward begin ctor
+    LLTreeWalkIter(const typename super::ptr_type& node,
+                   const typename super::func_type& beginfunc,
+                   const typename super::func_type& endfunc):
+        super(node, beginfunc, endfunc)
+    {}
+    /// forward end ctor
+    LLTreeWalkIter():
+        super()
+    {}
+};
+
+#endif /* ! defined(LL_LLTREEITERATORS_H) */