Ещё один заход по "причёсыванию" используемых типов.

extensions/ModbusMaster/MBExchange.h

@@ -204,8 +204,8 @@ class MBExchange:
 			bool resp_invert;
 			bool resp_force = { false };
 			Trigger trInitOK; // триггер для "инициализации"
-			std::atomic<unsigned int> numreply; // количество успешных запросов..
-			std::atomic<unsigned int> prev_numreply;
+			std::atomic<size_t> numreply; // количество успешных запросов..
+			std::atomic<size_t> prev_numreply;
 
 			//
 			bool ask_every_reg; /*!< опрашивать ли каждый регистр, независимо от результата опроса предыдущего. По умолчанию false - прервать опрос при первом же timeout */
@@ -340,13 +340,13 @@ class MBExchange:
 		bool force =  { false };        /*!< флаг означающий, что надо сохранять в SM, даже если значение не менялось */
 		bool force_out = { false };    /*!< флаг означающий, принудительного чтения выходов */
 		bool mbregFromID = { false };
-		int polltime = { 100 };    /*!< переодичность обновления данных, [мсек] */
+		timeout_t polltime = { 100 };    /*!< переодичность обновления данных, [мсек] */
 		timeout_t sleepPause_msec;
-		unsigned int maxQueryCount = { ModbusRTU::MAXDATALEN }; /*!< максимальное количество регистров для одного запроса */
+		size_t maxQueryCount = { ModbusRTU::MAXDATALEN }; /*!< максимальное количество регистров для одного запроса */
 
 		PassiveTimer ptHeartBeat;
 		UniSetTypes::ObjectId sidHeartBeat = { UniSetTypes::DefaultObjectId };
-		int maxHeartBeat = { 10 };
+		long maxHeartBeat = { 10 };
 		IOController::IOStateList::iterator itHeartBeat;
 		UniSetTypes::ObjectId test_id = { UniSetTypes::DefaultObjectId };
 
@@ -355,14 +355,14 @@ class MBExchange:
 		long exchangeMode = {emNone}; /*!< режим работы см. ExchangeMode */
 
 		std::atomic_bool activated = { false };
-		int activateTimeout = { 20000 }; // msec
+		timeout_t activateTimeout = { 20000 }; // msec
 		bool noQueryOptimization = { false };
 		bool no_extimer = { false };
 
 		std::string prefix;
 
 		timeout_t stat_time = { 0 };      /*!< время сбора статистики обмена, 0 - отключена */
-		unsigned int poll_count = { 0 };
+		size_t poll_count = { 0 };
 		PassiveTimer ptStatistic; /*!< таймер для сбора статистики обмена */
 		std::string statInfo = { "" };
 
@@ -374,7 +374,7 @@ class MBExchange:
 		timeout_t recv_timeout = { 500 }; // msec
 		timeout_t default_timeout = { 5000 }; // msec
 
-		int aftersend_pause = { 0 };
+		timeout_t aftersend_pause = { 0 };
 
 		PassiveTimer ptReopen; /*!< таймер для переоткрытия соединения */
 		Trigger trReopen;
@@ -399,7 +399,7 @@ class MBExchange:
 
 		VMonitor vmon;
 
-		unsigned long ncycle = { 0 }; /*!< текущий номер цикла опроса */
+		size_t ncycle = { 0 }; /*!< текущий номер цикла опроса */
 
 	private:
 		MBExchange();

extensions/ModbusMaster/MBTCPMultiMaster.h

@@ -267,10 +267,9 @@ class MBTCPMultiMaster:
 		void check_thread();
 		void final_thread();
 
-
 		UniSetTypes::uniset_rwmutex mbMutex;
 		bool force_disconnect;
-		int checktime;
+		timeout_t checktime;
 
 	private:
 		MBTCPMultiMaster();
@@ -310,9 +309,9 @@ class MBTCPMultiMaster:
 				use = st;
 			}
 
-			int recv_timeout;
-			int aftersend_pause;
-			int sleepPause_usec;
+			timeout_t recv_timeout;
+			timeout_t aftersend_pause;
+			timeout_t sleepPause_usec;
 			bool force_disconnect;
 
 			std::string myname;

extensions/ModbusSlave/MBSlave.h

@@ -335,8 +335,8 @@ class MBSlave:
 			ModbusRTU::ModbusData mbreg;    /*!< регистр */
 			AccessMode amode;
 			VTypes::VType vtype;    /*!< type of value */
-			int wnum;               /*!< номер слова (для типов с размеров больше 2х байт */
-			int nbyte;              /*!< номер байта, который надо "сохранить" из "пришедщего в запросе" слова. [1-2] */
+			size_t wnum;               /*!< номер слова (для типов с размеров больше 2х байт */
+			size_t nbyte;              /*!< номер байта, который надо "сохранить" из "пришедщего в запросе" слова. [1-2] */
 			bool rawdata;           /*!< флаг, что в SM просто сохраняются 4-байта (актуально для типа F4)*/
 			std::shared_ptr<BitRegProperty> bitreg; /*!< указатель, как признак является ли данный регистр "сборным" из битовых */
 			ModbusRTU::RegID regID;
@@ -523,7 +523,7 @@ class MBSlave:
 
 		PassiveTimer ptHeartBeat;
 		UniSetTypes::ObjectId sidHeartBeat = { UniSetTypes::DefaultObjectId };
-		int maxHeartBeat = { 10 };
+		long maxHeartBeat = { 10 };
 		IOController::IOStateList::iterator itHeartBeat;
 		UniSetTypes::ObjectId test_id = { UniSetTypes::DefaultObjectId };
 
@@ -539,7 +539,7 @@ class MBSlave:
 
 		std::atomic_bool activated = { false };
 		std::atomic_bool cancelled = { false };
-		int activateTimeout = { 20000 }; // msec
+		timeout_t activateTimeout = { 20000 }; // msec
 		bool pingOK = { false };
 		timeout_t wait_msec = { 3000 };
 		bool force = { false };        /*!< флаг означающий, что надо сохранять в SM, даже если значение не менялось */
@@ -582,7 +582,7 @@ class MBSlave:
 		timeout_t updateStatTime = { 4000 };
 		ModbusTCPServer::Sessions sess; /*!< список открытых сессий */
 		std::mutex sessMutex;
-		unsigned int sessMaxNum = { 5 };
+		size_t sessMaxNum = { 5 };
 		std::shared_ptr<ModbusTCPServerSlot> tcpserver;
 
 		struct ClientInfo

extensions/UNetUDP/UDPPacket.cc

@@ -61,7 +61,7 @@ static unsigned short crc_16_tab[] =
 // -------------------------------------------------------------------------
 /* CRC-16 is based on the polynomial x^16 + x^15 + x^2 + 1.  Bits are */
 /* sent LSB to MSB. */
-static int get_crc_16( unsigned short crc, unsigned char* buf, int size )
+static int get_crc_16( uint16_t crc, unsigned char* buf, int size )
 {
 
 	while( size-- )
@@ -89,9 +89,9 @@ static int get_crc_16( unsigned short crc, unsigned char* buf, int size )
 	return crc;
 }
 // -------------------------------------------------------------------------
-unsigned short UniSetUDP::makeCRC( unsigned char* buf, size_t len )
+uint16_t UniSetUDP::makeCRC( unsigned char* buf, size_t len )
 {
-	unsigned short crc = 0xffff;
+	uint16_t crc = 0xffff;
 	crc = get_crc_16(crc, (unsigned char*)(buf), len);
 	return crc;
 }
@@ -317,9 +317,9 @@ size_t UDPMessage::getMessage( UDPMessage& m, UDPPacket& p )
 	return i + sz;
 }
 // -----------------------------------------------------------------------------
-unsigned short UDPMessage::getDataCRC()
+uint16_t UDPMessage::getDataCRC()
 {
-	unsigned short crc[3];
+	uint16_t crc[3];
 	crc[0] = makeCRC( (unsigned char*)(a_dat), sizeof(a_dat) );
 	crc[1] = makeCRC( (unsigned char*)(d_id), sizeof(d_id) );
 	crc[2] = makeCRC( (unsigned char*)(d_dat), sizeof(d_dat) );

extensions/UNetUDP/UDPPacket.h

@@ -32,8 +32,10 @@ namespace UniSetUDP
 
 	    \todo Подумать на тему сделать два отдельных вида пакетов для булевых значений и для аналоговых,
 	          чтобы уйти от преобразования UDPMessage --> UDPPacket --> UDPMessage.
-	*/
 
+		\warning ТЕКУЩАЯ ВЕРСИЯ ПРОТОКОЛА НЕ БУДЕТ РАБОТАТЬ МЕЖДУ 32-битными и 64-битными системами (из-за отличия в типе long).
+		т.к. это не сильно актуально, пока не переделываю.
+	*/
 
 	const unsigned int UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола
 
@@ -41,7 +43,7 @@ namespace UniSetUDP
 	{
 		UDPHeader(): magic(UNETUDP_MAGICNUM), num(0), nodeID(0), procID(0), dcount(0), acount(0) {}
 		unsigned int magic;
-		unsigned long num;
+		size_t num;
 		long nodeID;
 		long procID;
 
@@ -80,10 +82,10 @@ namespace UniSetUDP
 		UDPPacket(): len(0) {}
 
 		size_t len;
-		unsigned char data[ sizeof(UDPHeader) + MaxDCount * sizeof(long) + MaxDDataCount + MaxACount * sizeof(UDPAData) ];
+		uint8_t data[ sizeof(UDPHeader) + MaxDCount * sizeof(long) + MaxDDataCount + MaxACount * sizeof(UDPAData) ];
 	} __attribute__((packed));
 
-	static const int MaxDataLen = sizeof(UDPPacket);
+	static const size_t MaxDataLen = sizeof(UDPPacket);
 
 	struct UDPMessage:
 		public UDPHeader
@@ -126,7 +128,8 @@ namespace UniSetUDP
 		{
 			return acount;
 		}
-		unsigned short getDataCRC();
+
+		uint16_t getDataCRC();
 
 		// количество байт в пакете с булевыми переменными...
 		size_t d_byte() const
@@ -136,12 +139,12 @@ namespace UniSetUDP
 
 		UDPAData a_dat[MaxACount]; /*!< аналоговые величины */
 		long d_id[MaxDCount];      /*!< список дискретных ID */
-		unsigned char d_dat[MaxDDataCount];  /*!< битовые значения */
+		uint8_t d_dat[MaxDDataCount];  /*!< битовые значения */
 
 		friend std::ostream& operator<<( std::ostream& os, UDPMessage& p );
 	};
 
-	unsigned short makeCRC( unsigned char* buf, size_t len );
+	uint16_t makeCRC( unsigned char* buf, size_t len );
 }
 // -----------------------------------------------------------------------------
 #endif // UDPPacket_H_

extensions/UNetUDP/UNetReceiver.h

@@ -116,7 +116,7 @@ class UNetReceiver:
 		{
 			return !ptRecvTimeout.checkTime();
 		}
-		inline unsigned long getLostPacketsNum() const
+		inline size_t getLostPacketsNum() const
 		{
 			return lostPackets;
 		}

extensions/UNetUDP/UNetSender.h

@@ -192,7 +192,7 @@ class UNetSender
 		DMap dlist;
 		size_t maxItem = { 0 };
 		size_t packetnum = { 1 }; /*!< номер очередного посылаемого пакета */
-		unsigned short lastcrc = { 0 };
+		uint16_t lastcrc = { 0 };
 		UniSetUDP::UDPPacket s_msg;
 
 		size_t maxAData = { UniSetUDP::MaxACount };

include/CallbackTimer.h

@@ -60,7 +60,7 @@ namespace UniSetTypes
         class MyClass
         {
             public:
-                void Time(int id){ cout << "Timer id: "<< id << endl;}
+				void Time(size_t id){ cout << "Timer id: "<< id << endl;}
         };
 
         MyClass* rec = new MyClass();
@@ -81,10 +81,10 @@ class CallbackTimer
 	public:
 
 		/*! Максимальное количество таймеров */
-		static const unsigned int MAXCallbackTimer = 20;
+		static const size_t MAXCallbackTimer = 20;
 
 		/*! прототип функции вызова */
-		typedef void(Caller::* Action)( int id );
+		typedef void(Caller::* Action)( size_t id );
 
 		CallbackTimer(Caller* r, Action a);
 		~CallbackTimer();
@@ -94,14 +94,14 @@ class CallbackTimer
 		void terminate();  /*!< остановка    */
 
 		// Работа с таймерами (на основе интерфейса PassiveTimer)
-		void reset(int id);                 /*!< перезапустить таймер */
-		void setTiming(int id, int timrMS); /*!< установить таймер и запустить */
-		int getInterval(int id);            /*!< получить интервал, на который установлен таймер, в мс */
-		int getCurrent(int id);             /*!< получить текущее значение таймера */
+		void reset(size_t id);                 /*!< перезапустить таймер */
+		void setTiming(size_t id, timeout_t timrMS); /*!< установить таймер и запустить */
+		timeout_t getInterval(size_t id);            /*!< получить интервал, на который установлен таймер, в мс */
+		timeout_t getCurrent(size_t id);             /*!< получить текущее значение таймера */
 
 
-		void add( int id, int timeMS )throw(UniSetTypes::LimitTimers); /*!< добавление нового таймера */
-		void remove( int id ); /*!< удаление таймера */
+		void add( size_t id, timeout_t timeMS )throw(UniSetTypes::LimitTimers); /*!< добавление нового таймера */
+		void remove( size_t id ); /*!< удаление таймера */
 
 	protected:
 
@@ -123,10 +123,10 @@ class CallbackTimer
 
 		struct TimerInfo
 		{
-			TimerInfo(int id, PassiveTimer& pt):
+			TimerInfo(size_t id, PassiveTimer& pt):
 				id(id), pt(pt) {};
 
-			int id;
+			size_t id;
 			PassiveTimer pt;
 		};
 
@@ -136,14 +136,15 @@ class CallbackTimer
 		// функция-объект для поиска по id
 		struct FindId_eq: public std::unary_function<TimerInfo, bool>
 		{
-			FindId_eq(const int id): id(id) {}
+			FindId_eq(const size_t id): id(id) {}
 			inline bool operator()(const TimerInfo& ti) const
 			{
 				return ti.id == id;
 			}
-			int id;
+			size_t id;
 		};
 };
-
+//----------------------------------------------------------------------------------------
 #include "CallbackTimer.tcc"
+//----------------------------------------------------------------------------------------
 # endif //CallbackTimer_H_

include/CallbackTimer.tcc

@@ -101,7 +101,7 @@ void CallbackTimer<Caller>::terminate()
 // ------------------------------------------------------------------------------------------
 
 template <class Caller>
-void CallbackTimer<Caller>::add( int id, int timeMS )throw(UniSetTypes::LimitTimers)
+void CallbackTimer<Caller>::add(size_t id, timeout_t timeMS )throw(UniSetTypes::LimitTimers)
 {
 	if( lst.size() >= MAXCallbackTimer )
 	{
@@ -118,7 +118,7 @@ void CallbackTimer<Caller>::add( int id, int timeMS )throw(UniSetTypes::LimitTim
 // ------------------------------------------------------------------------------------------
 
 template <class Caller>
-void CallbackTimer<Caller>::remove( int id )
+void CallbackTimer<Caller>::remove( size_t id )
 {
 	// STL - способ поиска
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));	
@@ -142,7 +142,7 @@ void CallbackTimer<Caller>::clearTimers()
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallbackTimer<Caller>::reset( int id )
+void CallbackTimer<Caller>::reset( size_t id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));	
 	if( li!=lst.end() )
@@ -150,7 +150,7 @@ void CallbackTimer<Caller>::reset( int id )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-void CallbackTimer<Caller>::setTiming( int id, int timeMS )
+void CallbackTimer<Caller>::setTiming( size_t id, timeout_t timeMS )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));		
 	if( li!=lst.end() )
@@ -158,23 +158,23 @@ void CallbackTimer<Caller>::setTiming( int id, int timeMS )
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-int CallbackTimer<Caller>::getInterval( int id )
+timeout_t CallbackTimer<Caller>::getInterval( size_t id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));		
 	if( li!=lst.end() )
 		return li->pt.getInterval();
-	return -1;
+
+	return TIMEOUT_INF;
 }
 // ------------------------------------------------------------------------------------------
 template <class Caller>
-int CallbackTimer<Caller>::getCurrent( int id )
+timeout_t CallbackTimer<Caller>::getCurrent( size_t id )
 {
 	typename TimersList::iterator li= find_if(lst.begin(),lst.end(),FindId_eq(id));			
 	if( li!=lst.end() )
 		return li->pt.getCurrent();
 	
-	return -1;
+	return TIMEOUT_INF;
 }
 // ------------------------------------------------------------------------------------------
-
 # endif //CallbackTimer_TCC_H_

include/ComPort.h

@@ -126,10 +126,10 @@ class ComPort
 	protected:
 		void openPort();
 
-		static const int BufSize = 8192;
+		static const size_t BufSize = 8192;
 		unsigned char buf[BufSize];
-		int curSym = { 0 };
-		int bufLength = { 0 };
+		size_t curSym = { 0 };
+		size_t bufLength = { 0 };
 		int fd = { -1 };
 		timeout_t uTimeout = { 0 };
 		bool waiting = { false };

include/ComPort485F.h

@@ -49,9 +49,9 @@ class ComPort485F:
 	protected:
 
 		virtual unsigned char m_receiveByte( bool wait ) override;
-		void save2queue( unsigned char* msg, int len, int bnum );
-		bool remove_echo( unsigned char tb[], int len );
-		void m_read( int tmsec );
+		void save2queue(unsigned char* msg, size_t len, size_t bnum );
+		bool remove_echo( unsigned char tb[], size_t len );
+		void m_read( timeout_t tmsec );
 
 		/*! просто временный буфер для считывания данных */
 		unsigned char tbuf[ComPort::BufSize];

include/Configuration.h

@@ -134,15 +134,15 @@ namespace UniSetTypes
 			UniversalIO::IOType getIOType( const std::string& name );
 
 			// net
-			inline unsigned int getCountOfNet() const
+			inline size_t getCountOfNet() const
 			{
 				return countOfNet;
 			}
-			inline unsigned int getRepeatTimeout() const
+			inline size_t getRepeatTimeout() const
 			{
 				return repeatTimeout;
 			}
-			inline unsigned int getRepeatCount() const
+			inline size_t getRepeatCount() const
 			{
 				return repeatCount;
 			}
@@ -162,7 +162,7 @@ namespace UniSetTypes
 				return imagesDir;    // временно
 			}
 
-			inline int getHeartBeatTime()
+			inline timeout_t getHeartBeatTime()
 			{
 				return heartbeat_msec;
 			}
@@ -193,7 +193,6 @@ namespace UniSetTypes
 				return docDir;
 			}
 
-
 			inline bool isLocalIOR() const
 			{
 				return localIOR;
@@ -273,11 +272,11 @@ namespace UniSetTypes
 			CORBA::PolicyList policyList;
 
 			std::string NSName = { "" };        /*!< имя сервиса именования на ланной машине (обычно "NameService") */
-			unsigned int countOfNet = { 1 };    /*!< количество резервных каналов */
-			unsigned int repeatCount = { 3 };    /*!< количество попыток получить доступ к удаленному объекту
+			size_t countOfNet = { 1 };    /*!< количество резервных каналов */
+			size_t repeatCount = { 3 };    /*!< количество попыток получить доступ к удаленному объекту
                                             прежде чем будет выработано исключение TimeOut.        */
 
-			unsigned int repeatTimeout = { 50 };    /*!< пауза между попытками [мс] */
+			timeout_t repeatTimeout = { 50 };    /*!< пауза между попытками [мс] */
 
 			UniSetTypes::ListOfNode lnodes;
 
@@ -311,7 +310,7 @@ namespace UniSetTypes
 			bool localIOR = { false };
 			bool transientIOR = { false };
 
-			int heartbeat_msec = { 3000 };
+			timeout_t heartbeat_msec = { 3000 };
 	};
 
 	/*! Глобальный указатель на конфигурацию (singleton) */

include/Pulse.h

@@ -40,7 +40,7 @@ class Pulse
 
 		// t1_msec - интервал "вкл"
 		// t0_msec - интерфал "откл"
-		inline void run( int _t1_msec, int _t0_msec )
+		inline void run( timeout_t _t1_msec, timeout_t _t0_msec )
 		{
 			t1_msec = _t1_msec;
 			t0_msec = _t0_msec;
@@ -49,7 +49,7 @@ class Pulse
 			set(true);
 		}
 
-		inline void set_next( int _t1_msec, int _t0_msec )
+		inline void set_next( timeout_t _t1_msec, timeout_t _t0_msec )
 		{
 			t1_msec = _t1_msec;
 			t0_msec = _t0_msec;
@@ -116,11 +116,11 @@ class Pulse
 		}
 
 
-		inline long getT1()
+		inline timeout_t getT1()
 		{
 			return t1_msec;
 		}
-		inline long getT0()
+		inline timeout_t getT0()
 		{
 			return t0_msec;
 		}
@@ -131,8 +131,8 @@ class Pulse
 		PassiveTimer tCorr;    // корректирующий таймер
 		bool ostate;
 		bool isOn;
-		long t1_msec;
-		long t0_msec;
+		timeout_t t1_msec;
+		timeout_t t0_msec;
 
 };
 // --------------------------------------------------------------------------

include/UniSetTypes.h

@@ -57,7 +57,7 @@ namespace UniSetTypes
 
 	const ObjectId AdminID = -2; /*!< сервисный идентификатор используемый утилитой admin */
 
-	typedef unsigned long KeyType;    /*!< уникальный ключ объекта */
+	typedef size_t KeyType;    /*!< уникальный ключ объекта */
 
 	/*! генератор уникального положительного ключа
 	 *    Уникальность гарантируется только для пары значений

include/UniXML.h

@@ -260,7 +260,7 @@ class UniXML
 		static const xmlChar* local2xml( const std::string& text );
 		static std::string local2utf8( const std::string& text );
 
-		static int recur;
+		static size_t recur;
 };
 // --------------------------------------------------------------------------
 #endif

src/Communications/ComPort485F.cc

@@ -253,18 +253,15 @@ void ComPort485F::sendByte( unsigned char x )
 	}
 }
 // --------------------------------------------------------------------------------
-void ComPort485F::save2queue( unsigned char* msg, int len, int bnum )
+void ComPort485F::save2queue( unsigned char* msg, size_t len, size_t bnum )
 {
-	for( auto i = 0; i < len && i < bnum; i++ )
-	{
+	for( size_t i = 0; i < len && i < bnum; i++ )
 		wq.push(msg[i]);
-		//        fprintf(stderr,"save 2 squeue: %x\n",msg[i]);
-	}
 }
 // --------------------------------------------------------------------------------
-bool ComPort485F::remove_echo( unsigned char tb[], int len )
+bool ComPort485F::remove_echo( unsigned char tb[], size_t len )
 {
-	int i = 0;
+	size_t i = 0;
 
 	while( !wq.empty() )
 	{
@@ -291,10 +288,10 @@ bool ComPort485F::remove_echo( unsigned char tb[], int len )
 	return wq.empty();
 }
 // --------------------------------------------------------------------------------
-void ComPort485F::m_read( int tmsec )
+void ComPort485F::m_read( timeout_t tmsec )
 {
 	ptRecv.setTiming(tmsec);
-	int rc = 0;
+	ssize_t rc = 0;
 
 	while( !ptRecv.checkTime() )
 	{

src/Various/UniXML.cc

@@ -41,7 +41,7 @@ using namespace std;
 */
 
 // Временная переменная для подсчёта рекурсии
-int UniXML::recur = 0;
+size_t UniXML::recur = 0;
 
 UniXML::UniXML(const string& filename):
 	doc(0),

tests/test_callbacktimer.cc

@@ -12,7 +12,7 @@ class MyTestClass
 		MyTestClass(): num1(0), num2(0), num3(0) {}
 		~MyTestClass() {}
 
-		void Time( int id )
+		void Time( size_t id )
 		{
 			if( id == 1 )
 				num1++;