(Refactoring): подправил инициализацию vector-ов, подправил типы.

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.h

@@ -110,7 +110,7 @@ class DBServer_PostgreSQL:
 		typedef std::queue<std::string> QueryBuffer;
 
 		QueryBuffer qbuf;
-		unsigned int qbufSize; // размер буфера сообщений.
+		size_t qbufSize; // размер буфера сообщений.
 		bool lastRemove = { false };
 
 		void flushBuffer();

extensions/UNetUDP/UNetSender.cc

@@ -39,12 +39,12 @@ UNetSender::UNetSender(const std::string& _host, const int _port, const std::sha
 	sendpause(150),
 	packsendpause(5),
 	activated(false),
-	items(100),
 	packetnum(1),
 	lastcrc(0),
 	maxAData(maxACount),
 	maxDData(maxDCount)
 {
+	items.reserve(100);
 
 	{
 		ostringstream s;

extensions/lib/DigitalFilter.cc

@@ -33,7 +33,6 @@ DigitalFilter::DigitalFilter( unsigned int bufsize, double T, double lsq,
 	S(0),
 	tmr(UniSetTimer::WaitUpTime),
 	maxsize(bufsize),
-	mvec(bufsize),
 	mvec_sorted(false),
 	w(bufsize),
 	lsparam(lsq),

include/ThreadCreator.h

@@ -93,7 +93,7 @@ class ThreadCreator:
 		typedef void(ThreadMaster::* Action)(void);
 
 		ThreadCreator( ThreadMaster* m, Action a );
-		~ThreadCreator();
+		virtual ~ThreadCreator();
 
 		inline Poco::Thread::TID getTID() const
 		{

src/Communications/TCP/TCPCheck.cc

@@ -14,10 +14,12 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 // -----------------------------------------------------------------------------
+#include <functional>
 #include <sstream>
 #include <cstdlib>
 #include "UniSetTypes.h"
 #include "PassiveTimer.h"
+#include "ThreadCreator.h"
 #include "TCPCheck.h"
 #include "UTCPStream.h"
 // -----------------------------------------------------------------------------
@@ -81,6 +83,33 @@ void TCPCheck::check_thread()
 	catch( ... ) {}
 }
 // -----------------------------------------------------------------------------
+template<typename T>
+class TGuard
+{
+	public:
+
+		TGuard( T* m, typename ThreadCreator<T>::Action a ):
+			t(m,a)
+		{
+			t.start();
+		}
+
+		~TGuard()
+		{
+			if( t.isRunning() )
+				t.stop();
+		}
+
+		inline bool isRunning()
+		{
+			return t.isRunning();
+		}
+
+	protected:
+		ThreadCreator<T> t;
+};
+
+// -----------------------------------------------------------------------------
 bool TCPCheck::ping( const std::string& _ip, timeout_t tout, timeout_t sleep_msec, const std::string& _ping_args )
 {
 	ip = _ip;
@@ -89,17 +118,13 @@ bool TCPCheck::ping( const std::string& _ip, timeout_t tout, timeout_t sleep_mse
 
 	setResult(false);
 
-	ThreadCreator<TCPCheck> t(this, &TCPCheck::ping_thread);
-	t.start();
+	TGuard<TCPCheck> t(this, &TCPCheck::ping_thread);
 
 	PassiveTimer pt(tout);
 
 	while( !pt.checkTime() && t.isRunning() )
 		msleep(sleep_msec);
 
-	if( t.isRunning() ) // !getResult() )
-		t.stop();
-
 	return result;
 }
 // -----------------------------------------------------------------------------

src/Log/LogServer.cc

@@ -42,28 +42,38 @@ LogServer::~LogServer() noexcept
 LogServer::LogServer( std::shared_ptr<LogAgregator> log ):
 	LogServer()
 {
-	elog = static_pointer_cast<DebugStream>(log);
+	elog = dynamic_pointer_cast<DebugStream>(log);
+	if( !elog )
+	{
+		ostringstream err;
+		err << myname << "(LogServer): dynamic_pointer_cast FAILED! ";
+
+		if( mylog.is_info() )
+			mylog.info() << myname << "(evfinish): terminate..." << endl;
+
+		if( mylog.is_crit() )
+			mylog.crit() << err.str() << endl;
+
+		cerr << err.str()  << endl;
+
+		throw SystemError(err.str());
+	}
 }
 // -------------------------------------------------------------------------
 LogServer::LogServer( std::shared_ptr<DebugStream> log ):
-	timeout(UniSetTimer::WaitUpTime),
-	cmdTimeout(2000),
-	sessLogLevel(Debug::NONE),
-	slist(sessMaxCount),
-	sock(0),
-	elog(log)
+	LogServer()
 {
-
+	elog = log;
 }
 // -------------------------------------------------------------------------
 LogServer::LogServer():
 	timeout(UniSetTimer::WaitUpTime),
 	cmdTimeout(2000),
 	sessLogLevel(Debug::NONE),
-	slist(sessMaxCount),
 	sock(0),
 	elog(nullptr)
 {
+	slist.reserve(sessMaxCount);
 }
 // -------------------------------------------------------------------------
 void LogServer::evfinish( const ev::loop_ref& loop )

src/ObjectRepository/ObjectIndex_XML.cc

@@ -24,9 +24,10 @@
 using namespace UniSetTypes;
 using namespace std;
 // -----------------------------------------------------------------------------------------
-ObjectIndex_XML::ObjectIndex_XML(const string& xmlfile, size_t minSize ):
-	omap(minSize)
+ObjectIndex_XML::ObjectIndex_XML(const string& xmlfile, size_t minSize )
 {
+	omap.reserve(minSize);
+
 	shared_ptr<UniXML> xml = make_shared<UniXML>();
 	//    try
 	//    {
@@ -36,9 +37,9 @@ ObjectIndex_XML::ObjectIndex_XML(const string& xmlfile, size_t minSize ):
 	//    catch(...){}
 }
 // -----------------------------------------------------------------------------------------
-ObjectIndex_XML::ObjectIndex_XML(const std::shared_ptr<UniXML>& xml, size_t minSize ):
-	omap(minSize)
+ObjectIndex_XML::ObjectIndex_XML(const std::shared_ptr<UniXML>& xml, size_t minSize )
 {
+	omap.reserve(minSize);
 	build(xml);
 }
 // -----------------------------------------------------------------------------------------
@@ -111,6 +112,7 @@ void ObjectIndex_XML::build( const std::shared_ptr<UniXML>& xml )
 
 	//
 	omap.resize(ind);
+	omap.shrink_to_fit();
 	//    omap[ind].repName=NULL;
 	//    omap[ind].textName=NULL;
 	//    omap[ind].id = ind;
@@ -199,7 +201,7 @@ size_t ObjectIndex_XML::read_section( const std::shared_ptr<UniXML>& xml, const
 		//        cout << "read: " << "(" << ind << ") " << omap[ind].repName << "\t" << omap[ind].textName << endl;
 		ind++;
 
-		if( (unsigned)ind >= omap.size() )
+		if( ind >= omap.size() )
 		{
 			uinfo << "(ObjectIndex_XML::build): не хватило размера массива maxSize=" << omap.size()
 				  << "... Делаем resize + 100" << endl;

tests/test_logserver.cc

@@ -3,6 +3,7 @@
 #include <memory>
 #include <sstream>
 #include <thread>
+#include <future>
 
 #include "Mutex.h"
 #include "UniSetTypes.h"
@@ -47,8 +48,10 @@ void la_logOnEvent( const std::string& s )
 	la_msg << s;
 }
 // --------------------------------------------------------------------------
-void readlog_thread1()
+bool readlog_thread1()
 {
+	try
+	{
 		LogReader lr;
 		lr.setinTimeout(readTimeout);
 		lr.signal_stream_event().connect( sigc::ptr_fun(rlog1OnEvent) );
@@ -57,10 +60,20 @@ void readlog_thread1()
 
 		while( !g_read_cancel )
 			lr.readlogs(ip, port); // ,LogServerTypes::cmdNOP,0,"",true);
+
+		return true;
+	}
+	catch( std::exception& ex )
+	{
+	}
+
+	return false;
 }
 // --------------------------------------------------------------------------
-void readlog_thread2()
+bool readlog_thread2()
 {
+	try
+	{
 		LogReader lr;
 		lr.setinTimeout(readTimeout);
 		lr.signal_stream_event().connect( sigc::ptr_fun(rlog2OnEvent) );
@@ -69,6 +82,13 @@ void readlog_thread2()
 
 		while( !g_read_cancel )
 			lr.readlogs(ip, port); // ,LogServerTypes::cmdNOP,0,"",true);
+		return true;
+	}
+	catch( std::exception& ex )
+	{
+	}
+
+	return false;
 }
 // --------------------------------------------------------------------------
 TEST_CASE("LogAgregator", "[LogServer][LogAgregator]" )
@@ -133,7 +153,7 @@ TEST_CASE("LogServer", "[LogServer]" )
 	REQUIRE( ls.isRunning() );
 
 	msg.str("");
-	auto r_thr = make_shared<std::thread>(readlog_thread1);
+	auto ret = std::async(std::launch::async, readlog_thread1); // make_shared<std::thread>(readlog_thread1);
 
 	msleep(100); // небольшая пауза на создание потока и т.п.
 
@@ -168,10 +188,7 @@ TEST_CASE("LogServer", "[LogServer]" )
 	}
 
 	g_read_cancel = true;
-	msleep(readTimeout);
-
-	if( r_thr->joinable() )
-		r_thr->join();
+	ret.get();
 }
 // --------------------------------------------------------------------------
 TEST_CASE("MaxSessions", "[LogServer]" )
@@ -205,11 +222,11 @@ TEST_CASE("MaxSessions", "[LogServer]" )
 	msg.str("");
 	msg2.str("");
 
-	auto r1_thr = make_shared<std::thread>(readlog_thread1);
+	auto ret1 = std::async(std::launch::async, readlog_thread1); // make_shared<std::thread>(readlog_thread1);
 
 	msleep(500); // пауза чтобы первый заведомо успел подключиться раньше второго..
 
-	auto r2_thr = make_shared<std::thread>(readlog_thread2);
+	auto ret2 = std::async(std::launch::async, readlog_thread1); // make_shared<std::thread>(readlog_thread2);
 
 	msleep(100); // небольшая пауза на создание потока и т.п.
 
@@ -240,13 +257,8 @@ TEST_CASE("MaxSessions", "[LogServer]" )
 	}
 
 	g_read_cancel = true;
-	msleep(readTimeout);
-
-	if( r1_thr->joinable() )
-		r1_thr->join();
-
-	if( r2_thr->joinable() )
-		r2_thr->join();
+	ret1.get();
+	ret2.get();
 }
 // --------------------------------------------------------------------------
 TEST_CASE("LogAgregator regexp", "[LogAgregator]" )