change to private section

maybe fix hang on PIEthernet::interrupt()
replace piLetobe with piChangeEndian:
 * piChangeEndianBinary
 * piChangeBinary
 * piChangedBinary
PIDiagnostics::start now accept PISystemTime instead of number
add PITimer::start(PISystemTime, std::function<void()>) overload

CMakeLists.txt

@@ -2,9 +2,9 @@ cmake_minimum_required(VERSION 3.0)
 cmake_policy(SET CMP0017 NEW) # need include() with .cmake
 project(PIP)
 set(PIP_MAJOR    4)
-set(PIP_MINOR    0)
+set(PIP_MINOR    1)
 set(PIP_REVISION 0)
-set(PIP_SUFFIX   _alpha)
+set(PIP_SUFFIX   )
 set(PIP_COMPANY  SHS)
 set(PIP_DOMAIN   org.SHS)
 

libs/main/core/pibase.h

@@ -35,6 +35,7 @@
 #define PIBASE_H
 
 #include "pibase_macros.h"
+#include "pimemoryblock.h"
 #include "pip_export.h"
 
 #include <string.h>
@@ -352,14 +353,6 @@ inline constexpr T piClamp(const T & v, const T & min, const T & max) {
 	return (v > max ? max : (v < min ? min : v));
 }
 
-//! \~\brief
-//! \~english Function inverse byte order in memory block ([1..N] -> [N..1])
-//! \~russian Метод для смены порядка байт в блоке памяти ([1..N] -> [N..1])
-inline void piLetobe(void * data, int size) {
-	for (int i = 0; i < size / 2; i++)
-		piSwap<uchar>(((uchar *)data)[size - i - 1], ((uchar *)data)[i]);
-}
-
 //! \~\brief
 //! \~english Function for compare two numeric values with epsilon
 //! \~russian Метод для сравнения двух чисел с порогом
@@ -383,66 +376,98 @@ inline bool piCompare(const T & a, const T & b, const T & epsilon = std::numeric
 	return piAbs(a - b) <= epsilon;
 }
 
+
+// Endians
+
+
+//! \~\brief
+//! \~english Function inverse byte order in memory block ([1..N] -> [N..1])
+//! \~russian Метод для смены порядка байт в блоке памяти ([1..N] -> [N..1])
+inline void piChangeEndianBinary(void * data, size_t size) {
+	auto hs = size / 2;
+	for (size_t i = 0; i < hs; i++)
+		piSwap<uchar>(((uchar *)data)[size - i - 1], ((uchar *)data)[i]);
+}
+
+//! \~\brief
+//! \~english Function inverse byte order in memory block ([1..N] -> [N..1])
+//! \~russian Метод для смены порядка байт в блоке памяти ([1..N] -> [N..1])
+inline void piChangeEndianBinary(PIMemoryBlock mem_blk) {
+	if (mem_blk.isNull()) return;
+	piChangeEndianBinary(mem_blk.data(), mem_blk.size());
+}
+
+
 //! \~\brief
 //! \~english Templated function that inverse byte order of value "v"
 //! \~russian Шаблонный метод, меняющий порядок байт в переменной "v"
 template<typename T>
-inline void piLetobe(T * v) {
-	piLetobe(v, sizeof(T));
-}
+inline void piChangeEndian(T & v);
+
 
 //! \~\brief
-//! \~english Templated function that returns "v" with inversed byte order
-//! \~russian Шаблонный метод, возвращающий переменную "v" с измененным порядком байт
-//! \~\details
-//! \~english
-//! This function used to convert values between little and big endian \n
-//! There are some macros:
-//! - \c piLetobes for "ushort"
-//! - \c piLetobei for "uint"
-//! - \c piLetobel for "ulong"
-//! - \c piLetobell for "ullong"
-//!
-//! Example:
-//! \snippet piincludes.cpp letobe
-//! \~russian
-//! Этот метод используется для изменения порядка байт между little и big endian
-//! Есть несколько макросов:
-//! - \c piLetobes для "ushort"
-//! - \c piLetobei для "uint"
-//! - \c piLetobel для "ulong"
-//! - \c piLetobell для "ullong"
-//!
-//! Пример:
-//! \snippet piincludes.cpp letobe
+//! \~english Templated function that returns value "v" with inversed byte order
+//! \~russian Шаблонный метод, возвращающий значение "v" с измененным порядком байт
 template<typename T>
-inline T piLetobe(const T & v) {
-	T tv(v);
-	piLetobe(&tv, sizeof(T));
-	return tv;
+inline T piChangedEndian(const T & v);
+
+
+template<typename T>
+inline void piChangeEndian(T & v) {
+	piChangeEndianBinary(&v, sizeof(T));
 }
 
-// specialization
+template<typename T>
+inline T piChangedEndian(const T & v) {
+	T ret = v;
+	piChangeEndianBinary(&ret, sizeof(T));
+	return ret;
+}
 template<>
-inline uint16_t piLetobe(const uint16_t & v) {
+inline uint16_t piChangedEndian(const uint16_t & v) {
 	return (v << 8) | (v >> 8);
 }
 template<>
-inline uint32_t piLetobe(const uint32_t & v) {
+inline uint32_t piChangedEndian(const uint32_t & v) {
 	return (v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | ((v << 24) & 0xFF000000);
 }
 template<>
-inline float piLetobe(const float & v) {
-	union _pletobe_f {
-		_pletobe_f(const float & f_) { f = f_; }
+inline float piChangedEndian(const float & v) {
+	union {
 		float f;
-		uint32_t v;
-	};
-	_pletobe_f a(v);
-	a.v = (a.v >> 24) | ((a.v >> 8) & 0xFF00) | ((a.v << 8) & 0xFF0000) | ((a.v << 24) & 0xFF000000);
-	return a.f;
+		uint32_t i;
+	} u;
+	u.f = v;
+	u.i = piChangedEndian(u.i);
+	return u.f;
 }
 
+template<>
+inline void piChangeEndian(uint16_t & v) {
+	v = piChangedEndian(v);
+}
+template<>
+inline void piChangeEndian(uint32_t & v) {
+	v = piChangedEndian(v);
+}
+template<>
+inline void piChangeEndian(float & v) {
+	v = piChangedEndian(v);
+}
+
+
+DEPRECATEDM("use piChangeEndianBinary()")
+inline void piLetobe(void * data, int size) {
+	piChangeEndianBinary(data, size);
+}
+
+template<typename T>
+DEPRECATEDM("use piChangedEndian()")
+inline T piLetobe(const T & v) {
+	return piChangedEndian(v);
+}
+
+
 //! \~\brief
 //! \~english Generic hash function, implements murmur3/32 algorithm
 //! \~russian Хэш-функция общего назначения, по алгоритму murmur3/32

libs/main/core/pimemoryblock.h

@@ -36,10 +36,7 @@ struct PIMemoryBlock {
 public:
 	//! \~english Constructs data block
 	//! \~russian Создает блок данных
-	PIMemoryBlock(void * data_ = 0, int size_ = 0) {
-		d = data_;
-		s = size_;
-	}
+	PIMemoryBlock() {}
 
 	//! \~english Constructs data block
 	//! \~russian Создает блок данных
@@ -71,9 +68,13 @@ public:
 	//! \~russian Размер данных в байтах
 	int size() const { return s; }
 
+	//! \~english Returns if this block points to nothing
+	//! \~russian Возвращает пустой ли указатель на данные
+	bool isNull() const { return d; }
+
 private:
-	void * d;
-	int s;
+	void * d = nullptr;
+	int s    = 0;
 };
 
 //! \~english Returns PIMemoryBlock from pointer to variable "ptr" with type "T"

libs/main/core/piwaitevent_p.cpp

@@ -51,6 +51,7 @@ void PIWaitEvent::create() {
 		piCout << "Error with pipe:" << errorString();
 	} else {
 		fcntl(pipe_fd[ReadEnd], F_SETFL, O_NONBLOCK);
+		fcntl(pipe_fd[WriteEnd], F_SETFL, O_NONBLOCK);
 	}
 #endif
 }

libs/main/io_utils/pibasetransfer.cpp

@@ -19,6 +19,7 @@
 
 #include "pibasetransfer.h"
 
+#include "piliterals_time.h"
 #include "pitime.h"
 
 const uint PIBaseTransfer::signature = 0x54424950;
@@ -37,7 +38,7 @@ PIBaseTransfer::PIBaseTransfer(): crc(standardCRC_16()), diag(false) {
 	timeout_              = 10.;
 	diag.setDisconnectTimeout(PISystemTime::fromSeconds(timeout_ / 10.));
 	diag.setName("PIBaseTransfer");
-	diag.start(50);
+	diag.start(20_Hz);
 	packets_count = 10;
 #ifdef MICRO_PIP
 	setPacketSize(512);

libs/main/io_utils/pidiagnostics.cpp

@@ -94,16 +94,14 @@ PIString PIDiagnostics::sendSpeed() const {
 
 
 void PIDiagnostics::start() {
-	PITimer::start(10_Hz);
-	changeDisconnectTimeout(disconn_);
+	PIDiagnostics::start(10_Hz);
 }
 
 
-void PIDiagnostics::start(double msecs) {
-	if (msecs > 0.) {
-		PITimer::start(PISystemTime::fromMilliseconds(msecs));
-		changeDisconnectTimeout(disconn_);
-	}
+void PIDiagnostics::start(PISystemTime interval) {
+	if (interval.isNull()) return;
+	PITimer::start(interval);
+	changeDisconnectTimeout(disconn_);
 }
 
 

libs/main/io_utils/pidiagnostics.h

@@ -96,7 +96,7 @@ public:
 
 
 	EVENT_HANDLER0(void, start);
-	EVENT_HANDLER1(void, start, double, msecs);
+	EVENT_HANDLER1(void, start, PISystemTime, interval);
 	EVENT_HANDLER0(void, reset);
 
 	EVENT_HANDLER1(void, received, int, size) { received(size, true); }

libs/main/state_machine/pistatemachine.h

@@ -40,16 +40,32 @@ public:
 
 	bool start();
 	bool isRunning() const { return is_running; }
-	void addOnFinish(std::function<void()> f) { on_finish = f; }
+	void setOnFinish(std::function<void()> f) { on_finish = f; }
 
 	template<typename... Args>
 	bool postEvent(int event_id, Args... args) {
 		if (!is_running) return false;
+		if (in_post.exchange(true)) {
+			PIMutexLocker ml(nested_mutex);
+			nested_posts.enqueue([this, event_id, args...] { postEvent(event_id, args...); });
+			// piCout << "queue nested post";
+			return false;
+		}
 		need_finish = false;
 		PIScopeExitCall exit_call([this] {
+			in_post = false;
 			if (need_finish) {
 				is_running = false;
 				if (on_finish) on_finish();
+			} else {
+				nested_mutex.lock();
+				while (nested_posts.isNotEmpty()) {
+					auto np = nested_posts.dequeue();
+					nested_mutex.unlock();
+					np();
+					nested_mutex.lock();
+				}
+				nested_mutex.unlock();
 			}
 		});
 		PIVector<PIStateBase *> active_states;
@@ -71,6 +87,9 @@ private:
 	void onFinish() override;
 
 	bool is_running = false, need_finish = false;
+	PIQueue<std::function<void()>> nested_posts;
+	PIMutex nested_mutex;
+	std::atomic_bool in_post = {false};
 	std::function<void()> on_finish;
 };
 

libs/main/state_machine/pistatemachine_state.cpp

@@ -97,8 +97,8 @@ void PIStateBase::print(PIString prefix) {
 }
 
 
-bool PIStateBase::start() {
-	if (isActive()) return true;
+bool PIStateBase::start(bool force) {
+	if (!force && isActive()) return true;
 	if (isAtomic()) {
 		setActive(true);
 		return true;
@@ -197,6 +197,20 @@ void PIStateBase::propagateRoot(PIStateMachine * r) {
 }
 
 
+PIVector<PIStateBase *> PIStateBase::gatherStates() {
+	PIVector<PIStateBase *> ret, slice, prev_slice({this});
+	while (prev_slice.isNotEmpty()) {
+		slice.clear();
+		for (auto s: prev_slice) {
+			ret << s;
+			slice << s->children;
+		}
+		prev_slice.swap(slice);
+	}
+	return ret;
+}
+
+
 void PIStateBase::gatherActiveStates(PIVector<PIStateBase *> & output) {
 	for (auto * c: children)
 		c->gatherActiveStates(output);

libs/main/state_machine/pistatemachine_state.h

@@ -38,6 +38,7 @@
 class PIP_EXPORT PIStateBase {
 	friend class PIStateMachine;
 	friend class PITransitionBase;
+	friend class PIStateFinal;
 
 public:
 	PIStateBase(const PIString & n = {}): name_(n) { ; }
@@ -74,8 +75,10 @@ public:
 
 	void print(PIString prefix = {});
 
-protected:
-	bool start();
+	PIVector<PIStateBase *> gatherStates();
+
+private:
+	bool start(bool force = false);
 	void setActive(bool yes);
 	void setActiveRecursive(bool yes);
 	void setChildrenActive(bool yes);

libs/main/state_machine/pistatemachine_transition.cpp

@@ -91,7 +91,7 @@ void PITransitionBase::trigger() {
 		else
 			source_target_path[i]->activeChild(source_target_path[i + 1]);
 	}
-	if (target_state->isCompound()) target_state->start();
+	if (target_state->isCompound()) target_state->start(true);
 }
 
 

libs/main/thread/pitimer.cpp

@@ -259,6 +259,14 @@ bool PITimer::start(PISystemTime interval) {
 }
 
 
+bool PITimer::start(PISystemTime interval, std::function<void()> func) {
+	if (isRunning()) stopAndWait();
+	setInterval(interval);
+	setSlot(func);
+	return start();
+}
+
+
 void PITimer::stopAndWait(PISystemTime timeout) {
 	stop();
 	thread->waitForFinish(timeout);

libs/main/thread/pitimer.h

@@ -73,12 +73,14 @@ public:
 	//! \~russian Ожидает остановки таймера
 	bool waitForFinish(PISystemTime timeout = {});
 
-	//! \fn bool start(PISystemTime interval)
-	//! \brief
 	//! \~english Start timer with "interval" loop delay
 	//! \~russian Запустить таймер с интервалом "interval"
 	bool start(PISystemTime interval);
 
+	//! \~english Start timer with "interval" loop delay and tick function "func"
+	//! \~russian Запустить таймер с интервалом "interval" и вызываевымым методом "func"
+	bool start(PISystemTime interval, std::function<void()> func);
+
 	bool start(double interval_ms) DEPRECATEDM("use start(PISystemTime)") { return start(PISystemTime::fromMilliseconds(interval_ms)); }
 	EVENT_HANDLER0(bool, start);
 

main.cpp

@@ -28,7 +28,12 @@ void tfunc4(int delim) {
 
 
 int main(int argc, char * argv[]) {
-	PIPackedTCP * tcp_s =
+	uint v = 0xaabbccdd;
+	piCout << Hex << v << piChangedEndian(v);
+	piChangeEndianBinary(&v, sizeof(v));
+	piCout << Hex << v << piChangedEndian(v);
+	return 0;
+	/*PIPackedTCP * tcp_s =
 		PIIODevice::createFromFullPath("ptcp://s::8000")->cast<PIPackedTCP>(); // new PIPackedTCP(PIPackedTCP::Server, {"0.0.0.0:8000"});
 	PIPackedTCP * tcp_c = PIIODevice::createFromFullPath("ptcp://c:127.0.0.1:8000")
 							  ->cast<PIPackedTCP>();                           // new PIPackedTCP(PIPackedTCP::Client, {"127.0.0.1:8000"});
@@ -78,7 +83,7 @@ int main(int argc, char * argv[]) {
 	// piCout << tcp_s->constructFullPath();
 	delete tcp_s;
 	delete tcp_c;
-	return 0;
+	return 0;*/
 	/*PITimer timer(tfunc);
 	// timer.addDelimiter(2);
 	timer.addDelimiter(40, tfunc4);
@@ -95,11 +100,12 @@ int main(int argc, char * argv[]) {
 
 	bool posted;
 	PIStateMachine * root = new PIStateMachine("Machine");
-	root->addOnFinish([] { piCout << "finish"; });
+	root->setOnFinish([] { piCout << "finish"; });
 
 	PIStateLambda * s1   = new PIStateLambda([] { piCout << "+ enter s1"; }, [] { piCout << "- exit s1"; }, "s1");
 	PIStateLambda * s2   = new PIStateLambda([] { piCout << "+ enter s2"; }, [] { piCout << "- exit s2"; }, "s2");
 	PIStateLambda * s3   = new PIStateLambda([] { piCout << "+ enter s3"; }, [] { piCout << "- exit s3"; }, "s3");
+	PIStateLambda * s4   = new PIStateLambda([] { piCout << "+ enter s4"; }, [] { piCout << "- exit s4"; }, "s4");
 	PIStateLambda * s11  = new PIStateLambda([] { piCout << "  + enter s11"; }, [] { piCout << "  - exit s11"; }, "s11");
 	PIStateLambda * s12  = new PIStateLambda([] { piCout << "  + enter s12"; }, [] { piCout << "  - exit s12"; }, "s12");
 	PIStateLambda * s13  = new PIStateLambda([] { piCout << "  + enter s13"; }, [] { piCout << "  - exit s13"; }, "s13");
@@ -111,33 +117,35 @@ int main(int argc, char * argv[]) {
 	PIStateLambda * s213 = new PIStateLambda([] { piCout << "    + enter s213"; }, [] { piCout << "    - exit s213"; }, "s213");
 	PIStateFinal * s214  = new PIStateFinal([] { piCout << "    + enter s214 final"; }, "s214f");
 
-	root->addStates({s1, s2, s3});
-	s1->addStates({s11, s12, s13});
-	s2->addStates({s21, s22, s23});
-	s21->addStates({s211, s212, s213});
-	// root->addState(s214);
+	root->addStates({s1, s2, s3, s4});
+	// s1->addStates({s11, s12, s13});
+	// s2->addStates({s21, s22, s23});
+	// s21->addStates({s211, s212, s213});
+	//  root->addState(s214);
 
 	s2->setParallel(true);
 
-	root->setInitialState(s2);
+	root->setInitialState(s1);
 	s1->setInitialState(s11);
 	s2->setInitialState(s21);
 	s21->setInitialState(s213);
 
 	// s213->addTransition(s13, meVoid)->addAction([] { piCout << "action transition s21 -> s22"; });
 	// s3->addTransition(s212, meVoid)->addAction([] { piCout << "action transition s1 -> s213"; });
-	s2->addTransition(s3, meVoid);
-	s2->addTimeoutTransition(s3, .5_s);
-	// s3->addTransition(s1, meIntString)->addGuard([](int i, PIString str) { return i == 2 && str == "hello"; });
+	s1->addTransition(s2, meVoid)->addAction([root] { root->postEvent(meInt, 1); });
+	s2->addTransition(s3, meInt)->addGuard([](int i) { return i == 1; })->addAction([root] { root->postEvent(meInt, 2); });
+	s3->addTransition(s4, meInt)->addGuard([](int i) { return i == 2; })->addAction([root] { root->postEvent(meInt, 3); });
+	// s2->addTimeoutTransition(s3, .5_s);
+	//  s3->addTransition(s1, meIntString)->addGuard([](int i, PIString str) { return i == 2 && str == "hello"; });
 
 	root->start();
 	piCout << "initial" << root->isRunning() << "\n";
-	piCout << "active atomics" << root->activeAtomics();
+	// piCout << "active atomics" << root->activeAtomics();
 	root->print();
 
-	// piCout << "\npost event";
-	// posted = root->postEvent(meVoid);
-	// piCout << "posted" << posted << "\n";
+	piCout << "\npost event";
+	posted = root->postEvent(meVoid);
+	piCout << "posted" << posted << "\n";
 	// piCout << "active atomics" << root->activeAtomics();
 	piSleep(1.);
 	root->print();