tools/source/generic/config.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cstddef>
  21 #include <cstdlib>
  22 #include <string.h>
  23
  24 #ifdef _WIN32
  25 #include <stdlib.h>
  26 #endif
  27
  28 #include <osl/file.hxx>
  29 #include <tools/config.hxx>
  30 #include <sal/log.hxx>
  31
  32 namespace {
  33
  34 struct ImplKeyData
  35 {
  36     ImplKeyData*    mpNext;
  37     OString         maKey;
  38     OString         maValue;
  39     bool            mbIsComment;
  40 };
  41
  42 }
  43
  44 struct ImplGroupData
  45 {
  46     ImplGroupData*  mpNext;
  47     ImplKeyData*    mpFirstKey;
  48     OString         maGroupName;
  49     sal_uInt16      mnEmptyLines;
  50 };
  51
  52 struct ImplConfigData
  53 {
  54     ImplGroupData*  mpFirstGroup;
  55     OUString        maFileName;
  56     sal_uInt32      mnDataUpdateId;
  57     sal_uInt32      mnTimeStamp;
  58     bool            mbModified;
  59     bool            mbRead;
  60     bool            mbIsUTF8BOM;
  61 };
  62
  63 static OUString toUncPath( const OUString& rPath )
  64 {
  65     OUString aFileURL;
  66
  67     // check if rFileName is already a URL; if not make it so
  68     if( rPath.startsWith( "file://"))
  69     {
  70         aFileURL = rPath;
  71     }
  72     else if( ::osl::FileBase::getFileURLFromSystemPath( rPath, aFileURL ) != ::osl::FileBase::E_None )
  73     {
  74         aFileURL = rPath;
  75     }
  76     return aFileURL;
  77 }
  78
  79 static sal_uInt32 ImplSysGetConfigTimeStamp( const OUString& rFileName )
  80 {
  81     sal_uInt32 nTimeStamp = 0;
  82     ::osl::DirectoryItem aItem;
  83     ::osl::FileStatus aStatus( osl_FileStatus_Mask_ModifyTime );
  84
  85     if( ::osl::DirectoryItem::get( rFileName, aItem ) == ::osl::FileBase::E_None &&
  86         aItem.getFileStatus( aStatus ) == ::osl::FileBase::E_None )
  87     {
  88         nTimeStamp = aStatus.getModifyTime().Seconds;
  89     }
  90
  91     return nTimeStamp;
  92 }
  93
  94 static std::unique_ptr<sal_uInt8[]> ImplSysReadConfig( const OUString& rFileName,
  95                                 sal_uInt64& rRead, bool& rbRead, bool& rbIsUTF8BOM, sal_uInt32& rTimeStamp )
  96 {
  97     std::unique_ptr<sal_uInt8[]> pBuf;
  98     ::osl::File aFile( rFileName );
  99
 100     if( aFile.open( osl_File_OpenFlag_Read ) == ::osl::FileBase::E_None )
 101     {
 102         sal_uInt64 nPos = 0;
 103         if( aFile.getSize( nPos ) == ::osl::FileBase::E_None )
 104         {
 105             if (nPos > SAL_MAX_SIZE) {
 106                 aFile.close();
 107                 return nullptr;
 108             }
 109             pBuf.reset(new sal_uInt8[static_cast< std::size_t >(nPos)]);
 110             sal_uInt64 nRead = 0;
 111             if( aFile.read( pBuf.get(), nPos, nRead ) == ::osl::FileBase::E_None && nRead == nPos )
 112             {
 113                 //skip the byte-order-mark 0xEF 0xBB 0xBF, if it was UTF8 files
 114                 unsigned char const BOM[3] = {0xEF, 0xBB, 0xBF};
 115                 if (nRead > 2 && memcmp(pBuf.get(), BOM, 3) == 0)
 116                 {
 117                     nRead -= 3;
 118                     memmove(pBuf.get(), pBuf.get() + 3, sal::static_int_cast<std::size_t>(nRead * sizeof(sal_uInt8)) );
 119                     rbIsUTF8BOM = true;
 120                 }
 121
 122                 rTimeStamp = ImplSysGetConfigTimeStamp( rFileName );
 123                 rbRead = true;
 124                 rRead = nRead;
 125             }
 126             else
 127             {
 128                 pBuf.reset();
 129             }
 130         }
 131         aFile.close();
 132     }
 133
 134     return pBuf;
 135 }
 136
 137 static bool ImplSysWriteConfig( const OUString& rFileName,
 138                                 const sal_uInt8* pBuf, sal_uInt32 nBufLen, bool rbIsUTF8BOM, sal_uInt32& rTimeStamp )
 139 {
 140     bool bSuccess = false;
 141     bool bUTF8BOMSuccess = false;
 142
 143     ::osl::File aFile( rFileName );
 144     ::osl::FileBase::RC eError = aFile.open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 145     if( eError != ::osl::FileBase::E_None )
 146         eError = aFile.open( osl_File_OpenFlag_Write );
 147     if( eError == ::osl::FileBase::E_None )
 148     {
 149         // truncate
 150         aFile.setSize( 0 );
 151         sal_uInt64 nWritten;
 152
 153         //write the byte-order-mark 0xEF 0xBB 0xBF first , if it was UTF8 files
 154         if ( rbIsUTF8BOM )
 155         {
 156             unsigned char const BOM[3] = {0xEF, 0xBB, 0xBF};
 157             sal_uInt64 nUTF8BOMWritten;
 158             if( aFile.write( BOM, 3, nUTF8BOMWritten ) == ::osl::FileBase::E_None && 3 == nUTF8BOMWritten )
 159             {
 160                 bUTF8BOMSuccess = true;
 161             }
 162         }
 163
 164         if( aFile.write( pBuf, nBufLen, nWritten ) == ::osl::FileBase::E_None && nWritten == nBufLen )
 165         {
 166             bSuccess = true;
 167         }
 168         if ( rbIsUTF8BOM ? bSuccess && bUTF8BOMSuccess : bSuccess )
 169         {
 170             rTimeStamp = ImplSysGetConfigTimeStamp( rFileName );
 171         }
 172     }
 173
 174     return rbIsUTF8BOM ? bSuccess && bUTF8BOMSuccess : bSuccess;
 175 }
 176
 177 namespace {
 178 OString makeOString(const sal_uInt8* p, sal_uInt64 n)
 179 {
 180     if (n > SAL_MAX_INT32)
 181     {
 182         #ifdef _WIN32
 183         abort();
 184         #else
 185         ::std::abort(); //TODO: handle this gracefully
 186         #endif
 187     }
 188     return OString(
 189         reinterpret_cast< char const * >(p),
 190         sal::static_int_cast< sal_Int32 >(n));
 191 }
 192 }
 193
 194 static void ImplMakeConfigList( ImplConfigData* pData,
 195                                 const sal_uInt8* pBuf, sal_uInt64 nLen )
 196 {
 197     if ( !nLen )
 198         return;
 199
 200     // Parse buffer and build config list
 201     sal_uInt64 nStart;
 202     sal_uInt64 nLineLen;
 203     sal_uInt64 nNameLen;
 204     sal_uInt64 nKeyLen;
 205     sal_uInt64 i;
 206     const sal_uInt8*    pLine;
 207     ImplKeyData*    pPrevKey = nullptr;
 208     ImplGroupData*  pPrevGroup = nullptr;
 209     ImplGroupData*  pGroup = nullptr;
 210     i = 0;
 211     while ( i < nLen )
 212     {
 213         // Ctrl+Z
 214         if ( pBuf[i] == 0x1A )
 215             break;
 216
 217         // Remove spaces and tabs
 218         while ( (pBuf[i] == ' ') || (pBuf[i] == '\t') )
 219             i++;
 220
 221         // remember line-starts
 222         nStart = i;
 223         pLine = pBuf+i;
 224
 225         // search line-endings
 226         while (  (i < nLen) && pBuf[i] && (pBuf[i] != '\r') && (pBuf[i] != '\n') &&
 227                 (pBuf[i] != 0x1A) )
 228             i++;
 229
 230         nLineLen = i-nStart;
 231
 232         // if Line-ending is found, continue once
 233         if ( (i+1 < nLen) &&
 234              (pBuf[i] != pBuf[i+1]) &&
 235              ((pBuf[i+1] == '\r') || (pBuf[i+1] == '\n')) )
 236             i++;
 237         i++;
 238
 239         // evaluate line
 240         if ( *pLine == '[' )
 241         {
 242             pGroup               = new ImplGroupData;
 243             pGroup->mpNext       = nullptr;
 244             pGroup->mpFirstKey   = nullptr;
 245             pGroup->mnEmptyLines = 0;
 246             if ( pPrevGroup )
 247                 pPrevGroup->mpNext = pGroup;
 248             else
 249                 pData->mpFirstGroup = pGroup;
 250             pPrevGroup  = pGroup;
 251             pPrevKey    = nullptr;
 252
 253             // filter group names
 254             pLine++;
 255             assert(nLineLen > 0);
 256             nLineLen--;
 257             // remove spaces and tabs
 258             while ( nLineLen > 0 && (*pLine == ' ' || *pLine == '\t') )
 259             {
 260                 nLineLen--;
 261                 pLine++;
 262             }
 263             nNameLen = 0;
 264             while ( (nNameLen < nLineLen) && (pLine[nNameLen] != ']') )
 265                 nNameLen++;
 266             while ( nNameLen > 0 && (pLine[nNameLen-1] == ' ' || pLine[nNameLen-1] == '\t') )
 267                 nNameLen--;
 268             pGroup->maGroupName = makeOString(pLine, nNameLen);
 269         }
 270         else
 271         {
 272             if ( nLineLen )
 273             {
 274                 // If no group exists yet, add to default
 275                 if ( !pGroup )
 276                 {
 277                     pGroup              = new ImplGroupData;
 278                     pGroup->mpNext      = nullptr;
 279                     pGroup->mpFirstKey  = nullptr;
 280                     pGroup->mnEmptyLines = 0;
 281                     pData->mpFirstGroup = pGroup;
 282                     pPrevGroup  = pGroup;
 283                     pPrevKey    = nullptr;
 284                 }
 285
 286                 // if empty line, append it
 287                 if ( pPrevKey )
 288                 {
 289                     while ( pGroup->mnEmptyLines )
 290                     {
 291                         ImplKeyData* pKey = new ImplKeyData;
 292                         pKey->mbIsComment   = true;
 293                         pPrevKey->mpNext    = pKey;
 294                         pPrevKey            = pKey;
 295                         pGroup->mnEmptyLines--;
 296                     }
 297                 }
 298
 299                 // Generate new key
 300                 ImplKeyData* pKey = new ImplKeyData;
 301                 pKey->mpNext = nullptr;
 302                 if ( pPrevKey )
 303                     pPrevKey->mpNext = pKey;
 304                 else
 305                     pGroup->mpFirstKey = pKey;
 306                 pPrevKey = pKey;
 307                 if ( pLine[0] == ';' )
 308                 {
 309                     pKey->maValue = makeOString(pLine, nLineLen);
 310                     pKey->mbIsComment = true;
 311                 }
 312                 else
 313                 {
 314                     pKey->mbIsComment = false;
 315                     nNameLen = 0;
 316                     while ( (nNameLen < nLineLen) && (pLine[nNameLen] != '=') )
 317                         nNameLen++;
 318                     nKeyLen = nNameLen;
 319                     // Remove spaces and tabs
 320                     while ( nNameLen > 0 && (pLine[nNameLen-1] == ' ' || pLine[nNameLen-1] == '\t') )
 321                         nNameLen--;
 322                     pKey->maKey = makeOString(pLine, nNameLen);
 323                     nKeyLen++;
 324                     if ( nKeyLen < nLineLen )
 325                     {
 326                         pLine += nKeyLen;
 327                         nLineLen -= nKeyLen;
 328                         // Remove spaces and tabs
 329                         while ( (*pLine == ' ') || (*pLine == '\t') )
 330                         {
 331                             nLineLen--;
 332                             pLine++;
 333                         }
 334                         if ( nLineLen )
 335                         {
 336                             while ( (pLine[nLineLen-1] == ' ') || (pLine[nLineLen-1] == '\t') )
 337                                 nLineLen--;
 338                             pKey->maValue = makeOString(pLine, nLineLen);
 339                         }
 340                     }
 341                 }
 342             }
 343             else
 344             {
 345                 // Spaces are counted and appended only after key generation,
 346                 // as we want to store spaces even after adding new keys
 347                 if ( pGroup )
 348                     pGroup->mnEmptyLines++;
 349             }
 350         }
 351     }
 352 }
 353
 354 static std::unique_ptr<sal_uInt8[]> ImplGetConfigBuffer( const ImplConfigData* pData, sal_uInt32& rLen )
 355 {
 356     std::unique_ptr<sal_uInt8[]> pWriteBuf;
 357     sal_uInt8*      pBuf;
 358     sal_uInt8       aLineEndBuf[2] = {0, 0};
 359     ImplKeyData*    pKey;
 360     ImplGroupData*  pGroup;
 361     sal_uInt32      nBufLen;
 362     sal_uInt32      nValueLen;
 363     sal_uInt32      nKeyLen;
 364     sal_uInt32      nLineEndLen;
 365
 366     aLineEndBuf[0] = '\r';
 367     aLineEndBuf[1] = '\n';
 368     nLineEndLen = 2;
 369
 370     nBufLen = 0;
 371     pGroup = pData->mpFirstGroup;
 372     while ( pGroup )
 373     {
 374         // Don't write empty groups
 375         if ( pGroup->mpFirstKey )
 376         {
 377             nBufLen += pGroup->maGroupName.getLength() + nLineEndLen + 2;
 378             pKey = pGroup->mpFirstKey;
 379             while ( pKey )
 380             {
 381                 nValueLen = pKey->maValue.getLength();
 382                 if ( pKey->mbIsComment )
 383                     nBufLen += nValueLen + nLineEndLen;
 384                 else
 385                     nBufLen += pKey->maKey.getLength() + nValueLen + nLineEndLen + 1;
 386
 387                 pKey = pKey->mpNext;
 388             }
 389
 390             // Write empty lines after each group
 391             if ( !pGroup->mnEmptyLines )
 392                 pGroup->mnEmptyLines = 1;
 393             nBufLen += nLineEndLen * pGroup->mnEmptyLines;
 394         }
 395
 396         pGroup = pGroup->mpNext;
 397     }
 398
 399     // Output buffer length
 400     rLen = nBufLen;
 401     if ( !nBufLen )
 402     {
 403         pWriteBuf.reset(new sal_uInt8[nLineEndLen]);
 404         pWriteBuf[0] = aLineEndBuf[0];
 405         if ( nLineEndLen == 2 )
 406             pWriteBuf[1] = aLineEndBuf[1];
 407         return pWriteBuf;
 408     }
 409
 410     // Allocate new write buffer (caller frees it)
 411     pWriteBuf.reset(new sal_uInt8[nBufLen]);
 412
 413     // fill buffer
 414     pBuf = pWriteBuf.get();
 415     pGroup = pData->mpFirstGroup;
 416     while ( pGroup )
 417     {
 418         // Don't write empty groups
 419         if ( pGroup->mpFirstKey )
 420         {
 421             *pBuf = '[';    pBuf++;
 422             memcpy( pBuf, pGroup->maGroupName.getStr(), pGroup->maGroupName.getLength() );
 423             pBuf += pGroup->maGroupName.getLength();
 424             *pBuf = ']';    pBuf++;
 425             *pBuf = aLineEndBuf[0]; pBuf++;
 426             if ( nLineEndLen == 2 )
 427             {
 428                 *pBuf = aLineEndBuf[1]; pBuf++;
 429             }
 430             pKey = pGroup->mpFirstKey;
 431             while ( pKey )
 432             {
 433                 nValueLen = pKey->maValue.getLength();
 434                 if ( pKey->mbIsComment )
 435                 {
 436                     if ( nValueLen )
 437                     {
 438                         memcpy( pBuf, pKey->maValue.getStr(), nValueLen );
 439                         pBuf += nValueLen;
 440                     }
 441                     *pBuf = aLineEndBuf[0]; pBuf++;
 442                     if ( nLineEndLen == 2 )
 443                     {
 444                         *pBuf = aLineEndBuf[1]; pBuf++;
 445                     }
 446                 }
 447                 else
 448                 {
 449                     nKeyLen = pKey->maKey.getLength();
 450                     memcpy( pBuf, pKey->maKey.getStr(), nKeyLen );
 451                     pBuf += nKeyLen;
 452                     *pBuf = '=';    pBuf++;
 453                     memcpy( pBuf, pKey->maValue.getStr(), nValueLen );
 454                     pBuf += nValueLen;
 455                     *pBuf = aLineEndBuf[0]; pBuf++;
 456                     if ( nLineEndLen == 2 )
 457                     {
 458                         *pBuf = aLineEndBuf[1]; pBuf++;
 459                     }
 460                 }
 461
 462                 pKey = pKey->mpNext;
 463             }
 464
 465             // Store empty line after each group
 466             sal_uInt16 nEmptyLines = pGroup->mnEmptyLines;
 467             while ( nEmptyLines )
 468             {
 469                 *pBuf = aLineEndBuf[0]; pBuf++;
 470                 if ( nLineEndLen == 2 )
 471                 {
 472                     *pBuf = aLineEndBuf[1]; pBuf++;
 473                 }
 474                 nEmptyLines--;
 475             }
 476         }
 477
 478         pGroup = pGroup->mpNext;
 479     }
 480
 481     return pWriteBuf;
 482 }
 483
 484 static void ImplReadConfig( ImplConfigData* pData )
 485 {
 486     sal_uInt32   nTimeStamp = 0;
 487     sal_uInt64  nRead = 0;
 488     bool    bRead = false;
 489     bool    bIsUTF8BOM = false;
 490     std::unique_ptr<sal_uInt8[]> pBuf = ImplSysReadConfig( pData->maFileName, nRead, bRead, bIsUTF8BOM, nTimeStamp );
 491
 492     // Read config list from buffer
 493     if ( pBuf )
 494     {
 495         ImplMakeConfigList( pData, pBuf.get(), nRead );
 496         pBuf.reset();
 497     }
 498     pData->mnTimeStamp = nTimeStamp;
 499     pData->mbModified  = false;
 500     if ( bRead )
 501         pData->mbRead = true;
 502     if ( bIsUTF8BOM )
 503         pData->mbIsUTF8BOM = true;
 504 }
 505
 506 static void ImplWriteConfig( ImplConfigData* pData )
 507 {
 508     SAL_WARN_IF( pData->mnTimeStamp != ImplSysGetConfigTimeStamp( pData->maFileName ),
 509         "tools.generic", "Config overwrites modified configfile: " << pData->maFileName );
 510
 511     // Read config list from buffer
 512     sal_uInt32 nBufLen;
 513     std::unique_ptr<sal_uInt8[]> pBuf = ImplGetConfigBuffer( pData, nBufLen );
 514     if ( pBuf )
 515     {
 516         if ( ImplSysWriteConfig( pData->maFileName, pBuf.get(), nBufLen, pData->mbIsUTF8BOM, pData->mnTimeStamp ) )
 517             pData->mbModified = false;
 518     }
 519     else
 520         pData->mbModified = false;
 521 }
 522
 523 static void ImplDeleteConfigData( ImplConfigData* pData )
 524 {
 525     ImplKeyData*    pTempKey;
 526     ImplKeyData*    pKey;
 527     ImplGroupData*  pTempGroup;
 528     ImplGroupData*  pGroup = pData->mpFirstGroup;
 529     while ( pGroup )
 530     {
 531         pTempGroup = pGroup->mpNext;
 532
 533         // remove all keys
 534         pKey = pGroup->mpFirstKey;
 535         while ( pKey )
 536         {
 537             pTempKey = pKey->mpNext;
 538             delete pKey;
 539             pKey = pTempKey;
 540         }
 541
 542         // remove group and continue
 543         delete pGroup;
 544         pGroup = pTempGroup;
 545     }
 546
 547     pData->mpFirstGroup = nullptr;
 548 }
 549
 550 static std::unique_ptr<ImplConfigData> ImplGetConfigData( const OUString& rFileName )
 551 {
 552     std::unique_ptr<ImplConfigData> pData(new ImplConfigData);
 553     pData->maFileName       = rFileName;
 554     pData->mpFirstGroup     = nullptr;
 555     pData->mnDataUpdateId   = 0;
 556     pData->mbRead           = false;
 557     pData->mbIsUTF8BOM      = false;
 558     ImplReadConfig( pData.get() );
 559
 560     return pData;
 561 }
 562
 563 bool Config::ImplUpdateConfig() const
 564 {
 565     // Re-read file if timestamp differs
 566     if ( mpData->mnTimeStamp != ImplSysGetConfigTimeStamp( maFileName ) )
 567     {
 568         ImplDeleteConfigData( mpData.get() );
 569         ImplReadConfig( mpData.get() );
 570         mpData->mnDataUpdateId++;
 571         return true;
 572     }
 573     else
 574         return false;
 575 }
 576
 577 ImplGroupData* Config::ImplGetGroup() const
 578 {
 579     if ( !mpActGroup || (mnDataUpdateId != mpData->mnDataUpdateId) )
 580     {
 581         ImplGroupData* pPrevGroup = nullptr;
 582         ImplGroupData* pGroup = mpData->mpFirstGroup;
 583         while ( pGroup )
 584         {
 585             if ( pGroup->maGroupName.equalsIgnoreAsciiCase(maGroupName) )
 586                 break;
 587
 588             pPrevGroup = pGroup;
 589             pGroup = pGroup->mpNext;
 590         }
 591
 592         // Add group if not exists
 593         if ( !pGroup )
 594         {
 595             pGroup               = new ImplGroupData;
 596             pGroup->mpNext       = nullptr;
 597             pGroup->mpFirstKey   = nullptr;
 598             pGroup->mnEmptyLines = 1;
 599             if ( pPrevGroup )
 600                 pPrevGroup->mpNext = pGroup;
 601             else
 602                 mpData->mpFirstGroup = pGroup;
 603         }
 604
 605         // Always inherit group names and update cache members
 606         pGroup->maGroupName             = maGroupName;
 607         const_cast<Config*>(this)->mnDataUpdateId = mpData->mnDataUpdateId;
 608         const_cast<Config*>(this)->mpActGroup     = pGroup;
 609     }
 610
 611     return mpActGroup;
 612 }
 613
 614 Config::Config( const OUString& rFileName )
 615 {
 616     // Initialize config data
 617     maFileName      = toUncPath( rFileName );
 618     mpData          = ImplGetConfigData( maFileName );
 619     mpActGroup      = nullptr;
 620     mnDataUpdateId  = 0;
 621
 622     SAL_INFO("tools.generic", "Config::Config( " << maFileName << " )");
 623 }
 624
 625 Config::~Config()
 626 {
 627     SAL_INFO("tools.generic", "Config::~Config()" );
 628
 629     Flush();
 630     ImplDeleteConfigData( mpData.get() );
 631 }
 632
 633 void Config::SetGroup(const OString& rGroup)
 634 {
 635     // If group is to be reset, it needs to be updated on next call
 636     if ( maGroupName != rGroup )
 637     {
 638         maGroupName     = rGroup;
 639         mnDataUpdateId  = mpData->mnDataUpdateId-1;
 640     }
 641 }
 642
 643 void Config::DeleteGroup(std::string_view rGroup)
 644 {
 645     // Update config data if necessary
 646     if ( !mpData->mbRead )
 647     {
 648         ImplUpdateConfig();
 649         mpData->mbRead = true;
 650     }
 651
 652     ImplGroupData* pPrevGroup = nullptr;
 653     ImplGroupData* pGroup = mpData->mpFirstGroup;
 654     while ( pGroup )
 655     {
 656         if ( pGroup->maGroupName.equalsIgnoreAsciiCase(rGroup) )
 657             break;
 658
 659         pPrevGroup = pGroup;
 660         pGroup = pGroup->mpNext;
 661     }
 662
 663     if ( !pGroup )
 664         return;
 665
 666     // Remove all keys
 667     ImplKeyData* pTempKey;
 668     ImplKeyData* pKey = pGroup->mpFirstKey;
 669     while ( pKey )
 670     {
 671         pTempKey = pKey->mpNext;
 672         delete pKey;
 673         pKey = pTempKey;
 674     }
 675
 676     // Rewire pointers and remove group
 677     if ( pPrevGroup )
 678         pPrevGroup->mpNext = pGroup->mpNext;
 679     else
 680         mpData->mpFirstGroup = pGroup->mpNext;
 681     delete pGroup;
 682
 683     // Rewrite config data
 684     mpData->mbModified = true;
 685
 686     mnDataUpdateId = mpData->mnDataUpdateId;
 687     mpData->mnDataUpdateId++;
 688 }
 689
 690 OString Config::GetGroupName(sal_uInt16 nGroup) const
 691 {
 692     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 693     sal_uInt16          nGroupCount = 0;
 694     OString aGroupName;
 695     while ( pGroup )
 696     {
 697         if ( nGroup == nGroupCount )
 698         {
 699             aGroupName = pGroup->maGroupName;
 700             break;
 701         }
 702
 703         nGroupCount++;
 704         pGroup = pGroup->mpNext;
 705     }
 706
 707     return aGroupName;
 708 }
 709
 710 sal_uInt16 Config::GetGroupCount() const
 711 {
 712     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 713     sal_uInt16          nGroupCount = 0;
 714     while ( pGroup )
 715     {
 716         nGroupCount++;
 717         pGroup = pGroup->mpNext;
 718     }
 719
 720     return nGroupCount;
 721 }
 722
 723 bool Config::HasGroup(std::string_view rGroup) const
 724 {
 725     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 726     bool            bRet = false;
 727
 728     while( pGroup )
 729     {
 730         if( pGroup->maGroupName.equalsIgnoreAsciiCase(rGroup) )
 731         {
 732             bRet = true;
 733             break;
 734         }
 735
 736         pGroup = pGroup->mpNext;
 737     }
 738
 739     return bRet;
 740 }
 741
 742 OString Config::ReadKey(const OString& rKey) const
 743 {
 744     return ReadKey(rKey, OString());
 745 }
 746
 747 OString Config::ReadKey(const OString& rKey, const OString& rDefault) const
 748 {
 749     SAL_INFO("tools.generic", "Config::ReadKey( " << rKey << " ) from " << GetGroup()
 750                       << " in " << maFileName);
 751
 752     // Search key, return value if found
 753     ImplGroupData* pGroup = ImplGetGroup();
 754     if ( pGroup )
 755     {
 756         ImplKeyData* pKey = pGroup->mpFirstKey;
 757         while ( pKey )
 758         {
 759             if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 760                 return pKey->maValue;
 761
 762             pKey = pKey->mpNext;
 763         }
 764     }
 765
 766     return rDefault;
 767 }
 768
 769 void Config::WriteKey(const OString& rKey, const OString& rStr)
 770 {
 771     SAL_INFO("tools.generic", "Config::WriteKey( " << rKey << ", " << rStr << " ) to "
 772                        << GetGroup() << " in " << maFileName);
 773
 774     // Update config data if necessary
 775     if ( !mpData->mbRead )
 776     {
 777         ImplUpdateConfig();
 778         mpData->mbRead = true;
 779     }
 780
 781     // Search key and update value if found
 782     ImplGroupData* pGroup = ImplGetGroup();
 783     if ( !pGroup )
 784         return;
 785
 786     ImplKeyData* pPrevKey = nullptr;
 787     ImplKeyData* pKey = pGroup->mpFirstKey;
 788     while ( pKey )
 789     {
 790         if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 791             break;
 792
 793         pPrevKey = pKey;
 794         pKey = pKey->mpNext;
 795     }
 796
 797     bool bNewValue;
 798     if ( !pKey )
 799     {
 800         pKey              = new ImplKeyData;
 801         pKey->mpNext      = nullptr;
 802         pKey->maKey       = rKey;
 803         pKey->mbIsComment = false;
 804         if ( pPrevKey )
 805             pPrevKey->mpNext = pKey;
 806         else
 807             pGroup->mpFirstKey = pKey;
 808         bNewValue = true;
 809     }
 810     else
 811         bNewValue = pKey->maValue != rStr;
 812
 813     if ( bNewValue )
 814     {
 815         pKey->maValue = rStr;
 816
 817         mpData->mbModified = true;
 818     }
 819 }
 820
 821 void Config::DeleteKey(std::string_view rKey)
 822 {
 823     // Update config data if necessary
 824     if ( !mpData->mbRead )
 825     {
 826         ImplUpdateConfig();
 827         mpData->mbRead = true;
 828     }
 829
 830     // Search key and update value
 831     ImplGroupData* pGroup = ImplGetGroup();
 832     if ( !pGroup )
 833         return;
 834
 835     ImplKeyData* pPrevKey = nullptr;
 836     ImplKeyData* pKey = pGroup->mpFirstKey;
 837     while ( pKey )
 838     {
 839         if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 840             break;
 841
 842         pPrevKey = pKey;
 843         pKey = pKey->mpNext;
 844     }
 845
 846     if ( pKey )
 847     {
 848         // Rewire group pointers and delete
 849         if ( pPrevKey )
 850             pPrevKey->mpNext = pKey->mpNext;
 851         else
 852             pGroup->mpFirstKey = pKey->mpNext;
 853         delete pKey;
 854
 855         mpData->mbModified = true;
 856     }
 857 }
 858
 859 sal_uInt16 Config::GetKeyCount() const
 860 {
 861     SAL_INFO("tools.generic", "Config::GetKeyCount() from " << GetGroup() << " in " << maFileName);
 862
 863     // Search key and update value
 864     sal_uInt16 nCount = 0;
 865     ImplGroupData* pGroup = ImplGetGroup();
 866     if ( pGroup )
 867     {
 868         ImplKeyData* pKey = pGroup->mpFirstKey;
 869         while ( pKey )
 870         {
 871             if ( !pKey->mbIsComment )
 872                 nCount++;
 873
 874             pKey = pKey->mpNext;
 875         }
 876     }
 877
 878     return nCount;
 879 }
 880
 881 OString Config::GetKeyName(sal_uInt16 nKey) const
 882 {
 883     SAL_INFO("tools.generic", "Config::GetKeyName( " << OString::number(static_cast<sal_Int32>(nKey))
 884                       << " ) from " << GetGroup() << " in " << maFileName);
 885
 886     // search key and return name if found
 887     ImplGroupData* pGroup = ImplGetGroup();
 888     if ( pGroup )
 889     {
 890         ImplKeyData* pKey = pGroup->mpFirstKey;
 891         while ( pKey )
 892         {
 893             if ( !pKey->mbIsComment )
 894             {
 895                 if ( !nKey )
 896                     return pKey->maKey;
 897                 nKey--;
 898             }
 899
 900             pKey = pKey->mpNext;
 901         }
 902     }
 903
 904     return OString();
 905 }
 906
 907 OString Config::ReadKey(sal_uInt16 nKey) const
 908 {
 909     SAL_INFO("tools.generic", "Config::ReadKey( " << OString::number(static_cast<sal_Int32>(nKey))
 910                        << " ) from " << GetGroup() << " in " << maFileName);
 911
 912     // Search key and return value if found
 913     ImplGroupData* pGroup = ImplGetGroup();
 914     if ( pGroup )
 915     {
 916         ImplKeyData* pKey = pGroup->mpFirstKey;
 917         while ( pKey )
 918         {
 919             if ( !pKey->mbIsComment )
 920             {
 921                 if ( !nKey )
 922                     return pKey->maValue;
 923                 nKey--;
 924             }
 925
 926             pKey = pKey->mpNext;
 927         }
 928     }
 929
 930     return OString();
 931 }
 932
 933 void Config::Flush()
 934 {
 935     if ( mpData->mbModified )
 936         ImplWriteConfig( mpData.get() );
 937 }
 938
 939 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */