add doxygen via opencode

libs/main/state_machine/pistatemachine_base.h

@@ -31,12 +31,16 @@
 
 namespace PIStateMachineHelpers {
 
+//! \~english Base class for function wrappers
+//! \~russian Базовый класс для обёрток функций
 class FunctionBase {
 public:
 	virtual ~FunctionBase() {}
 	virtual uint formatHash() = 0;
 };
 
+//! \~english Template class for function wrappers
+//! \~russian Шаблонный класс для обёрток функций
 template<typename... Args>
 class Function: public FunctionBase {
 public:
@@ -47,6 +51,8 @@ public:
 	std::function<bool(Args...)> func;
 };
 
+//! \~english Creates function wrapper from std::function
+//! \~russian Создает обёртку функции из std::function
 template<typename Ret, typename... Args>
 FunctionBase * makeFunction(std::function<Ret(Args...)> func) {
 	auto * ret = new Function<Args...>();

libs/main/state_machine/pistatemachine_state.h

@@ -31,50 +31,117 @@
 #include "pisystemtime.h"
 
 
-//! \ingroup StateMachine
-//! \~\brief
-//! \~english
-//! \~russian
+//! \~english Base class for state machine states
+//! \~russian Базовый класс для состояний машины состояний
 class PIP_EXPORT PIStateBase {
 	friend class PIStateMachine;
 	friend class PITransitionBase;
 	friend class PIStateFinal;
 
 public:
+	//! \~english Creates state with name
+	//! \~russian Создает состояние с именем
 	PIStateBase(const PIString & n = {}): name_(n) { ; }
 	virtual ~PIStateBase();
 
+	//! \~english Called when state is \~russian Вы entered
+	//! зывается при входе в состояние
 	virtual void onEnter() {}
+
+	//! \~english Called when state is exited
+	//! \~russian Вызывается при выходе из состояния
 	virtual void onExit() {}
+
+	//! \~english Called when state machine finishes (for final states)
+	//! \~russian Вызывается при завершении машины состояний (для финальных состояний)
 	virtual void onFinish() {}
 
+	//! \~english Returns state machine this state belongs to
+	//! \~russian Возвращает машину состояний, которой принадлежит это состояние
 	PIStateMachine * machine() const { return root; }
+
+	//! \~english Returns parent state
+	//! \~russian Возвращает родительское состояние
 	PIStateBase * parent() const { return parent_state; }
+
+	//! \~english Returns active child state
+	//! \~russian Возвращает активное дочернее состояние
 	PIStateBase * activeChild() const { return active_state; }
+
+	//! \~english Returns all active child states
+	//! \~russian Возвращает все активные дочерние состояния
 	PIVector<PIStateBase *> activeChildren() const;
+
+	//! \~english Returns all active atomic states
+	//! \~russian Возвращает все активные атомарные состояния
 	PIVector<PIStateBase *> activeAtomics() const;
 
+	//! \~english Adds child state
+	//! \~russian Добавляет дочернее состояние
 	void addState(PIStateBase * s);
+
+	//! \~english Adds multiple child states
+	//! \~russian Добавляет несколько дочерних состояний
 	void addStates(PIVector<PIStateBase *> s);
+
+	//! \~english Sets initial state for compound state
+	//! \~russian Устанавливает начальное состояние для составного состояния
 	void setInitialState(PIStateBase * s);
 
+	//! \~english Adds transition to target state on event
+	//! \~russian Добавляет переход к целевому состоянию по событию
 	PITransitionBase * addTransition(PIStateBase * target, int event_id);
+
+	//! \~english Adds timeout transition to target state
+	//! \~russian Добавляет переход по таймауту к целевому состоянию
 	PITransitionTimeout * addTimeoutTransition(PIStateBase * target, PISystemTime timeout);
 
+	//! \~english Sets parallel mode for state
+	//! \~russian Устанавливает параллельный режим для состояния
 	void setParallel(bool yes) { is_parallel = yes; }
 
+	//! \~english Returns state name
+	//! \~russian Возвращает имя состояния
 	const PIString & getName() const { return name_; }
+
+	//! \~english Checks if this is root state machine
+	//! \~russian Проверяет является ли это корневой машиной состояний
 	bool isStateMachine() const { return is_root; }
+
+	//! \~english Checks if state is active
+	//! \~russian Проверяет активно ли состояние
 	bool isActive() const { return is_active; }
+
+	//! \~english Checks if state is in parallel mode
+	//! \~russian Проверяет находится ли состояние в параллельном режиме
 	bool isParallel() const { return is_parallel; }
+
+	//! \~english Checks if state is final
+	//! \~russian Проверяет является ли состояние финальным
 	bool isFinal() const { return is_final; }
+
+	//! \~english Checks if state is atomic (no children)
+	//! \~russian Проверяет является ли состояние атомарным (нет потомков)
 	bool isAtomic() const { return children.isEmpty(); }
+
+	//! \~english Checks if state is compound (has children)
+	//! \~russian Проверяет является ли состояние составным (есть потомки)
 	bool isCompound() const { return children.isNotEmpty(); }
+
+	//! \~english Returns child states
+	//! \~russian Возвращает дочерние состояния
 	const PIVector<PIStateBase *> & getChildren() const { return children; }
+
+	//! \~english Returns transitions from this state
+	//! \~russian Возвращает переходы из этого состояния
 	const PIVector<PITransitionBase *> & getTransitions() const { return transitions; }
 
+	//! \~english Prints state tree to string
+	//! \~russian Выводит дерево состояний в строку
 	void print(PIString prefix = {});
 
+	//! \~english Returns all states in machine
+	//! \~russian Возвращает все состояния в машине
 	PIVector<PIStateBase *> gatherStates();
 
 private:
@@ -100,8 +167,12 @@ private:
 };
 
 
+//! \~english State with lambda callbacks
+//! \~russian Состояние с lambda коллбэками
 class PIP_EXPORT PIStateLambda: public PIStateBase {
 public:
+	//! \~english Creates lambda state with callbacks
+	//! \~russian Создает lambda состояние с коллбэками
 	PIStateLambda(std::function<void()> on_enter, std::function<void()> on_exit = nullptr, const PIString & n = {}): PIStateBase(n) {
 		enter = on_enter;
 		exit  = on_exit;
@@ -118,8 +189,12 @@ private:
 };
 
 
+//! \~english Final state of state machine
+//! \~russian Финальное состояние машины состояний
 class PIP_EXPORT PIStateFinal: public PIStateBase {
 public:
+	//! \~english Creates final state with finish callback
+	//! \~russian Создает финальное состояние с коллбэком завершения
 	PIStateFinal(std::function<void()> on_finish = nullptr, const PIString & n = {}): PIStateBase(n) {
 		is_final = true;
 		enter    = on_finish;

libs/main/state_machine/pistatemachine_transition.h

@@ -30,22 +30,32 @@
 #include "pitimer.h"
 
 
-//! \ingroup StateMachine
-//! \~\brief
-//! \~english
-//! \~russian
+//! \~english Base class for state machine transitions
+//! \~russian Базовый класс для переходов машины состояний
 class PIP_EXPORT PITransitionBase {
 	friend class PIStateMachine;
 	friend class PIStateBase;
 
 public:
+	//! \~english Creates transition from source to target on event
+	//! \~russian Создает переход от source к target по событию
 	PITransitionBase(PIStateBase * source, PIStateBase * target, int event_id);
 	virtual ~PITransitionBase();
 
+	//! \~english Returns state machine this transition belongs to
+	//! \~russian Возвращает машину состояний, которой принадлежит этот переход
 	PIStateMachine * machine() const { return root; }
+
+	//! \~english Returns source state
+	//! \~russian Возвращает исходное состояние
 	PIStateBase * source() const { return source_state; }
+
+	//! \~english Returns target state
+	//! \~russian Возвращает целевое состояние
 	PIStateBase * target() const { return target_state; }
 
+	//! \~english Adds guard function to transition
+	//! \~russian Добавляет сторожевую функцию к переходу
 	template<typename R, typename... Args>
 	PITransitionBase * addGuard(std::function<R(Args...)> f) {
 		static_assert(std::is_same<R, bool>::value, "guard function should return bool!");
@@ -54,11 +64,15 @@ public:
 		return this;
 	}
 
+	//! \~english Adds guard function to transition (callable)
+	//! \~russian Добавляет сторожевую функцию к переходу (callable)
 	template<typename L>
 	PITransitionBase * addGuard(L f) {
 		return addGuard(toStdFunction(f));
 	}
 
+	//! \~english Tests guard function with arguments
+	//! \~russian Тестирует сторожевую функцию с аргументами
 	template<typename... Args>
 	bool testGuard(Args... args) {
 		if (!guard) return true;
@@ -69,13 +83,25 @@ public:
 		return reinterpret_cast<PIStateMachineHelpers::Function<Args...> *>(guard)->func(args...);
 	}
 
+	//! \~english Adds action to transition
+	//! \~russian Добавляет действие к переходу
 	PITransitionBase * addAction(std::function<void()> a);
+
+	//! \~english Executes transition action
+	//! \~russian Выполняет действие перехода
 	void makeAction();
 
+	//! \~english Triggers transition
+	//! \~russian Запускает переход
 	void trigger();
 
 protected:
+	//! \~english Called when transition becomes enabled
+	//! \~russian Вызывается когда переход становится доступным
 	virtual void enabled() {}
+
+	//! \~english Called when transition becomes disabled
+	//! \~russian Вызывается когда переход становится недоступным
 	virtual void disabled() {}
 
 	int eventID               = 0;
@@ -86,8 +112,12 @@ protected:
 };
 
 
+//! \~english Timeout transition
+//! \~russian Переход по таймауту
 class PIP_EXPORT PITransitionTimeout: public PITransitionBase {
 public:
+	//! \~english Creates timeout transition
+	//! \~russian Создает переход по таймауту
 	PITransitionTimeout(PIStateBase * source, PIStateBase * target, PISystemTime timeout);
 	~PITransitionTimeout();