sal/osl/unx/file_path_helper.cxx

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