Автогенерация классов в C++

#cpp #препроцессор

Имеется структура данных, подобная следующей:

Group_1
    Type_1_1 Variable_1_1
    . . .
    Type_1_N Variable_1_N
    Group_1_1 Name_1_1
        Type_1_1_1  Variable_1_1_1
        . . .
        Type_1_1_N1 Variable_1_1_N1
    . . .
    Group_1_M Name_1_M
        Type_1_M_1  Variable_1_M_1
        . . .
        Type_1_M_N2 Variable_1_M_N2


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

Для указанной структуры необходимо построить C++-код следующего вида:

class Group_1_1 {
    public :
        Type_1_1_1  Variable_1_1_1;
        // . . .
        Type_1_1_N1 Variable_1_1_N1;
        void f(Worker& worker) {
            worker.begin("Group_1_1");
            worker.work("Variable_1_1_1",  Variable_1_1_1);
            // . . .
            worker.work("Variable_1_1_N1", Variable_1_1_N1);
            worker.end();
        }
}
// . . .

class Group_1 {
    public :
        Type_1_1 Variable_1_1;
        // . . .
        Type_1_N Variable_1_N;
        Group_1_1 Name_1_1;
        // . . .
        Group_1_M Name_1_M;
        void f(Worker& worker) {
            worker.begin("Group_1");
            worker.work("Variable_1_1",  Variable_1_1_1);
            // . . .
            worker.work("Variable_1_N", Variable_1_1_N1);
            Name_1_1.f(worker);
            // . . .
            Name_1_M.f(worker);
            worker.end();
        }
}


Здесь Worker - некоторый внешний класс.

Построить код необходимо без использования каких-либо внешних инструментов, можно
использовать только стандартные возможности компилятора и препроцессора. То есть можно
использовать макросы и шаблоны, но нельзя запускать какие-либо программы, не входящие
в состав компилятора. Можно при этом ограничиться стандартом c++11, совместимость с
предыдущими стандартами не требуется. Решение должно работать по меньшей мере со следующими
компиляторами: GCC 4.9+ (Linux), MinGW 4.9+ (Windows), MSVC 2015.

Собственно вопрос: можно ли это реализовать и если можно, то как?
    

Ответы

Ответ 1

Предлагаю решение с ипользованием boost::preprocessor. Пока что это решение только
половины задачи, генерации отдельных классов.

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

#define GEN_GROUP 1
#define GEN_VAR   0

#define MY_STRUCT \
   (GEN_GROUP, AType, A, (GEN_VAR, int, AInt)  \
                       , (GEN_GROUP, BType, B, (GEN_VAR, int, BInt)     \
                                             , (GEN_VAR, float, BFloat) \
                         ) \
                       , (GEN_VAR, char, AChar) \
   )


В понятиях boost::preprocessor это кортежи (tuple). А точнее кортежи которые содержат
другие кортежи и таким образом образуют дерево. Струтура это дерева такая: элемент
0 - тип узла (группа или переменная), элемент 1 - тип данных, 2 - имя узла, и в случае
группы остальные элементы начиная с 3 это поля или подгруппы:

  группа = (1, тип, имя, [переменная | группа]+ )
  переменная = (0, тип, имя)


Использовать эту структуру надо следующим образом, приведу просто код с коментариями:

#include 

#define GEN_NODE_TYPE(node) BOOST_PP_TUPLE_ELEM(0, node)
#define GEN_TYPE(node) BOOST_PP_TUPLE_ELEM(1, node)
#define GEN_NAME(node) BOOST_PP_TUPLE_ELEM(2, node)
#define GEN_CHILDS(node) \ // конвертируем в список, выкусываем хвост начиная с элемента 3
   BOOST_PP_LIST_REST_N(3, BOOST_PP_TUPLE_TO_LIST(node)) 

// функтор для генерации полей класа вида "тип имя;"
#define GENERATE_MEMBER_PRED(r, data, member) \
   GEN_TYPE(member) GEN_NAME(member); 

// функтор для генерации вызовов worker внутри фнукции f
#define GENERATE_WORK_CALL_PRED(r, data, member)     \
 BOOST_PP_IF(GEN_NODE_TYPE(member)                   \ // если тип "группа"
  , GEN_NAME(member).f(worker)                       \ // то "имя.f(worker)"
  , worker.work(BOOST_PP_STRINGAZE(GEN_NAME(member)) \ // заковычиваем имя
               ,GEN_NAME(2, member))                 \ // иначе worker.work("имя", имя)
 );  // точка с запятой для всех

#define GENERATE_CLASS(node) \
class GEN_TYPE(node)         \  // "class тип"
{       \
public: \
   \ // генерируем поля
   BOOST_PP_LIST_FOR_EACH(  \
       GENERATE_MEMBER_PRED \  // выполняем для каждого элемента
      , _                   \  // здесь можно пусто
      , GEN_CHILDS(node)    \  // список детей
   )                        \  
   \
   void f(Worker & worker)  \
   { \  
       worker.begin(BOOST_PP_STRINGAZE(GEN_TYPE(member))); \ // заковычивам тип
       \
       \ // генерируем вызовы worker для полей
       BOOST_PP_LIST_FOR_EACH(      \
           GENERATE_WORK_CALL_PRED  \ // выполняем для каждого ребенка
          , _                       \ // здесь можно пусто
          , GEN_CHILDS(node)        \ // список детей
       )                            \ 
       \
       worker.end(); \
   } \
}; 


Результат для GENERATE_CLASS(MY_STRUCT):

class AType
{
public:
    int AInt;
    BType B;
    char AChar;

    void f(Worker & worker)
    {
       worker.begin("AType");
       worker.work("AInt", AInt);
       B.f(worker);
       worker.work("AChar", AChar);
       worker.end();
    }
};


Как видите, классы для вложенных групп не генерируются, но это уже хоть что-то. Чтобы
сделать вложенные группы необходимо реализовать обход входного дерева, при котором
для каждого узла, если он группа, вызывать GENERATE_CLASS. Так как препроцессор не
поддерживает рекурсию макросов, обход надо делать нерекурсивный со стеком. На boost::preprocessor
по идее это возможно, но сложно, предлагаю это для самостоятельной проработки.

Внимание! Самое большое ограничение такого подхода в том, что бесконечную структуру
обработать не получится. Так как количество итераций в любом циклическом операторе
boost::preprocessor ограничено, равно как и в любом другом подобном инструменте основанном
на препроцессоре Си. Сейчас, например, максимальное количество итераций для FOR_* составляет
256. Поэтому для больших циклов вам нужно править библиотеку boost::preprocessor либо
делать свой клон с каким вам надо количеством итераций.