qadevOOo/runner/convwatch/IniFile.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package convwatch;
  20
  21 import java.io.File;
  22 import java.io.RandomAccessFile;
  23 import java.util.ArrayList;
  24
  25 /**
  26    Helper class to give a simple API to read/write windows like ini files
  27  */
  28 /* public */ // is only need, if we need this class outside package convwatch
  29 class IniFile
  30 {
  31     /**
  32      * internal representation of the ini file content.
  33      * Problem, if ini file changed why other write something difference, we don't realise this.
  34      */
  35     String m_sFilename;
  36     ArrayList<String> m_aList;
  37     boolean m_bListContainUnsavedChanges = false;
  38
  39     /**
  40        open a ini file by it's name
  41        @param _sFilename string a filename, if the file doesn't exist, a new empty ini file will create.
  42        write back to disk only if there are really changes.
  43      */
  44     public IniFile(String _sFilename)
  45         {
  46             m_sFilename = _sFilename;
  47             m_aList = loadLines();
  48         }
  49
  50     ArrayList<String> loadLines()
  51         {
  52             File aFile = new File(m_sFilename);
  53             ArrayList<String> aLines = new ArrayList<String>();
  54             if (! aFile.exists())
  55             {
  56                 GlobalLogWriter.get().println("couldn't find file " + m_sFilename);
  57                 // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
  58                 // m_bListContainUnsavedChanges = false;
  59                 return aLines;
  60             }
  61             RandomAccessFile aReader = null;
  62             try
  63             {
  64                 aReader = new RandomAccessFile(aFile,"r");
  65                 String aLine = "";
  66                 while (aLine != null)
  67                 {
  68                     aLine = aReader.readLine();
  69                     if (aLine != null)
  70                     {
  71                         aLines.add(aLine);
  72                         }
  73                     }
  74                 }
  75             catch (java.io.FileNotFoundException fne)
  76             {
  77                 GlobalLogWriter.get().println("couldn't open file " + m_sFilename);
  78                 GlobalLogWriter.get().println("Message: " + fne.getMessage());
  79                 // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
  80             }
  81             catch (java.io.IOException ie)
  82             {
  83                 GlobalLogWriter.get().println("Exception occurs while reading from file " + m_sFilename);
  84                 GlobalLogWriter.get().println("Message: " + ie.getMessage());
  85                 // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
  86             }
  87             try
  88             {
  89                 aReader.close();
  90             }
  91             catch (java.io.IOException ie)
  92             {
  93                 GlobalLogWriter.get().println("Couldn't close file " + m_sFilename);
  94                 GlobalLogWriter.get().println("Message: " + ie.getMessage());
  95                 // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
  96             }
  97             return aLines;
  98         }
  99
 100     /**
 101      * @return true, if the ini file contain some readable data
 102      */
 103     public boolean is()
 104         {
 105             return m_aList.size() > 1 ? true : false;
 106         }
 107
 108     // -----------------------------------------------------------------------------
 109
 110     boolean isRemark(String _sLine)
 111         {
 112             if ( ((_sLine.length() < 2) ) ||
 113                  ( _sLine.startsWith("#")) ||
 114                  ( _sLine.startsWith(";")) )
 115             {
 116                 return true;
 117             }
 118             return false;
 119         }
 120
 121     String getItem(int i)
 122         {
 123             return m_aList.get(i);
 124         }
 125
 126     String buildSectionName(String _sSectionName)
 127         {
 128             String sFindSection = "[" + _sSectionName + "]";
 129             return sFindSection;
 130         }
 131     String toLowerIfNeed(String _sName)
 132         {
 133             return _sName.toLowerCase();
 134         }
 135
 136     // return the number where this section starts
 137     int findSection(String _sSection)
 138         {
 139             String sFindSection = toLowerIfNeed(buildSectionName(_sSection));
 140             // ----------- find _sSection ---------------
 141             int i;
 142             for (i=0; i<m_aList.size();i++)
 143             {
 144                 String sLine = toLowerIfNeed(getItem(i).trim());
 145                 if (isRemark(sLine))
 146             {
 147                     continue;
 148                 }
 149                 if (sFindSection.equals("[]"))
 150                 {
 151                     // special case, empty Section.
 152                     return i - 1;
 153                 }
 154                 if (sLine.startsWith(sFindSection))
 155                 {
 156                     return i;
 157                 }
 158             }
 159             return -1;
 160         }
 161
 162     // return the line number, where the key is found.
 163     int findKey(String _sSection, String _sKey)
 164         {
 165             int i = findSection(_sSection);
 166             if (i == -1)
 167             {
 168                 // Section not found, therefore the value can't exist
 169                 return -1;
 170             }
 171             return findKeyFromKnownSection(i, _sKey);
 172         }
 173
 174     // i must be the index in the list, where the well known section starts
 175     int findKeyFromKnownSection(int _nSectionIndex, String _sKey)
 176         {
 177             _sKey = toLowerIfNeed(_sKey);
 178             for (int j=_nSectionIndex + 1; j<m_aList.size();j++)
 179             {
 180                 String sLine = getItem(j).trim();
 181
 182                 if (isRemark(sLine))
 183                 {
 184                     continue;
 185                 }
 186
 187                 if (sLine.startsWith("[") /* && sLine.endsWith("]") */)
 188                 {
 189                     // found end.
 190                     break;
 191                 }
 192
 193                 int nEqual = sLine.indexOf("=");
 194                 if (nEqual >= 0)
 195                 {
 196                     String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim());
 197                     if (sKey.equals(_sKey))
 198                     {
 199                         return j;
 200                     }
 201             }
 202             }
 203             return -1;
 204         }
 205
 206     // i must be the index in the list, where the well known section starts
 207     int findLastKnownKeyIndex(int _nSectionIndex, String _sKey)
 208         {
 209             _sKey = toLowerIfNeed(_sKey);
 210             int i = _nSectionIndex + 1;
 211             for (int j=i; j<m_aList.size();j++)
 212             {
 213                 String sLine = getItem(j).trim();
 214
 215                 if (isRemark(sLine))
 216                 {
 217                     continue;
 218                 }
 219
 220                 if (sLine.startsWith("[") /* && sLine.endsWith("]") */)
 221                 {
 222                     // found end.
 223                     return j;
 224                 }
 225
 226                 int nEqual = sLine.indexOf("=");
 227                 if (nEqual >= 0)
 228                 {
 229                     String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim());
 230                     if (sKey.equals(_sKey))
 231                     {
 232                         return j;
 233                     }
 234                 }
 235             }
 236             return i;
 237         }
 238
 239     String getValue(int _nIndex)
 240         {
 241             String sLine = getItem(_nIndex).trim();
 242             if (isRemark(sLine))
 243             {
 244                 return "";
 245             }
 246             int nEqual = sLine.indexOf("=");
 247             if (nEqual >= 0)
 248             {
 249                 sLine.substring(0, nEqual).trim();
 250                 String sValue = sLine.substring(nEqual + 1).trim();
 251                 return sValue;
 252                     }
 253             return "";
 254                 }
 255
 256     /**
 257        @param _sSection string
 258        @param _sKey string
 259        @return the value found in the inifile which is given by the section and key parameter
 260     */
 261     public String getValue(String _sSection, String _sKey)
 262         {
 263             String sValue = "";
 264             int i = findKey(_sSection, _sKey);
 265             if (i == -1)
 266             {
 267                 // Section not found, therefore the value can't exist
 268                 return "";
 269             }
 270
 271             sValue = getValue(i);
 272
 273             return sValue;
 274         }
 275
 276     /**
 277        write back the ini file to the disk, only if there exist changes
 278     */
 279     public void store()
 280         {
 281             if (m_bListContainUnsavedChanges == false)
 282             {
 283                 // nothing has changed, so no need to store
 284                 return;
 285             }
 286
 287             File aFile = new File(m_sFilename);
 288             if (aFile.exists())
 289             {
 290                 // System.out.println("couldn't find file " + m_sFilename);
 291                 aFile.delete();
 292                 if (aFile.exists())
 293                 {
 294                     GlobalLogWriter.get().println("Couldn't delete the file " + m_sFilename);
 295                     return;
 296                     // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, "Couldn't delete the file " + m_sFilename);
 297                 }
 298             }
 299             // if (! aFile.canWrite())
 300             // {
 301             //    System.out.println("Couldn't write to file " + m_sFilename);
 302             //    DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, "");
 303             // }
 304             try
 305             {
 306                 RandomAccessFile aWriter = new RandomAccessFile(aFile, "rw");
 307                 for (int i=0; i<m_aList.size();i++)
 308                 {
 309                     String sLine = getItem(i);
 310                     aWriter.writeBytes(sLine);
 311                     aWriter.writeByte('\n');
 312                 }
 313                 aWriter.close();
 314             }
 315
 316             catch (java.io.FileNotFoundException fne)
 317             {
 318                 GlobalLogWriter.get().println("couldn't open file for writing " + m_sFilename);
 319                 GlobalLogWriter.get().println("Message: " + fne.getMessage());
 320                 // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
 321             }
 322             catch(java.io.IOException ie)
 323             {
 324                 GlobalLogWriter.get().println("Exception occurs while writing to file " + m_sFilename);
 325                 GlobalLogWriter.get().println("Message: " + ie.getMessage());
 326                 // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
 327             }
 328         }
 329
 330
 331
 332     /**
 333        insert a value
 334        there are 3 cases
 335        1. section doesn't exist, goto end and insert a new section, insert a new key value pair
 336        2. section exist but key not, search section, search key, if key is -1 get last known key position and insert new key value pair there
 337        3. section exist and key exist, remove the old key and insert the key value pair at the same position
 338     */
 339     public void insertValue(String _sSection, String _sKey, String _sValue)
 340         {
 341             int i = findSection(_sSection);
 342             if (i == -1)
 343             {
 344                 // case 1: section doesn't exist
 345                 String sFindSection = buildSectionName(_sSection);
 346
 347                 m_aList.add(sFindSection);
 348                 String sKeyValuePair = _sKey + "=" + _sValue;
 349                 m_aList.add(sKeyValuePair);
 350                 m_bListContainUnsavedChanges = true;
 351                 return;
 352             }
 353             int j = findKeyFromKnownSection(i, _sKey);
 354             if (j == -1)
 355             {
 356                 // case 2: section exist, but not the key
 357                 j = findLastKnownKeyIndex(i, _sKey);
 358                 String sKeyValuePair = _sKey + "=" + _sValue;
 359                 m_aList.add(j, sKeyValuePair);
 360                 m_bListContainUnsavedChanges = true;
 361                 return;
 362             }
 363             else
 364             {
 365                 // case 3: section exist, and also the key
 366                 String sKeyValuePair = _sKey + "=" + _sValue;
 367                 m_aList.set(j, sKeyValuePair);
 368                 m_bListContainUnsavedChanges = true;
 369             }
 370         }
 371     // -----------------------------------------------------------------------------
 372     // String replaceEvaluatedValue(String _sSection, String _sValue)
 373     //     {
 374     //         String sValue = _sValue;
 375     //         int nIndex = 0;
 376     //         while (( nIndex = sValue.indexOf("$(", nIndex)) >= 0)
 377     //         {
 378     //             int nNextIndex = sValue.indexOf(")", nIndex);
 379     //             if (nNextIndex >= 0)
 380     //             {
 381     //                 String sKey = sValue.substring(nIndex + 2, nNextIndex);
 382     //                 String sNewValue = getValue(_sSection, sKey);
 383     //                 if (sNewValue != null && sNewValue.length() > 0)
 384     //                 {
 385     //                     String sRegexpKey = "\\$\\(" + sKey + "\\)";
 386     //                     sValue = sValue.replaceAll(sRegexpKey, sNewValue);
 387     //                 }
 388     //                 nIndex = nNextIndex;
 389     //             }
 390     //             else
 391     //             {
 392     //                 nIndex += 2;
 393     //             }
 394     //         }
 395     //         return sValue;
 396     //     }
 397     // -----------------------------------------------------------------------------
 398
 399     // public String getLocalEvaluatedValue(String _sSection, String _sKey)
 400     //     {
 401     //         String sValue = getValue(_sSection, _sKey);
 402     //         sValue = replaceEvaluatedValue(_sSection, sValue);
 403     //         return sValue;
 404     //     }
 405
 406     // -----------------------------------------------------------------------------
 407
 408     // this is a special behaviour.
 409     // public String getGlobalLocalEvaluatedValue(String _sSection, String _sKey)
 410     //     {
 411     //         String sGlobalValue = getKey("global", _sKey);
 412     //         String sLocalValue = getKey(_sSection, _sKey);
 413     //         if (sLocalValue.length() == 0)
 414     //         {
 415     //             sGlobalValue = replaceEvaluatedKey(_sSection, sGlobalValue);
 416     //             sGlobalValue = replaceEvaluatedKey("global", sGlobalValue);
 417     //             return sGlobalValue;
 418     //         }
 419     //         sLocalValue = replaceEvaluatedKey(_sSection, sLocalValue);
 420     //         sLocalValue = replaceEvaluatedKey("global", sLocalValue);
 421     //
 422     //         return sLocalValue;
 423     //     }
 424
 425
 426     /**
 427      * some tests for this class
 428      */
 429 //    public static void main(String[] args)
 430 //        {
 431 //            IniFile aIniFile = new IniFile("/tmp/inifile");
 432 //            String sValue = aIniFile.getValue("Section","Key");
 433 //            // insert a new value to a already exist section
 434 //            aIniFile.insertValue("Section","Key2","a new value in a existing section");
 435 //            // replace a value
 436 //            aIniFile.insertValue("Section","Key","replaced value");
 437 //            // create a new value
 438 //            aIniFile.insertValue("New Section", "Key", "a new key value pair");
 439 //
 440 //            String sValue2 = aIniFile.getValue("Section2","Key");
 441 //            aIniFile.store();
 442 //        }
 443 }