(2.0): небольшие правки описаний

include/DefaultMessageInterface.h

-/* This file is part of the UniSet project
- * Copyright (c) 2002 Free Software Foundation, Inc.
- * Copyright (c) 2002 Pavel Vainerman
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-// --------------------------------------------------------------------------
-/*! \file
- *  \brief "Пустая" реализация интерфейса работы с сообщениями
- *  \author Pavel Vainerman
- */
-// --------------------------------------------------------------------------
-#ifndef DefaultMessageInterface_H_
-#define DefaultMessageInterface_H_
-// --------------------------------------------------------------------------
-#include "MessageInterface.h"
-// --------------------------------------------------------------------------
-class DefaultMessageInterface:
-	public MessageInterface
-{
-	public:
-		DefaultMessageInterface(){}
-		virtual ~DefaultMessageInterface(){}
-		virtual	std::string getMessage( UniSetTypes::MessageCode code ){ return ""; }
-		virtual	bool isExist(UniSetTypes::MessageCode code){ return false; }
-		virtual	UniSetTypes::MessageCode getCode( const std::string& msg ){ return UniSetTypes::DefaultMessageCode; }
-		virtual	UniSetTypes::MessageCode getCodeByIdName( const std::string& name ){ return UniSetTypes::DefaultMessageCode; }
-		virtual std::ostream& printMessagesMap(std::ostream& os){ return os; }
-};
-// --------------------------------------------------------------------------
-#endif

include/HourGlass.h

@@ -20,30 +20,59 @@
 // idea: lav@etersoft.ru
 // realisation: pv@etersoft.ru, lav@etersoft.ru
 // --------------------------------------------------------------------------
-#ifndef SandClock_H_
-#define SandClock_H_
-// --------------------------------------------------------------------------
-/*! WARNING! This class is DEPRECATED! Use HourGlass.. */
+#ifndef HourGlass_H_
+#define HourGlass_H_
 // --------------------------------------------------------------------------
 #include "PassiveTimer.h"
 // --------------------------------------------------------------------------
-/*! WARNING! This class is DEPRECATED! Use HourGlass.. */
-class SandClock
+/*! Песочные часы.  Класс реализующий логику песочных часов.
+	Удобен для создания задержек на срабатывание и на отпускание
+	(как фильтр от кратковременных изменений) с "накоплением времени".
+	Аналогия с песочными часами:
+	\par
+	Выставляете время 'run(msec)'.. устанавливаются в какое-то положение часы 'rotate(true)'...
+	песок сыплется... если весь пересыпался - срабатывает условие 'check()==true'.
+	Если во время работы условие изменилось (часы перевернули в обратную сторону), то
+	уже успевший пересыпаться песок, начинает пересыпаться в обратную сторону. Если опять
+	повернули часы... продолжает сыпаться опять (добвляясь к тому песку, что "не успел" высыпаться обратно).
+	Т.е. до момента срабатывания уже меньше времени чем "полное время" и т.д.
+
+	Класс является "пассивным", т.е. требует периодического вызова функции rotate и check,
+	для проверки наступления условия срабатывания.
+
+	\par Пример использования.
+	Допустим у вас есть сигнал "перегрев"(in_overheating) и вам необходимо выставить какой-то
+	флаг о перегреве (isOverheating), если этот сигнал устойчиво держится в течение 10 секунд,
+	и при этом если сигнал снялся, то вам необходимо как минимум те же 10 секунд,
+	подождать прежде чем "снять" флаг. Для этого удобно использовать данный класс.
+\code
+	HourGlass hg;
+	hg.run(10000); // настраиваем часы на 10 сек..
+
+	while( ....)
+	{
+	     hg.rotate(in_overheating); // управляем состоянием песочных часов (прямой или обратный ход часов).
+	     isOverheating = hg.check();
+	}
+
+\endcode
+*/
+class HourGlass
 {
 	public:
-		SandClock(): _state(false),_sand(0),_size(0){}
-		~SandClock(){}
-	
+		HourGlass(): _state(false),_sand(0),_size(0){}
+		~HourGlass(){}
+
 		// запустить часы (заново)
-		inline void run( int msec )
+		inline void run( timeout_t msec )
 		{
 			t.setTiming(msec);
 			_state 	= true;
 			_sand	= msec;
 			_size	= msec;
 		}
-		
-		inline void reset ()
+
+		inline void reset()
 		{
 			run(_size);
 		}
@@ -60,7 +89,7 @@ class SandClock
 		{
 			if( st == _state )
 				return st;
-				
+
 			_state = st;
 			if( !_state )
 			{
@@ -71,7 +100,7 @@ class SandClock
 					_sand = 0;
 
 //				std::cout << "перевернули: прошло " << cur
-//							<< " осталось " << sand 
+//							<< " осталось " << sand
 //							<< " засекаем " << cur << endl;
 
 				t.setTiming(cur);
@@ -83,9 +112,9 @@ class SandClock
 					_sand = _size;
 
 //				std::cout << "вернули: прошло " << t.getCurrent()
-//							<< " осталось " << sand 
+//							<< " осталось " << sand
 //							<< " засекам " << sand << endl;
-	
+
 				t.setTiming(_sand);
 			}
 			return st;
@@ -93,18 +122,18 @@ class SandClock
 
 		// получить прошедшее время
 		// для положения st
-		inline int current( bool st )
+		inline timeout_t current( bool st )
 		{
 			return t.getCurrent();
 		}
 
 		// получить заданное время
 		// для положения st
-		inline int interval( bool st )
+		inline timeout_t interval( bool st )
 		{
 			return t.getInterval();
 		}
-		
+
 		// проверить наступление
 		inline bool check()
 		{
@@ -117,12 +146,12 @@ class SandClock
 		}
 
 		inline bool state(){ return _state; }
-		
+
 	protected:
 		PassiveTimer t;
 		bool _state;
 		int _sand;
-		int _size;
+		timeout_t _size;
 };
 // --------------------------------------------------------------------------
 #endif

include/Pulse.h

@@ -5,6 +5,13 @@
 #include <iostream>
 #include "PassiveTimer.h"
 // --------------------------------------------------------------------------
+/*! Класс реализующий формирование импульсов заданной длительности(t1) и заданных пауз между ними(t0).
+	Класс пассивный, для работы требует постоянного вызова функции step().
+	Для получения текущего состояния "выхода" использовать out().
+	Формирование импульсов включается функцией run() либо функцией set(true).
+	Вызов reset() тоже включает формирование импульсов.
+	Выключается формирование вызовом set(false).
+*/
 class Pulse
 {
 	public:
@@ -58,6 +65,7 @@ class Pulse
 		}
 
 		inline bool out(){ return ostate; }
+
 		inline void set( bool state )
 		{ 
 			isOn = state; 

include/RunLock.h

@@ -27,19 +27,26 @@
 // ---------------------------------------------------------------------------
 #include <string>
 // ---------------------------------------------------------------------------
+/*! Защита от поторного запуска программы(процесса).
+	При вызове lock(lockFile) в файл lockFile записывается pid текущего процесса.
+	При вызове isLocked() проверяется состояние процесса по его pid (записанному в файл).
+	unlock() - удаляет файл.
+
+\warning Код не переносимый, т.к. рассчитан на наличие каталога /proc,
+по которому проверяется статус процесса (по pid).
+*/
 class RunLock
 {
 	public:
 		RunLock();
 		~RunLock();
 		
-		static bool isLocked(const std::string& lockName); //, char* **argv );
-		static bool lock(const std::string& lockName);
-		static bool unlock(const std::string& lockName);
+		static bool isLocked(const std::string& lockFile); //, char* **argv );
+		static bool lock(const std::string& lockFile);
+		static bool unlock(const std::string& lockFile);
 		
 	protected:
 	
 };
 // ----------------------------------------------------------------------------
 #endif
-

include/UniversalInterface.h

@@ -49,11 +49,7 @@ namespace UniversalIO
 }
 
 // -----------------------------------------------------------------------------------------
-//#define REPEAT_TIMEOUT	100 // [мс] пауза между попытками вызвать удаленную функцию объекта
-//#define REPEAT_COUNT	5 	// количество попыток, после которого вырабатывается TimeOut
-
 #define IO_THROW_EXCEPTIONS UniSetTypes::TimeOut,UniSetTypes::IOBadParam,UniSetTypes::ORepFailed
-
 // -----------------------------------------------------------------------------------------
 /*!
  * \class UniversalInterface
@@ -96,7 +92,7 @@ class UniversalInterface
 		
 		//! Выставление состояния датчика
 		void setValue ( UniSetTypes::ObjectId id, long value, UniSetTypes::ObjectId node ) throw(IO_THROW_EXCEPTIONS);
-		void setValue ( UniSetTypes::ObjectId id, long value);
+		void setValue ( UniSetTypes::ObjectId id, long value );
 		void setValue ( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId supplier );
 
 		void fastSetValue( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId supplier );
@@ -116,7 +112,7 @@ class UniversalInterface
 
 
 		//! Заказ информации об изменении дискретного датчика
-		void askThreshold ( UniSetTypes::ObjectId sensorId, UniSetTypes::ThresholdId tid,
+		void askThreshold( UniSetTypes::ObjectId sensorId, UniSetTypes::ThresholdId tid,
 							UniversalIO::UIOCommand cmd,
 							CORBA::Long lowLimit=0, CORBA::Long hiLimit=0, CORBA::Long sensibility=0, 
 							UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId );
@@ -220,16 +216,14 @@ class UniversalInterface
 						UniSetTypes::ObjectId node = UniSetTypes::conf->getLocalNode() ); 	// used exist
 
 		bool waitWorking( UniSetTypes::ObjectId id, int msec, int pause=3000,
-							UniSetTypes::ObjectId node = UniSetTypes::conf->getLocalNode() ); 	// used getState
+							UniSetTypes::ObjectId node = UniSetTypes::conf->getLocalNode() ); 	// used getValue
 
 		inline void setCacheMaxSize( unsigned int newsize)
 		{
 			rcache.setMaxSize(newsize);
 		}
 
-		/*!
-			\todo Убедится в уникальности возвращаемого результата	hash(...)	
-		*/
+		/*! Кэш ссылок на объекты */
 		class CacheOfResolve
 		{
 			public:
@@ -241,7 +235,7 @@ class UniversalInterface
 					void cache(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node, UniSetTypes::ObjectVar ptr);
 					void erase(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node);
 					
-					inline void setMaxSize( unsigned int ms)
+					inline void setMaxSize( unsigned int ms )
 					{
 						MaxSize = ms;
 					};
@@ -250,6 +244,7 @@ class UniversalInterface
 
 			protected:
 					CacheOfResolve(){};
+
 			private:
 			
 				bool clean(); 		/*!< функция очистки кэш-а от старых ссылок */
@@ -264,7 +259,7 @@ class UniversalInterface
 				*/
 				struct Info
 				{
-					Info( UniSetTypes::ObjectVar ptr, time_t tm=0):
+					Info( UniSetTypes::ObjectVar ptr, time_t tm=0 ):
 							ptr(ptr)
 					{
 						if(!tm)
@@ -310,6 +305,7 @@ class UniversalInterface
 		void initBackId( UniSetTypes::ObjectId backid );
 	protected:
 		std::string set_err(const std::string& pre, UniSetTypes::ObjectId id, UniSetTypes::ObjectId node); 
+
 	private:
 		void init();
 

src/Various/RunLock.cc

@@ -24,7 +24,6 @@
 // --------------------------------------------------------------------------
 #include <dirent.h>
 #include "RunLock.h"
-#include "Exceptions.h"
 #include "Configuration.h"
 // --------------------------------------------------------------------------
 using namespace UniSetTypes;