[RuCodeGen::ValueIncapsulator] cfg

Кодогенерирующий скрипт

        require 'rubygems'
        require 'RuCodeGen'

        cpp_value_incapsulator :cfg_t do |c|
                c.decl_file :script_relative => "cfg.decl.hpp"
                c.impl_file :script_relative => "cfg.impl.cpp"

                c.attr_suffix "_"

                c.attr :listening_mbox, "std::string"
                c.attr :self_mbox, "std::string", :default => :"default_self_mbox()"
                c.attr :interception_priority, "int", :default => 2
                c.attr :low_watermark, "unsigned int", :default => :default_low_watermark
                c.attr :high_watermark, "unsigned int"
                c.attr :cprov_high_watermark, "unsigned int"
                c.attr :max_life_time, "unsigned int", :default => 60
                c.attr :check_life_time_period, "unsigned int", :default => 5

        end

Файл для использования результатов кодогенерации

        #include <string>

        std::string
        default_self_mbox() { return "default"; }

        const unsigned int default_low_watermark = 30;

        #include "cfg.decl.hpp"
        #include "cfg.impl.cpp"

        int
        main()
                {
                        cfg_t cfg;
                }

Результат кодогенерации

Файл cfg.decl.hpp

        class cfg_t
                {
                private :
                        std::string listening_mbox_;
                        std::string self_mbox_;
                        int interception_priority_;
                        unsigned int low_watermark_;
                        unsigned int high_watermark_;
                        unsigned int cprov_high_watermark_;
                        unsigned int max_life_time_;
                        unsigned int check_life_time_period_;

                public :
                        cfg_t();

                        const std::string &
                        listening_mbox() const;
                        void
                        listening_mbox( const std::string & v__ );
                        const std::string &
                        self_mbox() const;
                        void
                        self_mbox( const std::string & v__ );
                        int
                        interception_priority() const;
                        void
                        interception_priority( int v__ );
                        unsigned int
                        low_watermark() const;
                        void
                        low_watermark( unsigned int v__ );
                        unsigned int
                        high_watermark() const;
                        void
                        high_watermark( unsigned int v__ );
                        unsigned int
                        cprov_high_watermark() const;
                        void
                        cprov_high_watermark( unsigned int v__ );
                        unsigned int
                        max_life_time() const;
                        void
                        max_life_time( unsigned int v__ );
                        unsigned int
                        check_life_time_period() const;
                        void
                        check_life_time_period( unsigned int v__ );

                };

Файл cfg.impl.cpp

        cfg_t::cfg_t()
                :     listening_mbox_()
                ,     self_mbox_(default_self_mbox())
                ,     interception_priority_(2)
                ,     low_watermark_(default_low_watermark)
                ,     high_watermark_(0)
                ,     cprov_high_watermark_(0)
                ,     max_life_time_(60)
                ,     check_life_time_period_(5)

                {}

        const std::string &
        cfg_t::listening_mbox() const
                { return listening_mbox_; }
        void
        cfg_t::listening_mbox( const std::string & v__ )
                { listening_mbox_ = v__; }
        const std::string &
        cfg_t::self_mbox() const
                { return self_mbox_; }
        void
        cfg_t::self_mbox( const std::string & v__ )
                { self_mbox_ = v__; }
        int
        cfg_t::interception_priority() const
                { return interception_priority_; }
        void
        cfg_t::interception_priority( int v__ )
                { interception_priority_ = v__; }
        unsigned int
        cfg_t::low_watermark() const
                { return low_watermark_; }
        void
        cfg_t::low_watermark( unsigned int v__ )
                { low_watermark_ = v__; }
        unsigned int
        cfg_t::high_watermark() const
                { return high_watermark_; }
        void
        cfg_t::high_watermark( unsigned int v__ )
                { high_watermark_ = v__; }
        unsigned int
        cfg_t::cprov_high_watermark() const
                { return cprov_high_watermark_; }
        void
        cfg_t::cprov_high_watermark( unsigned int v__ )
                { cprov_high_watermark_ = v__; }
        unsigned int
        cfg_t::max_life_time() const
                { return max_life_time_; }
        void
        cfg_t::max_life_time( unsigned int v__ )
                { max_life_time_ = v__; }
        unsigned int
        cfg_t::check_life_time_period() const
                { return check_life_time_period_; }
        void
        cfg_t::check_life_time_period( unsigned int v__ )
                { check_life_time_period_ = v__; }