sal/osl/os2/file_path_helper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: file_path_helper.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31  /*******************************************
  32      Includes
  33   ******************************************/
  34
  35  #ifndef _OSL_THREAD_H_
  36  #include "osl/thread.h"
  37  #endif
  38
  39  #ifndef _OSL_FILE_PATH_HELPER_H_
  40  #include "file_path_helper.h"
  41  #endif
  42
  43  #ifndef _OSL_FILE_PATH_HELPER_HXX_
  44  #include "file_path_helper.hxx"
  45  #endif
  46
  47  #ifndef _OSL_UUNXAPI_HXX_
  48  #include "uunxapi.hxx"
  49  #endif
  50
  51  #ifndef _OSL_DIAGNOSE_H_
  52  #include <osl/diagnose.h>
  53  #endif
  54
  55  #ifndef _RTL_USTRING_HXX_
  56  #include <rtl/ustring.hxx>
  57  #endif
  58
  59  /*******************************************
  60      Constants
  61   ******************************************/
  62
  63   const sal_Unicode FPH_CHAR_PATH_SEPARATOR = (sal_Unicode)'\\';
  64   const sal_Unicode FPH_CHAR_DOT            = (sal_Unicode)'.';
  65   const sal_Unicode FPH_CHAR_COLON          = (sal_Unicode)':';
  66
  67   inline const rtl::OUString FPH_PATH_SEPARATOR()
  68       { return rtl::OUString::createFromAscii("\\"); }
  69   inline const rtl::OUString FPH_LOCAL_DIR_ENTRY()
  70       { return rtl::OUString::createFromAscii("."); }
  71   inline const rtl::OUString FPH_PARENT_DIR_ENTRY()
  72       { return rtl::OUString::createFromAscii(".."); }
  73
  74  /*******************************************
  75   *  osl_systemPathRemoveSeparator
  76   ******************************************/
  77
  78  void SAL_CALL osl_systemPathRemoveSeparator(rtl_uString* pustrPath)
  79  {
  80      OSL_PRECOND(pustrPath, "osl_systemPathRemoveSeparator: Invalid parameter");
  81
  82     // maybe there are more than one separator at end
  83     // so we run in a loop
  84     while ((pustrPath->length > 1) && (FPH_CHAR_PATH_SEPARATOR == pustrPath->buffer[pustrPath->length - 1]))
  85     {
  86         pustrPath->length--;
  87         pustrPath->buffer[pustrPath->length] = (sal_Unicode)'\0';
  88     }
  89
  90     OSL_POSTCOND((0 == pustrPath->length) || (1 == pustrPath->length) || \
  91                  (pustrPath->length > 1 && pustrPath->buffer[pustrPath->length - 1] != FPH_CHAR_PATH_SEPARATOR), \
  92                  "osl_systemPathRemoveSeparator: Post condition failed");
  93  }
  94
  95  /*******************************************
  96     osl_systemPathEnsureSeparator
  97   ******************************************/
  98
  99  void SAL_CALL osl_systemPathEnsureSeparator(rtl_uString** ppustrPath)
 100  {
 101      OSL_PRECOND(ppustrPath && (NULL != *ppustrPath), \
 102                 "osl_systemPathEnsureSeparator: Invalid parameter");
 103
 104      rtl::OUString path(*ppustrPath);
 105     sal_Int32     lp = path.getLength();
 106     sal_Int32     i  = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 107
 108     if ((lp > 1 && i != (lp - 1)) || ((lp < 2) && i < 0))
 109     {
 110         path += FPH_PATH_SEPARATOR();
 111         rtl_uString_assign(ppustrPath, path.pData);
 112     }
 113
 114     OSL_POSTCOND(path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR) == (path.getLength() - 1), \
 115                  "osl_systemPathEnsureSeparator: Post condition failed");
 116  }
 117
 118  /*******************************************
 119   *  osl_systemPathIsRelativePath
 120   ******************************************/
 121
 122  sal_Bool SAL_CALL osl_systemPathIsRelativePath(const rtl_uString* pustrPath)
 123  {
 124      OSL_PRECOND(pustrPath, "osl_systemPathIsRelativePath: Invalid parameter");
 125      return (!osl_systemPathIsAbsolutePath(pustrPath));
 126  }
 127
 128  /******************************************
 129   *  osl_systemPathIsAbsolutePath
 130   *****************************************/
 131
 132  sal_Bool SAL_CALL osl_systemPathIsAbsolutePath(const rtl_uString* pustrPath)
 133  {
 134      OSL_PRECOND(pustrPath, "osl_systemPathIsAbsolutePath: Invalid parameter");
 135     if (pustrPath->length == 0)
 136         return sal_False;
 137     if (pustrPath->buffer[0] == FPH_CHAR_PATH_SEPARATOR)
 138         return sal_True;
 139     if (pustrPath->buffer[1] == FPH_CHAR_COLON
 140             && pustrPath->buffer[2] == FPH_CHAR_PATH_SEPARATOR)
 141         return sal_True;
 142     return sal_False;
 143  }
 144
 145  /******************************************
 146     osl_systemPathMakeAbsolutePath
 147   *****************************************/
 148
 149  void SAL_CALL osl_systemPathMakeAbsolutePath(
 150      const rtl_uString* pustrBasePath,
 151     const rtl_uString* pustrRelPath,
 152     rtl_uString**          ppustrAbsolutePath)
 153 {
 154     rtl::OUString base(rtl_uString_getStr(const_cast<rtl_uString*>(pustrBasePath)));
 155     rtl::OUString rel(const_cast<rtl_uString*>(pustrRelPath));
 156
 157     if (base.getLength() > 0)
 158         osl_systemPathEnsureSeparator(&base.pData);
 159
 160     base += rel;
 161
 162     rtl_uString_acquire(base.pData);
 163     *ppustrAbsolutePath = base.pData;
 164 }
 165
 166
 167  /*****************************************
 168     osl_systemPathGetParent
 169   ****************************************/
 170
 171  sal_Int32 SAL_CALL osl_systemPathGetParent(rtl_uString* pustrPath)
 172  {
 173      return 0;
 174  }
 175
 176  /*******************************************
 177      osl_systemPathGetFileOrLastDirectoryPart
 178   ******************************************/
 179
 180  void SAL_CALL osl_systemPathGetFileNameOrLastDirectoryPart(
 181      const rtl_uString*         pustrPath,
 182     rtl_uString**               ppustrFileNameOrLastDirPart)
 183 {
 184     OSL_PRECOND(pustrPath && ppustrFileNameOrLastDirPart, \
 185                 "osl_systemPathGetFileNameOrLastDirectoryPart: Invalid parameter");
 186
 187     rtl::OUString path(const_cast<rtl_uString*>(pustrPath));
 188
 189     osl_systemPathRemoveSeparator(path.pData);
 190
 191     rtl::OUString last_part;
 192
 193     if (path.getLength() > 1 || (1 == path.getLength() && *path.getStr() != FPH_CHAR_PATH_SEPARATOR))
 194     {
 195         sal_Int32 idx_ps = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 196         idx_ps++; // always right to increment by one even if idx_ps == -1!
 197         last_part = rtl::OUString(path.getStr() + idx_ps);
 198     }
 199     rtl_uString_assign(ppustrFileNameOrLastDirPart, last_part.pData);
 200 }
 201
 202
 203  /********************************************
 204      osl_systemPathIsHiddenFileOrDirectoryEntry
 205  *********************************************/
 206
 207  sal_Bool SAL_CALL osl_systemPathIsHiddenFileOrDirectoryEntry(
 208      const rtl_uString* pustrPath)
 209 {
 210     OSL_PRECOND(pustrPath, "osl_systemPathIsHiddenFileOrDirectoryEntry: Invalid parameter");
 211
 212     sal_Bool is_hidden = sal_False;
 213
 214     if (pustrPath->length > 0)
 215     {
 216         rtl::OUString fdp;
 217
 218         osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &fdp.pData);
 219
 220         is_hidden = ((fdp.pData->length > 0) && (fdp.pData->buffer[0] == FPH_CHAR_DOT) &&
 221                      !osl_systemPathIsLocalOrParentDirectoryEntry(fdp.pData));
 222      }
 223
 224     return is_hidden;
 225 }
 226
 227
 228  /************************************************
 229      osl_systemPathIsLocalOrParentDirectoryEntry
 230  ************************************************/
 231
 232 sal_Bool SAL_CALL osl_systemPathIsLocalOrParentDirectoryEntry(
 233     const rtl_uString* pustrPath)
 234 {
 235     OSL_PRECOND(pustrPath, "osl_systemPathIsLocalOrParentDirectoryEntry: Invalid parameter");
 236
 237     rtl::OUString dirent;
 238
 239     osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &dirent.pData);
 240
 241     return (
 242             (dirent == FPH_LOCAL_DIR_ENTRY()) ||
 243             (dirent == FPH_PARENT_DIR_ENTRY())
 244            );
 245 }
 246
 247 /***********************************************
 248  Simple iterator for a path list separated by
 249  the specified character
 250  **********************************************/
 251
 252 class path_list_iterator
 253 {
 254 public:
 255
 256     /******************************************
 257       constructor
 258
 259      after construction get_current_item
 260      returns the first path in list, no need
 261      to call reset first
 262      *****************************************/
 263     path_list_iterator(const rtl::OUString& path_list, sal_Unicode list_separator = FPH_CHAR_COLON) :
 264         m_path_list(path_list),
 265         m_end(m_path_list.getStr() + m_path_list.getLength() + 1),
 266         m_separator(list_separator)
 267     {
 268         reset();
 269     }
 270
 271     /******************************************
 272      reset the iterator
 273      *****************************************/
 274     void reset()
 275     {
 276         m_path_segment_begin = m_path_segment_end = m_path_list.getStr();
 277         advance();
 278     }
 279
 280     /******************************************
 281      move the iterator to the next position
 282      *****************************************/
 283     void next()
 284     {
 285         OSL_PRECOND(!done(), "path_list_iterator: Already done!");
 286
 287         m_path_segment_begin = ++m_path_segment_end;
 288         advance();
 289     }
 290
 291     /******************************************
 292      check if done
 293      *****************************************/
 294     bool done() const
 295     {
 296         return (m_path_segment_end >= m_end);
 297     }
 298
 299     /******************************************
 300      return the current item
 301      *****************************************/
 302     rtl::OUString get_current_item() const
 303     {
 304         return rtl::OUString(
 305             m_path_segment_begin,
 306             (m_path_segment_end - m_path_segment_begin));
 307     }
 308
 309 private:
 310
 311     /******************************************
 312      move m_path_end to the next separator or
 313      to the edn of the string
 314      *****************************************/
 315     void advance()
 316     {
 317         while (!done() && *m_path_segment_end && (*m_path_segment_end != m_separator))
 318             ++m_path_segment_end;
 319
 320         OSL_ASSERT(m_path_segment_end <= m_end);
 321     }
 322
 323 private:
 324     rtl::OUString               m_path_list;
 325     const sal_Unicode*  m_end;
 326     const sal_Unicode   m_separator;
 327     const sal_Unicode*  m_path_segment_begin;
 328     const sal_Unicode*  m_path_segment_end;
 329
 330 // prevent copy and assignment
 331 private:
 332     /******************************************
 333      copy constructor
 334      remember: do not simply copy m_path_begin
 335      and m_path_end because they point to
 336      the memory of other.m_path_list!
 337      *****************************************/
 338     path_list_iterator(const path_list_iterator& other);
 339
 340     /******************************************
 341      assignment operator
 342       remember: do not simply copy m_path_begin
 343      and m_path_end because they point to
 344      the memory of other.m_path_list!
 345      *****************************************/
 346     path_list_iterator& operator=(const path_list_iterator& other);
 347 };
 348
 349  /************************************************
 350       osl_searchPath
 351   ***********************************************/
 352
 353 sal_Bool SAL_CALL osl_searchPath(
 354      const rtl_uString* pustrFilePath,
 355     const rtl_uString* pustrSearchPathList,
 356     rtl_uString**      ppustrPathFound)
 357 {
 358     OSL_PRECOND(pustrFilePath && pustrSearchPathList && ppustrPathFound, "osl_searchPath: Invalid parameter");
 359
 360     bool               bfound = false;
 361     rtl::OUString      fp(const_cast<rtl_uString*>(pustrFilePath));
 362     rtl::OUString      pl = rtl::OUString(const_cast<rtl_uString*>(pustrSearchPathList));
 363     path_list_iterator pli(pl);
 364
 365     while (!pli.done())
 366     {
 367         rtl::OUString p = pli.get_current_item();
 368         osl::systemPathEnsureSeparator(p);
 369         p += fp;
 370
 371         if (osl::access(p, F_OK) > -1)
 372         {
 373             bfound = true;
 374             rtl_uString_assign(ppustrPathFound, p.pData);
 375             break;
 376         }
 377         pli.next();
 378     }
 379     return bfound;
 380 }