path.hxx File Reference

#include <string>
#include <string_view>
#include <cosmos/dso_export.h>
#include <cosmos/SysString.hxx>

Go to the source code of this file.

Functions
std::string	cosmos::fs::normalize_path (const std::string_view path)
	Takes an input path and returns a normalized version of it.
std::string	cosmos::fs::canonicalize_path (const SysString path)
	Normalizes path and resolves any symbolic link components.

Detailed Description

File system path related helpers.

Definition in file path.hxx.

Function Documentation

canonicalize_path()

COSMOS_API std::string cosmos::fs::canonicalize_path

(

const SysString

path

)

Normalizes path and resolves any symbolic link components.

Definition at line 64 of file path.cxx.

                                                  {
        // implementing this on foot is non-trivial so rely on realpath() for
        // the time being.
        std::string ret;
        ret.resize(max::PATH);
        if (::realpath(path.raw(), ret.data()) == nullptr) {
                cosmos_throw (FileError(path, "realpath()"));
        }
 
        ret.resize(std::strlen(ret.data()));
        return ret;
}

normalize_path()

COSMOS_API std::string cosmos::fs::normalize_path

(

const std::string_view

path

)

Takes an input path and returns a normalized version of it.

A normalized path is an absolute path without any redundant separators ('/') or relative path components (".", "..").

To achieve this, this function eliminates redundant components and expands the current working directory, if necessary. Retrieving the CWD is the only potential system call performed by this function.

Symbolic links will not be resolved. If you want this you can use canonicalize_path() instead.

Definition at line 17 of file path.cxx.

                                                    {
        std::string ret;
 
        size_t slashes = 0;
        size_t start = 0;
        auto end = path.find('/');
 
        while (start < path.size()) {
                const auto component = path.substr(start, end - start);
 
                if (component.size() > 0) {
 
                        // path starts without a leading /, so it's a relative
                        // path, add the CWD
                        if (!slashes && ret.empty()) {
                                ret.append(get_working_dir());
                        }
 
                        // remove the last component
                        if (component == "..") {
                                // don't remove the root directory
                                if (ret.size() > 1) {
                                        ret.erase(ret.rfind('/'));
                                }
                                slashes++;
                        // references to the CWD are simply ignored
                        } else if (component == ".") {
                                slashes++;
                        } else {
                                // add exactly this component
                                ret.push_back('/');
                                ret.append(component);
                        }
                } else {
                        slashes++;
                }
 
                start = end != path.npos ? end + 1 : end;
                end = path.find('/', start);
        }
 
        if (slashes && ret.empty())
                ret.push_back('/');
 
        return ret;
}