Public API Reference

csutil/syspath.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSSYS_SYSPATH_H__
#define __CS_CSSYS_SYSPATH_H__

#include "csextern.h"
#include "array.h"
#include "csstring.h"
#include "ref.h"
#include "util.h"
#include "iutil/stringarray.h"

class csPathsList;

CS_CRYSTALSPACE_EXPORT csString csGetConfigPath ();

CS_CRYSTALSPACE_EXPORT csPathsList* csGetPluginPaths (const char* argv0);

class CS_CRYSTALSPACE_EXPORT csPathsList
{
public:
  struct CS_CRYSTALSPACE_EXPORT Entry
  {
    csString path;
    csString type;
    bool scanRecursive;
    
    void FixSeparators();

    Entry () : scanRecursive (false) {}
    Entry (const char* path, const char* type, bool recursive = false)
    {
      Entry::path = path;
      FixSeparators();
      Entry::type = type;
      scanRecursive = recursive;
    };
    Entry (const Entry& src)
    {
      path = src.path;
      type = src.type;
      scanRecursive = src.scanRecursive;
    };
  };
private:
  csArray<Entry> paths;
public:
  csPathsList () : paths (4, 4) {}
  csPathsList (csPathsList const& o) : paths(o.paths) {}
  csPathsList (const char* pathList, bool expand = false);
  csPathsList (const char* const pathList[], bool expand = false);
  ~csPathsList() {}
  csPathsList& operator= (csPathsList const& o)
  { if (&o != this) paths = o.paths; return *this; }

  size_t AddUnique (const char* path, bool scanRecursive = false, 
    const char* type = 0, bool overrideRecursive = true);
  size_t AddUniqueExpanded (const char* path, bool scanRecursive = false, 
    const char* type = 0, bool overrideRecursive = true);
  size_t AddUnique (const Entry& path, bool overrideRecursive = true);
  size_t AddUniqueExpanded (const Entry& path, bool overrideRecursive = true);
  void AddUnique (const csPathsList& list, bool overrideRecursive = true)
  {
    for (size_t i = 0; i < list.Length(); i++)
    {
      AddUnique (list[i], overrideRecursive);
    }
  }
  void AddUniqueExpanded (const csPathsList& list, 
    bool overrideRecursive = true)
  {
    for (size_t i = 0; i < list.Length(); i++)
    {
      AddUniqueExpanded (list[i], overrideRecursive);
    }
  }
  void DeleteIndex (size_t index)
  { paths.DeleteIndex (index); }
  

  size_t Length () const { return paths.Length(); }
  size_t GetSize () const { return paths.Length(); }
  CS_DEPRECATED_METHOD_MSG("Use Length() instead") 
  size_t GetCount () const { return Length(); }

  Entry const& operator [] (size_t n) const { return paths[n]; }
  Entry& operator [] (size_t n) { return paths[n]; }
  

  CS_CRYSTALSPACE_EXPORT friend csPathsList operator* (const csPathsList& left,
    const csPathsList& right);
  inline csPathsList operator*= (const csPathsList& right)
  { return (*this = *this * right); }
  inline friend csPathsList operator* (const Entry& left, 
    const csPathsList& right)
  {
    csPathsList newPaths;
    newPaths.paths.Push (left);
    return newPaths * right;
  }
  inline friend csPathsList operator* (const char* left, 
    const csPathsList& right)
  { return Entry (left, 0) * right; }
  inline friend csPathsList operator* (const csPathsList& left, 
    const Entry& right)
  {
    csPathsList newPaths;
    newPaths.paths.Push (right);
    return left * newPaths;
  }
  inline friend csPathsList operator* (const csPathsList& left, 
    const char* right)
  { return left * Entry (right, 0); }
  inline csPathsList operator*= (const Entry& right)
  { return (*this = *this * right); }
  inline csPathsList operator*= (const char* right)
  { return (*this = *this * right); }
};

class CS_CRYSTALSPACE_EXPORT csPathsUtilities
{
public:
  static bool PathsIdentical (const char* path1, const char* path2);
  static char* ExpandPath (const char* path);
  
  static csPathsList LocateFile (const csPathsList& paths, 
    const char* file, bool thorough = false);

  static void FilterInvalid (csPathsList& paths);

  static csPathsList ExpandAll (const csPathsList& paths);
};

class CS_CRYSTALSPACE_EXPORT csInstallationPathsHelper
{
public:
  static csPathsList* GetPlatformInstallationPaths ();
  static csRef<iStringArray> FindSystemRoots();
  static csString GetAppPath (const char* argv0);
  
  static csString GetAppDir (const char* argv0);
  
  static csString GetResourceDir (const char* argv0);
  static csPathsList* GetPluginPaths (const char* argv0);
  static csString GetAppFilename (const char* basename);
};


CS_DEPRECATED_METHOD inline bool csPathsIdentical (const char* path1, 
  const char* path2)
{ return csPathsUtilities::PathsIdentical (path1, path2); }
CS_DEPRECATED_METHOD inline csRef<iStringArray> csFindSystemRoots()
{ return csInstallationPathsHelper::FindSystemRoots (); }
CS_DEPRECATED_METHOD inline char* csExpandPath (const char* path)
{ return csPathsUtilities::ExpandPath (path); }
CS_DEPRECATED_METHOD inline csString csGetAppPath (const char* argv0)
{ return csInstallationPathsHelper::GetAppPath (argv0); }
CS_DEPRECATED_METHOD inline csString csGetAppDir (const char* argv0)
{ return csInstallationPathsHelper::GetAppDir (argv0); }
CS_DEPRECATED_METHOD inline csString csGetResourceDir (const char* argv0)
{ return csInstallationPathsHelper::GetResourceDir (argv0); }

#endif

---