inipp::Ini< CharT > Class Template Reference

#include <inipp.h>

Public Types
using	String = std::basic_string<CharT>
using	Section = std::map<String, String>
using	Sections = std::map<String, Section>

Public Member Functions
	Ini ()
	Ini (std::shared_ptr< Format< CharT > > fmt)
void	generate (std::basic_ostream< CharT > &os) const
void	parse (std::basic_istream< CharT > &is)
void	interpolate ()
void	default_section (const Section &sec)
void	strip_trailing_comments ()
void	clear ()

Public Attributes
Sections	sections
std::list< String >	errors
std::shared_ptr< Format< CharT > >	format

Static Public Attributes
static const int	max_interpolation_depth = 10

Member Typedef Documentation

Section

template<class CharT>

using inipp::Ini< CharT >::Section = std::map<String, String>

Sections

template<class CharT>

using inipp::Ini< CharT >::Sections = std::map<String, Section>

String

template<class CharT>

using inipp::Ini< CharT >::String = std::basic_string<CharT>

Constructor & Destructor Documentation

Ini() [1/2]

template<class CharT>

inipp::Ini< CharT >::Ini ( )

inline

          :
        format(std::make_shared<Format<CharT>>()) {};

Ini() [2/2]

template<class CharT>

inipp::Ini< CharT >::Ini ( std::shared_ptr< Format< CharT > > fmt )

inline

                                          :
        format(fmt) {};

Member Function Documentation

clear()

template<class CharT>

void inipp::Ini< CharT >::clear ( )

inline

    {
        sections.clear();
        errors.clear();
    }

default_section()

template<class CharT>

void inipp::Ini< CharT >::default_section ( const Section & sec )

inline

    {
        for (auto & sec2 : sections)
            for (const auto & val : sec)
                sec2.second.insert(val);
    }

generate()

template<class CharT>

void inipp::Ini< CharT >::generate ( std::basic_ostream< CharT > & os ) const

inline

    {
        for (auto const & sec : sections)
        {
            os << format->char_section_start << sec.first << format->char_section_end << std::endl;
            for (auto const & val : sec.second)
            {
                os << val.first << format->char_assign << val.second << std::endl;
            }
            os << std::endl;
        }
    }

interpolate()

template<class CharT>

void inipp::Ini< CharT >::interpolate ( )

inline

    {
        int  global_iteration = 0;
        auto changed          = false;
        // replace each "${variable}" by "${section:variable}"
        for (auto & sec : sections)
            replace_symbols(local_symbols(sec.first, sec.second), sec.second);
        // replace each "${section:variable}" by its value
        do
        {
            changed         = false;
            const auto syms = global_symbols();
            for (auto & sec : sections)
                changed |= replace_symbols(syms, sec.second);
        } while (changed && (max_interpolation_depth > global_iteration++));
    }

parse()

template<class CharT>

void inipp::Ini< CharT >::parse ( std::basic_istream< CharT > & is )

inline

    {
        String            line;
        String            section;
        const std::locale loc {"C"};
        while (std::getline(is, line))
        {
            detail::ltrim(line, loc);
            detail::rtrim(line, loc);
            const auto length = line.length();
            if (length > 0)
            {
                const auto   pos   = std::find_if(line.begin(), line.end(), [this](CharT ch) { return format->is_assign(ch); });
                const auto & front = line.front();
                if (format->is_comment(front))
                {
                }
                else if (format->is_section_start(front))
                {
                    if (format->is_section_end(line.back()))
                        section = line.substr(1, length - 2);
                    else
                        errors.push_back(line);
                }
                else if (pos != line.begin() && pos != line.end())
                {
                    String variable(line.begin(), pos);
                    String value(pos + 1, line.end());
                    detail::rtrim(variable, loc);
                    detail::ltrim(value, loc);
                    auto & sec = sections[section];
                    if (sec.find(variable) == sec.end())
                        sec.emplace(variable, value);
                    else
                        errors.push_back(line);
                }
                else
                {
                    errors.push_back(line);
                }
            }
        }
    }

strip_trailing_comments()

template<class CharT>

void inipp::Ini< CharT >::strip_trailing_comments ( )

inline

    {
        const std::locale loc {"C"};
        for (auto & sec : sections)
            for (auto & val : sec.second)
            {
                detail::rtrim2(val.second, [this](CharT ch) { return format->is_comment(ch); });
                detail::rtrim(val.second, loc);
            }
    }

Member Data Documentation

errors

template<class CharT>

std::list<String> inipp::Ini< CharT >::errors

format

template<class CharT>

std::shared_ptr<Format<CharT> > inipp::Ini< CharT >::format

max_interpolation_depth

template<class CharT>

const int inipp::Ini< CharT >::max_interpolation_depth = 10

static

sections

template<class CharT>

Sections inipp::Ini< CharT >::sections

---

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

• hyperdbg/libhyperdbg/header/inipp.h