path.hpp

Go to the documentation of this file.

#pragma once
/*
 * Copyright (c) 2012, 2014 Aldebaran Robotics. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the COPYING file.
 */

#ifndef _QI_PATH_HPP_
# define _QI_PATH_HPP_

# include <string>
# include <vector>
# include <locale>
# include <iosfwd>
# include <boost/scoped_ptr.hpp>
# include <qi/api.hpp>

namespace boost { namespace filesystem {
  class path;
}}

namespace qi
{

  class PrivatePath;
  class Path;
  typedef std::vector<Path> PathVector;

  class QI_API Path {
  public:
    Path(const std::string& unicodePath = std::string());

    Path(const char* unicodePath);

    Path(const Path& path);

    Path(const boost::filesystem::path& path);

    ~Path();

    bool isEmpty() const;

    bool exists() const;

    bool isDir() const;

    bool isRegularFile() const;

    bool isSymlink() const;

    std::string filename() const;

    std::string extension() const;

    Path parent() const;

    Path absolute() const;

    PathVector files() const;

    PathVector recursiveFiles() const;

    PathVector dirs() const;

    operator std::string() const;

    std::string str() const;

    const boost::filesystem::path& bfsPath() const;

    Path operator/(const qi::Path& rhs) const;

    const Path& operator/=(const qi::Path& rhs) const;

    const Path& operator=(const qi::Path& rhs) const;

    friend std::ostream& operator<<(std::ostream& output, const qi::Path& path)
    {
      output << path.str();
      return output;
    }

  private:
    Path(PrivatePath* p);
    boost::scoped_ptr<PrivatePath> _p;
  };


  namespace path
  {
    class QI_API ScopedDir
    {
    public:
      ScopedDir(qi::Path path = qi::Path());
      ~ScopedDir();

      operator qi::Path() const;

      const qi::Path& path() const;

    private:
      void removeAll(int retry);

      qi::Path _path;
    };

    class QI_API ScopedFile
    {
    public:
      ScopedFile(qi::Path filePath = qi::Path());
      ~ScopedFile();

      const qi::Path& path() const;

    private:
      qi::path::ScopedDir _dir;
      qi::Path _path;
    };

    QI_API std::string sdkPrefix();

    namespace detail {

      QI_API std::vector<std::string> getSdkPrefixes();

      QI_API void addOptionalSdkPrefix(const char* prefix);

      QI_API void clearOptionalSdkPrefix();

      QI_API void setWritablePath(const std::string &path);
    }

    QI_API std::string findBin(const std::string& name, bool searchInPath=false);

    QI_API std::string findLib(const std::string& name);


    QI_API std::string findConf(const std::string& applicationName,
                                const std::string& filename);

    QI_API std::string findData(const std::string& applicationName,
                                const std::string& filename,
                                bool excludeUserWritablePath = false);


    QI_API std::vector<std::string> listData(const std::string& applicationName,
                                             const std::string& pattern="*",
                                             bool excludeUserWritablePath = false);

    QI_API std::vector<std::string> listLib(const std::string& subfolder,
                                            const std::string& pattern="*");

    QI_API std::vector<std::string> confPaths(const std::string& applicationName="");

    QI_API std::vector<std::string> dataPaths(const std::string& applicationName="",
                                              bool excludeUserWritablePath = false);

    QI_API std::vector<std::string> binPaths();

    QI_API std::vector<std::string> libPaths();

    QI_API std::string userWritableDataPath(const std::string& applicationName,
                                            const std::string& filename);

    QI_API std::string userWritableConfPath(const std::string& applicationName,
                                            const std::string& filename="");

    QI_API std::string convertToDosPath(const std::string &pathString);

    QI_API QI_API_DEPRECATED void setWritablePath(const std::string &path);
  }

  typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;

  QI_API codecvt_type &unicodeFacet();
}

#endif  // _QI_PATH_HPP_