Slic3r::client::expr Struct Reference

Collaboration diagram for Slic3r::client::expr:

Classes
union	Data

Public Types
enum	Type {   TYPE_EMPTY = 0 , TYPE_BOOL , TYPE_INT , TYPE_DOUBLE ,   TYPE_STRING }
enum class	Deferred : unsigned char { None , Value , Text }
enum	Function2ParamsType { FUNCTION_MIN , FUNCTION_MAX }

Public Member Functions
	expr ()
	expr (const expr &rhs)
	expr (expr &&rhs)
	expr (bool b)
	expr (bool b, const Iterator &it_begin, const Iterator &it_end)
	expr (int i)
	expr (int i, const Iterator &it_begin, const Iterator &it_end)
	expr (double d)
	expr (double d, const Iterator &it_begin, const Iterator &it_end)
	expr (const char *s)
	expr (const std::string &s)
	expr (std::string &&s)
	expr (const std::string &s, const Iterator &it_begin, const Iterator &it_end)
	expr (expr &&rhs, const Iterator &it_begin, const Iterator &it_end)
expr &	operator= (const expr &rhs)
expr &	operator= (expr &&rhs)
void	reset ()
	~expr ()
Type	type () const
bool	numeric_type () const
bool	deferred () const
void	set_deferred (Deferred deferred)
bool &	b ()
bool	b () const
void	set_b (bool v)
void	set_b_lite (bool v)
int &	i ()
int	i () const
void	set_i (int v)
void	set_i_lite (int v)
int	as_i () const
int	as_i_rounded () const
double &	d ()
double	d () const
void	set_d (double v)
void	set_d_lite (double v)
double	as_d () const
std::string &	s ()
const std::string &	s () const
void	set_s (const std::string &s)
void	set_s (std::string &&s)
void	set_s (const char *s)
std::string	to_string () const
expr	unary_minus (const Iterator start_pos) const
expr	unary_integer (const Iterator start_pos) const
expr	round (const Iterator start_pos) const
expr	floor (const Iterator start_pos) const
expr	ceil (const Iterator start_pos) const
expr	unary_not (const Iterator start_pos) const
expr &	operator+= (const expr &rhs)
expr &	operator-= (const expr &rhs)
expr &	operator*= (const expr &rhs)
expr &	operator/= (const expr &rhs)
expr &	operator%= (const expr &rhs)
void	throw_exception (const char *message) const
void	throw_if_not_numeric (const char *message) const
void	throw_if_deferred () const

Static Public Member Functions
static void	to_string2 (expr &self, std::string &out)
static void	evaluate_boolean (expr &self, bool &out)
static void	evaluate_boolean_to_string (expr &self, std::string &out)
static void	compare_op (expr &lhs, expr &rhs, char op, bool invert)
static void	equal (expr &lhs, expr &rhs)
static void	not_equal (expr &lhs, expr &rhs)
static void	lower (expr &lhs, expr &rhs)
static void	greater (expr &lhs, expr &rhs)
static void	leq (expr &lhs, expr &rhs)
static void	geq (expr &lhs, expr &rhs)
static void	throw_if_not_numeric (const expr &param)
static void	function_2params (expr &param1, expr &param2, Function2ParamsType fun)
static void	min (expr &param1, expr &param2)
static void	max (expr &param1, expr &param2)
static void	random (expr &param1, expr &param2, std::mt19937 &rng)
template<bool leading_zeros>
static void	digits (expr &param1, expr &param2, expr &param3)
static void	regex_op (const expr &lhs, IteratorRange &rhs, char op, expr &out)
static void	regex_matches (expr &lhs, IteratorRange &rhs)
static void	regex_doesnt_match (expr &lhs, IteratorRange &rhs)
static void	regex_replace (expr &subject, IteratorRange &pattern, expr &replacement)
static void	one_of_test_init (expr &out)
template<bool RegEx>
static void	one_of_test (const expr &match, const expr &pattern, expr &out)
static void	one_of_test_regex (const expr &match, IteratorRange &pattern, expr &out)
static void	logical_op (expr &lhs, expr &rhs, char op)
static void	logical_or (expr &lhs, expr &rhs)
static void	logical_and (expr &lhs, expr &rhs)
static const char *	deferred_message ()

Public Attributes
IteratorRange	it_range

Private Member Functions
void	set_s_take_ownership (std::string *s)

Private Attributes
Type	m_type = TYPE_EMPTY
Deferred	m_deferred = Deferred::None
union Slic3r::client::expr::Data	m_data

Detailed Description

Member Enumeration Documentation

Deferred

enum class Slic3r::client::expr::Deferred : unsigned char

strong

Enumerator
None
Value
Text

: unsigned char { None, Value, Text };

Function2ParamsType

enum Slic3r::client::expr::Function2ParamsType

Enumerator
FUNCTION_MIN
FUNCTION_MAX

                                 {
            FUNCTION_MIN,
            FUNCTION_MAX,
        };

Type

enum Slic3r::client::expr::Type

Enumerator
TYPE_EMPTY
TYPE_BOOL
TYPE_INT
TYPE_DOUBLE
TYPE_STRING

                  {
            TYPE_EMPTY = 0,
            TYPE_BOOL,
            TYPE_INT,
            TYPE_DOUBLE,
            TYPE_STRING,
        };

Constructor & Destructor Documentation

expr() [1/14]

Slic3r::client::expr::expr ( )

inline

{}

Referenced by expr(), expr(), expr(), ceil(), compare_op(), digits(), equal(), evaluate_boolean(), evaluate_boolean_to_string(), floor(), function_2params(), geq(), greater(), leq(), logical_and(), logical_op(), logical_or(), lower(), max(), min(), not_equal(), one_of_test(), one_of_test_init(), one_of_test_regex(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), operator=(), random(), regex_doesnt_match(), regex_matches(), regex_op(), regex_replace(), round(), throw_if_not_numeric(), to_string2(), unary_integer(), unary_minus(), and unary_not().

Here is the caller graph for this function:

expr() [2/14]

Slic3r::client::expr::expr ( const expr & rhs )

inline

                                       : m_type(rhs.type()), it_range(rhs.it_range), m_deferred(rhs.m_deferred)
                    { if (rhs.type() == TYPE_STRING) m_data.s = new std::string(*rhs.m_data.s); else m_data.set(rhs.m_data); }

References expr(), it_range, m_data, m_deferred, m_type, Slic3r::client::expr::Data::s, type(), and TYPE_STRING.

Here is the call graph for this function:

expr() [3/14]

Slic3r::client::expr::expr ( expr && rhs )

inline

: expr(std::move(rhs), rhs.it_range.begin(), rhs.it_range.end()) {}

References expr(), and it_range.

Here is the call graph for this function:

expr() [4/14]

Slic3r::client::expr::expr ( bool b )

inlineexplicit

: m_type(TYPE_BOOL) { m_data.b = b; }

References b(), m_data, m_type, and TYPE_BOOL.

Here is the call graph for this function:

expr() [5/14]

Slic3r::client::expr::expr ( bool b, const Iterator & it_begin, const Iterator & it_end )

inlineexplicit

: m_type(TYPE_BOOL), it_range(it_begin, it_end) { m_data.b = b; }

References b(), it_range, m_data, m_type, and TYPE_BOOL.

Here is the call graph for this function:

expr() [6/14]

Slic3r::client::expr::expr ( int i )

inlineexplicit

: m_type(TYPE_INT) { m_data.i = i; }

References i(), m_data, m_type, and TYPE_INT.

Here is the call graph for this function:

expr() [7/14]

Slic3r::client::expr::expr ( int i, const Iterator & it_begin, const Iterator & it_end )

inlineexplicit

: m_type(TYPE_INT), it_range(it_begin, it_end) { m_data.i = i; }

References i(), it_range, m_data, m_type, and TYPE_INT.

Here is the call graph for this function:

expr() [8/14]

Slic3r::client::expr::expr ( double d )

inlineexplicit

: m_type(TYPE_DOUBLE) { m_data.d = d; }

References d(), m_data, m_type, and TYPE_DOUBLE.

Here is the call graph for this function:

expr() [9/14]

Slic3r::client::expr::expr ( double d, const Iterator & it_begin, const Iterator & it_end )

inlineexplicit

: m_type(TYPE_DOUBLE), it_range(it_begin, it_end) { m_data.d = d; }

References d(), it_range, m_data, m_type, and TYPE_DOUBLE.

Here is the call graph for this function:

expr() [10/14]

Slic3r::client::expr::expr ( const char * s )

inlineexplicit

: m_type(TYPE_STRING) { m_data.s = new std::string(s); }

References m_data, m_type, s(), and TYPE_STRING.

Here is the call graph for this function:

expr() [11/14]

Slic3r::client::expr::expr ( const std::string & s )

inlineexplicit

: m_type(TYPE_STRING) { m_data.s = new std::string(s); }

References m_data, m_type, s(), and TYPE_STRING.

Here is the call graph for this function:

expr() [12/14]

Slic3r::client::expr::expr ( std::string && s )

inlineexplicit

: m_type(TYPE_STRING) { m_data.s = new std::string(std::move(s)); }

References m_data, m_type, s(), and TYPE_STRING.

Here is the call graph for this function:

expr() [13/14]

Slic3r::client::expr::expr ( const std::string & s, const Iterator & it_begin, const Iterator & it_end )

inlineexplicit

                                                                                            :
            m_type(TYPE_STRING), it_range(it_begin, it_end) { m_data.s = new std::string(s); }

References it_range, m_data, m_type, s(), and TYPE_STRING.

Here is the call graph for this function:

expr() [14/14]

Slic3r::client::expr::expr ( expr && rhs, const Iterator & it_begin, const Iterator & it_end )

inlineexplicit

                                                                                    : m_type(rhs.type()), it_range{ it_begin, it_end }, m_deferred(rhs.m_deferred)
        {
            m_data.set(rhs.m_data);
            rhs.m_type     = TYPE_EMPTY;
            rhs.m_deferred = Deferred::None;
        }

References expr(), it_range, m_data, m_deferred, m_type, None, type(), and TYPE_EMPTY.

Here is the call graph for this function:

~expr()

Slic3r::client::expr::~expr ( )

inline

{ reset(); }

References reset().

Here is the call graph for this function:

Member Function Documentation

as_d()

double Slic3r::client::expr::as_d ( ) const

inline

{ return this->type() == TYPE_DOUBLE ? this->d() : double(this->i()); }

References d(), i(), type(), and TYPE_DOUBLE.

Referenced by Slic3r::client::InterpolateTableContext::add_pair(), compare_op(), digits(), Slic3r::client::InterpolateTableContext::evaluate(), function_2params(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), random(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), and Slic3r::client::MyContext::vector_variable_element_assign_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

as_i()

int Slic3r::client::expr::as_i ( ) const

inline

{ return this->type() == TYPE_INT ? this->i() : int(this->d()); }

References d(), i(), type(), and TYPE_INT.

Referenced by digits(), Slic3r::client::MyContext::filament_change(), function_2params(), random(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), and Slic3r::client::MyContext::vector_variable_element_assign_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

as_i_rounded()

int Slic3r::client::expr::as_i_rounded ( ) const

inline

{ return this->type() == TYPE_INT ? this->i() : int(std::round(this->d())); }

References d(), i(), type(), and TYPE_INT.

Referenced by digits().

Here is the call graph for this function:

Here is the caller graph for this function:

b() [1/2]

bool & Slic3r::client::expr::b ( )

inline

{ return m_data.b; }

References m_data.

Referenced by expr(), expr(), compare_op(), evaluate_boolean(), evaluate_boolean_to_string(), logical_op(), one_of_test(), one_of_test_regex(), Slic3r::client::operator<<(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), to_string(), unary_not(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), Slic3r::client::MyContext::vector_variable_element_assign_scalar(), and Slic3r::client::MyContext::vector_variable_new_from_array().

Here is the caller graph for this function:

b() [2/2]

bool Slic3r::client::expr::b ( ) const

inline

{ return m_data.b; }

References m_data.

ceil()

expr Slic3r::client::expr::ceil ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_INT:
                return expr(this->i(), start_pos, this->it_range.end());
            case TYPE_DOUBLE:
                return expr(static_cast<int>(std::ceil(this->d())), start_pos, this->it_range.end());
            default:
                this->throw_exception(L("Cannot ceil a non-numeric value."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), L, throw_exception(), type(), TYPE_DOUBLE, and TYPE_INT.

Referenced by Slic3r::client::FactorActions::ceil().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_op()

void Slic3r::client::expr::compare_op ( expr & lhs, expr & rhs, char op, bool invert )

inlinestatic

        {
            if (lhs.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            lhs.throw_if_deferred();
            rhs.throw_if_deferred();
            bool value = false;
            if (lhs.numeric_type() && rhs.numeric_type()) {
                // Both types are numeric.
                switch (op) {
                    case '=':
                        value = (lhs.type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE) ?
                            (std::abs(lhs.as_d() - rhs.as_d()) < 1e-8) : (lhs.i() == rhs.i());
                        break;
                    case '<':
                        value = (lhs.type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE) ?
                            (lhs.as_d() < rhs.as_d()) : (lhs.i() < rhs.i());
                        break;
                    case '>':
                    default:
                        value = (lhs.type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE) ?
                            (lhs.as_d() > rhs.as_d()) : (lhs.i() > rhs.i());
                        break;
                }
            } else if (lhs.type() == TYPE_BOOL && rhs.type() == TYPE_BOOL) {
                // Both type are bool.
                if (op != '=')
                    boost::throw_exception(qi::expectation_failure<Iterator>(
                        lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot compare the types."))));
                value = lhs.b() == rhs.b();
            } else if (lhs.type() == TYPE_STRING || rhs.type() == TYPE_STRING) {
                // One type is string, the other could be converted to string.
                value = (op == '=') ? (lhs.to_string() == rhs.to_string()) :
                        (op == '<') ? (lhs.to_string() < rhs.to_string()) : (lhs.to_string() > rhs.to_string());
            } else {
                boost::throw_exception(qi::expectation_failure<Iterator>(
                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot compare the types."))));
            }
            lhs.reset();
            lhs.set_b_lite(invert ? ! value : value);
        }

References expr(), as_d(), b(), i(), it_range, L, numeric_type(), reset(), set_b_lite(), throw_if_deferred(), to_string(), type(), TYPE_BOOL, TYPE_DOUBLE, TYPE_EMPTY, and TYPE_STRING.

Referenced by equal(), geq(), greater(), leq(), lower(), and not_equal().

Here is the call graph for this function:

Here is the caller graph for this function:

d() [1/2]

double & Slic3r::client::expr::d ( )

inline

{ return m_data.d; }

References m_data.

Referenced by expr(), expr(), as_d(), as_i(), as_i_rounded(), ceil(), floor(), function_2params(), operator%=(), operator/=(), Slic3r::client::operator<<(), round(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), to_string(), unary_integer(), unary_minus(), and Slic3r::client::MyContext::vector_variable_new_from_array().

Here is the caller graph for this function:

d() [2/2]

double Slic3r::client::expr::d ( ) const

inline

{ return m_data.d; }

References m_data.

deferred()

bool Slic3r::client::expr::deferred ( ) const

inline

{ return m_deferred != Deferred::None; }

References m_deferred, and None.

Referenced by operator+=(), operator=(), set_deferred(), throw_exception(), and throw_if_deferred().

Here is the caller graph for this function:

deferred_message()

const char * Slic3r::client::expr::deferred_message ( )

inlinestatic

        {
            return L("This value is known only after the G-code is generated. It can be printed, but not used in a calculation or a comparison.");
        }

References L.

Referenced by throw_exception(), and throw_if_deferred().

Here is the caller graph for this function:

digits()

template<bool leading_zeros>

void Slic3r::client::expr::digits ( expr & param1, expr & param2, expr & param3 )

inlinestatic

        {
            if (param1.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            throw_if_not_numeric(param1);
            if (param2.type() != TYPE_INT)
                param2.throw_exception(L("digits: second parameter must be integer"));
            bool has_decimals = param3.type() != TYPE_EMPTY;
            if (has_decimals && param3.type() != TYPE_INT)
                param3.throw_exception(L("digits: third parameter must be integer"));
 
            char buf[256];
            int  ndigits = std::clamp(param2.as_i(), 0, 64);
            if (has_decimals) {
                // Format as double.
                int decimals = std::clamp(param3.as_i(), 0, 64);
                sprintf(buf, leading_zeros ? "%0*.*lf" : "%*.*lf", ndigits, decimals, param1.as_d());
            } else
                // Format as int.
                sprintf(buf, leading_zeros ? "%0*d" : "%*d", ndigits, param1.as_i_rounded());
            param1.set_s(buf);
        }

References expr(), as_d(), as_i(), as_i_rounded(), L, set_s(), throw_exception(), throw_if_not_numeric(), type(), TYPE_EMPTY, and TYPE_INT.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

equal()

void Slic3r::client::expr::equal ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '=', false); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_boolean()

void Slic3r::client::expr::evaluate_boolean ( expr & self, bool & out )

inlinestatic

        {
            if (self.type() != TYPE_EMPTY) {
                // Not inside an if / else block to be skipped
                if (self.type() != TYPE_BOOL)
                    self.throw_exception(L("Not a boolean expression"));
                out = self.b();
            }
        }

References expr(), b(), L, throw_exception(), type(), TYPE_BOOL, and TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_boolean_to_string()

void Slic3r::client::expr::evaluate_boolean_to_string ( expr & self, std::string & out )

inlinestatic

        {
            assert(self.type() != TYPE_EMPTY);
            if (self.type() != TYPE_BOOL)
                self.throw_exception(L("Not a boolean expression"));
            out = self.b() ? "true" : "false";
        }

References expr(), b(), L, throw_exception(), type(), TYPE_BOOL, and TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

floor()

expr Slic3r::client::expr::floor ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_INT:
                return expr(this->i(), start_pos, this->it_range.end());
            case TYPE_DOUBLE:
                return expr(static_cast<int>(std::floor(this->d())), start_pos, this->it_range.end());
            default:
                this->throw_exception(L("Cannot floor a non-numeric value."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), L, throw_exception(), type(), TYPE_DOUBLE, and TYPE_INT.

Referenced by Slic3r::client::FactorActions::floor().

Here is the call graph for this function:

Here is the caller graph for this function:

function_2params()

void Slic3r::client::expr::function_2params ( expr & param1, expr & param2, Function2ParamsType fun )

inlinestatic

        {
            if (param1.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            throw_if_not_numeric(param1);
            throw_if_not_numeric(param2);
            if (param1.type() == TYPE_DOUBLE || param2.type() == TYPE_DOUBLE) {
                double d = 0.;
                switch (fun) {
                    case FUNCTION_MIN:  d = std::min(param1.as_d(), param2.as_d()); break;
                    case FUNCTION_MAX:  d = std::max(param1.as_d(), param2.as_d()); break;
                    default: param1.throw_exception("Internal error: invalid function");
                }
                param1.set_d_lite(d);
            } else {
                int i = 0;
                switch (fun) {
                    case FUNCTION_MIN:  i = std::min(param1.as_i(), param2.as_i()); break;
                    case FUNCTION_MAX:  i = std::max(param1.as_i(), param2.as_i()); break;
                    default: param1.throw_exception("Internal error: invalid function");
                }
                param1.set_i_lite(i);
            }
        }

References expr(), as_d(), as_i(), d(), FUNCTION_MAX, FUNCTION_MIN, i(), set_d_lite(), set_i_lite(), throw_exception(), throw_if_not_numeric(), type(), TYPE_DOUBLE, and TYPE_EMPTY.

Referenced by max(), and min().

Here is the call graph for this function:

Here is the caller graph for this function:

geq()

void Slic3r::client::expr::geq ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '<', true ); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

greater()

void Slic3r::client::expr::greater ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '>', false); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

i() [1/2]

int & Slic3r::client::expr::i ( )

inline

{ return m_data.i; }

References m_data.

Referenced by expr(), expr(), as_d(), as_i(), as_i_rounded(), ceil(), compare_op(), Slic3r::client::MyContext::evaluate_count(), Slic3r::client::MyContext::evaluate_index(), floor(), function_2params(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), Slic3r::client::operator<<(), round(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), to_string(), unary_integer(), unary_minus(), and Slic3r::client::MyContext::vector_variable_new_from_array().

Here is the caller graph for this function:

i() [2/2]

int Slic3r::client::expr::i ( ) const

inline

{ return m_data.i; }

References m_data.

leq()

void Slic3r::client::expr::leq ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '>', true ); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_and()

void Slic3r::client::expr::logical_and ( expr & lhs, expr & rhs )

inlinestatic

{ logical_op(lhs, rhs, '&'); }

References expr(), and logical_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_op()

void Slic3r::client::expr::logical_op ( expr & lhs, expr & rhs, char op )

inlinestatic

        {
            if (lhs.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;            
            lhs.throw_if_deferred();
            rhs.throw_if_deferred();
            bool value = false;
            if (lhs.type() == TYPE_BOOL && rhs.type() == TYPE_BOOL) {
                value = (op == '|') ? (lhs.b() || rhs.b()) : (lhs.b() && rhs.b());
            } else {
                boost::throw_exception(qi::expectation_failure<Iterator>(
                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot apply logical operation to non-boolean operands."))));
            }
            lhs.set_b_lite(value);
        }

References expr(), b(), it_range, L, set_b_lite(), throw_if_deferred(), type(), TYPE_BOOL, and TYPE_EMPTY.

Referenced by logical_and(), and logical_or().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_or()

void Slic3r::client::expr::logical_or ( expr & lhs, expr & rhs )

inlinestatic

{ logical_op(lhs, rhs, '|'); }

References expr(), and logical_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

lower()

void Slic3r::client::expr::lower ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '<', false); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

max()

void Slic3r::client::expr::max ( expr & param1, expr & param2 )

inlinestatic

{ function_2params(param1, param2, FUNCTION_MAX); }

References expr(), function_2params(), and FUNCTION_MAX.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

min()

void Slic3r::client::expr::min ( expr & param1, expr & param2 )

inlinestatic

{ function_2params(param1, param2, FUNCTION_MIN); }

References expr(), function_2params(), and FUNCTION_MIN.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

not_equal()

void Slic3r::client::expr::not_equal ( expr & lhs, expr & rhs )

inlinestatic

{ compare_op(lhs, rhs, '=', true ); }

References expr(), and compare_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

numeric_type()

bool Slic3r::client::expr::numeric_type ( ) const

inline

{ return m_type == TYPE_INT || m_type == TYPE_DOUBLE; }

References m_type, TYPE_DOUBLE, and TYPE_INT.

Referenced by Slic3r::client::InterpolateTableContext::add_pair(), Slic3r::client::MyContext::check_numeric(), compare_op(), Slic3r::client::InterpolateTableContext::init(), and throw_if_not_numeric().

Here is the caller graph for this function:

one_of_test()

template<bool RegEx>

void Slic3r::client::expr::one_of_test ( const expr & match, const expr & pattern, expr & out )

inlinestatic

                                                                                   { 
            if (match.type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped
                out.reset();
                return;            
            }
            if (! out.b()) {
                match.throw_if_deferred();
                pattern.throw_if_deferred();
                if (match.type() != TYPE_STRING)
                    match.throw_exception(L("one_of(): First parameter (the string to match against) has to be a string value"));
                if (pattern.type() != TYPE_STRING)
                    match.throw_exception(L("one_of(): Pattern has to be a string value"));
                if (RegEx) {
                    try {
                        out.set_b(SLIC3R_REGEX_NAMESPACE::regex_match(match.s(), SLIC3R_REGEX_NAMESPACE::regex(pattern.s())));
                    } catch (SLIC3R_REGEX_NAMESPACE::regex_error &) {
                        // Syntax error in the regular expression
                        pattern.throw_exception(L("Regular expression compilation failed"));
                    }
                } else
                    out.set_b(match.s() == pattern.s());
            }
        }

References expr(), b(), L, reset(), s(), set_b(), throw_exception(), throw_if_deferred(), type(), TYPE_EMPTY, and TYPE_STRING.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

one_of_test_init()

void Slic3r::client::expr::one_of_test_init ( expr & out )

inlinestatic

                                                {
            out.set_b(false);
        }

References expr(), and set_b().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

one_of_test_regex()

void Slic3r::client::expr::one_of_test_regex ( const expr & match, IteratorRange & pattern, expr & out )

inlinestatic

                                                                                            {
            if (match.type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped
                out.reset();
                return;            
            }
            if (! out.b()) {
                if (match.type() != TYPE_STRING)
                    match.throw_exception(L("one_of(): First parameter (the string to match against) has to be a string value"));
                regex_op(match, pattern, '=', out);
            }
        }

References expr(), b(), L, regex_op(), reset(), throw_exception(), type(), TYPE_EMPTY, and TYPE_STRING.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

operator%=()

expr & Slic3r::client::expr::operator%= ( const expr & rhs )

inline

        {
            if (this->type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped.
                this->reset();
            } else {
                this->throw_if_not_numeric(L("Cannot divide a non-numeric type."));
                rhs.throw_if_not_numeric(L("Cannot divide with a non-numeric type."));
                if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
                    rhs.throw_exception(L("Division by zero"));
                if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                    this->set_d_lite(std::fmod(this->as_d(), rhs.as_d()));
                else
                    m_data.i %= rhs.i();
                this->it_range = IteratorRange(this->it_range.begin(), rhs.it_range.end());
            }
            return *this;
        }

References expr(), as_d(), d(), i(), it_range, L, m_data, reset(), set_d_lite(), throw_exception(), throw_if_not_numeric(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_INT.

Here is the call graph for this function:

operator*=()

expr & Slic3r::client::expr::operator*= ( const expr & rhs )

inline

        {
            if (this->type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped.
                this->reset();
            } else {
                const char *err_msg = L("Cannot multiply with non-numeric type.");
                this->throw_if_not_numeric(err_msg);
                rhs.throw_if_not_numeric(err_msg);
                if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                    this->set_d_lite(this->as_d() * rhs.as_d());
                else
                    m_data.i *= rhs.i();
                this->it_range = IteratorRange(this->it_range.begin(), rhs.it_range.end());
            }
            return *this;
        }

References expr(), as_d(), i(), it_range, L, m_data, reset(), set_d_lite(), throw_if_not_numeric(), type(), TYPE_DOUBLE, and TYPE_EMPTY.

Here is the call graph for this function:

operator+=()

expr & Slic3r::client::expr::operator+= ( const expr & rhs )

inline

        {
            if (this->type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped.
            } else if (m_deferred == Deferred::Value && (rhs.type() != TYPE_STRING || rhs.m_deferred == Deferred::Value)) {
                // A deferred value added to a number or to another deferred value is meant as a sum.
                this->throw_if_deferred();
            } else if (rhs.m_deferred == Deferred::Value && this->type() != TYPE_STRING) {
                rhs.throw_if_deferred();
            } else if (this->type() == TYPE_STRING) {
                // Convert the right hand side to string and append.
                *m_data.s += rhs.to_string();
                if (this->deferred() || rhs.deferred())
                    m_deferred = Deferred::Text;
            } else if (rhs.type() == TYPE_STRING) {
                // Conver the left hand side to string, append rhs.
                this->set_s(this->to_string() + rhs.s());
                if (rhs.deferred())
                    m_deferred = Deferred::Text;
            } else {
                const char *err_msg = L("Cannot add non-numeric types.");
                this->throw_if_not_numeric(err_msg);
                rhs.throw_if_not_numeric(err_msg);
                if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                    this->set_d_lite(this->as_d() + rhs.as_d());
                else
                    m_data.i += rhs.i();
            }
            this->it_range = IteratorRange(this->it_range.begin(), rhs.it_range.end());
            return *this;
        }

References expr(), as_d(), deferred(), i(), it_range, L, m_data, m_deferred, s(), set_d_lite(), set_s(), Text, throw_if_deferred(), throw_if_not_numeric(), to_string(), type(), TYPE_DOUBLE, TYPE_EMPTY, TYPE_STRING, and Value.

Here is the call graph for this function:

operator-=()

expr & Slic3r::client::expr::operator-= ( const expr & rhs )

inline

        {
            if (this->type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped.
                this->reset();
            } else {
                const char *err_msg = L("Cannot subtract non-numeric types.");
                this->throw_if_not_numeric(err_msg);
                rhs.throw_if_not_numeric(err_msg);
                if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                    this->set_d_lite(this->as_d() - rhs.as_d());
                else
                    m_data.i -= rhs.i();
                this->it_range = IteratorRange(this->it_range.begin(), rhs.it_range.end());
            }
            return *this;
        }

References expr(), as_d(), i(), it_range, L, m_data, reset(), set_d_lite(), throw_if_not_numeric(), type(), TYPE_DOUBLE, and TYPE_EMPTY.

Here is the call graph for this function:

operator/=()

expr & Slic3r::client::expr::operator/= ( const expr & rhs )

inline

        {
            if (this->type() == TYPE_EMPTY) {
                // Inside an if / else block to be skipped.
                this->reset();
            } else {
                this->throw_if_not_numeric(L("Cannot divide a non-numeric type."));
                rhs.throw_if_not_numeric(L("Cannot divide with a non-numeric type."));
                if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
                    rhs.throw_exception(L("Division by zero"));
                if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                    this->set_d_lite(this->as_d() / rhs.as_d());
                else
                    m_data.i /= rhs.i();
                this->it_range = IteratorRange(this->it_range.begin(), rhs.it_range.end());
            }
            return *this;
        }

References expr(), as_d(), d(), i(), it_range, L, m_data, reset(), set_d_lite(), throw_exception(), throw_if_not_numeric(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_INT.

Here is the call graph for this function:

operator=() [1/2]

expr & Slic3r::client::expr::operator= ( const expr & rhs )

inline

        { 
            // set_s() clears m_deferred, which is also rhs.m_deferred on a self-assignment.
            const Deferred deferred = rhs.m_deferred;
            if (rhs.type() == TYPE_STRING) {
                this->set_s(rhs.s());
            } else  {
                m_type = rhs.type();
                m_data.set(rhs.m_data);
            }
            this->it_range = rhs.it_range;
            m_deferred     = deferred;
            return *this;
        }

References expr(), deferred(), it_range, m_data, m_deferred, m_type, s(), set_s(), type(), and TYPE_STRING.

Here is the call graph for this function:

operator=() [2/2]

expr & Slic3r::client::expr::operator= ( expr && rhs )

inline

        {
            if (this != &rhs) {
                this->reset();
                m_type          = rhs.type();
                this->it_range  = rhs.it_range;
                m_deferred      = rhs.m_deferred;
                m_data.set(rhs.m_data);
                rhs.m_type      = TYPE_EMPTY;
                rhs.m_deferred  = Deferred::None;
            }
            return *this;
        }

References expr(), it_range, m_data, m_deferred, m_type, None, reset(), and TYPE_EMPTY.

Here is the call graph for this function:

random()

void Slic3r::client::expr::random ( expr & param1, expr & param2, std::mt19937 & rng )

inlinestatic

        {
            if (param1.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            throw_if_not_numeric(param1);
            throw_if_not_numeric(param2);
            if (param1.type() == TYPE_DOUBLE || param2.type() == TYPE_DOUBLE)
                param1.set_d_lite(std::uniform_real_distribution<>(param1.as_d(), param2.as_d())(rng));
            else
                param1.set_i_lite(std::uniform_int_distribution<>(param1.as_i(), param2.as_i())(rng));
        }

References expr(), as_d(), as_i(), set_d_lite(), set_i_lite(), throw_if_not_numeric(), type(), TYPE_DOUBLE, and TYPE_EMPTY.

Referenced by Slic3r::client::MyContext::random().

Here is the call graph for this function:

Here is the caller graph for this function:

regex_doesnt_match()

void Slic3r::client::expr::regex_doesnt_match ( expr & lhs, IteratorRange & rhs )

inlinestatic

{ return regex_op(lhs, rhs, '!', lhs); }

References expr(), and regex_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

regex_matches()

void Slic3r::client::expr::regex_matches ( expr & lhs, IteratorRange & rhs )

inlinestatic

{ return regex_op(lhs, rhs, '=', lhs); }

References expr(), and regex_op().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

regex_op()

void Slic3r::client::expr::regex_op ( const expr & lhs, IteratorRange & rhs, char op, expr & out )

inlinestatic

        {
            if (lhs.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            lhs.throw_if_deferred();
            const std::string *subject  = nullptr;
            if (lhs.type() == TYPE_STRING) {
                // One type is string, the other could be converted to string.
                subject = &lhs.s();
            } else {
                lhs.throw_exception(L("Left hand side of a regex match must be a string."));
            }
            try {
                std::string pattern(++ rhs.begin(), -- rhs.end());
                bool result = SLIC3R_REGEX_NAMESPACE::regex_match(*subject, SLIC3R_REGEX_NAMESPACE::regex(pattern));
                if (op == '!')
                    result = ! result;
                out.set_b(result);
            } catch (SLIC3R_REGEX_NAMESPACE::regex_error &ex) {
                // Syntax error in the regular expression
                boost::throw_exception(qi::expectation_failure<Iterator>(
                    rhs.begin(), rhs.end(), spirit::info("*" + Slic3r::format(_u8L("Regular expression compilation failed: %1%"), ex.what()))));
            }
        }

References expr(), _u8L, Slic3r::format(), L, s(), set_b(), throw_exception(), throw_if_deferred(), type(), TYPE_EMPTY, and TYPE_STRING.

Referenced by one_of_test_regex(), regex_doesnt_match(), and regex_matches().

Here is the call graph for this function:

Here is the caller graph for this function:

regex_replace()

void Slic3r::client::expr::regex_replace ( expr & subject, IteratorRange & pattern, expr & replacement )

inlinestatic

        {
            if (subject.type() == TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            subject.throw_if_deferred();
            if (subject.type() != TYPE_STRING)
                subject.throw_exception(L("regex_replace() first parameter must be a string."));
            try {
                std::string re(++ pattern.begin(), -- pattern.end());
                std::string result = SLIC3R_REGEX_NAMESPACE::regex_replace(subject.s(), SLIC3R_REGEX_NAMESPACE::regex(re), replacement.to_string());
                subject.set_s(std::move(result));
            } catch (SLIC3R_REGEX_NAMESPACE::regex_error &ex) {
                // Syntax error in the regular expression
                boost::throw_exception(qi::expectation_failure<Iterator>(
                    pattern.begin(), pattern.end(), spirit::info("*" + Slic3r::format(_u8L("Regular expression compilation failed: %1%"), ex.what()))));
            }
        }

References expr(), _u8L, Slic3r::format(), L, s(), set_s(), throw_exception(), throw_if_deferred(), to_string(), type(), TYPE_EMPTY, and TYPE_STRING.

Referenced by Slic3r::client::MyContext::regex_replace().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void Slic3r::client::expr::reset ( )

inline

        { 
            if (this->type() == TYPE_STRING)
                delete m_data.s;
            m_type     = TYPE_EMPTY;
            m_deferred = Deferred::None;
        }

References m_data, m_deferred, m_type, None, type(), TYPE_EMPTY, and TYPE_STRING.

Referenced by ~expr(), Slic3r::client::FactorActions::bool_(), compare_op(), Slic3r::client::FactorActions::double_(), Slic3r::client::FactorActions::int_(), Slic3r::client::FactorActions::noexpr(), one_of_test(), one_of_test_regex(), operator%=(), operator*=(), operator-=(), operator/=(), operator=(), set_b(), set_d(), set_i(), and Slic3r::client::FactorActions::string_().

Here is the call graph for this function:

Here is the caller graph for this function:

round()

expr Slic3r::client::expr::round ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_EMPTY:
                // Inside an if / else block to be skipped.
                return expr();
            case TYPE_INT:
                return expr(this->i(), start_pos, this->it_range.end());
            case TYPE_DOUBLE:
                return expr(static_cast<int>(std::round(this->d())), start_pos, this->it_range.end());
            default:
                this->throw_exception(L("Cannot round a non-numeric value."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), L, throw_exception(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_INT.

Referenced by Slic3r::client::FactorActions::round().

Here is the call graph for this function:

Here is the caller graph for this function:

s() [1/2]

std::string & Slic3r::client::expr::s ( )

inline

{ return *m_data.s; }

References m_data.

Referenced by expr(), expr(), expr(), expr(), Slic3r::client::MyContext::mark_deferred(), one_of_test(), operator+=(), Slic3r::client::operator<<(), operator=(), regex_op(), regex_replace(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), set_s(), set_s(), set_s(), set_s_take_ownership(), to_string(), and Slic3r::client::MyContext::vector_variable_new_from_array().

Here is the caller graph for this function:

s() [2/2]

const std::string & Slic3r::client::expr::s ( ) const

inline

{ return *m_data.s; }

References m_data.

set_b()

void Slic3r::client::expr::set_b ( bool v )

inline

{ this->reset(); this->set_b_lite(v); }

References reset(), and set_b_lite().

Referenced by Slic3r::client::MyContext::is_nil_test(), Slic3r::client::MyContext::is_vector_empty(), one_of_test(), one_of_test_init(), regex_op(), Slic3r::client::MyContext::scalar_variable_to_expr(), and Slic3r::client::MyContext::vector_element_to_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

set_b_lite()

void Slic3r::client::expr::set_b_lite ( bool v )

inline

{ assert(this->type() != TYPE_STRING); Data tmp; tmp.b = v; m_data.set(tmp); m_type = TYPE_BOOL; }

References Slic3r::client::expr::Data::b, m_data, m_type, type(), TYPE_BOOL, and TYPE_STRING.

Referenced by compare_op(), logical_op(), and set_b().

Here is the call graph for this function:

Here is the caller graph for this function:

set_d()

void Slic3r::client::expr::set_d ( double v )

inline

{ this->reset(); this->set_d_lite(v); }

References reset(), and set_d_lite().

Referenced by Slic3r::client::InterpolateTableContext::evaluate(), Slic3r::client::MyContext::scalar_variable_to_expr(), and Slic3r::client::MyContext::vector_element_to_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

set_d_lite()

void Slic3r::client::expr::set_d_lite ( double v )

inline

{ assert(this->type() != TYPE_STRING); Data tmp; tmp.d = v; m_data.set(tmp); m_type = TYPE_DOUBLE; }

References Slic3r::client::expr::Data::d, m_data, m_type, type(), TYPE_DOUBLE, and TYPE_STRING.

Referenced by function_2params(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), random(), and set_d().

Here is the call graph for this function:

Here is the caller graph for this function:

set_deferred()

void Slic3r::client::expr::set_deferred ( Deferred deferred )

inline

{ m_deferred = deferred; }

References deferred(), and m_deferred.

Referenced by Slic3r::client::MyContext::mark_deferred().

Here is the call graph for this function:

Here is the caller graph for this function:

set_i()

void Slic3r::client::expr::set_i ( int v )

inline

{ this->reset(); set_i_lite(v); }

References reset(), and set_i_lite().

Referenced by Slic3r::client::MyContext::scalar_variable_to_expr(), Slic3r::client::MyContext::vector_element_to_expr(), and Slic3r::client::MyContext::vector_size().

Here is the call graph for this function:

Here is the caller graph for this function:

set_i_lite()

void Slic3r::client::expr::set_i_lite ( int v )

inline

{ assert(this->type() != TYPE_STRING); Data tmp; tmp.i = v; m_data.set(tmp); m_type = TYPE_INT; }

References Slic3r::client::expr::Data::i, m_data, m_type, type(), TYPE_INT, and TYPE_STRING.

Referenced by function_2params(), random(), and set_i().

Here is the call graph for this function:

Here is the caller graph for this function:

set_s() [1/3]

void Slic3r::client::expr::set_s ( const char * s )

inline

                                                 {
            m_deferred = Deferred::None;
            if (this->type() == TYPE_STRING)
                *m_data.s = s;
            else
                this->set_s_take_ownership(new std::string(s));
        }

References m_data, m_deferred, None, s(), set_s_take_ownership(), type(), and TYPE_STRING.

Here is the call graph for this function:

set_s() [2/3]

void Slic3r::client::expr::set_s ( const std::string & s )

inline

                                                      {
            m_deferred = Deferred::None;
            if (this->type() == TYPE_STRING)
                *m_data.s = s;
            else 
                this->set_s_take_ownership(new std::string(s));
        }

References m_data, m_deferred, None, s(), set_s_take_ownership(), type(), and TYPE_STRING.

Referenced by digits(), operator+=(), operator=(), regex_replace(), Slic3r::client::MyContext::scalar_variable_to_expr(), and Slic3r::client::MyContext::vector_element_to_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

set_s() [3/3]

void Slic3r::client::expr::set_s ( std::string && s )

inline

                                                 {
            m_deferred = Deferred::None;
            if (this->type() == TYPE_STRING)
                *m_data.s = std::move(s);
            else
                this->set_s_take_ownership(new std::string(std::move(s)));
        }

References m_data, m_deferred, None, s(), set_s_take_ownership(), type(), and TYPE_STRING.

Here is the call graph for this function:

set_s_take_ownership()

void Slic3r::client::expr::set_s_take_ownership ( std::string * s )

inlineprivate

{ assert(this->type() != TYPE_STRING); Data tmp; tmp.s = s; m_data.set(tmp); m_type = TYPE_STRING; }

References m_data, m_type, Slic3r::client::expr::Data::s, s(), type(), and TYPE_STRING.

Referenced by set_s(), set_s(), and set_s().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_exception()

void Slic3r::client::expr::throw_exception ( const char * message ) const

inline

        {
            if (this->deferred())
                message = deferred_message();
            boost::throw_exception(qi::expectation_failure<Iterator>(
                this->it_range.begin(), this->it_range.end(), spirit::info(std::string("*") + message)));
        }

References deferred(), and deferred_message().

Referenced by Slic3r::client::InterpolateTableContext::add_pair(), ceil(), Slic3r::client::MyContext::check_numeric(), digits(), Slic3r::client::InterpolateTableContext::evaluate(), evaluate_boolean(), evaluate_boolean_to_string(), Slic3r::client::MyContext::evaluate_count(), Slic3r::client::MyContext::evaluate_index(), floor(), function_2params(), Slic3r::client::InterpolateTableContext::init(), one_of_test(), one_of_test_regex(), operator%=(), operator/=(), regex_op(), regex_replace(), round(), throw_if_deferred(), throw_if_not_numeric(), unary_integer(), unary_minus(), unary_not(), and Slic3r::client::MyContext::vector_variable_assign_expr_with_count().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_deferred()

void Slic3r::client::expr::throw_if_deferred ( ) const

inline

        {
            if (this->deferred())
                this->throw_exception(deferred_message());
        }

References deferred(), deferred_message(), and throw_exception().

Referenced by compare_op(), Slic3r::client::MyContext::filament_change(), logical_op(), one_of_test(), operator+=(), regex_op(), and regex_replace().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_not_numeric() [1/2]

void Slic3r::client::expr::throw_if_not_numeric ( const char * message ) const

inline

        {
            if (! this->numeric_type())
                this->throw_exception(message);
        }

References numeric_type(), and throw_exception().

Here is the call graph for this function:

throw_if_not_numeric() [2/2]

void Slic3r::client::expr::throw_if_not_numeric ( const expr & param )

inlinestatic

        {
            const char *err_msg = L("Not a numeric type.");
            param.throw_if_not_numeric(err_msg);
        }

References expr(), L, and throw_if_not_numeric().

Referenced by digits(), function_2params(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), random(), and throw_if_not_numeric().

Here is the call graph for this function:

Here is the caller graph for this function:

to_string()

std::string Slic3r::client::expr::to_string ( ) const

inline

        {
            std::string out;
            switch (this->type()) {
            case TYPE_EMPTY:
                // Inside an if / else block to be skipped.
                break;
      case TYPE_BOOL:   out = this->b() ? "true" : "false"; break;
            case TYPE_INT:    out = std::to_string(this->i()); break;
            case TYPE_DOUBLE:
#if 0
                // The default converter produces trailing zeros after the decimal point.
        out = std::to_string(data.d);
#else
                // ostringstream default converter produces no trailing zeros after the decimal point.
                // It seems to be doing what the old boost::to_string() did.
        {
          std::ostringstream ss;
          ss << this->d();
          out = ss.str();
        }
#endif
        break;
            case TYPE_STRING: out = this->s(); break;
            default:          break;
            }
            return out;
        }

References b(), d(), i(), s(), type(), TYPE_BOOL, TYPE_DOUBLE, TYPE_EMPTY, TYPE_INT, and TYPE_STRING.

Referenced by compare_op(), operator+=(), regex_replace(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), to_string2(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), and Slic3r::client::MyContext::vector_variable_element_assign_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

to_string2()

void Slic3r::client::expr::to_string2 ( expr & self, std::string & out )

inlinestatic

        {
            if (self.type() != TYPE_EMPTY)
                // Not inside an if / else block to be skipped
                out = self.to_string();
        }

References expr(), to_string(), type(), and TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

type()

Type Slic3r::client::expr::type ( ) const

inline

{ return m_type; }

References m_type.

Referenced by expr(), expr(), Slic3r::client::InterpolateTableContext::add_pair(), as_d(), as_i(), as_i_rounded(), ceil(), compare_op(), digits(), Slic3r::client::InterpolateTableContext::evaluate(), evaluate_boolean(), evaluate_boolean_to_string(), Slic3r::client::MyContext::evaluate_count(), Slic3r::client::MyContext::evaluate_index(), Slic3r::client::MyContext::filament_change(), floor(), function_2params(), Slic3r::client::InterpolateTableContext::init(), Slic3r::client::MyContext::initializer_list_append(), logical_op(), Slic3r::client::MyContext::mark_deferred(), one_of_test(), one_of_test_regex(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), Slic3r::client::operator<<(), operator=(), random(), regex_op(), regex_replace(), reset(), round(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), set_b_lite(), set_d_lite(), set_i_lite(), set_s(), set_s(), set_s(), set_s_take_ownership(), to_string(), to_string2(), unary_integer(), unary_minus(), unary_not(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), Slic3r::client::MyContext::vector_variable_element_assign_scalar(), and Slic3r::client::MyContext::vector_variable_new_from_array().

unary_integer()

expr Slic3r::client::expr::unary_integer ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_EMPTY:
                // Inside an if / else block to be skipped.
                return expr();
            case TYPE_INT:
                return expr(this->i(), start_pos, this->it_range.end());
            case TYPE_DOUBLE:
                return expr(static_cast<int>(this->d()), start_pos, this->it_range.end()); 
            default:
                this->throw_exception(L("Cannot convert to integer."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), L, throw_exception(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_INT.

Referenced by Slic3r::client::FactorActions::to_int().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_minus()

expr Slic3r::client::expr::unary_minus ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_EMPTY:
                // Inside an if / else block to be skipped.
                return expr();
            case TYPE_INT :
                return expr(- this->i(), start_pos, this->it_range.end());
            case TYPE_DOUBLE:
                return expr(- this->d(), start_pos, this->it_range.end()); 
            default:
                this->throw_exception(L("Cannot apply unary minus operator."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), L, throw_exception(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_INT.

Referenced by Slic3r::client::FactorActions::minus_().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_not()

expr Slic3r::client::expr::unary_not ( const Iterator start_pos ) const

inline

        {
            switch (this->type()) {
            case TYPE_EMPTY:
                // Inside an if / else block to be skipped.
                return expr();
            case TYPE_BOOL:
                return expr(! this->b(), start_pos, this->it_range.end());
            default:
                this->throw_exception(L("Cannot apply a not operator."));
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), b(), L, throw_exception(), type(), TYPE_BOOL, and TYPE_EMPTY.

Referenced by Slic3r::client::FactorActions::not_().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

it_range

IteratorRange Slic3r::client::expr::it_range

Referenced by expr(), expr(), expr(), expr(), expr(), expr(), expr(), Slic3r::client::InterpolateTableContext::add_pair(), Slic3r::client::FactorActions::bool_(), Slic3r::client::FactorActions::ceil(), compare_op(), Slic3r::client::FactorActions::double_(), Slic3r::client::FactorActions::expr_(), Slic3r::client::FactorActions::floor(), Slic3r::client::FactorActions::int_(), Slic3r::client::MyContext::is_nil_test(), Slic3r::client::MyContext::is_vector_empty(), logical_op(), Slic3r::client::FactorActions::minus_(), Slic3r::client::FactorActions::not_(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), Slic3r::client::operator<<(), operator=(), operator=(), Slic3r::client::MyContext::random(), Slic3r::client::FactorActions::round(), Slic3r::client::MyContext::scalar_variable_assign_scalar(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), Slic3r::client::FactorActions::set_start_pos(), Slic3r::client::FactorActions::string_(), Slic3r::client::FactorActions::to_int(), Slic3r::client::MyContext::variable_value(), Slic3r::client::MyContext::vector_size(), Slic3r::client::MyContext::vector_variable_assign_array(), Slic3r::client::MyContext::vector_variable_element_assign_scalar(), and Slic3r::client::MyContext::vector_variable_new_from_array().

m_data

union Slic3r::client::expr::Data Slic3r::client::expr::m_data

private

Referenced by expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), b(), b(), d(), d(), i(), i(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), operator=(), reset(), s(), s(), set_b_lite(), set_d_lite(), set_i_lite(), set_s(), set_s(), set_s(), and set_s_take_ownership().

m_deferred

Deferred Slic3r::client::expr::m_deferred = Deferred::None

private

Referenced by expr(), expr(), deferred(), operator+=(), operator=(), operator=(), reset(), set_deferred(), set_s(), set_s(), and set_s().

m_type

Type Slic3r::client::expr::m_type = TYPE_EMPTY

private

Referenced by expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), expr(), numeric_type(), operator=(), operator=(), reset(), set_b_lite(), set_d_lite(), set_i_lite(), set_s_take_ownership(), and type().

---

The documentation for this struct was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PlaceholderParser.cpp