LINUX.ORG.RU

История изменений

Исправление thunar, (текущая версия) :

И память для config_holder-а вместе с инициализацией происходит точно так же, как и в случае прямого использования голого config_var.

Ну, например, там внутри ещё харнятся unique_ptr для ресурсов, дополнительные методы и пр.. Я не стал их все указывать что бы не загромождать минимальный пример.

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должно работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру. Из них уже как из конструктора собирается расчётная задача.

Знание о том что это экспортируется в python не обязательно, достаточно того что наружу торчат статично-полиморфные классы.

Исправление thunar, :

И память для config_holder-а вместе с инициализацией происходит точно так же, как и в случае прямого использования голого config_var.

Ну, например, там внутри ещё харнятся unique_ptr для ресурсов, дополнительные методы и пр.. Я не стал их все указывать что бы не загромождать минимальный пример.

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должно работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру. Из них уже как из конструктора собирается расчётная задача.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должно работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру. Из них уже как из конструктора собирается расчётная задача.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должно работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру. Из них уже как из конструктора пишется расчётная задача.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должно работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должнл работать:

                                            <- config_t<1> 
python <- config_holder(RAII, arg0: n, ...) <- config_t<2>
                                            <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должнл работать:

                                       <- config_t<1> 
python <- config_holder(RAII, arg0: n) <- config_t<2>
                                       <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func instance
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру.

Исправление thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должнл работать:

                                       <- config_t<1> 
python <- config_holder(RAII, arg0: n) <- config_t<2>
                                       <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру.

Исходная версия thunar, :

В общем, картина мира есть только в вашей голове, делиться ей с участниками обсуждения вы не хотите, ну и ваше дело.

Вот я попытался изобразить схему как это должнл работать:

                              <- config_t<1> 
python <- config_holder(RAII) <- config_t<2>
                              <- config_t<3>
                              
                                                      <- data_t<float>
python <- data_holder(RAII, arg0: config_holder, ...) <- data_t<double>
                                                      <- data_t<int>

python -> func(arg0: config_holder, arg1: data_holder, ...) -> call func_t<nd, tp> -> call backend func
Вот эти func, *_holder'ы биндятся в пайтон и только они доступны юзеру.