Make localization a bit more effective

1. get rid of some unefficiency
The "old" executables used to parse items which has
other language than en-US. To this items executables
search MergeEntrys(read from po) and change the content if
possible. This mixed localization method not need any longer.
-cfgex: cfgmerge:WorkOnText()
-xrmex: xrmmerge:WorkOnText()
-transex3: export:PrepareTextToMerge()

2. Change the container of MergeData to get a bit efficiency.
The new MergeDataHashMap is exploit that in most case the
insertion and search happen in the same order.(similar to fifo)
So add an iterator-chain to define an insertion order in the
original hashmap.
Every call of find it is a hint that the next element, to
the last found one, is the searched one. If not than search
such like in a HasMap.

3. Set up some order in helpex
Helpex is the only one, which was not used to merge strings
in the same order as export, so change it to work effective
with the new HashMap.
Helpex works with all file of a specific directory and po
files contain the strings of these files in lexical order
 so use the same order for merge.(HelpTarget.mk)

4. Make export use MergeDataHashMap a bit more effective
-The same MergeData contains strings to all language,
so it need to get only once.
-Just text entrys have MergeData, others not need to
search for it. (e.g. bitmap)

Plus delete some unused code.

Change-Id: I6ec80cd2323ffea8f783d0b59dc89ca7eac3c205

l10ntools/inc/export.hxx

@@ -52,9 +52,6 @@ typedef boost::unordered_map<OString, OString, OStringHash>
 typedef boost::unordered_map<OString, bool, OStringHash>
     OStringBoolHashMap;
 
-typedef boost::unordered_map<OString, MergeData*, OStringHash>
-    MergeDataHashMap;
-
 #define SOURCE_LANGUAGE "en-US"
 #define X_COMMENT "x-comment"
 #define LIST_REFID  "LIST_REFID"
@@ -193,7 +190,6 @@ private:
     bool bSkipFile;
     sal_Bool bMergeMode;
     OString sMergeSrc;
-    OString sLastListLine;
     sal_Bool bError;                        // any errors while export?
     sal_Bool bReadOver;
     sal_Bool bDontWriteOutput;
@@ -219,8 +215,12 @@ private:
     void CleanValue( OString &rValue );
     OString GetText(const OString &rSource, int nToken);
 
-    sal_Bool PrepareTextToMerge(OString &rText, sal_uInt16 nTyp,
-        OString &rLangIndex, ResData *pResData);
+    /**
+      Get all MergeEntrys for the ExportList identified by pResData
+      Check whether list can merge and load all needed MergeEntry from DataBase.
+    */
+    bool GetAllMergeEntrysOfList(ResData *pResData, std::vector<MergeEntrys*>& o_vMergeEntrys, ExportList*& o_pList);
+
     void ResData2Output( MergeEntrys *pEntry, sal_uInt16 nType, const OString& rTextType );
     void MergeRest( ResData *pResData, sal_uInt16 nMode = MERGE_MODE_NORMAL );
     void ConvertMergeContent( OString &rText );
@@ -277,10 +277,56 @@ public:
         bTitleFirst[ rId ] = true;
     }
     sal_Bool GetText( OString &rReturn, sal_uInt16 nTyp, const OString &nLangIndex, sal_Bool bDel = sal_False );
+
+    /**
+      Generate QTZ string with ResData
+      For executable which works one language and without PO files.
+    */
     static OString GetQTZText(const ResData& rResData, const OString& rOrigText);
 
 };
 
+/** Container for MergeData
+
+  This class is an HashMap with a hidden insertion
+  order. The class can used just like a simple
+  HashMap, but good to know that it's use is
+  more effective if the accessing(find) order
+  match with the insertion order.
+
+  In the most case, this match is good.
+  (e.g. reading PO files of different languages,
+  executables merging)
+*/
+class MergeDataHashMap
+{
+    private:
+        typedef boost::unordered_map<OString, MergeData*, OStringHash> HashMap_t;
+
+    public:
+        MergeDataHashMap():bFirstSearch(true){};
+        ~MergeDataHashMap(){};
+
+        typedef HashMap_t::iterator iterator;
+        typedef HashMap_t::const_iterator const_iterator;
+
+        std::pair<iterator,bool> insert(const OString& rKey, MergeData* pMergeData);
+        iterator find(const OString& rKey);
+
+        iterator begin() {return m_aHashMap.begin();}
+        iterator end() {return m_aHashMap.end();}
+
+        const_iterator begin() const {return m_aHashMap.begin();}
+        const_iterator end() const {return m_aHashMap.end();}
+
+    private:
+        bool bFirstSearch;
+        iterator aLastInsertion;
+        iterator aLastFound;
+        iterator aFirstInOrder;
+        HashMap_t m_aHashMap;
+};
+
 //
 // class MergeData
 //
@@ -293,12 +339,16 @@ class MergeDataFile;
 
 class MergeData
 {
+    friend class MergeDataHashMap;
+
 public:
     OString sTyp;
     OString sGID;
     OString sLID;
     OString sFilename;
     MergeEntrys* pMergeEntrys;
+private:
+    MergeDataHashMap::iterator m_aNextData;
 public:
     MergeData( const OString &rTyp, const OString &rGID, const OString &rLID , const OString &rFilename );
     ~MergeData();
@@ -326,7 +376,7 @@ class MergeDataFile
             const OString &rLID, const OString &nLang,
             const OString &rTEXT, const OString &rQHTEXT,
             const OString &rTITLE, const OString &sFilename,
-            bool bCaseSensitive);
+            bool bFirstLang, bool bCaseSensitive);
     public:
         explicit MergeDataFile(
             const OString &rFileName, const OString& rFile,

l10ntools/source/cfgmerge.cxx

@@ -450,7 +450,7 @@ CfgMerge::~CfgMerge()
     delete pResData;
 }
 
-void CfgMerge::WorkOnText(OString &rText, const OString& rLangIndex)
+void CfgMerge::WorkOnText(OString &, const OString& rLangIndex)
 {
 
     if ( pMergeDataFile && bLocalize ) {
@@ -470,19 +470,8 @@ void CfgMerge::WorkOnText(OString &rText, const OString& rLangIndex)
             pResData->sResTyp = pStackData->sResTyp;
         }
 
-        if (rLangIndex.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")))
+        if (rLangIndex.equalsIgnoreAsciiCase("en-US"))
             bEnglish = sal_True;
-
-        MergeEntrys *pEntrys = pMergeDataFile->GetMergeEntrysCaseSensitive( pResData );
-        if ( pEntrys ) {
-            OString sContent;
-            pEntrys->GetText( sContent, STRING_TYP_TEXT, rLangIndex );
-
-            if ( !rLangIndex.equalsIgnoreAsciiCase("en-US") && !sContent.isEmpty())
-            {
-                rText = helper::QuotHTML( rText );
-            }
-        }
     }
 }
 

l10ntools/source/helpmerge.cxx

@@ -119,7 +119,6 @@ bool HelpParser::CreatePO(
     {
         posm = aXMLStrHM->find( *pos );
         pElem = posm->second;
-        OString sCur;
 
         pXMLElement = (*pElem)[ "en-US" ];
 
@@ -138,7 +137,7 @@ bool HelpParser::CreatePO(
         }
         else
         {
-            fprintf(stdout,"\nDBG: NullPointer in HelpParser::CreatePO, Language %s, File %s\n", sCur.getStr(), sHelpFile.getStr());
+            fprintf(stdout,"\nDBG: NullPointer in HelpParser::CreatePO, File %s\n", sHelpFile.getStr());
         }
     }
     aPoOutput.close();
@@ -174,17 +173,21 @@ bool HelpParser::MergeSingleFile( XMLFile* file , MergeDataFile* pMergeDataFile
     static  ResData pResData("","");
     pResData.sResTyp   = "help";
 
-    for(XMLHashMap::iterator pos=aXMLStrHM->begin();pos!=aXMLStrHM->end();++pos)    // Merge every l10n related string
-    {
+    std::vector<OString> order = file->getOrder();
+    std::vector<OString>::iterator pos;
+    XMLHashMap::iterator posm;
 
-        aLangHM             = pos->second;
+    for( pos = order.begin(); pos != order.end() ; ++pos ) // Merge every l10n related string in the same order as export
+    {
+        posm = aXMLStrHM->find( *pos );
+        aLangHM = posm->second;
 #if OSL_DEBUG_LEVEL > 2
         printf("*********************DUMPING HASHMAP***************************************");
         Dump(aXMLStrHM);
         printf("DBG: sHelpFile = %s\n",sHelpFile.getStr() );
 #endif
 
-        pResData.sGId      =  pos->first;
+        pResData.sGId      =  posm->first;
         pResData.sFilename  =  sHelpFile;
 
         ProcessHelp( aLangHM , sLanguage, &pResData , pMergeDataFile );

l10ntools/source/merge.cxx

@@ -187,6 +187,60 @@ OString MergeEntrys::GetQTZText(const ResData& rResData, const OString& rOrigTex
     return sKey + "||" + rOrigText;
 }
 
+//
+// class MergeDataHashMap
+//
+
+std::pair<MergeDataHashMap::iterator,bool> MergeDataHashMap::insert(const OString& rKey, MergeData* pMergeData)
+{
+    std::pair<iterator,bool> aTemp = m_aHashMap.insert(HashMap_t::value_type( rKey, pMergeData ));
+    if( m_aHashMap.size() == 1 )
+    {
+        ///When first insert, set an iterator to the first element
+        aFirstInOrder = aTemp.first;
+    }
+    else
+    {
+        ///Define insertion order by setting an iterator to the next element.
+        aLastInsertion->second->m_aNextData = aTemp.first;
+    }
+    aLastInsertion = aTemp.first;
+    return aTemp;
+}
+
+MergeDataHashMap::iterator MergeDataHashMap::find(const OString& rKey)
+{
+    iterator aHint = m_aHashMap.end();
+
+    ///Add a hint
+    if( bFirstSearch && !m_aHashMap.empty() )
+    {
+        aHint = aFirstInOrder;
+    }
+    else if( aLastFound == aLastInsertion )
+    {
+        /// Next to the last element is the first element
+        aHint = aFirstInOrder;
+    }
+    else if( aLastFound != m_aHashMap.end() && aLastFound != aLastInsertion )
+    {
+        aHint = aLastFound->second->m_aNextData;
+    }
+
+    ///If hint works than no need for search
+    if( aHint != m_aHashMap.end() && aHint->first == rKey )
+    {
+        aLastFound = aHint;
+    }
+    else
+    {
+        aLastFound = m_aHashMap.find(rKey);
+    }
+
+    bFirstSearch = false;
+    return aLastFound;
+}
+
 //
 // class MergeData
 //
@@ -310,7 +364,8 @@ MergeDataFile::MergeDataFile(
             InsertEntry(
                 aActPo.getResourceType(), aActPo.getGroupId(),
                 aActPo.getLocalId(), sLang, sText,
-                sQHText, sTitle, aActPo.getSourceFile(), bCaseSensitive );
+                sQHText, sTitle, aActPo.getSourceFile(),
+                bFirstLang, bCaseSensitive );
 
             if( bFirstLang && bWithQtz &&
                 ( strcmp(getenv("ENABLE_RELEASE_BUILD"),"TRUE") ) )
@@ -321,7 +376,7 @@ MergeDataFile::MergeDataFile(
                     aActPo.getLocalId(), "qtz",
                     sExText, sExQHText,
                     sExTitle, aActPo.getSourceFile(),
-                    bCaseSensitive );
+                    false, bCaseSensitive );
             }
         }
         aPoInput.close();
@@ -357,11 +412,12 @@ MergeData *MergeDataFile::GetMergeData( ResData *pResData , bool bCaseSensitive
 
     OString sKey = CreateKey( pResData->sResTyp , pResData->sGId , pResData->sId , pResData->sFilename , bCaseSensitive );
 
-    if(aMap.find( sKey ) != aMap.end())
+    MergeDataHashMap::const_iterator mit = aMap.find( sKey );
+    if(mit != aMap.end())
     {
         pResData->sGId = sOldG;
         pResData->sId = sOldL;
-        return aMap[ sKey ];
+        return mit->second;
     }
     pResData->sGId = sOldG;
     pResData->sId = sOldL;
@@ -391,24 +447,28 @@ void MergeDataFile::InsertEntry(
     const OString &rLID, const OString &nLANG,
     const OString &rTEXT, const OString &rQHTEXT,
     const OString &rTITLE, const OString &rInFilename,
-    bool bCaseSensitive )
+    bool bFirstLang, bool bCaseSensitive )
 {
-    MergeData *pData;
+    MergeData *pData = 0;
 
     // search for MergeData
     OString sKey = CreateKey(rTYP , rGID , rLID , rInFilename , bCaseSensitive);
-    MergeDataHashMap::const_iterator mit;
-    mit = aMap.find( sKey );
-    if( mit != aMap.end() )
+
+    if( !bFirstLang )
     {
-        pData = mit->second;
+        MergeDataHashMap::const_iterator mit = aMap.find( sKey );
+        if(mit != aMap.end())
+            pData = mit->second;
+
     }
-    else
+
+    if( !pData )
     {
         pData = new MergeData( rTYP, rGID, rLID, rInFilename );
-        aMap.insert( MergeDataHashMap::value_type( sKey, pData ) );
+        aMap.insert( sKey, pData );
     }
 
+
     // insert the cur string
     MergeEntrys *pMergeEntrys = pData->GetMergeEntries();
     if( nLANG =="qtz" )

l10ntools/source/xrmmerge.cxx

@@ -523,7 +523,7 @@ void XRMResMerge::WorkOnDesc(
 /*****************************************************************************/
 void XRMResMerge::WorkOnText(
     const OString &rOpenTag,
-    OString &rText
+    OString &
 )
 /*****************************************************************************/
 {
@@ -534,18 +534,6 @@ void XRMResMerge::WorkOnText(
             pResData = new ResData( GetGID(), sFilename );
             pResData->sResTyp = sResourceType;
         }
-
-        MergeEntrys *pEntrys = pMergeDataFile->GetMergeEntrys( pResData );
-            if ( pEntrys ) {
-                OString sContent;
-                if ( !sLang.equalsIgnoreAsciiCase("en-US") &&
-                    ( pEntrys->GetText(
-                        sContent, STRING_TYP_TEXT, sLang )) && !sContent.isEmpty() &&
-                    helper::isWellFormedXML( sContent ))
-                {
-                    rText = sContent;
-                }
-            }
     }
 }
 

solenv/gbuild/HelpTarget.mk

@@ -38,7 +38,7 @@ gb_HelpTranslatePartTarget_COMMAND := $(call gb_Executable_get_command,helpex)
 
 define gb_HelpTranslatePartTarget__command
 $(call gb_Output_announce,$(2),$(true),HPX,1)
-HELPFILES=$(call var2file,$(shell $(gb_MKTEMP)),100,$(filter %.xhp,$(3))) && \
+HELPFILES=$(call var2file,$(shell $(gb_MKTEMP)),100,$(sort $(filter %.xhp,$(3)))) && \
 $(call gb_Helper_abbreviate_dirs, \
 	$(if $(filter-out qtz,$(HELP_LANG)), \
 		POFILES=$(call var2file,$(shell $(gb_MKTEMP)),100,$(sort $(POFILES))) && \