file.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>

#include <string>

#include <archon/util/file.H>

using namespace std;

static size_t maxBufferSize = 32767-1024;

namespace Archon
{
  namespace Utilities
  {
    namespace File
    {
      string getCWD()
      {
        size_t bufferSize = 1024;
        char *buffer;
        for(;;)
        {
          buffer = new char[bufferSize];
          if(getcwd(buffer, bufferSize)) break;
          if(errno != ERANGE)
          {
            delete[] buffer;
            ARCHON_THROW1(ResourceException,
                          string("Utilities::File::getCWD: 'getcwd' failed: ") +
                          strerror(errno));
          }

          delete[] buffer;
          bufferSize += 1024;
          if(bufferSize > maxBufferSize)
            ARCHON_THROW1(ResourceException,
                          "System::File::getCWD: Path is too long");
        }
        const string result = buffer;
        delete[] buffer;
        return result;
      }

      string getHomeDir()
      {
        char *s = getenv("HOME");
        if(!s) ARCHON_THROW1(ResourceException,
                             "Could not determine home directory of "
                             "the logged in user");
        return s;
      }

      void makeDir(string path)
      {
        int error = mkdir(path.c_str(), S_IRWXU|S_IRWXG|S_IRWXO);
        if(error < 0)
          ARCHON_THROW1(ArgumentException,
                        "'mkdir " + path + "' failed: " + strerror(errno));
      }

      vector<string> getDirNames(string dirPath)
      {
        DIR *dir = opendir(dirPath.c_str());
        if(!dir)
          ARCHON_THROW1(ArgumentException,
                        "Utilities::File::getDirNames: 'opendir " +
                        dirPath + "' failed: " + strerror(errno));

        vector<string> v;

        for(;;)
        {
          dirent *e = readdir(dir);
          if(!e) break;
          v.push_back(e->d_name);
        }

        closedir(dir);

        return v;
      }

      Stat::Stat(string path)
      {
        struct stat s;
        if(stat(path.c_str(), &s))
          ARCHON_THROW1(ArgumentException,
                        "Utilities::File::Stat::Stat: 'stat " + path +
                        "' failed: " + strerror(errno));

        type =
          S_ISREG(s.st_mode)  ? type_regular :
          S_ISDIR(s.st_mode)  ? type_directory :
          S_ISCHR(s.st_mode)  ? type_characterDevice :
          S_ISBLK(s.st_mode)  ? type_blockDevice :
          S_ISFIFO(s.st_mode) ? type_fifo :
          S_ISLNK(s.st_mode)  ? type_symbolicLink :
          S_ISSOCK(s.st_mode) ? type_socket : type_other;
      }

      bool isRegular(string p)
      {
        try
        {
          Stat s(p);
          return s.getType() == Stat::type_regular;
        }
        catch(ArgumentException &)
        {
          return false;
        }
      }

      bool isDir(string p)
      {
        try
        {
          Stat s(p);
          return s.getType() == Stat::type_directory;
        }
        catch(ArgumentException &)
        {
          return false;
        }
      }

      bool isSymbolicLink(string p)
      {
        try
        {
          Stat s(p);
          return s.getType() == Stat::type_symbolicLink;
        }
        catch(ArgumentException &)
        {
          return false;
        }
      }

      string nameOf(string filePath)
      {
        const string::size_type p = filePath.rfind('/');
        return p == string::npos ? filePath : string(filePath, p+1);
      }

      string suffixOf(string filePath)
      {
        const string name = nameOf(filePath);
        const string::size_type p = name.rfind('.');
        return p == string::npos ? "" : string(name, p+1);
      }
    }
  }
}

---