diff -u -r -x 'unxlng*' configmgr/source/backend/binaryreadhandler.cxx configmgr/source/backend/binaryreadhandler.cxx
--- configmgr/source/backend/binaryreadhandler.cxx	2006-06-20 00:18:33.000000000 +0100
+++ configmgr/source/backend/binaryreadhandler.cxx	2006-09-14 14:56:37.000000000 +0100
@@ -78,6 +78,8 @@
         , m_aNodeFactory()
         , m_aComponentName(_aComponentName)
 		{
+			for (int i = 0; i < LastEntry; i++)
+				m_nInsert[i] = 0;
 		}
 		// -----------------------------------------------------------------------------
 		BinaryReadHandler::~BinaryReadHandler()
@@ -283,6 +285,21 @@
 			m_BinaryReader.read (_aString);
 		}
 
+		void BinaryReadHandler::readName(rtl::OUString &_aString, NamePool ePool)
+			SAL_THROW( (io::IOException, uno::RuntimeException) )
+		{
+			m_BinaryReader.read (_aString);
+			const int nElems = (sizeof (m_aPreviousName[0])
+								/ sizeof (m_aPreviousName[0][0]));
+			for (int i = 0; i < nElems; i++)
+			{
+				if (m_aPreviousName[ePool][i] == _aString)
+					_aString = m_aPreviousName[ePool][i];
+			}
+			m_aPreviousName[ePool][m_nInsert[ePool]++] = _aString;
+			m_nInsert[ePool] %= nElems;
+		}
+
 		// -----------------------------------------------------------------------------
 		void BinaryReadHandler::readAttributes(node::Attributes  &_aAttributes)
 			SAL_THROW( (io::IOException, uno::RuntimeException) )
@@ -311,7 +344,7 @@
 			SAL_THROW( (io::IOException, uno::RuntimeException) )
 		{
 			readAttributes(_aAttributes);
-			readString(_aName);
+			readName(_aName, GroupName);
 		}
 		// -----------------------------------------------------------------------------	
 		void BinaryReadHandler::readSet(rtl::OUString &_aName, node::Attributes &_aAttributes,
@@ -319,9 +352,9 @@
 			SAL_THROW( (io::IOException, uno::RuntimeException) )
 		{
 			readAttributes(_aAttributes);
-			readString(_aName);
-			readString(_sInstanceName);
-			readString(_sInstanceModule);	
+			readName(_aName, SetName);
+			readName(_sInstanceName, InstanceName);
+			readName(_sInstanceModule, InstanceModule);
 		}
 			
 		// -----------------------------------------------------------------------------
@@ -421,7 +454,7 @@
 
 			ValueFlags::Type eBasicType = readValueFlags(bSeq, bHasValue, bHasDefault);
 			readAttributes(_aAttributes);
-			readString(_aName);
+			readName(_aName, ValueName);
 			
 			if (!bSeq && (bHasValue || bHasDefault))
 			{
diff -u -r -x 'unxlng*' configmgr/source/backend/binaryreadhandler.hxx configmgr/source/backend/binaryreadhandler.hxx
--- configmgr/source/backend/binaryreadhandler.hxx	2006-01-19 17:52:58.000000000 +0000
+++ configmgr/source/backend/binaryreadhandler.hxx	2006-09-14 14:55:49.000000000 +0100
@@ -95,6 +95,18 @@
 			BinaryReader         m_BinaryReader;	
             ComponentDataFactory m_aNodeFactory;
             rtl::OUString        m_aComponentName;
+
+			// pool recent strings for re-use
+			enum NamePool {
+					GroupName,
+					SetName,
+					InstanceName,
+					InstanceModule,
+					ValueName,
+					LastEntry
+			};
+			int           m_nInsert[LastEntry];
+			rtl::OUString m_aPreviousName[LastEntry][16];
 		public:
 			BinaryReadHandler(rtl::OUString const & _aFileURL, rtl::OUString const & _aComponentName, MultiServiceFactory const & _aFactory);
 			~BinaryReadHandler();
@@ -154,8 +166,10 @@
 			void readValue(rtl::OUString &_aName, node::Attributes &_aAttributes,
 											  uno::Any& _aValue, uno::Any& _aDefaultValue,uno::Type& _aType)
 			    SAL_THROW( (io::IOException, uno::RuntimeException) );
-			
+
+			void readName(rtl::OUString &_aString, NamePool ePool)
+				SAL_THROW( (io::IOException, uno::RuntimeException) );
 		};
 	// ---------------------------------------------------------------------------
 	}


--- configmgr/source/data/types.cxx	2005-12-28 17:29:35.000000000 +0000
+++ configmgr/source/data/types.cxx	2006-09-09 13:02:04.000000000 +0100
@@ -60,26 +60,6 @@
 //-----------------------------------------------------------------------------	
         using memory::Allocator;
         using memory::Accessor;
-//-----------------------------------------------------------------------------	
-HeapSize const c_nDataOffset        = sizeof(sal_Int32);
-HeapSize const c_nStringCharSize    = sizeof(sal_Unicode);
-//-----------------------------------------------------------------------------	
-static inline
-sal_Int32& implGetLength(Allocator const& _anAllocator, String _aString)
-{
-    OSL_ASSERT(_aString != 0);
-    void * pBase = _anAllocator.access(_aString);
-    return * static_cast<sal_Int32 *>(pBase);
-}
-
-//-----------------------------------------------------------------------------	
-static inline
-sal_Int32 implGetLength(Accessor const& _anAccessor, String _aString)
-{
-    OSL_ASSERT(_aString != 0);
-    void const * pBase = _anAccessor.access( memory::Pointer(_aString) );
-    return * static_cast<sal_Int32 const *>(pBase);
-}
 
 //-----------------------------------------------------------------------------	
 //-----------------------------------------------------------------------------	
@@ -88,83 +68,57 @@
 
 Name allocName(Allocator const& _anAllocator, rtl::OUString const & _sString)
 {
-    return allocString(_anAllocator, _sString);
+	rtl_uString_acquire(_sString.pData);
+	return _sString.pData;
 }
 //-----------------------------------------------------------------------------	
 // Name copyName(Allocator const& _anAllocator, Name _aName);
 //-----------------------------------------------------------------------------	
 
-void freeName(Allocator const& _anAllocator, Name _aName)
+void freeName(memory::Allocator const& _anAllocator, Name _aName)
 {
-    freeString(_anAllocator, _aName);
+	rtl_uString_release(_aName);
 }
+
 //-----------------------------------------------------------------------------	
 
-::rtl::OUString readName(Accessor const& _anAccessor, Name _aName)
+::rtl::OUString readName(memory::Accessor const& _anAccessor, Name _aName)
 {
-    return readString(_anAccessor, _aName);
+	return rtl::OUString(_aName);
 }
+
 //-----------------------------------------------------------------------------	
 
-NameChar const * accessName(Accessor const& _anAccessor, Name _aName)
+NameChar const * accessName(memory::Accessor const& _anAccessor, Name _aName)
 {
-    return accessString(_anAccessor, _aName);
+	return _aName->buffer;
 }
+
 //-----------------------------------------------------------------------------	
 //-----------------------------------------------------------------------------	
 
 String allocString(Allocator const& _anAllocator, rtl::OUString const & _sString)
 {
-    sal_Int32 nLength = _sString.getLength();
-    HeapSize nTextSize = HeapSize(nLength + 1) * c_nStringCharSize;
-
-    String anAddress = _anAllocator.allocate(c_nDataOffset + nTextSize);
-    if (anAddress)
-    {
-        implGetLength(_anAllocator, anAddress) = nLength;
-
-        void * pData = _anAllocator.access(anAddress + c_nDataOffset);
-        ::memcpy(pData, _sString.getStr(), nTextSize);
-    }
-    return anAddress;
+	return allocName(_anAllocator, _sString);
 }
-//-----------------------------------------------------------------------------	
-
-//String copyString(Allocator const& _anAllocator, String _aString);
 
 //-----------------------------------------------------------------------------	
 
 void freeString(Allocator const& _anAllocator, String _aString)
 {
-    _anAllocator.deallocate(_aString);
+	return freeName(_anAllocator, _aString);
 }
 //-----------------------------------------------------------------------------	
 
 ::rtl::OUString readString(Accessor const& _anAccessor, String _aString)
 {
-    OSL_ENSURE(_aString, "Trying to read a NULL string");
-    if (!_aString) return rtl::OUString();
-
-    sal_Int32 nLength = implGetLength(_anAccessor, _aString);
-
-    void const * pData = _anAccessor.access( memory::Pointer(_aString + c_nDataOffset) );
-
-    sal_Unicode const * pText = static_cast<sal_Unicode const *>(pData);
-
-    return rtl::OUString(pText,nLength);
+	return readName(_anAccessor, _aString);
 }
 //-----------------------------------------------------------------------------	
 
 StringChar const * accessString(Accessor const& _anAccessor, String _aString)
 {
-    OSL_ENSURE(_aString, "Trying to read a NULL string");
-    if (!_aString) return NULL;
-
-    void const * pData = _anAccessor.access( memory::Pointer(_aString + c_nDataOffset) );
-
-    sal_Unicode const * pText = static_cast<sal_Unicode const *>(pData);
-
-    return pText;
+	return accessName(_anAccessor, _aString);
 }
 //-----------------------------------------------------------------------------	
     }
diff -u -r -x 'unxlng*' configmgr/source/inc/types.hxx configmgr/source/inc/types.hxx
--- configmgr/source/inc/types.hxx	2005-12-28 17:31:06.000000000 +0000
+++ configmgr/source/inc/types.hxx	2006-09-09 13:00:18.000000000 +0100
@@ -43,6 +43,9 @@
 #ifndef _SAL_TYPES_H_
 #include <sal/types.h>
 #endif
+#ifndef _RTL_USTRING_H_
+#include <rtl/ustring.h>
+#endif
 
 //-----------------------------------------------------------------------------
 namespace rtl { class OUString; }
@@ -65,8 +68,8 @@
         typedef sal_uInt8  Byte;  
 
     // some derived types 
-        typedef Address Name;    // points to counted sequence of char (7-bit ASCII) (!?)
-        typedef Address String;  // points to counted sequence of sal_Unicode
+        typedef rtl_uString *  Name;
+        typedef rtl_uString *  String;
         typedef Address List;    // singly linked intrusive, used for set elements
         typedef Address Vector;   // points to counted sequence of some type
 
@@ -75,7 +78,6 @@
         // for now Name == String
         typedef sal_Unicode NameChar;
         Name allocName(memory::Allocator const& _anAllocator, ::rtl::OUString const & _sString);
-        // Name copyName(memory::Allocator const& _anAllocator, Name _aName);
         void freeName(memory::Allocator const& _anAllocator, Name _aName);
         ::rtl::OUString readName(memory::Accessor const& _anAccessor, Name _aName);
         NameChar const * accessName(memory::Accessor const& _anAccessor, Name _aName);
@@ -84,7 +86,6 @@
 
         typedef sal_Unicode StringChar;
         String allocString(memory::Allocator const& _anAllocator, ::rtl::OUString const & _sString);
-        // String copyString(memory::Allocator const& _anAllocator, String _aString);
         void   freeString(memory::Allocator const& _anAllocator, String _aString);
         ::rtl::OUString readString(memory::Accessor const& _anAccessor, String _aString);
         StringChar const * accessString(memory::Accessor const& _anAccessor, String _aString);
diff -u -r -x 'unxlng*' configmgr/source/tree/node.cxx configmgr/source/tree/node.cxx
--- configmgr/source/tree/node.cxx	2006-06-20 00:29:34.000000000 +0100
+++ configmgr/source/tree/node.cxx	2006-08-24 13:09:04.000000000 +0100
@@ -33,6 +33,7 @@
  *
  ************************************************************************/
 
+#include "types.hxx"
 #include "node.hxx"
 
 #ifndef INCLUDED_SHARABLE_ANYDATA_HXX
@@ -78,7 +79,7 @@
 
 rtl::OUString NodeInfo::getName(memory::Accessor const & _aAccessor) const
 {
-    return readString(_aAccessor,this->name);
+    return readName(_aAccessor,this->name);
 }
 //-----------------------------------------------------------------------------
 
@@ -406,7 +407,7 @@
 
 bool Node::isNamed(rtl::OUString const & _aName, memory::Accessor const & _aAccessor) const
 {
-    return 0 == rtl_ustr_compare(_aName.getStr(),accessString(_aAccessor,node.info.name));
+    return 0 == rtl_ustr_compare(_aName.getStr(),accessName(_aAccessor,node.info.name));
 }
 //-----------------------------------------------------------------------------
 
