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	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 &	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	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

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	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)

Public Attributes
IteratorRange	it_range

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

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

Detailed Description

Member Enumeration Documentation

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 round(), 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)
                    { if (rhs.type() == TYPE_STRING) m_data.s = new std::string(*rhs.m_data.s); else m_data.set(rhs.m_data); }

References m_data, Slic3r::client::expr::Data::s, Slic3r::client::expr::Data::set(), 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()) {}

expr() [4/14]

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

inlineexplicit

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

References b(), Slic3r::client::expr::Data::b, and m_data.

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(), Slic3r::client::expr::Data::b, and m_data.

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(), Slic3r::client::expr::Data::i, and m_data.

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(), Slic3r::client::expr::Data::i, and m_data.

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(), Slic3r::client::expr::Data::d, and m_data.

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(), Slic3r::client::expr::Data::d, and m_data.

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, s(), and Slic3r::client::expr::Data::s.

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, s(), and Slic3r::client::expr::Data::s.

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, s(), and Slic3r::client::expr::Data::s.

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 m_data, s(), and Slic3r::client::expr::Data::s.

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_data.set(rhs.m_data);
            rhs.m_type = TYPE_EMPTY;
        }

References m_data, Slic3r::client::expr::Data::set(), 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 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(), 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 Slic3r::client::expr::Data::b, and 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 Slic3r::client::expr::Data::b, and m_data.

compare_op()

static 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;
            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("*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("*Cannot compare the types.")));
            }
            lhs.reset();
            lhs.set_b_lite(invert ? ! value : value);
        }

References as_d(), b(), i(), it_range, numeric_type(), reset(), set_b_lite(), 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 Slic3r::client::expr::Data::d, and m_data.

Referenced by expr(), expr(), as_d(), as_i(), as_i_rounded(), 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 Slic3r::client::expr::Data::d, and m_data.

digits()

template<bool leading_zeros>

static 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("digits: second parameter must be integer");
            bool has_decimals = param3.type() != TYPE_EMPTY;
            if (has_decimals && param3.type() != TYPE_INT)
                param3.throw_exception("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 as_d(), as_i(), as_i_rounded(), set_s(), throw_exception(), throw_if_not_numeric(), type(), TYPE_EMPTY, and TYPE_INT.

Here is the call graph for this function:

equal()

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

inlinestatic

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

References 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()

static 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("Not a boolean expression");
                out = self.b();
            }
        }

References b(), 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()

static 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("Not a boolean expression");
            out = self.b() ? "true" : "false";
        }

References b(), 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:

function_2params()

static 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 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()

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

inlinestatic

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

References 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()

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

inlinestatic

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

References 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 Slic3r::client::expr::Data::i, and m_data.

Referenced by expr(), expr(), as_d(), as_i(), as_i_rounded(), compare_op(), Slic3r::client::MyContext::evaluate_count(), Slic3r::client::MyContext::evaluate_index(), 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 Slic3r::client::expr::Data::i, and m_data.

leq()

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

inlinestatic

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

References 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()

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

inlinestatic

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

References 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()

static 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;            
            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("*Cannot apply logical operation to non-boolean operators.")));
            }
            lhs.set_b_lite(value);
        }

References b(), it_range, set_b_lite(), 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()

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

inlinestatic

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

References 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()

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

inlinestatic

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

References 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()

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

inlinestatic

{ function_2params(param1, param2, FUNCTION_MAX); }

References 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()

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

inlinestatic

{ function_2params(param1, param2, FUNCTION_MIN); }

References 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()

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

inlinestatic

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

References 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::MyContext::check_numeric(), compare_op(), and throw_if_not_numeric().

Here is the caller graph for this function:

one_of_test()

template<bool RegEx>

static 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()) {
                if (match.type() != TYPE_STRING)
                    match.throw_exception("one_of(): First parameter (the string to match against) has to be a string value");
                if (pattern.type() != TYPE_STRING)
                    match.throw_exception("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("Regular expression compilation failed");
                    }
                } else
                    out.set_b(match.s() == pattern.s());
            }
        }

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

Here is the call graph for this function:

one_of_test_init()

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

inlinestatic

                                                {
            out.set_b(false);
        }

References 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()

static 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("one_of(): First parameter (the string to match against) has to be a string value");
                regex_op(match, pattern, '=', out);
            }
        }

References b(), 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("Cannot divide a non-numeric type.");
                rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
                if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
                    rhs.throw_exception("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 as_d(), d(), i(), Slic3r::client::expr::Data::i, it_range, 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 = "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 as_d(), i(), Slic3r::client::expr::Data::i, it_range, 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 (this->type() == TYPE_STRING) {
                // Convert the right hand side to string and append.
                *m_data.s += rhs.to_string();
            } else if (rhs.type() == TYPE_STRING) {
                // Conver the left hand side to string, append rhs.
                this->set_s(this->to_string() + rhs.s());
            } else {
                const char *err_msg = "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 as_d(), i(), Slic3r::client::expr::Data::i, it_range, m_data, s(), Slic3r::client::expr::Data::s, set_d_lite(), set_s(), throw_if_not_numeric(), to_string(), type(), TYPE_DOUBLE, TYPE_EMPTY, and TYPE_STRING.

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 = "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 as_d(), i(), Slic3r::client::expr::Data::i, it_range, 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("Cannot divide a non-numeric type.");
                rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
                if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
                    rhs.throw_exception("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 as_d(), d(), i(), Slic3r::client::expr::Data::i, it_range, 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

        { 
            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;
            return *this;
        }

References it_range, m_data, m_type, s(), Slic3r::client::expr::Data::set(), 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_data.set(rhs.m_data);
                rhs.m_type      = TYPE_EMPTY;
            }
            return *this;
        }

References it_range, m_data, m_type, reset(), Slic3r::client::expr::Data::set(), and TYPE_EMPTY.

Here is the call graph for this function:

random()

static 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 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()

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

inlinestatic

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

References 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()

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

inlinestatic

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

References 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()

static 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;
            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("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(std::string("*Regular expression compilation failed: ") + ex.what())));
            }
        }

References s(), set_b(), throw_exception(), 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:

reset()

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

inline

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

References m_data, m_type, Slic3r::client::expr::Data::s, 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("Cannot round a non-numeric value.");
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), 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, and Slic3r::client::expr::Data::s.

Referenced by expr(), expr(), expr(), expr(), one_of_test(), operator+=(), Slic3r::client::operator<<(), operator=(), regex_op(), 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, and Slic3r::client::expr::Data::s.

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, Slic3r::client::expr::Data::set(), 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, Slic3r::client::expr::Data::set(), 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_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, Slic3r::client::expr::Data::set(), 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

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

References m_data, s(), Slic3r::client::expr::Data::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

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

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

Referenced by digits(), operator+=(), operator=(), 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

                                                 {
            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, s(), Slic3r::client::expr::Data::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, s(), Slic3r::client::expr::Data::s, Slic3r::client::expr::Data::set(), 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

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

Referenced by 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(), function_2params(), one_of_test(), one_of_test_regex(), operator%=(), operator/=(), regex_op(), round(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), throw_if_not_numeric(), unary_integer(), unary_minus(), unary_not(), Slic3r::client::MyContext::vector_variable_assign_array(), Slic3r::client::MyContext::vector_variable_assign_expr_with_count(), and Slic3r::client::MyContext::vector_variable_new_from_array().

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]

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

inlinestatic

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

References 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+=(), 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()

static 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 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(), as_d(), as_i(), as_i_rounded(), compare_op(), digits(), Slic3r::client::InterpolateTableContext::evaluate(), evaluate_boolean(), evaluate_boolean_to_string(), Slic3r::client::MyContext::evaluate_count(), Slic3r::client::MyContext::evaluate_index(), function_2params(), Slic3r::client::MyContext::initializer_list_append(), logical_op(), one_of_test(), one_of_test_regex(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), Slic3r::client::operator<<(), operator=(), random(), regex_op(), 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().

Here is the caller graph for this function:

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("Cannot convert to integer.");
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), 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("Cannot apply unary minus operator.");
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), d(), i(), 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("Cannot apply a not operator.");
            }
            assert(false);
            // Suppress compiler warnings.
            return expr();
        }

References expr(), b(), 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 Slic3r::client::FactorActions::bool_(), compare_op(), Slic3r::client::FactorActions::double_(), Slic3r::client::FactorActions::expr_(), 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::FactorActions::set_start_pos(), Slic3r::client::FactorActions::string_(), Slic3r::client::FactorActions::to_int(), Slic3r::client::MyContext::variable_value(), Slic3r::client::MyContext::vector_size(), and Slic3r::client::MyContext::vector_variable_element_assign_scalar().

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_type

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

private

Referenced by 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:

• src/libslic3r/PlaceholderParser.cpp