Slic3r::resource_path Namespace Reference

Functions
std::string	ascii_lower_copy (const std::string &value)
boost::filesystem::path	portable_path_copy (const boost::filesystem::path &value)
int	hex_digit_value (char ch)
std::string	percent_decode_copy (const std::string &value)
std::string	strip_file_uri_prefix_copy (const std::string &value)
bool	file_uri_has_remote_authority (const std::string &value)
bool	looks_like_windows_absolute_path (const boost::filesystem::path &path)
boost::filesystem::path	filename_from_portable_path (const boost::filesystem::path &value)
boost::filesystem::path	find_child_case_insensitive (const boost::filesystem::path &directory, const boost::filesystem::path &requested_name, const char *context)
boost::filesystem::path	resolve_existing_path_case_insensitive (const boost::filesystem::path &requested_path, const char *context="resource_path")
boost::filesystem::path	resolve_existing_relative_path_case_insensitive (const boost::filesystem::path &base_dir, const boost::filesystem::path &resource_path, const char *context="resource_path")
boost::filesystem::path	resolve_external_resource_path (const boost::filesystem::path &base_dir, const std::string &raw_path, const char *context="resource_path", bool allow_basename_fallback=true)

Function Documentation

ascii_lower_copy()

std::string Slic3r::resource_path::ascii_lower_copy ( const std::string & value )

inline

{
    std::string lowered;
    lowered.reserve(value.size());
    for (unsigned char ch : value)
        lowered.push_back(static_cast<char>(std::tolower(ch)));
    return lowered;
}

Referenced by file_uri_has_remote_authority(), find_child_case_insensitive(), and strip_file_uri_prefix_copy().

Here is the caller graph for this function:

file_uri_has_remote_authority()

bool Slic3r::resource_path::file_uri_has_remote_authority ( const std::string & value )

inline

{
    const std::string lower = ascii_lower_copy(value);
    if (lower.rfind("file://", 0) != 0)
        return false;
 
    const std::string path = value.substr(7);
    if (path.empty() || path.front() == '/')
        return false;
 
    const std::size_t slash = path.find('/');
    const std::string authority = path.substr(0, slash);
    return ascii_lower_copy(authority) != "localhost";
}

References ascii_lower_copy().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

filename_from_portable_path()

boost::filesystem::path Slic3r::resource_path::filename_from_portable_path ( const boost::filesystem::path & value )

inline

{
    const boost::filesystem::path portable = portable_path_copy(value);
    return portable.filename();
}

References portable_path_copy().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

find_child_case_insensitive()

boost::filesystem::path Slic3r::resource_path::find_child_case_insensitive ( const boost::filesystem::path & directory, const boost::filesystem::path & requested_name, const char * context )

inline

{
    if (!boost::filesystem::exists(directory) || !boost::filesystem::is_directory(directory))
        return {};
 
    const std::string requested_lower = ascii_lower_copy(requested_name.filename().string());
    std::vector<boost::filesystem::path> matches;
 
    boost::system::error_code ec;
    for (boost::filesystem::directory_iterator it(directory, ec), end; !ec && it != end; it.increment(ec)) {
        if (ascii_lower_copy(it->path().filename().string()) == requested_lower)
            matches.push_back(it->path());
    }
 
    if (matches.size() == 1)
        return matches.front();
 
    if (matches.size() > 1) {
        BOOST_LOG_TRIVIAL(warning) << context << ": ambiguous case-insensitive resource match for "
                                   << requested_name << " in " << directory;
    }
 
    return {};
}

References ascii_lower_copy().

Referenced by resolve_existing_path_case_insensitive().

Here is the call graph for this function:

Here is the caller graph for this function:

hex_digit_value()

int Slic3r::resource_path::hex_digit_value ( char ch )

inline

{
    if (ch >= '0' && ch <= '9') return ch - '0';
    if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
    if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
    return -1;
}

Referenced by percent_decode_copy().

Here is the caller graph for this function:

looks_like_windows_absolute_path()

bool Slic3r::resource_path::looks_like_windows_absolute_path ( const boost::filesystem::path & path )

inline

{
    const std::string portable = portable_path_copy(path).string();
    return portable.size() >= 3
        && std::isalpha(static_cast<unsigned char>(portable[0]))
        && portable[1] == ':'
        && portable[2] == '/';
}

References portable_path_copy().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

percent_decode_copy()

std::string Slic3r::resource_path::percent_decode_copy ( const std::string & value )

inline

{
    std::string decoded;
    decoded.reserve(value.size());
    for (std::size_t i = 0; i < value.size(); ++i) {
        if (value[i] == '%' && i + 2 < value.size()) {
            const int hi = hex_digit_value(value[i + 1]);
            const int lo = hex_digit_value(value[i + 2]);
            if (hi >= 0 && lo >= 0) {
                decoded.push_back(static_cast<char>((hi << 4) | lo));
                i += 2;
                continue;
            }
        }
        decoded.push_back(value[i]);
    }
    return decoded;
}

References hex_digit_value().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

portable_path_copy()

boost::filesystem::path Slic3r::resource_path::portable_path_copy ( const boost::filesystem::path & value )

inline

{
    std::string portable = value.string();
    std::replace(portable.begin(), portable.end(), '\\', '/');
    return boost::filesystem::path(portable);
}

Referenced by filename_from_portable_path(), looks_like_windows_absolute_path(), resolve_existing_path_case_insensitive(), and resolve_external_resource_path().

Here is the caller graph for this function:

resolve_existing_path_case_insensitive()

boost::filesystem::path Slic3r::resource_path::resolve_existing_path_case_insensitive ( const boost::filesystem::path & requested_path, const char * context = "resource_path" )

inline

{
    const boost::filesystem::path normalized_path = portable_path_copy(requested_path);
 
    if (normalized_path.empty())
        return {};
 
    if (boost::filesystem::exists(normalized_path))
        return normalized_path;
 
    boost::filesystem::path current;
    bool initialized = false;
 
    for (const boost::filesystem::path& part : normalized_path) {
        if (part == normalized_path.root_name() || part == normalized_path.root_directory()) {
            current /= part;
            initialized = true;
            continue;
        }
 
        if (!initialized) {
            current = boost::filesystem::current_path();
            initialized = true;
        }
 
        boost::filesystem::path exact = current / part;
        if (boost::filesystem::exists(exact)) {
            current = exact;
            continue;
        }
 
        boost::filesystem::path matched = find_child_case_insensitive(current, part, context);
        if (matched.empty())
            return {};
 
        BOOST_LOG_TRIVIAL(info) << context << ": resolved resource path case-insensitively from "
                                << exact << " to " << matched;
        current = matched;
    }
 
    return boost::filesystem::exists(current) ? current : boost::filesystem::path();
}

References find_child_case_insensitive(), initialized, and portable_path_copy().

Referenced by resolve_existing_relative_path_case_insensitive(), and resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_existing_relative_path_case_insensitive()

boost::filesystem::path Slic3r::resource_path::resolve_existing_relative_path_case_insensitive ( const boost::filesystem::path & base_dir, const boost::filesystem::path & resource_path, const char * context = "resource_path" )

inline

{
    const boost::filesystem::path requested = resource_path.is_absolute() ? resource_path : base_dir / resource_path;
    return resolve_existing_path_case_insensitive(requested, context);
}

References resolve_existing_path_case_insensitive().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_external_resource_path()

boost::filesystem::path Slic3r::resource_path::resolve_external_resource_path ( const boost::filesystem::path & base_dir, const std::string & raw_path, const char * context = "resource_path", bool allow_basename_fallback = true )

inline

{
    if (raw_path.empty())
        return {};
 
    const bool remote_file_uri = file_uri_has_remote_authority(raw_path);
    const std::string decoded_path = percent_decode_copy(strip_file_uri_prefix_copy(raw_path));
    const boost::filesystem::path requested = portable_path_copy(boost::filesystem::path(decoded_path));
 
    boost::filesystem::path resolved = (requested.is_absolute() || looks_like_windows_absolute_path(requested)) ?
        resolve_existing_path_case_insensitive(requested, context) :
        resolve_existing_relative_path_case_insensitive(base_dir, requested, context);
    if (!resolved.empty())
        return resolved;
 
    if (!allow_basename_fallback || remote_file_uri)
        return {};
 
    const boost::filesystem::path basename = filename_from_portable_path(requested);
    if (basename.empty())
        return {};
 
    resolved = resolve_existing_relative_path_case_insensitive(base_dir, basename, context);
    if (!resolved.empty()) {
        BOOST_LOG_TRIVIAL(info) << context << ": resolved resource by basename from "
                                << requested << " to " << resolved;
    }
    return resolved;
}

References file_uri_has_remote_authority(), filename_from_portable_path(), looks_like_windows_absolute_path(), percent_decode_copy(), portable_path_copy(), resolve_existing_path_case_insensitive(), resolve_existing_relative_path_case_insensitive(), and strip_file_uri_prefix_copy().

Referenced by Slic3r::anonymous_namespace{AssimpImport.cpp}::collect_materials().

Here is the call graph for this function:

Here is the caller graph for this function:

strip_file_uri_prefix_copy()

std::string Slic3r::resource_path::strip_file_uri_prefix_copy ( const std::string & value )

inline

{
    const std::string lower = ascii_lower_copy(value);
    if (lower.rfind("file://", 0) != 0)
        return value;
 
    std::string path = value.substr(7);
    if (ascii_lower_copy(path).rfind("localhost/", 0) == 0)
        path.erase(0, std::string("localhost").size());
    else if (!path.empty() && path.front() != '/')
        path = "//" + path;
 
    // file:///C:/... should become C:/..., while file:///tmp/... keeps /tmp/...
    if (path.size() >= 3 && path[0] == '/' && std::isalpha(static_cast<unsigned char>(path[1])) && path[2] == ':')
        path.erase(path.begin());
    return path;
}

References ascii_lower_copy().

Referenced by resolve_external_resource_path().

Here is the call graph for this function:

Here is the caller graph for this function: