sal/osl/unx/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.8 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sal.hxx"
  33
  34  /*******************************************
  35      Includes
  36   ******************************************/
  37
  38  #ifndef _OSL_FILE_PATH_HELPER_H_
  39  #include "file_path_helper.h"
  40  #endif
  41
  42  #ifndef _OSL_FILE_PATH_HELPER_HXX_
  43  #include "file_path_helper.hxx"
  44  #endif
  45
  46  #ifndef _OSL_UUNXAPI_HXX_
  47  #include "uunxapi.hxx"
  48  #endif
  49
  50  #ifndef _OSL_DIAGNOSE_H_
  51  #include <osl/diagnose.h>
  52  #endif
  53
  54  #ifndef _RTL_USTRING_HXX_
  55  #include <rtl/ustring.hxx>
  56  #endif
  57
  58  /*******************************************
  59      Constants
  60   ******************************************/
  61
  62   const sal_Unicode FPH_CHAR_PATH_SEPARATOR = (sal_Unicode)'/';
  63   const sal_Unicode FPH_CHAR_DOT            = (sal_Unicode)'.';
  64   const sal_Unicode FPH_CHAR_COLON          = (sal_Unicode)':';
  65
  66   inline const rtl::OUString FPH_PATH_SEPARATOR()
  67       { return rtl::OUString::createFromAscii("/"); }
  68   inline const rtl::OUString FPH_LOCAL_DIR_ENTRY()
  69       { return rtl::OUString::createFromAscii("."); }
  70   inline const rtl::OUString FPH_PARENT_DIR_ENTRY()
  71       { return rtl::OUString::createFromAscii(".."); }
  72
  73  /*******************************************
  74   *  osl_systemPathRemoveSeparator
  75   ******************************************/
  76
  77  void SAL_CALL osl_systemPathRemoveSeparator(rtl_uString* pustrPath)
  78  {
  79      OSL_PRECOND(pustrPath, "osl_systemPathRemoveSeparator: Invalid parameter");
  80
  81     // maybe there are more than one separator at end
  82     // so we run in a loop
  83     while ((pustrPath->length > 1) && (FPH_CHAR_PATH_SEPARATOR == pustrPath->buffer[pustrPath->length - 1]))
  84     {
  85         pustrPath->length--;
  86         pustrPath->buffer[pustrPath->length] = (sal_Unicode)'\0';
  87     }
  88
  89     OSL_POSTCOND((0 == pustrPath->length) || (1 == pustrPath->length) || \
  90                  (pustrPath->length > 1 && pustrPath->buffer[pustrPath->length - 1] != FPH_CHAR_PATH_SEPARATOR), \
  91                  "osl_systemPathRemoveSeparator: Post condition failed");
  92  }
  93
  94  /*******************************************
  95     osl_systemPathEnsureSeparator
  96   ******************************************/
  97
  98  void SAL_CALL osl_systemPathEnsureSeparator(rtl_uString** ppustrPath)
  99  {
 100      OSL_PRECOND(ppustrPath && (NULL != *ppustrPath), \
 101                 "osl_systemPathEnsureSeparator: Invalid parameter");
 102
 103      rtl::OUString path(*ppustrPath);
 104     sal_Int32     lp = path.getLength();
 105     sal_Int32     i  = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 106
 107     if ((lp > 1 && i != (lp - 1)) || ((lp < 2) && i < 0))
 108     {
 109         path += FPH_PATH_SEPARATOR();
 110         rtl_uString_assign(ppustrPath, path.pData);
 111     }
 112
 113     OSL_POSTCOND(path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR) == (path.getLength() - 1), \
 114                  "osl_systemPathEnsureSeparator: Post condition failed");
 115  }
 116
 117  /*******************************************
 118   *  osl_systemPathIsRelativePath
 119   ******************************************/
 120
 121  sal_Bool SAL_CALL osl_systemPathIsRelativePath(const rtl_uString* pustrPath)
 122  {
 123      OSL_PRECOND(pustrPath, "osl_systemPathIsRelativePath: Invalid parameter");
 124      return ((0 == pustrPath->length) || (pustrPath->buffer[0] != FPH_CHAR_PATH_SEPARATOR));
 125  }
 126
 127  /******************************************
 128     osl_systemPathMakeAbsolutePath
 129   *****************************************/
 130
 131  void SAL_CALL osl_systemPathMakeAbsolutePath(
 132      const rtl_uString* pustrBasePath,
 133     const rtl_uString* pustrRelPath,
 134     rtl_uString**          ppustrAbsolutePath)
 135 {
 136     rtl::OUString base(rtl_uString_getStr(const_cast<rtl_uString*>(pustrBasePath)));
 137     rtl::OUString rel(const_cast<rtl_uString*>(pustrRelPath));
 138
 139     if (base.getLength() > 0)
 140         osl_systemPathEnsureSeparator(&base.pData);
 141
 142     base += rel;
 143
 144     rtl_uString_acquire(base.pData);
 145     *ppustrAbsolutePath = base.pData;
 146 }
 147
 148
 149  /*******************************************
 150      osl_systemPathGetFileOrLastDirectoryPart
 151   ******************************************/
 152
 153  void SAL_CALL osl_systemPathGetFileNameOrLastDirectoryPart(
 154      const rtl_uString*         pustrPath,
 155     rtl_uString**               ppustrFileNameOrLastDirPart)
 156 {
 157     OSL_PRECOND(pustrPath && ppustrFileNameOrLastDirPart, \
 158                 "osl_systemPathGetFileNameOrLastDirectoryPart: Invalid parameter");
 159
 160     rtl::OUString path(const_cast<rtl_uString*>(pustrPath));
 161
 162     osl_systemPathRemoveSeparator(path.pData);
 163
 164     rtl::OUString last_part;
 165
 166     if (path.getLength() > 1 || (1 == path.getLength() && *path.getStr() != FPH_CHAR_PATH_SEPARATOR))
 167     {
 168         sal_Int32 idx_ps = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 169         idx_ps++; // always right to increment by one even if idx_ps == -1!
 170         last_part = rtl::OUString(path.getStr() + idx_ps);
 171     }
 172     rtl_uString_assign(ppustrFileNameOrLastDirPart, last_part.pData);
 173 }
 174
 175
 176  /********************************************
 177      osl_systemPathIsHiddenFileOrDirectoryEntry
 178  *********************************************/
 179
 180  sal_Bool SAL_CALL osl_systemPathIsHiddenFileOrDirectoryEntry(
 181      const rtl_uString* pustrPath)
 182 {
 183     OSL_PRECOND(pustrPath, "osl_systemPathIsHiddenFileOrDirectoryEntry: Invalid parameter");
 184
 185     sal_Bool is_hidden = sal_False;
 186
 187     if (pustrPath->length > 0)
 188     {
 189         rtl::OUString fdp;
 190
 191         osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &fdp.pData);
 192
 193         is_hidden = ((fdp.pData->length > 0) && (fdp.pData->buffer[0] == FPH_CHAR_DOT) &&
 194                      !osl_systemPathIsLocalOrParentDirectoryEntry(fdp.pData));
 195      }
 196
 197     return is_hidden;
 198 }
 199
 200
 201  /************************************************
 202      osl_systemPathIsLocalOrParentDirectoryEntry
 203  ************************************************/
 204
 205 sal_Bool SAL_CALL osl_systemPathIsLocalOrParentDirectoryEntry(
 206     const rtl_uString* pustrPath)
 207 {
 208     OSL_PRECOND(pustrPath, "osl_systemPathIsLocalOrParentDirectoryEntry: Invalid parameter");
 209
 210     rtl::OUString dirent;
 211
 212     osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &dirent.pData);
 213
 214     return (
 215             (dirent == FPH_LOCAL_DIR_ENTRY()) ||
 216             (dirent == FPH_PARENT_DIR_ENTRY())
 217            );
 218 }
 219
 220 /***********************************************
 221  Simple iterator for a path list separated by
 222  the specified character
 223  **********************************************/
 224
 225 class path_list_iterator
 226 {
 227 public:
 228
 229     /******************************************
 230       constructor
 231
 232      after construction get_current_item
 233      returns the first path in list, no need
 234      to call reset first
 235      *****************************************/
 236     path_list_iterator(const rtl::OUString& path_list, sal_Unicode list_separator = FPH_CHAR_COLON) :
 237         m_path_list(path_list),
 238         m_end(m_path_list.getStr() + m_path_list.getLength() + 1),
 239         m_separator(list_separator)
 240     {
 241         reset();
 242     }
 243
 244     /******************************************
 245      reset the iterator
 246      *****************************************/
 247     void reset()
 248     {
 249         m_path_segment_begin = m_path_segment_end = m_path_list.getStr();
 250         advance();
 251     }
 252
 253     /******************************************
 254      move the iterator to the next position
 255      *****************************************/
 256     void next()
 257     {
 258         OSL_PRECOND(!done(), "path_list_iterator: Already done!");
 259
 260         m_path_segment_begin = ++m_path_segment_end;
 261         advance();
 262     }
 263
 264     /******************************************
 265      check if done
 266      *****************************************/
 267     bool done() const
 268     {
 269         return (m_path_segment_end >= m_end);
 270     }
 271
 272     /******************************************
 273      return the current item
 274      *****************************************/
 275     rtl::OUString get_current_item() const
 276     {
 277         return rtl::OUString(
 278             m_path_segment_begin,
 279             (m_path_segment_end - m_path_segment_begin));
 280     }
 281
 282 private:
 283
 284     /******************************************
 285      move m_path_end to the next separator or
 286      to the edn of the string
 287      *****************************************/
 288     void advance()
 289     {
 290         while (!done() && *m_path_segment_end && (*m_path_segment_end != m_separator))
 291             ++m_path_segment_end;
 292
 293         OSL_ASSERT(m_path_segment_end <= m_end);
 294     }
 295
 296 private:
 297     rtl::OUString               m_path_list;
 298     const sal_Unicode*  m_end;
 299     const sal_Unicode   m_separator;
 300     const sal_Unicode*  m_path_segment_begin;
 301     const sal_Unicode*  m_path_segment_end;
 302
 303 // prevent copy and assignment
 304 private:
 305     /******************************************
 306      copy constructor
 307      remember: do not simply copy m_path_begin
 308      and m_path_end because they point to
 309      the memory of other.m_path_list!
 310      *****************************************/
 311     path_list_iterator(const path_list_iterator& other);
 312
 313     /******************************************
 314      assignment operator
 315       remember: do not simply copy m_path_begin
 316      and m_path_end because they point to
 317      the memory of other.m_path_list!
 318      *****************************************/
 319     path_list_iterator& operator=(const path_list_iterator& other);
 320 };
 321
 322  /************************************************
 323       osl_searchPath
 324   ***********************************************/
 325
 326 sal_Bool SAL_CALL osl_searchPath(
 327      const rtl_uString* pustrFilePath,
 328     const rtl_uString* pustrSearchPathList,
 329     rtl_uString**      ppustrPathFound)
 330 {
 331     OSL_PRECOND(pustrFilePath && pustrSearchPathList && ppustrPathFound, "osl_searchPath: Invalid parameter");
 332
 333     bool               bfound = false;
 334     rtl::OUString      fp(const_cast<rtl_uString*>(pustrFilePath));
 335     rtl::OUString      pl = rtl::OUString(const_cast<rtl_uString*>(pustrSearchPathList));
 336     path_list_iterator pli(pl);
 337
 338     while (!pli.done())
 339     {
 340         rtl::OUString p = pli.get_current_item();
 341         osl::systemPathEnsureSeparator(p);
 342         p += fp;
 343
 344         if (osl::access(p, F_OK) > -1)
 345         {
 346             bfound = true;
 347             rtl_uString_assign(ppustrPathFound, p.pData);
 348             break;
 349         }
 350         pli.next();
 351     }
 352     return bfound;
 353 }