Commits

Anonymous committed 26ba3c0

CWS-TOOLING: integrate CWS sb109
2009-04-21 13:42:45 +0200 sb r271035 : removed obsolete psprint dependency
2009-04-21 10:33:31 +0200 sb r271024 : changes to previous -c270971 so that build does not break for USE_SHELL!=bash (but instead resulting bridgetest_xxx scripts are nonfunctional)
2009-04-21 08:56:48 +0200 sb r271017 : merged in cws/sb107 -c 268250 (avoid warnings about format specifier and argument mismatch (on 64bit debug builds))
2009-04-20 16:42:27 +0200 sb r270995 : #i98625# add make_xxx functions for C++ representations of UNO polystructs; fixed and adapted tests (patch by thb, slightly adapted)
2009-04-20 14:23:45 +0200 sb r270981 : #i84751# selective performance improvements (patch by mmeeks, slightly adapted)
2009-04-20 13:39:50 +0200 sb r270978 : #i99711# removed dead code (patch by cmc, slightly modified)
2009-04-20 11:59:39 +0200 sb r270972 : #i97975# avoid crashes during shutdown (patch by cmc, slightly modified)
2009-04-20 11:57:52 +0200 sb r270971 : made tests work again after LD_LIBRARY_PATH clean up
2009-04-20 09:49:32 +0200 sb r270963 : #i95593# made tests work again after LD_LIBRARY_PATH cleanup
2009-04-17 13:52:33 +0200 sb r270941 : merged in cws/sb107 -c 270023 (added svn:ignore)
2009-04-15 13:46:24 +0200 sb r270841 : #i92131# dead code elimination (based on a patch by cmc)
2009-04-15 13:29:27 +0200 sb r270839 : #i100743# use a FastLess for the Data map (based on a patch my mmeeks)
2009-04-15 13:12:11 +0200 sb r270837 : #i100583# dead code elimination (patch by cmc)
2009-04-15 13:02:19 +0200 sb r270835 : avoid bogus Solaris C++ compiler warning when building with debug=x
2009-04-15 11:49:46 +0200 sb r270828 : adapted to cleared LD_LIBRARY_PATH
2009-04-15 10:49:48 +0200 sb r270826 : #i101101# for performance reasons, do not put ComponentContext in unsafe appartment
2009-04-15 10:08:20 +0200 sb r270824 : #i99113# removed duplicated stocservices.uno lib from basis layer

  • Participants
  • Parent commits 0169223

Comments (0)

Files changed (57)

bridges/source/remote/urp/urp_environment.cxx

 {
 	~StaticSingleton()
 		{
+            ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() );
 			g_bStaticDestructorsCalled = sal_True;
 		}
 };
   	}
 	// in case, that the static destructors already have been called, no
 	// tiding up is done.
-	if( ! g_bStaticDestructorsCalled  && ! pContext->m_pBridgeImpl->m_bDisposed )
+    bool tidyUp;
+    {
+        ::osl::MutexGuard guard2( ::osl::Mutex::getGlobalMutex() );
+        tidyUp = ! g_bStaticDestructorsCalled &&
+            ! pContext->m_pBridgeImpl->m_bDisposed;
+    }
+	if( tidyUp )
 	{
 		// TODO : not threadsafe
 		// synchronization with dispatch methods needed !
             pImpl->m_pReader = 0;
 		}
 
-		// delete the stubs
-		releaseStubs( pEnvRemote );
-
+        ::osl::MutexGuard guard2( ::osl::Mutex::getGlobalMutex() );
+        if( ! g_bStaticDestructorsCalled )
+        {
+            // delete the stubs
+            releaseStubs( pEnvRemote );
+        }
 	}
 }
 

bridges/test/java_uno/acquire/makefile.mk

     $(GIVE_EXEC_RIGHTS) $@
 
 $(BIN)$/testacquire-native-client$(SCRIPTEXT):
-    echo uno -c com.sun.star.test.bridges.testacquire.impl -l $(SHL1TARGETN:f) \
-        -ro $(TARGET).rdb -- $(TEST_JAVAUNO_ACQUIRE_UNO_URL) > $@
+    echo '$(AUGMENT_LIBRARY_PATH)' uno \
+        -c com.sun.star.test.bridges.testacquire.impl \
+        -l ../lib/$(SHL1TARGETN:f) -ro $(TARGET).rdb -- \
+        $(TEST_JAVAUNO_ACQUIRE_UNO_URL) > $@
     $(GIVE_EXEC_RIGHTS) $@
 
 $(BIN)$/testacquire-native-server$(SCRIPTEXT):
-    echo uno -c com.sun.star.test.bridges.testacquire.impl -l $(SHL1TARGETN:f) \
-        -ro $(TARGET).rdb -u $(TEST_JAVAUNO_ACQUIRE_UNO_URL) --singleaccept > $@
+    echo '$(AUGMENT_LIBRARY_PATH)' uno \
+        -c com.sun.star.test.bridges.testacquire.impl \
+        -l ../lib/$(SHL1TARGETN:f) -ro $(TARGET).rdb \
+        -u $(TEST_JAVAUNO_ACQUIRE_UNO_URL) --singleaccept > $@
     $(GIVE_EXEC_RIGHTS) $@

bridges/test/java_uno/any/makefile.mk

 
 $(OUT)$/bin$/TestJni$(SCRIPTEXT) : $(JAVACLASSFILES)
     -rm -f $@
-    echo java -classpath \
+    echo '$(AUGMENT_LIBRARY_PATH)' java -classpath \
         .$(PATH_SEPERATOR)..$/class$(PATH_SEPERATOR)$(EXEC_CLASSPATH) \
         -Djava.library.path=..$/lib test.java_uno.anytest.TestJni >> $@
     $(GIVE_EXEC_RIGHTS) $@

bridges/test/java_uno/equals/TestEquals.java

                                             loader.activate(
                                                 "com.sun.star.test.bridges."
                                                 + "testequals.impl",
-                                                "", "testequals.uno", null));
+                                                "", "../lib/testequals.uno",
+                                                null));
                                     XTestInterface test = (XTestInterface)
                                         UnoRuntime.queryInterface(
                                             XTestInterface.class,

bridges/test/java_uno/equals/makefile.mk

 $(SLOFILES) $(JAVACLASSFILES): $(MISC)$/$(TARGET).rdb
 
 $(BIN)$/testequals$(SCRIPTEXT): $(BIN)$/testequals_services.rdb
-    echo java -classpath \
+    echo '$(AUGMENT_LIBRARY_PATH)' java -classpath \
         ..$/class$/test$(PATH_SEPERATOR)..$/class$(PATH_SEPERATOR)\
 ..$/class$/java_uno.jar$(PATH_SEPERATOR)$(EXEC_CLASSPATH) \
         test.java_uno.equals.TestEquals $(SOLARBINDIR)$/types.rdb \

bridges/test/java_uno/nativethreadpool/makefile.mk

     $(REGCOMP) -register -r $(MISC)$/$(TARGET)$/bootstrap.rdb \
         -c javaloader.uno$(DLLPOST) -c javavm.uno$(DLLPOST) \
         -c stocservices.uno$(DLLPOST)
-.IF "$(GUI)" == "WNT"
+.IF "$(GUI)" == "WNT" || "$(USE_SHELL)" != "bash"
     ERROR -- missing platform
 .ELSE # GUI, WNT
-    + setenv OO_JAVA_PROPERTIES RuntimeLib=$(JVM_LIB_URL) ; \
+    + export OO_JAVA_PROPERTIES='RuntimeLib=$(JVM_LIB_URL)' && \
         $(REGCOMP) -register -r $@ -c file://$(PWD)/$(BIN)$/$(TARGET).uno.jar \
         -br $(MISC)$/$(TARGET)$/bootstrap.rdb -classpath $(EXEC_CLASSPATH) \
         -env:URE_INTERNAL_JAVA_DIR=file://$(SOLARBINDIR)
 .ENDIF # GUI, WNT
 
 test .PHONY: $(SHL1TARGETN) $(BIN)$/$(TARGET).uno.jar $(BIN)$/$(TARGET).rdb
-.IF "$(GUI)" == "WNT"
+.IF "$(GUI)" == "WNT" || "$(USE_SHELL)" != "bash"
     ERROR -- missing platform
 .ELSE # GUI, WNT
-    uno -c test.javauno.nativethreadpool.server -l $(SHL2TARGETN) \
-        -ro $(BIN)$/$(TARGET).rdb \
+    $(AUGMENT_LIBRARY_PATH) uno -c test.javauno.nativethreadpool.server \
+        -l $(SHL2TARGETN) -ro $(BIN)$/$(TARGET).rdb \
         -u 'uno:socket,host=localhost,port=3830;urp;test' --singleaccept &
-    + setenv OO_JAVA_PROPERTIES RuntimeLib=$(JVM_LIB_URL) ; \
-        setenv CLASSPATH \
-        $(EXEC_CLASSPATH)$(PATH_SEPERATOR)$(BIN)$/$(TARGET).uno.jar ; \
+    + $(AUGMENT_LIBRARY_PATH) OO_JAVA_PROPERTIES='RuntimeLib=$(JVM_LIB_URL)' \
+        CLASSPATH=$(EXEC_CLASSPATH)$(PATH_SEPERATOR)$(BIN)$/$(TARGET).uno.jar \
         uno -c test.javauno.nativethreadpool.client -l $(SHL1TARGETN) \
         -ro $(BIN)$/$(TARGET).rdb \
         -env:URE_INTERNAL_JAVA_DIR=file://$(SOLARBINDIR)

bridges/test/java_uno/nativethreadpool/testnativethreadpoolclient.cxx

 
 cppu::ImplementationEntry entries[] = {
     { &create, &getImplementationName, &getSupportedServiceNames,
-      &cppu::createSingleComponentFactory, 0, 0 } };
+      &cppu::createSingleComponentFactory, 0, 0 },
+    { 0, 0, 0, 0, 0, 0 }
+};
 
 }
 

bridges/test/java_uno/nativethreadpool/testnativethreadpoolserver.cxx

 
 cppu::ImplementationEntry entries[] = {
     { &create, &getImplementationName, &getSupportedServiceNames,
-      &cppu::createSingleComponentFactory, 0, 0 } };
+      &cppu::createSingleComponentFactory, 0, 0 },
+    { 0, 0, 0, 0, 0, 0 }
+};
 
 }
 

codemaker/source/cppumaker/cpputype.cxx

 	RTFieldAccess 	access = RT_ACCESS_INVALID;
 	OString 		fieldName;
 	OString 		fieldType;	
-	sal_uInt16 		i = 0;
-
-	for (i=0; i < fieldCount; i++)
+
+	for (sal_uInt16 i=0; i < fieldCount; i++)
 	{
 		access = m_reader.getFieldFlags(i);
 		
 
 		sal_Bool superHasMember = dumpSuperMember(o, superType, sal_True);
 
-		for (i=0; i < fieldCount; i++)
+		for (sal_uInt16 i=0; i < fieldCount; i++)
 		{
 			access = m_reader.getFieldFlags(i);
 			
 			first = sal_False;
 		}
 
-		for (i=0; i < fieldCount; i++)
+		for (sal_uInt16 i=0; i < fieldCount; i++)
 		{
 			access = m_reader.getFieldFlags(i);
 			
 		o << "{\n}\n\n";
 	}
 
+    if (isPolymorphic() && fieldCount > 0) {
+        o << indent();
+        dumpTemplateHead(o);
+        o << "\n";
+        o << indent();
+        o << "inline " << m_name;
+        dumpTemplateParameters(o);
+        o << "\n";
+        o << indent();
+        o << "make_" << m_name << "(";
+        for (sal_uInt16 i = 0; i < fieldCount; ++i) {
+            if (i > 0) {
+                o << ", ";
+            }
+            rtl::OString type(
+                rtl::OUStringToOString(
+                    m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
+            if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0)
+            {
+                dumpTypeParameterName(o, type);
+                o << " const &";
+            } else {
+                dumpType(o, type, true, true);
+            }
+            o << " "
+              << rtl::OUStringToOString(
+                  m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
+              << "_";
+        }
+        o << ") SAL_THROW(())\n";
+        o << indent() << "{\n";
+        inc();
+        o << indent() << "return " << m_name;
+        dumpTemplateParameters(o);
+        o << "(";
+        for (sal_uInt16 i = 0; i < fieldCount; ++i) {
+            if (i > 0) {
+                o << ", ";
+            }
+            o << rtl::OUStringToOString(
+                  m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
+              << "_";
+        }
+        o << ");\n";
+        dec();
+        o << indent() << "}\n\n";
+    }
+
     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
         o << "\n";
     }

codemaker/test/cppumaker/makefile.mk

 $(MISC)$/$(TARGET).cppumaker.flag: $(BIN)$/cppumaker$(EXECPOST)
 $(MISC)$/$(TARGET).cppumaker.flag: $(MISC)$/$(TARGET).rdb
     - $(MKDIRHIER) $(MISC)$/$(TARGET)$/inc
-    $(BIN)$/cppumaker$(EXECPOST) -O$(MISC)$/$(TARGET)$/inc -BUCR -C $< \
-        $(SOLARBINDIR)$/udkapi.rdb
+    $(AUGMENT_LIBRARY_PATH) $(BIN)$/cppumaker$(EXECPOST) \
+        -O$(MISC)$/$(TARGET)$/inc -BUCR -C $< $(SOLARBINDIR)$/udkapi.rdb
     $(TOUCH) $@
 
 $(MISC)$/$(TARGET).rdb: $(MISC)$/$(TARGET)$/types.urd
     $(IDLC) -O$(MISC)$/$(TARGET) -I$(SOLARIDLDIR) -cid -we $<
 
 test .PHONY: $(SHL1TARGETN)
-    testshl2 $<
+    $(AUGMENT_LIBRARY_PATH) testshl2 $<

codemaker/test/cppumaker/test_codemaker_cppumaker.cxx

 public:
     void testBigStruct();
 
-    void testPolyCharStruct();
+    void testPolyStruct();
 
     void testExceptions();
 
 
     CPPUNIT_TEST_SUITE(Test);
     CPPUNIT_TEST(testBigStruct);
-    CPPUNIT_TEST(testPolyCharStruct);
+    CPPUNIT_TEST(testPolyStruct);
     CPPUNIT_TEST(testExceptions);
     CPPUNIT_TEST(testConstants);
     CPPUNIT_TEST_SUITE_END();
     CPPUNIT_ASSERT_EQUAL(guard.p->m22.getLength(), static_cast< sal_Int32 >(0));
     CPPUNIT_ASSERT_EQUAL(guard.p->m23.getLength(), static_cast< sal_Int32 >(0));
 
-#if defined __GNUC__ && __GNUC__ >= 3
+#if defined __GNUC__ && __GNUC__ >= 3 // see CPPU_GCC3_ALIGN
     CPPUNIT_ASSERT_EQUAL(
+#if defined X86_64
+        static_cast< std::size_t >(24),
+#else
         static_cast< std::size_t >(16),
+#endif
         sizeof (test::codemaker::cppumaker::AlignmentDerivedStruct));
 #endif
     
     CPPUNIT_ASSERT_EQUAL(typelib_TypeClass_CHAR, std->aBase.ppTypeRefs[10]->eTypeClass); // char m11;
 }
 
-void Test::testPolyCharStruct() {
+void Test::testPolyStruct() {
     CPPUNIT_ASSERT_EQUAL(
         rtl::OUString(
             RTL_CONSTASCII_USTRINGPARAM(
         (com::sun::star::uno::makeAny(
             test::codemaker::cppumaker::Struct< sal_Unicode, sal_Int16 >()).
          getValueType().getTypeName()));
+    CPPUNIT_ASSERT_EQUAL(
+        (test::codemaker::cppumaker::make_Struct< sal_uInt32, sal_Bool >(5, 0).
+         member1),
+        static_cast< sal_uInt32 >(5));
 }
 
 namespace {

codemaker/test/cppumaker/types.idl

  *
  ************************************************************************/
 
-//TODO: Do not depend on types for which C++ header files are only generated
-// later in the build process in offuh:
+/*TODO: Do not depend on types for which C++ header files are only generated
+  later in the build process in offuh: */
 #include "com/sun/star/lang/ClassNotFoundException.idl"
 #include "com/sun/star/lang/IllegalAccessException.idl"
 #include "com/sun/star/lang/Locale.idl"

configmgr/qa/unit/makefile.mk

 
 $(MISC)$/$(TARGET).rdb .ERRREMOVE:
     $(COPY) $(SOLARBINDIR)$/types.rdb $@
-    regcomp -register -r $@ -c $(subst,$/,/ $(DLLDEST)$/configmgr2.uno$(DLLPOST))
-    regcomp -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/sax.uno$(DLLPOST))
-    regcomp -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/stocservices.uno$(DLLPOST))
-    regcomp -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/streams.uno$(DLLPOST))
+    $(REGCOMP) -register -r $@ -c $(subst,$/,/ $(DLLDEST)$/configmgr2.uno$(DLLPOST))
+    $(REGCOMP) -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/sax.uno$(DLLPOST))
+    $(REGCOMP) -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/stocservices.uno$(DLLPOST))
+    $(REGCOMP) -register -r $@ -c $(subst,$/,/ $(SOLARLIBDIR)/streams.uno$(DLLPOST))
 
 test .PHONY: $(SHL1TARGETN) $(MISC)$/$(TARGET).rdb
-    testshl2 $(SHL1TARGETN) -forward "$(MISC)$/$(TARGET).rdb#$(PWD)$/$(MISC)$/$(TARGET).registry"
+    $(AUGMENT_LIBRARY_PATH) testshl2 $(SHL1TARGETN) -forward "$(MISC)$/$(TARGET).rdb#$(PWD)$/$(MISC)$/$(TARGET).registry"

configmgr/source/api2/apiaccessobj.hxx

 
 			mutable ApiTreeImpl 	m_aTree;
 		public:
-			OSetElement(uno::XInterface* pUnoThis, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl& rParentTree)
-			: m_aTree(pUnoThis, aTree,rParentTree)
-			{}
 			OSetElement(uno::XInterface* pUnoThis, rtl::Reference< configuration::Tree > const& aTree, ApiProvider& rProvider, ApiTreeImpl* pParentTree = 0)
 			: m_aTree(pUnoThis, rProvider,aTree,pParentTree)
 			{}

configmgr/source/api2/apifactory.cxx

 }
 //-----------------------------------------------------------------------------
 
-uno::Reference< uno::XInterface > Factory::makeUnoGroupMember(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode)
-{
-	return implToUno(makeGroupMember(aTree,aNode));
-}
-//-----------------------------------------------------------------------------
-NodeElement* Factory::makeGroupMember(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode)
-{
-	OSL_PRECOND( !configuration::isEmpty(aTree.get()) , "ERROR: Configuration: Creating an object requires a valid tree");
-	if (configuration::isEmpty(aTree.get())) return 0;
-
-	OSL_PRECOND( aNode.isValid() , "ERROR: Configuration: Creating an object requires a valid node");
-	OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
-	if (!aTree->isValidNode(aNode.getOffset())) return 0;
-
-	OSL_PRECOND( configuration::isStructuralNode(aTree,aNode), "ERROR: Configuration: Cannot make object for value node");
-	OSL_ENSURE(!aTree->isRootNode(aNode),"INTERNAL ERROR: Root of Tree should not be used for a group member object");
-
-	configuration::NodeID aNodeID(aTree,aNode);
-	NodeElement* pRet = findElement(aNodeID);
-	if (0 == pRet)
-	{
-		rtl::Reference<configuration::Template> aTemplate = implGetSetElementTemplate(aTree,aNode);
-
-		pRet = doCreateGroupMember(aTree,aNode,aTemplate.get());
-
-		OSL_ENSURE( pRet,"WARNING: New API object could not be created");
-
-		implHaveNewElement(aNodeID,pRet);
-	}
-	return pRet;
-}
-//-----------------------------------------------------------------------------
-
 uno::Reference< uno::XInterface > Factory::makeUnoSetElement(rtl::Reference< configuration::ElementTree > const& aElementTree)
 {
 	uno::Reference< uno::XInterface > aRet = implToUno(makeSetElement(aElementTree));

configmgr/source/api2/apifactory.hxx

 			uno::Reference< uno::XInterface > makeUnoElement(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode);
 			uno::Reference< uno::XInterface > findUnoElement(configuration::NodeID const& aNode);
 
-			uno::Reference< uno::XInterface > makeUnoGroupMember(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode);
 			uno::Reference< uno::XInterface > makeUnoSetElement(rtl::Reference< configuration::ElementTree > const& aTree);
 
 			NodeElement* makeElement(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode);
 			NodeElement* findElement(configuration::NodeID const& aNode);
 
-			NodeElement*	makeGroupMember(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode);
 			TreeElement*	makeAccessRoot(rtl::Reference< configuration::Tree > const& aTree, RequestOptions const& _aOptions);
 			SetElement*		makeSetElement(rtl::Reference< configuration::ElementTree > const& aTree);
 

configmgr/source/api2/apitreeimplobj.cxx

         return configuration::DefaultProvider::createEmpty();
 }
 //-------------------------------------------------------------------------
-ApiTreeImpl::ApiTreeImpl(uno::XInterface* pInstance, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl& rParentTree)
-: m_aTree(aTree)
-, m_aNotifier(new NotifierImpl(aTree))
-, m_aDefaultProvider(rParentTree.getDefaultProvider())
-, m_xProvider()
-, m_rProvider(rParentTree.getProvider())
-, m_pParentTree(0)
-, m_pInstance(pInstance)
-{
-	setNodeInstance(aTree->getRootNode(), pInstance);
-	init(&rParentTree);
-}
-//-------------------------------------------------------------------------
 ApiTreeImpl::ApiTreeImpl(uno::XInterface* pInstance, ApiProvider& rProvider, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl* pParentTree)
 : m_aTree(aTree)
 , m_aNotifier(new NotifierImpl(aTree))

configmgr/source/api2/apitreeimplobj.hxx

 			uno::XInterface*		m_pInstance;
 
 		public:
-            explicit ApiTreeImpl(uno::XInterface* pInstance, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl& rParentTree);
 			explicit ApiTreeImpl(uno::XInterface* pInstance, ApiProvider& rProvider, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl* pParentTree);
 			explicit ApiTreeImpl(uno::XInterface* _pInstance, ApiProvider& _rProvider, rtl::Reference< configuration::Tree > const& _aTree, configuration::DefaultProvider const & _aDefaultProvider);
 			~ApiTreeImpl();

configmgr/source/api2/broadcaster.cxx

 	OSL_ASSERT(m_pImpl.isValid());
 }
 // ---------------------------------------------------------------------------------------------------
-Broadcaster::Broadcaster(Notifier const& aNotifier, configuration::NodeChangeInformation const& aChange, bool bLocal)
-: m_pImpl( Impl::create(aNotifier.m_aImpl,ApiTreeRef(aNotifier.m_pTree),aChange,bLocal) )
-{
-	OSL_ASSERT(m_pImpl.isValid());
-}
-// ---------------------------------------------------------------------------------------------------
 Broadcaster::Broadcaster(Notifier const& aNotifier, configuration::NodeChangesInformation const& aChanges, bool bLocal)
 : m_pImpl( Impl::create(aNotifier.m_aImpl,ApiTreeRef(aNotifier.m_pTree),aChanges,bLocal) )
 {
 }
 // ---------------------------------------------------------------------------------------------------
 
-void Broadcaster::notifyListeners(configuration::NodeChangeInformation const& aChange) throw()
-{
-	OSL_ENSURE(!aChange.isEmptyChange(),"Notifying without a change !");
-
-	configuration::NodeChangesInformation aChanges;
-	aChanges.push_back(aChange);
-	this->notifyListeners(aChanges, true);
-}
-// ---------------------------------------------------------------------------------------------------
-
 void Broadcaster::notifyListeners(configuration::NodeChanges const& aChanges, bool bSingleBase) throw()
 {
 	OSL_ENSURE(!aChanges.isEmpty(),"Notifying without a change !");

configmgr/source/api2/broadcaster.hxx

 			/// construct a broadcaster
 			Broadcaster(Notifier const& aNotifier, configuration::NodeChange const& aChange, bool bLocal);
 			Broadcaster(Notifier const& aNotifier, configuration::NodeChanges const& aChanges, bool bLocal);
-			Broadcaster(Notifier const& aNotifier, configuration::NodeChangeInformation const& aChange, bool bLocal);
 			Broadcaster(Notifier const& aNotifier, configuration::NodeChangesInformation const& aChanges, bool bLocal);
 			Broadcaster(Broadcaster const& aOther);
 			~Broadcaster();
 			void notifyListeners(configuration::NodeChange const& aChange) throw();
 			/// notify all listeners which are affected by any of these changes (potentially from many different bases)
 			void notifyListeners(configuration::NodeChanges const& aChanges, bool bSingleBase) throw();
-			/// notify all listeners which are affected by this change  
-			void notifyListeners(configuration::NodeChangeInformation const& aChange) throw();
 			/// notify all listeners which are affected by any of these changes (potentially from many different bases)
 			void notifyListeners(configuration::NodeChangesInformation const& aChanges, bool bSingleBase = false) throw();
 			

configmgr/source/api2/groupobjects.hxx

 	{
 	public:
 		// Construction/Destruction 
-		OSetElementGroupInfo(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiTreeImpl& rParentTree)
-		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rParentTree)
-		{
-		}
 		OSetElementGroupInfo(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiProvider& rProvider, configapi::ApiTreeImpl* pParentTree = 0)
 		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rProvider,pParentTree)
 		{
 	{
 	public:
 		// Construction/Destruction 
-		OSetElementGroupUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiTreeImpl& rParentTree)
-		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rParentTree)
-		{
-		}
 		OSetElementGroupUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiProvider& rProvider, configapi::ApiTreeImpl* pParentTree = 0)
 		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rProvider,pParentTree)
 		{

configmgr/source/api2/providerimpl.cxx

          m_pTreeManager->enableAsync(bEnableAsync);
     }
 	//-----------------------------------------------------------------------------
-	void SAL_CALL OProviderImpl::acquire(  ) throw ()
-	{
-		m_pProvider->acquire();
-	}
-
-	//-----------------------------------------------------------------------------
-	void SAL_CALL OProviderImpl::release(  ) throw ()
-	{
-		m_pProvider->release();
-	}
-
-	//-----------------------------------------------------------------------------
 	uno::XInterface* OProviderImpl::getProviderInstance()
 	{
 		return static_cast<com::sun::star::lang::XMultiServiceFactory*>(m_pProvider);

configmgr/source/api2/providerimpl.hxx

         virtual sal_Bool fetchDefaultData(configuration::AbsolutePath const& aSubtreePath, const RequestOptions& _aOptions
                                           ) SAL_THROW((com::sun::star::uno::Exception));
 
-        void SAL_CALL acquire(  ) throw ();
-        void SAL_CALL release(  ) throw ();
-
         // DefaultProvider access
         rtl::Reference< TreeManager >  getDefaultProvider() const SAL_THROW((com::sun::star::uno::RuntimeException));
 

configmgr/source/api2/setobjects.hxx

 	{
 	public:
 		// Construction/Destruction 
-		OSetElementSetInfo(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiTreeImpl& rParentTree)
-		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rParentTree)
-		{
-		}
 		OSetElementSetInfo(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiProvider& rProvider, configapi::ApiTreeImpl* pParentTree = 0)
 		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rProvider,pParentTree)
 		{
 	{
 	public:
 		// Construction/Destruction 
-		OSetElementTreeSetUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiTreeImpl& rParentTree)
-		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rParentTree)
-		{
-		}
 		OSetElementTreeSetUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiProvider& rProvider, configapi::ApiTreeImpl* pParentTree = 0)
 		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rProvider,pParentTree)
 		{
 	{
 	public:
 		// Construction/Destruction 
-		OSetElementValueSetUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiTreeImpl& rParentTree)
-		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rParentTree)
-		{
-		}
 		OSetElementValueSetUpdate(rtl::Reference< configuration::Tree > const& aTree, configapi::ApiProvider& rProvider, configapi::ApiTreeImpl* pParentTree = 0)
 		: m_aAccessElement(static_cast<css::container::XChild*>(this),aTree,rProvider,pParentTree)
 		{

configmgr/source/backend/binaryreader.cxx

 #include <com/sun/star/io/IOException.hpp>
 #include <com/sun/star/io/XOutputStream.hpp>
 #include <com/sun/star/io/XActiveDataSource.hpp>
+#include <com/sun/star/io/XDataInputStream.hpp>
 #include <com/sun/star/io/XDataOutputStream.hpp>
 #include <com/sun/star/io/BufferSizeExceededException.hpp>
 #include <com/sun/star/io/UnexpectedEOFException.hpp>
 		// BinaryReader implementation.
 		// --------------------------------------------------------------------------
 
+        BinaryReader::BinaryReader(rtl::OUString const & _sFileURL):
+            m_sFileURL(_sFileURL) {}
+
+        BinaryReader::~BinaryReader() {}
+
 		bool BinaryReader::open()
 			SAL_THROW( (io::IOException, uno::RuntimeException) )
 		{
 
 		// --------------------------------------------------------------------------
 
-        inline uno::Reference<io::XDataInputStream> BinaryReader::getDataInputStream()
+        inline BinaryReader_Impl * BinaryReader::getDataInputStream()
 		{
             OSL_ENSURE(m_xDataInputStream.is(),"Binary Cache: Reader was not opened - no input stream");
-            return m_xDataInputStream;
+            return m_xDataInputStream.get();
 		}
 
 		// --------------------------------------------------------------------------

configmgr/source/backend/binaryreader.hxx

 #ifndef CONFIGMGR_BINARYREADER_HXX
 #define CONFIGMGR_BINARYREADER_HXX
 
+#include <rtl/ref.hxx>
 #include <rtl/ustring.hxx>
 #include <osl/file.hxx>
 #include <com/sun/star/uno/Any.hxx>
 #include <com/sun/star/io/IOException.hpp>
 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
-#include <com/sun/star/io/XDataInputStream.hpp>
 
 namespace configmgr
 {
 		namespace uno  = css::uno;
 		namespace lang = css::lang;
 		// -----------------------------------------------------------------------------
+        class BinaryReader_Impl;
 		class BinaryReader 
 		{
 			rtl::OUString m_sFileURL;
 
-			uno::Reference<io::XDataInputStream> m_xDataInputStream;
+			rtl::Reference<BinaryReader_Impl> m_xDataInputStream;
 		public:
-			explicit BinaryReader (rtl::OUString const & _sFileURL)
-			: m_sFileURL(_sFileURL)
-			{}
+			explicit BinaryReader (rtl::OUString const & _sFileURL);
 			
-			~BinaryReader()
-			{}
+			~BinaryReader();
 
 		public:
 			bool open()     SAL_THROW( (io::IOException, uno::RuntimeException) );
 			void read(uno::Sequence< rtl::OUString > &_aValue)  SAL_THROW( (io::IOException, uno::RuntimeException) );
 
 		private:
-			inline uno::Reference<io::XDataInputStream> getDataInputStream();
+			inline BinaryReader_Impl * getDataInputStream();
 		};
 		// --------------------------------------------------------------------------
 

configmgr/source/inc/configgroup.hxx

 
             bool hasDoneSet() const { return m_bHasDoneSet; }
 
-            bool isDataAvailable();
-
 			NodeChange validateSetToDefaultValue(ValueRef const& aValueNode);
 
 			NodeChange validateSetToDefaultState(NodeRef const& aNode);

configmgr/source/inc/nodechange.hxx

 			NodeChange const& apply() const;
 
 			// retrieve the tree where the change is actually taking place
-            rtl::Reference< Tree > getBaseTree() const;
-			// retrieve the node where the change is actually taking place
-			NodeRef getBaseNode() const;
-
-			// retrieve the tree where the change is actually taking place
             rtl::Reference< Tree > getAffectedTree() const;
 			// retrieve the node where the change is actually taking place
 			NodeRef getAffectedNode() const;
-			// identify the node where the change is actually taking place
-			NodeID getAffectedNodeID() const;
 
 			// Comparison
 			friend bool operator==(NodeChange const& lhs, NodeChange const& rhs)
 			NodeChanges& test()				{ implTest(); return *this; }
 			NodeChanges const& test() const { implTest(); return *this; }
 
-			/// apply all changes
-			NodeChanges& apply()			{ implApply(); return *this; }
-			NodeChanges const& apply() const{ implApply(); return *this; }
-
 			/// remove all changes known to be doing nothing from this collection.
 			NodeChanges& compact();
 
 			*/
 			void add(NodeChange const& aChange);
 
-			/** insert changes into this collection
-			*/
-			void add(NodeChanges const& aChanges);
-
 			/// returns an STL-style iterator to the first element of the collection
 			std::vector<NodeChange>::const_iterator begin() const		{ return m_aChanges.begin(); }
 			std::vector<NodeChange>::iterator begin()	{ return m_aChanges.begin(); }
 
 		private:
 			void implTest() const;
-			void implApply() const;
 			std::vector<NodeChange> m_aChanges;
 		};
 

configmgr/source/inc/tree.hxx

 
             bool isValidValueNode(ValueRef const & value);
 
+#if OSL_DEBUG_LEVEL > 0
             bool isValidAnyNode(AnyNodeRef const & node);
+#endif
 
 			/// checks whether the node has any element nodes (of its own)
 			bool hasElements(NodeRef const & node);

configmgr/source/inc/treemanager.hxx

         void addListener(configuration::AbsolutePath const& aName, const RequestOptions& _aOptions, rtl::Reference<INodeListener> const& pListener);
         void removeListener(const RequestOptions& _aOptions, rtl::Reference<INodeListener> const& pListener);
 
-        void disposing(backend::CacheController & _rProvider)   SAL_THROW(());
         void componentCreated(backend::ComponentRequest const & _aComponent) SAL_THROW(());
         void componentChanged(backend::UpdateRequest  const & _anUpdate)     SAL_THROW(());
 

configmgr/source/inc/valueref.hxx

 			// checking
 			bool isValidNode() const;
 			// hashing
-			size_t hashCode() const;
+			size_t hashCode() const { return m_aParentID.hashCode() + 5*m_sNodeName.hashCode(); }
 			// containing node this
             NodeID getParentID() const { return m_aParentID; }
 			// containing node this

configmgr/source/tree/cmtree.cxx

 
 // ------------------------ ChildListSet implementations ------------------------
     ChildListSet::ChildListSet(ChildListSet const& aSet, treeop::DeepChildCopy)
-        : m_aChildList(0)
+        : m_aChildList(aSet.m_aChildList.size())
 	{
         for (size_t i = 0; i < aSet.m_aChildList.size(); i++)
         {
-			m_aChildList.insert(m_aChildList.end(),
-                                aSet.m_aChildList[i]->clone().release());
+            m_aChildList[i] = aSet.m_aChildList[i]->clone().release();
         }
 	}
 	ChildListSet::~ChildListSet()
 
 	struct ltNode
 	{
+        ltNode() {}
+
 		bool operator()(const configmgr::INode* n1, const configmgr::INode* n2) const
         {
             return n1->getName().compareTo(n2->getName()) < 0;

configmgr/source/treecache/cacheaccess.cxx

     return !_rPendingList.empty();
 }
 
-// -----------------------------------------------------------------------------
-void CacheLoadingAccess::clearData(std::vector< rtl::Reference<CacheLine> >& _rList) SAL_THROW(())
-{
-	CFG_TRACE_INFO("Tree Info: Removing all module trees for cleanup" );
-
-	ExtendedCacheData::ModuleList& rModules = this->m_aData.accessModuleList();
-
-	for(ExtendedCacheData::ModuleList::iterator it = rModules.begin();
-		it != rModules.end();
-		++it)
-	{
-		if (it->second.is())
-			_rList.push_back(it->second);
-	}
-
-	rModules.clear();
-	m_aDeadModules.clear();
-}
 // -------------------------------------------------------------------------
 
 TimeStamp CacheLoadingAccess::collectDisposeList(std::vector< rtl::Reference<CacheLine> > & _rList, TimeStamp const & _aLimitTime, TimeInterval const & _aDelay)

configmgr/source/treecache/cacheaccess.hxx

                                         TimeStamp const & _aLimitTime,			
                                         TimeInterval const & _aDelay);			
 
-		/// clear the contained tree, return all remaining modules
-		void clearData( std::vector< rtl::Reference<CacheLine> >& _rDisposeList) SAL_THROW(());
-
     // stuff that is particular for CacheLoadingAccess
 		/** add the given subtree at the given location,
 			return the tree that is then pertinent and clientAcquire() it once

configmgr/source/treecache/cachecontroller.cxx

 }
 
 // -------------------------------------------------------------------------
-void CacheController::disposeOne(RequestOptions const & _aOptions, bool _bFlushUpdates)
-{
-	CFG_TRACE_INFO("CacheController: Disposing data and TreeInfo for user '%s' with locale '%s'",
-					OUSTRING2ASCII(_aOptions.getEntity()), OUSTRING2ASCII(_aOptions.getLocale()) );
-
-	m_pDisposer->clearTasks(_aOptions);
-	if (!m_pCacheWriter->clearTasks(_aOptions)) // had no pending updates
-    {
-		_bFlushUpdates = false;
-    }
-	else if (!_bFlushUpdates)
-    {
-		CFG_TRACE_WARNING_NI("Found orphaned Changes in the cache - Discarding.");
-    }
-
-    rtl::Reference<CacheLoadingAccess> aRemoved = m_aCacheMap.remove(_aOptions);
-	
-	if (aRemoved.is())
-	{
-		// got it out of reachability - now dispose/notify without lock
-		implDisposeOne(aRemoved, _aOptions, _bFlushUpdates);
-	}
-	else
-		CFG_TRACE_INFO_NI("- No affected TreeInfo found" );
-}
-
-// -------------------------------------------------------------------------
-void CacheController::disposeUser(RequestOptions const & _aUserOptions, bool _bFlushUpdates)
-{
-	CFG_TRACE_INFO("CacheController: Disposing data and TreeInfo(s) for user '%s'",
-					OUSTRING2ASCII(_aUserOptions.getEntity()) );
-
-	std::vector< std::pair< RequestOptions, rtl::Reference<CacheLoadingAccess> > > aDisposeList;
-	// collect the ones to dispose
-	{
-		rtl::OUString sUser = _aUserOptions.getEntity();
-		OSL_ASSERT(sUser.getLength());
-
-		// This depends on the fact that Options are sorted (by struct ltOptions)
-		// so that all options belonging to one user are together
-		// (and that options with only a user set, sort first)
-
-        CacheMap::Map aCacheData;
-        m_aCacheMap.swap(aCacheData);
-
-		// find the lower_bound of all options for the user
-		CacheMap::Map::iterator const aFirst = aCacheData.lower_bound(_aUserOptions);
-
-		// find the upper_bound of all options for the user (using the lower one)
-		CacheMap::Map::iterator aLast = aFirst;
-		while (aLast != aCacheData.end() && aLast->first.getEntity() == sUser)
-			++aLast;
-
-		if (aFirst != aLast)
-		{
-			aDisposeList.reserve( std::distance(aFirst, aLast) );
-
-			bool bHasPendingChanges = false;
-
-			for (CacheMap::Map::iterator it = aFirst; it != aLast; ++it)
-			{
-				CFG_TRACE_INFO_NI("- Found TreeInfo for locale '%s'", OUSTRING2ASCII(it->first.getLocale()) );
-				m_pDisposer->clearTasks(it->first);
-
-				if (m_pCacheWriter->clearTasks(it->first))
-					bHasPendingChanges = true;
-
-				OSL_ASSERT(it->second.is());
-				if (it->second.is())
-				{
-					//aDisposeList.push_back( *it );
-					aDisposeList.push_back( std::make_pair(it->first,it->second) );
-				}
-			}
-
-			if (!bHasPendingChanges)
-				_bFlushUpdates = false;
-
-			else if (!_bFlushUpdates)
-				CFG_TRACE_WARNING_NI("Found orphaned Changes in the cache - Discarding.");
-
-			aCacheData.erase(aFirst, aLast);
-		}
-		else
-			CFG_TRACE_INFO_NI("- No affected TreeInfo found" );
-
-        // replace the data into the map
-        m_aCacheMap.swap(aCacheData);
-	}
-
-	// got all out of external reach - now dispose/notify without lock
-	for (std::vector< std::pair< RequestOptions, rtl::Reference<CacheLoadingAccess> > >::iterator i = aDisposeList.begin(); i != aDisposeList.end(); ++i)
-	{
-		if (i->second.is())
-		    implDisposeOne(i->second, i->first, _bFlushUpdates);
-	}
-}
-
-// -------------------------------------------------------------------------
-void CacheController::implDisposeOne(rtl::Reference<CacheLoadingAccess> const & _aDisposedCache, RequestOptions const & _aOptions, bool _bFlushUpdates)
-{
-    OSL_ASSERT(_aDisposedCache.is());
-	CFG_TRACE_INFO("Now removing Cache section (user '%s' with locale '%s')",
-					OUSTRING2ASCII(_aOptions.getEntity()), OUSTRING2ASCII(_aOptions.getLocale()) );
-
-	if (_bFlushUpdates) try
-	{
-		CFG_TRACE_INFO_NI("- Flushing pending changes" );
-
-		if ( !this->saveAllPendingChanges(_aDisposedCache,_aOptions) )
-        {
-		    CFG_TRACE_ERROR_NI("- Error while flushing - changes will be lost" );
-		    OSL_ENSURE(false,"Error while flushing changes from discarded Cache section - changes will be lost" );
-        }
-	}
-    catch (uno::Exception& e)
-    {
-        (void)e;
-		CFG_TRACE_ERROR_NI("- Failed with exception %s (ignoring here)", OUSTRING2ASCII(e.Message) );
-    }
-
-	std::vector< rtl::Reference<CacheLine> > aDisposedList;
-	_aDisposedCache->clearData(aDisposedList);
-
-	if (aDisposedList.size() > 0)
-	{
-		CFG_TRACE_INFO_NI("- Closing %d modules at the session",int(aDisposedList.size()));
-		this->closeModules(aDisposedList,_aOptions);
-	}
-}
-
-// -------------------------------------------------------------------------
 CacheController::CacheController(rtl::Reference< backend::IMergedDataProvider > const & _xBackend, 
 								 const uno::Reference<uno::XComponentContext>& xContext)
 : m_aNotifier()

configmgr/source/treecache/cachecontroller.hxx

 
 		// disposing
 		void disposeAll(bool _bFlushRemainingUpdates);
-        void disposeOne(RequestOptions const & _aOptions, bool _bFlushUpdates = true);		
-		void disposeUser(RequestOptions const & _aUserOptions, bool _bFlushUpdates = true);
-		void implDisposeOne(rtl::Reference<CacheLoadingAccess> const & _aCache, RequestOptions const & _aOptions, bool _bFlushUpdates);
  
         void closeModules(std::vector< rtl::Reference<CacheLine> > & _aList, RequestOptions const & _aOptions);
     private:

configmgr/source/treecache/cachemulticaster.cxx

 namespace
 {
 // manually implemented helpers, as rtl::References don't work well with std binders
-// ---------------------------------------------------------------------------
 
-    // replacing  std::bind2nd( std::mem_fun(&aFunc), aArg )
-    struct NotifyDisposing : std::unary_function<rtl::Reference<TreeManager>,void>
-    {
-        CacheController & m_arg;
-
-        NotifyDisposing(CacheController * _pProvider) SAL_THROW(())
-        : m_arg(*_pProvider)
-        {}
-
-        void operator()(rtl::Reference<TreeManager> const & _xListener) const SAL_THROW(())
-        { _xListener->disposing(m_arg); }
-    };
 // ---------------------------------------------------------------------------
 
     // replacing  std::bind2nd( std::mem_fun(&TreeManager::componentCreated), _aComponentName )

configmgr/source/treecache/disposetimer.cxx

 }
 // -------------------------------------------------------------------------
 
-void OTreeDisposeScheduler::clearTasks(RequestOptions const& _aOptions)
-{
-	CFG_TRACE_INFO("Cancelling all data cleanup tasks for user '%s' with locale '%s'",
-					OUSTRING2ASCII(_aOptions.getEntity()),
-                    OUSTRING2ASCII(_aOptions.getLocale()));
-
-	Agenda::iterator it = m_aAgenda.begin();
-	while(it != m_aAgenda.end())
-	{
-		Agenda::iterator cur = it++;
-		if (equivalentOptions(_aOptions,cur->second))
-		{
-			m_aAgenda.erase(cur);
-			CFG_TRACE_INFO_NI("- One pending task canceled");
-		}
-	}
-}
-// -------------------------------------------------------------------------
-
 void OTreeDisposeScheduler::stopAndClearTasks()
 {
 	CFG_TRACE_INFO("Cancelling all data cleanup tasks, Stopping Cleanup timer");

configmgr/source/treecache/disposetimer.hxx

 		/// ensure this will execute cleanup duties for _xOptions (no later than after getCleanupDelay() has elapsed)
         void scheduleCleanup(RequestOptions const & _aOptions); 
 
-		/// stop and discard pending activities for _xOptions
-		void clearTasks(RequestOptions const & _aOptions);
-
 		/// stop and discard pending activities
 		void stopAndClearTasks();
 

configmgr/source/treecache/treemanager.cxx

 
 // ----------------------------------------------------------------------------
 
-void TreeManager::disposing(backend::CacheController & /*_rProvider*/)   SAL_THROW(())
-{
-	CFG_TRACE_INFO("TreeManager: provider is being disposed");	
-    this->dispose();
-}
-// ----------------------------------------------------------------------------
-
 void TreeManager::componentCreated(backend::ComponentRequest const & ) SAL_THROW(())
 {
 	CFG_TRACE_INFO("TreeManager: component was created");	

configmgr/source/treemgr/configgroup.cxx

 }
 //-----------------------------------------------------------------------------
 
-bool GroupDefaulter::isDataAvailable()
-{ 
-    return m_aHelper.tree()->areValueDefaultsAvailable(m_aHelper.node()); 
-}
-//-----------------------------------------------------------------------------
-
 NodeChange GroupDefaulter::validateSetToDefaultValue(ValueRef const& aValueNode)
 {
 	m_aHelper.validateNode(aValueNode);

configmgr/source/treemgr/nodechange.cxx

 {
 	return m_pImpl && m_pImpl->fillChangeLocation(rLoc);
 }
-//-----------------------------------------------------------------------------
 
-rtl::Reference< Tree > NodeChange::getBaseTree() const
-{
-	return m_pImpl->getTargetTree().get();
-}
-//-----------------------------------------------------------------------------
-
-// retrieve the tree where the change is actually taking place
-NodeRef NodeChange::getBaseNode() const
-{
-	rtl::Reference<Tree> aTree = m_pImpl->getTargetTree();
-	unsigned int nOffset = m_pImpl->getTargetNode();
-
-	OSL_ASSERT(aTree.is() && aTree->isValidNode(nOffset));
-
-	if (aTree.is() && nOffset)
-		return aTree->getNode(nOffset);
-
-	return NodeRef();
-}
 //-----------------------------------------------------------------------------
 
 // retrieve the tree where the change is actually taking place
 }
 //-----------------------------------------------------------------------------
 
-NodeID NodeChange::getAffectedNodeID() const
-{
-	rtl::Reference<Tree> aTree = m_pImpl->getTargetTree();
-	unsigned int nOffset = m_pImpl->getTargetNode();
-
-	OSL_ASSERT(aTree.is() ? aTree->isValidNode(nOffset) : 0==nOffset);
-
-	return NodeID(aTree.get(),nOffset);
-}
-//-----------------------------------------------------------------------------
-
 NodeChange& NodeChange::test()
 {
 	if (m_pImpl) m_pImpl->test();
 	}
 }
 //-----------------------------------------------------------------------------
-void NodeChanges::implApply() const
-{
-	for(std::vector<NodeChange>::const_iterator it = begin(), stop = end(); it != stop; ++it)
-	{
-		it ->apply();
-	}
-}
-//-----------------------------------------------------------------------------
 /** insert a change into this collection
 */
 void NodeChanges::add(NodeChange const& aChange)
 {
 	m_aChanges.push_back(aChange);
 }
-//-----------------------------------------------------------------------------
 
-/** insert multiple changes into this collection
-*/
-void NodeChanges::add(NodeChanges const& aChanges)
-{
-	m_aChanges.insert(m_aChanges.end(),aChanges.begin(),aChanges.end());
-}
 //-----------------------------------------------------------------------------
 
 /** removes a change to <var>aNode</var> from this collection (if there is one)

configmgr/source/treemgr/noderef.cxx

 }
 //-----------------------------------------------------------------------------
 
-// hashing
-size_t SubNodeID::hashCode() const
-{
-	return m_aParentID.hashCode() + 5*m_sNodeName.hashCode();
-}
-//-----------------------------------------------------------------------------
-
 bool operator < (SubNodeID const& lhs, SubNodeID const& rhs)
 {
 	if (lhs.m_aParentID == rhs.m_aParentID)

configmgr/source/treemgr/setnodeimpl.hxx

 
 		class ElementSet
 		{
+            struct FastLess
+            {
+                bool operator ()(
+                    rtl::OUString const & a, rtl::OUString const & b) const
+                {
+                    // first sort by length; order is immaterial, and it is fast
+                    return a.getLength() == b.getLength()
+                        ? a < b : a.getLength() < b.getLength();
+                }
+            };
+
 		public:
-			typedef std::map<rtl::OUString, ElementTreeData>	Data;
+            typedef std::map<rtl::OUString, ElementTreeData, FastLess> Data;
 
 		// the following must be implemented by derived classes
 			bool isEmpty() const { return m_aData.empty(); }

configmgr/source/treemgr/treeimpl.cxx

     return true;
 }
 
+#if OSL_DEBUG_LEVEL > 0
 bool Tree::isValidAnyNode(AnyNodeRef const & node) {
     OSL_ASSERT(nodeCount() != 0);
     return node.isValid() && isValidNode(node.m_nUsedPos) &&
          (view::ViewTreeAccess(this).isGroupNodeAt(node.m_nUsedPos) &&
           getMemberNode(node.toValue()).isValid()));
 }
+#endif
 
 bool Tree::hasElements(NodeRef const & node) {
     OSL_ASSERT(

cppu/inc/typelib/typedescription.h

 	sal_Int32 nDefaultValue )
 	SAL_THROW_EXTERN_C();
 
-/** Inits incomplete static compound type reference. Thread synchronizes on typelib init mutex.
-	All discriminants are handled as int64 values. The pDiscriminantTypeRef must be of
-    type byte, short, ..., up to hyper.
-    
-	@param ppRef pointer to type reference pointer
-	@param pTypeName name of union type
-	@param pDiscriminantType discriminant type
-	@param nDefaultDiscriminant default discriminant
-	@param pDefaultType default value type of union
-	@param nMembers number of union members
-	@param pDiscriminants member discriminants
-	@param pMemberTypes member types
-*/
-void SAL_CALL typelib_static_union_type_init(
-	typelib_TypeDescriptionReference ** ppRef,
-	const sal_Char * pTypeName,
-	typelib_TypeDescriptionReference * pDiscriminantType,
-	sal_Int64 nDefaultDiscriminant,
-	typelib_TypeDescriptionReference * pDefaultType,
-	sal_Int32 nMembers,
-	sal_Int64 * pDiscriminants,
-	typelib_TypeDescriptionReference ** pMemberTypes )
-	SAL_THROW_EXTERN_C();
-
 /** Completes a typedescription to be used for, e.g., marshalling values. COMPOUND, UNION,
     INTERFACE and ENUM type descriptions may be partly initialized (see typelib_static_...(),
     typelib_TypeDescription::bComplete). For interface type descriptions, this will also

cppu/source/typelib/static_types.cxx

 	}
 }
 
-//##################################################################################################
-void SAL_CALL typelib_static_union_type_init(
-	typelib_TypeDescriptionReference ** ppRef,
-	const sal_Char * pTypeName,
-	typelib_TypeDescriptionReference * pDiscriminantTypeRef,
-	sal_Int64 nDefaultDiscriminant,
-	typelib_TypeDescriptionReference * pDefaultTypeRef,
-	sal_Int32 nMembers,
-	sal_Int64 * pDiscriminants,
-	typelib_TypeDescriptionReference ** pMemberTypes )
-	SAL_THROW_EXTERN_C()
-{
-	if (! *ppRef)
-	{
-		MutexGuard aGuard( typelib_StaticInitMutex::get() );
-		if (! *ppRef)
-		{
-			OSL_ASSERT( ! TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(typelib_TypeClass_UNION) );
-			OUString aTypeName( OUString::createFromAscii( pTypeName ) );
-            *ppRef = igetTypeByName( aTypeName.pData );
-			if (!*ppRef)
-			{
-				typelib_UnionTypeDescription * pUnion = 0;
-				::typelib_typedescription_newEmpty(
-					(typelib_TypeDescription **)&pUnion, typelib_TypeClass_UNION, aTypeName.pData );
-				// discriminant type
-				::typelib_typedescriptionreference_acquire( pUnion->pDiscriminantTypeRef = pDiscriminantTypeRef );
-				
-				sal_Int32 nPos;
-				
-				pUnion->nMembers = nMembers;
-				// default discriminant
-				if (nMembers)
-				{
-					pUnion->pDiscriminants = new sal_Int64[ nMembers ];
-					for ( nPos = nMembers; nPos--; )
-					{
-						pUnion->pDiscriminants[nPos] = pDiscriminants[nPos];
-					}
-				}
-				// default default discriminant
-				pUnion->nDefaultDiscriminant = nDefaultDiscriminant;
-				
-				// union member types
-				pUnion->ppTypeRefs = new typelib_TypeDescriptionReference *[ nMembers ];
-				for ( nPos = nMembers; nPos--; )
-				{
-					::typelib_typedescriptionreference_acquire(
-						pUnion->ppTypeRefs[nPos] = pMemberTypes[nPos] );
-				}
-				
-				// default union type
-				::typelib_typedescriptionreference_acquire( pUnion->pDefaultTypeRef = pDefaultTypeRef );
-				
-				typelib_TypeDescription * pReg = (typelib_TypeDescription *)pUnion;
-				
-				pReg->pWeakRef = (typelib_TypeDescriptionReference *)pReg;
-				pReg->nSize = typelib_typedescription_getAlignedUnoSize( pReg, 0, pReg->nAlignment );
-				pReg->nAlignment = adjustAlignment( pReg->nAlignment );
-				pReg->bComplete = sal_False;
-				
-				::typelib_typedescription_register( &pReg );
-				*ppRef = (typelib_TypeDescriptionReference *)pReg;
-				OSL_ASSERT( *ppRef == pReg->pWeakRef );
-			}
-#ifndef CPPU_LEAK_STATIC_DATA
-			// another static ref
-			++((*ppRef)->nStaticRefCount);
-#endif
-		}
-	}
-}
 } // extern "C"
 
 }

cppu/source/uno/lbmap.cxx

 
 	Mutex				aNegativeLibsMutex;
 	t_OUStringSet		aNegativeLibs;
-	~MappingsData() SAL_THROW( () );
 };
-//__________________________________________________________________________________________________
-MappingsData::~MappingsData() SAL_THROW( () )
-{
-#if OSL_DEBUG_LEVEL > 1
-	OSL_ENSURE( aName2Entry.empty() && aMapping2Entry.empty(), "### unrevoked mappings!" );
-	t_OUString2Entry::const_iterator iPos( aName2Entry.begin() );
-	while (iPos != aName2Entry.end())
-	{
-		MappingEntry * pEntry = (*iPos).second;
-		OString aName( OUStringToOString( pEntry->aMappingName, RTL_TEXTENCODING_ASCII_US ) );
-		OSL_TRACE( "### unrevoked mapping: %s", aName.getStr() );
-		++iPos;
-	}
-	OSL_ENSURE( aCallbacks.empty(), "### callbacks left!" );
-	if (aCallbacks.size())
-	{
-		OString aSize( OString::valueOf( (sal_Int32)aCallbacks.size() ) );
-		OSL_TRACE( "### %d unrevoked callbacks", aSize.getStr() );
-	}
-#endif
-}
 //--------------------------------------------------------------------------------------------------
 static MappingsData & getMappingsData() SAL_THROW( () )
 {

cppuhelper/source/component_context.cxx

     SAL_THROW( () )
 {
 	uno::Environment curr_env(Environment::getCurrent());
-	uno::Environment source_env(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV) ":unsafe")));
+	uno::Environment source_env(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV))));
 
 	uno::Mapping curr2source(curr_env, source_env);
 	uno::Mapping source2curr(source_env, curr_env);

padmin/prj/build.lst

-pd	padmin	:	psprint vcl svtools NULL
+pd	padmin	:	vcl svtools NULL
 pd	padmin									usr1	-	all	pd_mkout NULL
 pd	padmin\source							nmake	-	all	pd_source NULL

scp2/source/ooo/file_library_ooo.scp

 
 SPECIAL_UNO_LIB_FILE(gid_File_Lib_Srtrs1,srtrs1)
 
-File gid_File_Lib_Stocserv
-    TXT_FILE_BODY;
-    Dir = gid_Dir_Program;
-  #ifdef UNX
-    Name = STRING(CONCAT2(stocservices.uno,UNXSUFFIX));
-  #else
-    Name = "stocservices.uno.dll";
-  #endif
-    Styles = (PACKED,UNO_COMPONENT);
-    RegistryID = gid_Starregistry_Services_Rdb;
-End
-
 STD_LIB_FILE( gid_File_Lib_Sts , sts)
 
 STD_LIB_FILE_PATCH( gid_File_Lib_Svl, svl )

stoc/source/invocation/invocation.cxx

 #include <com/sun/star/lang/XTypeProvider.hpp>
 #include <com/sun/star/registry/XRegistryKey.hpp>
 
+#include <boost/scoped_array.hpp>
 #include <rtl/ustrbuf.hxx>
 #include <rtl/strbuf.hxx>
 
-#include <stdlib.h>
-#ifndef MACOSX
-#include <search.h>
-#endif
-
 #define SERVICENAME "com.sun.star.script.Invocation"
 #define IMPLNAME	 "com.sun.star.comp.stoc.Invocation"
 
 	sal_Int32 nIndex;
 };
 
-// qsort compare function for MemberItem
-//int __cdecl compare(const void *elem1, const void *elem2 )
-extern "C" int SAL_CALL compare(const void *elem1, const void *elem2 )
-{
-	MemberItem* pItem1 = *(MemberItem**)elem1;
-	MemberItem* pItem2 = *(MemberItem**)elem2;
-	return (int)pItem1->aName.compareTo( pItem2->aName );
-}
-
-
 // Implementation of getting name or info
 // String sequence will be filled when pStringSeq != NULL
 // Info sequence will be filled when pInfoSeq != NULL
 	sal_Int32 nTotalCount = nNameAccessCount + nPropertyCount + nMethodCount;
 
 	// Create and fill array of MemberItems
-	MemberItem* pItems = new MemberItem[ nTotalCount ];
+    boost::scoped_array< MemberItem > pItems( new MemberItem[ nTotalCount ] );
 	const OUString* pStrings = aNameAccessNames.getConstArray();
 	const Property* pProps = aPropertySeq.getConstArray();
 	const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
 
-	// Create array of MemberItem* for sorting
-	MemberItem** ppItems = new MemberItem*[ nTotalCount ];
-
 	// Fill array of MemberItems
 	sal_Int32 i, iTotal = 0;
 
 	for( i = 0 ; i < nNameAccessCount ; i++, iTotal++ )
 	{
 		MemberItem& rItem = pItems[ iTotal ];
-		ppItems[ iTotal ] = &rItem;
 		rItem.aName = pStrings[ i ];
 		rItem.eMode = MemberItem::NAMEACCESS;
 		rItem.nIndex = i;
 	for( i = 0 ; i < nPropertyCount ; i++, iTotal++ )
 	{
 		MemberItem& rItem = pItems[ iTotal ];
-		ppItems[ iTotal ] = &rItem;
 		rItem.aName = pProps[ i ].Name;
 		rItem.eMode = MemberItem::PROPERTYSET;
 		rItem.nIndex = i;
 	for( i = 0 ; i < nMethodCount ; i++, iTotal++ )
 	{
 		MemberItem& rItem = pItems[ iTotal ];
-		ppItems[ iTotal ] = &rItem;
 		Reference< XIdlMethod > xMethod = pMethods[ i ];
 		rItem.aName = xMethod->getName();
 		rItem.eMode = MemberItem::METHOD;
 		rItem.nIndex = i;
 	}
 
-	// Sort pointer array
-	qsort( ppItems, (size_t)nTotalCount, sizeof( MemberItem* ), compare );
-
 	// Setting up result sequences 
 	OUString* pRetStrings = NULL;
 	if( pStringSeq )

stoc/source/servicemanager/servicemanager.cxx

     return seq;
 }
 
-
-/*****************************************************************************
-	helper functions
-*****************************************************************************/
-OUString Point2Slash(const OUString& s)
-{
-	OUStringBuffer ret;
-
-    sal_Int32 nIndex = 0;
-    do
-    {
-		OUString token( s.getToken(0, '.', nIndex) );
-
-		if (token.getLength())
-        {
-            ret.append( (sal_Unicode)'/' );
-            ret.append( token );
-        }
-    } while( nIndex != -1 );
-
-	return ret.makeStringAndClear();
-}
-
 /*****************************************************************************
 	Enumeration by ServiceName
 *****************************************************************************/

testtools/source/bridgetest/bridgetest_client

-uno -ro uno_services.rdb -ro uno_types.rdb -s com.sun.star.test.bridge.BridgeTest -- -u "uno:socket,host=127.0.0.1,port=2002;urp;test"

testtools/source/bridgetest/bridgetest_inprocess

-uno -ro uno_services.rdb -ro uno_types.rdb -s com.sun.star.test.bridge.BridgeTest -- com.sun.star.test.bridge.CppTestObject

testtools/source/bridgetest/bridgetest_server

-uno -ro uno_services.rdb -ro uno_types.rdb -s com.sun.star.test.bridge.CppTestObject -u "uno:socket,host=127.0.0.1,port=2002;urp;test" --singleaccept

testtools/source/bridgetest/makefile.mk

 	$(GNUCOPY) $? $@
     $(REGMERGE) $@ / $(BIN)$/bridgetest.rdb
 
-$(DLLDEST)$/bridgetest_inprocess$(BATCH_SUFFIX) : bridgetest_inprocess
-	$(GNUCOPY) $? $@
+$(DLLDEST)$/bridgetest_inprocess$(BATCH_SUFFIX) .ERRREMOVE: makefile.mk
+.IF "$(USE_SHELL)" == "bash"
+    echo '$(AUGMENT_LIBRARY_PATH)' uno -ro uno_services.rdb -ro uno_types.rdb \
+        -s com.sun.star.test.bridge.BridgeTest -- \
+        com.sun.star.test.bridge.CppTestObject > $@
+.ELSE
+    echo echo ERROR: this script can only be created properly for \
+        USE_SHELL=bash > $@
+.ENDIF
 	$(GIVE_EXEC_RIGHTS) $@
 
-$(DLLDEST)$/bridgetest_client$(BATCH_SUFFIX) : bridgetest_client
-	$(GNUCOPY) $? $@
+$(DLLDEST)$/bridgetest_client$(BATCH_SUFFIX) .ERRREMOVE: makefile.mk
+.IF "$(USE_SHELL)" == "bash"
+    echo '$(AUGMENT_LIBRARY_PATH)' uno -ro uno_services.rdb -ro uno_types.rdb \
+        -s com.sun.star.test.bridge.BridgeTest -- \
+        -u \''uno:socket,host=127.0.0.1,port=2002;urp;test'\' > $@
+.ELSE
+    echo echo ERROR: this script can only be created properly for \
+        USE_SHELL=bash > $@
+.ENDIF
 	$(GIVE_EXEC_RIGHTS) $@
 
-$(DLLDEST)$/bridgetest_server$(BATCH_SUFFIX) : bridgetest_server
-	$(GNUCOPY) $? $@
+$(DLLDEST)$/bridgetest_server$(BATCH_SUFFIX) .ERRREMOVE: makefile.mk
+.IF "$(USE_SHELL)" == "bash"
+    echo '$(AUGMENT_LIBRARY_PATH)' uno -ro uno_services.rdb -ro uno_types.rdb \
+        -s com.sun.star.test.bridge.CppTestObject \
+        -u \''uno:socket,host=127.0.0.1,port=2002;urp;test'\' --singleaccept \
+        > $@
+.ELSE
+    echo echo ERROR: this script can only be created properly for \
+        USE_SHELL=bash > $@
+.ENDIF
 	$(GIVE_EXEC_RIGHTS) $@
 
 
 		com.sun.star.comp.bridge.TestComponentMain \""uno:socket,host=127.0.0.1,port=2002;urp;test"\" singleaccept > $@
 	$(GIVE_EXEC_RIGHTS) $@
 
-$(DLLDEST)$/bridgetest_inprocess_java$(BATCH_SUFFIX) : makefile.mk $(DLLDEST)$/uno_services.rdb
-	-rm -f $@
-	echo uno -ro uno_services.rdb -ro uno_types.rdb \
+$(DLLDEST)$/bridgetest_inprocess_java$(BATCH_SUFFIX) .ERRREMOVE: makefile.mk
+.IF "$(USE_SHELL)" == "bash"
+	echo '$(AUGMENT_LIBRARY_PATH)' uno -ro uno_services.rdb -ro uno_types.rdb \
         -s com.sun.star.test.bridge.BridgeTest \
         -env:URE_INTERNAL_JAVA_DIR=$(MY_URE_INTERNAL_JAVA_DIR) \
         -- com.sun.star.test.bridge.JavaTestObject noCurrentContext > $@
+.ELSE
+    echo echo ERROR: this script can only be created properly for \
+        USE_SHELL=bash > $@
+.ENDIF
 	$(GIVE_EXEC_RIGHTS) $@
 .ENDIF
 
         $(DLLDEST)$/bridgetest.uno$(DLLPOST) $(DLLDEST)$/cppobj.uno$(DLLPOST) \
         $(MISC)$/$(TARGET)$/bootstrap.rdb $(SHL3TARGETN)
     - $(MKDIR) $(@:d)
-    cd $(DLLDEST) && $(REGCOMP) -register -br uno_types.rdb -r uno_services.rdb -wop \
+    $(REGCOMP) -register -br $(DLLDEST)$/uno_types.rdb \
+        -r $(DLLDEST)$/uno_services.rdb -wop \
         -c acceptor.uno$(DLLPOST) \
         -c bridgefac.uno$(DLLPOST) \
         -c connector.uno$(DLLPOST) \
         -c remotebridge.uno$(DLLPOST) \
         -c uuresolver.uno$(DLLPOST) \
+        -c stocservices.uno$(DLLPOST)
+    cd $(DLLDEST) && $(REGCOMP) -register -br uno_types.rdb \
+        -r uno_services.rdb -wop=./ \
         -c .$/bridgetest.uno$(DLLPOST) \
         -c .$/cppobj.uno$(DLLPOST) \
-        -c stocservices.uno$(DLLPOST) \
         -c .$/$(SHL3TARGETN:f)
 .IF "$(SOLAR_JAVA)" != ""
     $(REGCOMP) -register -br $(DLLDEST)$/uno_types.rdb -r $@ \