Slic3r::GCodeFindReplace Class Reference

#include <src/libslic3r/GCode/FindReplace.hpp>

Collaboration diagram for Slic3r::GCodeFindReplace:

Classes
struct	Substitution

Public Member Functions
	GCodeFindReplace (const PrintConfig &print_config)
	GCodeFindReplace (const std::vector< std::string > &gcode_substitutions)
std::string	process_layer (const std::string &gcode)

Private Attributes
std::vector< Substitution >	m_substitutions

Detailed Description

---

Class Documentation

Slic3r::GCodeFindReplace::Substitution

struct Slic3r::GCodeFindReplace::Substitution

Collaboration diagram for Slic3r::GCodeFindReplace::Substitution:

Class Members
bool	case_insensitive { false }
string	format
string	plain_pattern
bool	regexp { false }
regex	regexp_pattern
bool	single_line { false }
bool	whole_word { false }

Constructor & Destructor Documentation

GCodeFindReplace() [1/2]

Slic3r::GCodeFindReplace::GCodeFindReplace ( const PrintConfig &  print_config )

inline

: GCodeFindReplace(print_config.gcode_substitutions.values) {}

GCodeFindReplace() [2/2]

Slic3r::GCodeFindReplace::GCodeFindReplace

(

const std::vector< std::string > &

gcode_substitutions

)

{
    if ((gcode_substitutions.size() % 4) != 0)
        throw RuntimeError("Invalid length of gcode_substitutions parameter");
 
    m_substitutions.reserve(gcode_substitutions.size() / 4);
    for (size_t i = 0; i < gcode_substitutions.size(); i += 4) {
        Substitution out;
        try {
            out.plain_pattern    = gcode_substitutions[i];
            out.format           = gcode_substitutions[i + 1];
            const std::string &params = gcode_substitutions[i + 2];
            out.regexp           = strchr(params.c_str(), 'r') != nullptr || strchr(params.c_str(), 'R') != nullptr;
            out.case_insensitive = strchr(params.c_str(), 'i') != nullptr || strchr(params.c_str(), 'I') != nullptr;
            out.whole_word       = strchr(params.c_str(), 'w') != nullptr || strchr(params.c_str(), 'W') != nullptr;
            out.single_line      = strchr(params.c_str(), 's') != nullptr || strchr(params.c_str(), 'S') != nullptr;
            if (out.regexp) {
                out.regexp_pattern.assign(
                    out.whole_word ? 
                        std::string("\\b") + out.plain_pattern + "\\b" :
                        out.plain_pattern,
                    (out.case_insensitive ? boost::regex::icase : 0) | boost::regex::optimize);
            } else {
                unescape_extended_search_mode(out.plain_pattern);
                unescape_extended_search_mode(out.format);
            }
        } catch (const std::exception &ex) {
            throw RuntimeError(std::string("Invalid gcode_substitutions parameter, failed to compile regular expression: ") + ex.what());
        }
        m_substitutions.emplace_back(std::move(out));
    }
}

References Slic3r::GCodeFindReplace::Substitution::case_insensitive, Slic3r::GCodeFindReplace::Substitution::format, Slic3r::gcode_substitutions(), m_substitutions, Slic3r::GCodeFindReplace::Substitution::plain_pattern, Slic3r::GCodeFindReplace::Substitution::regexp, Slic3r::GCodeFindReplace::Substitution::regexp_pattern, Slic3r::GCodeFindReplace::Substitution::single_line, Slic3r::unescape_extended_search_mode(), and Slic3r::GCodeFindReplace::Substitution::whole_word.

Here is the call graph for this function:

Member Function Documentation

process_layer()

std::string Slic3r::GCodeFindReplace::process_layer

(

const std::string &

gcode

)

{
    std::string out;
    const std::string *in = &ain;
    std::string temp;
    temp.reserve(in->size());
 
    for (const Substitution &substitution : m_substitutions) {
        if (substitution.regexp) {
            temp.clear();
            temp.reserve(in->size());
            boost::regex_replace(ToStringIterator(temp), in->begin(), in->end(),
                substitution.regexp_pattern, substitution.format, 
                (substitution.single_line ? boost::match_single_line | boost::match_default : boost::match_not_dot_newline | boost::match_default) | boost::format_all);
            std::swap(out, temp);
        } else {
            if (in == &ain)
                out = ain;
            // Plain substitution
            if (substitution.case_insensitive) {
                if (substitution.whole_word)
                    find_and_replace_whole_word(out, substitution.plain_pattern, substitution.format,
                        [](const std::string &str, size_t start_pos, const std::string &match) {
                            auto begin = str.begin() + start_pos;
                            boost::iterator_range<std::string::const_iterator> r1(begin, str.end());
                            boost::iterator_range<std::string::const_iterator> r2(match.begin(), match.end());
                            auto res = boost::ifind_first(r1, r2);
                            return res ? std::make_pair(size_t(res.begin() - str.begin()), size_t(res.end() - str.begin())) : std::make_pair(std::string::npos, std::string::npos);
                        });
                else
                    boost::ireplace_all(out, substitution.plain_pattern, substitution.format);
            } else {
                if (substitution.whole_word)
                    find_and_replace_whole_word(out, substitution.plain_pattern, substitution.format,
                        [](const std::string &str, size_t start_pos, const std::string &match) { 
                            size_t pos = str.find(match, start_pos);
                            return std::make_pair(pos, pos + (pos == std::string::npos ? 0 : match.size()));
                        });
                else
                    boost::replace_all(out, substitution.plain_pattern, substitution.format);
            }
        }
        in = &out;
    }
 
    return out;
}

References Slic3r::find_and_replace_whole_word(), and m_substitutions.

Here is the call graph for this function:

Member Data Documentation

m_substitutions

std::vector<Substitution> Slic3r::GCodeFindReplace::m_substitutions

private

Referenced by GCodeFindReplace(), and process_layer().

---

The documentation for this class was generated from the following files:

• src/libslic3r/GCode/FindReplace.hpp
• src/libslic3r/GCode/FindReplace.cpp