Slic3r::ConfigOptionEnumDef Class Reference

#include <src/libslic3r/Config.hpp>

Collaboration diagram for Slic3r::ConfigOptionEnumDef:

Public Member Functions
bool	has_values () const
bool	has_labels () const
const std::vector< std::string > &	values () const
const std::string &	value (int idx) const
const std::vector< std::string > &	enums () const
const std::vector< std::string > &	labels () const
const std::string &	label (int idx) const
int	index_to_enum (int index) const
std::optional< int >	enum_to_index (int enum_val) const
std::optional< int >	value_to_index (const std::string &value) const
std::optional< int >	label_to_index (const std::string &value) const
std::optional< std::reference_wrapper< const std::string > >	enum_to_value (int enum_val) const
std::optional< std::reference_wrapper< const std::string > >	enum_to_label (int enum_val) const
bool	is_valid_closed_enum () const
bool	is_valid_open_enum () const
void	clear ()
ConfigOptionEnumDef *	clone () const

Private Member Functions
	ConfigOptionEnumDef ()=default
void	set_values (const std::vector< std::string > &v)
void	set_values (const std::initializer_list< std::string_view > il)
void	set_values (const std::initializer_list< std::pair< std::string_view, std::string_view > > il)
void	set_labels (const std::initializer_list< std::string_view > il)
void	finalize_closed_enum ()
template<typename EnumType >
void	set_enum_map ()

Private Attributes
friend	ConfigDef
friend	ConfigOptionDef
std::vector< std::string >	m_values
std::vector< std::string >	m_labels
bool	m_values_ordinary { false }
const t_config_enum_names *	m_enum_names { nullptr }
const t_config_enum_values *	m_enum_keys_map { nullptr }

Detailed Description

Constructor & Destructor Documentation

ConfigOptionEnumDef()

Slic3r::ConfigOptionEnumDef::ConfigOptionEnumDef ( )

privatedefault

Member Function Documentation

clear()

void Slic3r::ConfigOptionEnumDef::clear ( )

inline

                                    {
        m_values_ordinary = false;
        m_enum_names      = nullptr;
        m_enum_keys_map   = nullptr;
        m_values.clear();
        m_labels.clear();
    }

References m_enum_keys_map, m_enum_names, m_labels, m_values, and m_values_ordinary.

clone()

ConfigOptionEnumDef * Slic3r::ConfigOptionEnumDef::clone ( ) const

inline

{ return new ConfigOptionEnumDef{ *this }; }

enum_to_index()

std::optional< int > Slic3r::ConfigOptionEnumDef::enum_to_index ( int  enum_val ) const

inline

                                                       {
        assert(this->is_valid_closed_enum());
        assert(enum_val >= 0 && enum_val < int(m_enum_names->size()));
        if (m_values_ordinary)
            return { enum_val };
        else {
            auto it = std::find(m_values.begin(), m_values.end(), (*m_enum_names)[enum_val]);
            return it == m_values.end() ? std::optional<int>{} : std::optional<int>{ int(it - m_values.begin()) };
        }
    }

References is_valid_closed_enum(), m_enum_names, m_values, and m_values_ordinary.

Referenced by enum_to_label(), and enum_to_value().

Here is the call graph for this function:

Here is the caller graph for this function:

enum_to_label()

std::optional< std::reference_wrapper< const std::string > > Slic3r::ConfigOptionEnumDef::enum_to_label ( int  enum_val ) const

inline

                                                                                         {
        assert(this->is_valid_closed_enum());
        auto opt = this->enum_to_index(enum_val);
        return opt.has_value() ?
            std::optional<std::reference_wrapper<const std::string>>{ this->label(*opt) } : 
            std::optional<std::reference_wrapper<const std::string>>{};
    }

References enum_to_index(), is_valid_closed_enum(), and label().

Here is the call graph for this function:

enum_to_value()

std::optional< std::reference_wrapper< const std::string > > Slic3r::ConfigOptionEnumDef::enum_to_value ( int  enum_val ) const

inline

                                                                                         {
        assert(this->is_valid_closed_enum());
        auto opt = this->enum_to_index(enum_val);
        return opt.has_value() ?
            std::optional<std::reference_wrapper<const std::string>>{ this->value(*opt) } :
            std::optional<std::reference_wrapper<const std::string>>{};
    }

References enum_to_index(), is_valid_closed_enum(), and value().

Here is the call graph for this function:

enums()

const std::vector< std::string > & Slic3r::ConfigOptionEnumDef::enums ( ) const

inline

                                              { 
        assert(this->is_valid_open_enum());
        return this->has_values() ? m_values : m_labels;
    }

References has_values(), is_valid_open_enum(), m_labels, and m_values.

Here is the call graph for this function:

finalize_closed_enum()

void Slic3r::ConfigOptionEnumDef::finalize_closed_enum ( )

inlineprivate

                                {
        assert(this->is_valid_closed_enum());
        // Check whether def.enum_values contains all the values of def.enum_keys_map and
        // that they are sorted by their ordinary values.
        m_values_ordinary = true;
        for (const auto& [enum_name, enum_int] : *m_enum_keys_map) {
            assert(enum_int >= 0);
            if (enum_int >= int(this->values().size()) || this->value(enum_int) != enum_name) {
                m_values_ordinary = false;
                break;
            }
        }
    }

References is_valid_closed_enum(), m_enum_keys_map, m_values_ordinary, value(), and values().

Here is the call graph for this function:

has_labels()

bool Slic3r::ConfigOptionEnumDef::has_labels ( ) const

inline

{ return ! m_labels.empty(); }

References m_labels.

Referenced by labels().

Here is the caller graph for this function:

has_values()

bool Slic3r::ConfigOptionEnumDef::has_values ( ) const

inline

{ return ! m_values.empty(); }

References m_values.

Referenced by enums().

Here is the caller graph for this function:

index_to_enum()

int Slic3r::ConfigOptionEnumDef::index_to_enum ( int  index ) const

inline

                                       {
        // It has to be a closed enum, thus values have to be defined.
        assert(this->is_valid_closed_enum());
        assert(index >= 0 && index < int(m_values.size()));
        if (m_values_ordinary)
            return index;
        else {
            auto it = m_enum_keys_map->find(m_values[index]);
            assert(it != m_enum_keys_map->end());
            return it->second;
        }
    }

References is_valid_closed_enum(), m_enum_keys_map, m_values, and m_values_ordinary.

Here is the call graph for this function:

is_valid_closed_enum()

bool Slic3r::ConfigOptionEnumDef::is_valid_closed_enum ( ) const

inline

                                      {
        return m_enum_names != nullptr && m_enum_keys_map != nullptr &&
            ! m_values.empty() && (m_labels.empty() || m_values.size() == m_labels.size());
    }

References m_enum_keys_map, m_enum_names, m_labels, and m_values.

Referenced by enum_to_index(), enum_to_label(), enum_to_value(), finalize_closed_enum(), index_to_enum(), and value_to_index().

Here is the caller graph for this function:

is_valid_open_enum()

bool Slic3r::ConfigOptionEnumDef::is_valid_open_enum ( ) const

inline

                                    {
        return m_enum_names == nullptr && m_enum_keys_map == nullptr &&
            (! m_values.empty() || ! m_labels.empty()) && (m_values.empty() || m_labels.empty() || m_values.size() == m_labels.size());
    }

References m_enum_keys_map, m_enum_names, m_labels, and m_values.

Referenced by enums(), label_to_index(), and value_to_index().

Here is the caller graph for this function:

label()

const std::string & Slic3r::ConfigOptionEnumDef::label ( int  idx ) const

inline

{ return this->labels()[idx]; }

References labels().

Referenced by enum_to_label().

Here is the call graph for this function:

Here is the caller graph for this function:

label_to_index()

std::optional< int > Slic3r::ConfigOptionEnumDef::label_to_index ( const std::string &  value ) const

inline

                                                                  {
        assert(is_valid_open_enum());
        const auto &ls = this->labels();
        auto it = std::find(ls.begin(), ls.end(), value);
        return it == ls.end() ? 
            std::optional<int>{} : std::optional<int>{ it - ls.begin() };
    }

References is_valid_open_enum(), labels(), and value().

Here is the call graph for this function:

labels()

const std::vector< std::string > & Slic3r::ConfigOptionEnumDef::labels ( ) const

inline

{ return this->has_labels() ? m_labels : m_values; }

References has_labels(), m_labels, and m_values.

Referenced by label(), and label_to_index().

Here is the call graph for this function:

Here is the caller graph for this function:

set_enum_map()

template<typename EnumType >

void Slic3r::ConfigOptionEnumDef::set_enum_map ( )

inlineprivate

    {
        m_enum_names    = &ConfigOptionEnum<EnumType>::get_enum_names();
        m_enum_keys_map = &ConfigOptionEnum<EnumType>::get_enum_values();
    }

References Slic3r::ConfigOptionEnum< T >::get_enum_names(), Slic3r::ConfigOptionEnum< T >::get_enum_values(), m_enum_keys_map, and m_enum_names.

Here is the call graph for this function:

set_labels()

void Slic3r::ConfigOptionEnumDef::set_labels ( const std::initializer_list< std::string_view >  il )

inlineprivate

                                                                  {
        m_labels.clear();
        m_labels.reserve(il.size());
        for (const std::string_view& p : il)
            m_labels.emplace_back(p);
        assert(m_values.empty() || m_labels.size() == m_values.size());
    }

References m_labels, and m_values.

set_values() [1/3]

void Slic3r::ConfigOptionEnumDef::set_values ( const std::initializer_list< std::pair< std::string_view, std::string_view > >  il )

inlineprivate

                                                                                           {
        m_values.clear();
        m_values.reserve(il.size());
        m_labels.clear();
        m_labels.reserve(il.size());
        for (const std::pair<std::string_view, std::string_view>& p : il) {
            m_values.emplace_back(p.first);
            m_labels.emplace_back(p.second);
        }
    }

References m_labels, and m_values.

set_values() [2/3]

void Slic3r::ConfigOptionEnumDef::set_values ( const std::initializer_list< std::string_view >  il )

inlineprivate

                                                                  {
        m_values.clear();
        m_values.reserve(il.size());
        for (const std::string_view& p : il)
            m_values.emplace_back(p);
        assert(m_labels.empty() || m_labels.size() == m_values.size());
    }

References m_labels, and m_values.

set_values() [3/3]

void Slic3r::ConfigOptionEnumDef::set_values ( const std::vector< std::string > &  v )

inlineprivate

                                                   {
        m_values = v;
        assert(m_labels.empty() || m_labels.size() == m_values.size());
    }

References m_labels, and m_values.

value()

const std::string & Slic3r::ConfigOptionEnumDef::value ( int  idx ) const

inline

{ return m_values[idx]; }

References m_values.

Referenced by enum_to_value(), finalize_closed_enum(), label_to_index(), and value_to_index().

Here is the caller graph for this function:

value_to_index()

std::optional< int > Slic3r::ConfigOptionEnumDef::value_to_index ( const std::string &  value ) const

inline

                                                                  {
        assert(this->is_valid_open_enum() || this->is_valid_closed_enum());
        auto it = std::find(m_values.begin(), m_values.end(), value);
        return it == m_values.end() ? 
            std::optional<int>{} : std::optional<int>{ it - m_values.begin() };
    }

References is_valid_closed_enum(), is_valid_open_enum(), m_values, and value().

Here is the call graph for this function:

values()

const std::vector< std::string > & Slic3r::ConfigOptionEnumDef::values ( ) const

inline

{ return m_values; }

References m_values.

Referenced by finalize_closed_enum().

Here is the caller graph for this function:

Member Data Documentation

ConfigDef

friend Slic3r::ConfigOptionEnumDef::ConfigDef

private

ConfigOptionDef

friend Slic3r::ConfigOptionEnumDef::ConfigOptionDef

private

m_enum_keys_map

const t_config_enum_values* Slic3r::ConfigOptionEnumDef::m_enum_keys_map { nullptr }

private

Referenced by clear(), finalize_closed_enum(), index_to_enum(), is_valid_closed_enum(), is_valid_open_enum(), and set_enum_map().

m_enum_names

const t_config_enum_names* Slic3r::ConfigOptionEnumDef::m_enum_names { nullptr }

private

Referenced by clear(), enum_to_index(), is_valid_closed_enum(), is_valid_open_enum(), and set_enum_map().

m_labels

std::vector<std::string> Slic3r::ConfigOptionEnumDef::m_labels

private

Referenced by clear(), enums(), has_labels(), is_valid_closed_enum(), is_valid_open_enum(), labels(), set_labels(), set_values(), set_values(), and set_values().

m_values

std::vector<std::string> Slic3r::ConfigOptionEnumDef::m_values

private

Referenced by clear(), enum_to_index(), enums(), has_values(), index_to_enum(), is_valid_closed_enum(), is_valid_open_enum(), labels(), set_labels(), set_values(), set_values(), set_values(), value(), value_to_index(), and values().

m_values_ordinary

bool Slic3r::ConfigOptionEnumDef::m_values_ordinary { false }

private

Referenced by clear(), enum_to_index(), finalize_closed_enum(), and index_to_enum().

---

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

• src/libslic3r/Config.hpp