ansible4ozw 0.0.2 → 0.0.3

data/lib/ansible/zwave/openzwave/src/platform/unix/WaitImpl.cpp

@@ -0,0 +1,160 @@
+//-----------------------------------------------------------------------------
+//
+//	WaitImpl.cpp
+//
+//	POSIX implementation of an abstract base class for objects we 
+//	want to be able to wait for.
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave 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 Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#include "Defs.h"
+#include "Wait.h"
+#include "WaitImpl.h"
+
+#include <stdio.h>
+#include <errno.h>
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<WaitImpl::WaitImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+WaitImpl::WaitImpl
+(	
+	Wait* _owner
+):
+	m_owner( _owner )
+{
+	pthread_mutexattr_t ma;
+	pthread_mutexattr_init ( &ma );
+	pthread_mutexattr_settype( &ma, PTHREAD_MUTEX_RECURSIVE );
+	pthread_mutex_init( &m_criticalSection, &ma );
+	pthread_mutexattr_destroy( &ma );
+}
+
+//-----------------------------------------------------------------------------
+//	<WaitImpl::~WaitImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+WaitImpl::~WaitImpl
+(
+)
+{
+	pthread_mutex_destroy( &m_criticalSection );
+}
+
+//-----------------------------------------------------------------------------
+//	<WaitImpl::AddWatcher>
+//	Add a watcher to our object.
+//-----------------------------------------------------------------------------
+void WaitImpl::AddWatcher
+( 
+	Wait::pfnWaitNotification_t _callback, 
+	void* _context
+)
+{
+	// Add the watcher to our list
+	Watcher watcher;
+	watcher.m_callback = _callback;
+	watcher.m_context = _context;
+	
+	if( pthread_mutex_lock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::AddWatcher lock error %d\n", errno );
+		assert( 0 );
+	}
+	m_watchers.push_back( watcher );
+	if( pthread_mutex_unlock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::AddWatcher unlock error %d\n", errno );
+		assert( 0 );
+	}
+
+	// If the object is already in a signalled state, notify the watcher immediately
+	if( m_owner->IsSignalled() )
+	{
+		_callback( _context );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<WaitImpl::RemoveWatcher>
+//	Remove a watcher from our object.
+//-----------------------------------------------------------------------------
+bool WaitImpl::RemoveWatcher
+( 
+	Wait::pfnWaitNotification_t _callback, 
+	void* _context
+)
+{
+	bool res = false;
+
+	if( pthread_mutex_lock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::RemoveWatcher lock error %d\n", errno );
+		assert( 0 );
+	}
+
+	for( list<Watcher>::iterator it=m_watchers.begin(); it!=m_watchers.end(); ++it )
+	{
+		Watcher const& watcher = *it;
+		if( ( watcher.m_callback == _callback ) && ( watcher.m_context == _context ) )
+		{
+			m_watchers.erase( it );
+			res = true;
+			break;
+		}
+	}
+
+	if( pthread_mutex_unlock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::RemoveWatcher unlock error %d\n", errno );
+		assert( 0 );
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+//	<WaitImpl::Notify>
+//	Notify all the watchers that the object has become signalled
+//-----------------------------------------------------------------------------
+void WaitImpl::Notify
+(
+)
+{
+	if( pthread_mutex_lock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::Notify lock error %d\n", errno );
+		assert( 0 );
+	}
+	for( list<Watcher>::iterator it=m_watchers.begin(); it!=m_watchers.end(); ++it )
+	{
+		Watcher const& watcher = *it;
+		watcher.m_callback( watcher.m_context );
+	}
+	if( pthread_mutex_unlock( &m_criticalSection ) != 0 )
+	{
+		fprintf(stderr, "WaitImpl::Notify unlock error %d\n", errno );
+		assert( 0 );
+	}
+}

data/lib/ansible/zwave/openzwave/src/platform/unix/WaitImpl.h

@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------------
+//
+//	WaitImpl.h
+//
+//	POSIX implementation of a base class for objects we 
+//  want to be able to wait for.
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave 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 Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _WaitImpl_H
+#define _WaitImpl_H
+
+#include <stdio.h>
+#include <pthread.h>
+#include <list>
+#include "Defs.h"
+#include "Ref.h"
+#include "Wait.h"
+
+namespace OpenZWave
+{
+	/** \brief Windows specific implementation of Wait objects.
+	 */
+	class WaitImpl
+	{
+	private:
+		friend class Wait;
+
+		WaitImpl( Wait* _owner );
+		virtual ~WaitImpl();
+
+		void AddWatcher( Wait::pfnWaitNotification_t _callback, void* _context );
+		bool RemoveWatcher( Wait::pfnWaitNotification_t _callback, void* _context );
+		void Notify();
+
+		static int32 Multiple( Wait** _objects, uint32 _numObjects, int32 _timeout = -1 );
+
+		WaitImpl( Wait const&	);					// prevent copy
+		WaitImpl& operator = ( WaitImpl const& );	// prevent assignment
+
+		struct Watcher
+		{
+			Wait::pfnWaitNotification_t		m_callback;
+			void*							m_context;
+		};
+
+		list<Watcher>		m_watchers;
+		Wait*				m_owner;
+		pthread_mutex_t		m_criticalSection;
+	};
+
+} // namespace OpenZWave
+
+#endif //_WaitImpl_H
+

data/lib/ansible/zwave/openzwave/src/platform/windows/EventImpl.cpp

@@ -0,0 +1,102 @@
+//-----------------------------------------------------------------------------
+//
+//	EventImpl.cpp
+//
+//	Windows implementation of a cross-platform event
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave 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 Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#include <windows.h>
+
+#include "Defs.h"
+#include "EventImpl.h"
+
+using namespace OpenZWave;
+
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::EventImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+EventImpl::EventImpl
+(
+)
+{
+	// Create a manual reset event
+	m_hEvent = ::CreateEvent( NULL, TRUE, FALSE, NULL );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::~EventImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+EventImpl::~EventImpl
+(
+)
+{
+	::CloseHandle( m_hEvent );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Set>
+//	Set the event to signalled
+//-----------------------------------------------------------------------------
+void EventImpl::Set
+(
+)
+{
+	::SetEvent( m_hEvent );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Reset>
+//	Set the event to not signalled
+//-----------------------------------------------------------------------------
+void EventImpl::Reset
+(
+)
+{
+	::ResetEvent( m_hEvent );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::IsSignalled>
+//	Test whether the event is set
+//-----------------------------------------------------------------------------
+bool EventImpl::IsSignalled
+(
+)
+{
+	return( WAIT_OBJECT_0 == WaitForSingleObject( m_hEvent, 0 ) );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Wait>
+//	Wait for the event to become signalled
+//-----------------------------------------------------------------------------
+bool EventImpl::Wait
+(
+	int32 const _timeout
+)
+{
+	return( WAIT_TIMEOUT != ::WaitForSingleObject( m_hEvent, (DWORD)_timeout ) );
+}

data/lib/ansible/zwave/openzwave/src/platform/windows/EventImpl.h

@@ -0,0 +1,60 @@
+//-----------------------------------------------------------------------------
+//
+//	EventImpl.h
+//
+//	Windows implementation of a cross-platform event
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave 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 Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _EventImpl_H
+#define _EventImpl_H
+
+#include <Windows.h>
+#include "Defs.h"
+
+namespace OpenZWave
+{
+	/** \brief Windows-specific implementation of the Event class.
+	 */
+	class EventImpl
+	{
+	private:
+		friend class Event;
+		friend class SocketImpl;
+		friend class Wait;
+
+		EventImpl();
+		~EventImpl();
+
+		void Set();
+		void Reset();
+
+		bool Wait( int32 _timeout );	// The wait method is to be used only by the Wait::Multiple method
+		bool IsSignalled();
+
+		HANDLE	m_hEvent;
+	};
+
+} // namespace OpenZWave
+
+#endif //_EventImpl_H
+

data/lib/ansible/zwave/openzwave/src/platform/windows/LogImpl.cpp

@@ -0,0 +1,302 @@
+//-----------------------------------------------------------------------------
+//
+//	LogImpl.cpp
+//
+//	Windows implementation of message and error logging
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave 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 Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#include <windows.h>
+
+#include "Defs.h"
+#include "LogImpl.h"
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::LogImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+LogImpl::LogImpl
+(
+	string const& _filename,
+	bool const _bAppendLog,
+	bool const _bConsoleOutput,
+	LogLevel const _saveLevel,
+	LogLevel const _queueLevel,
+	LogLevel const _dumpTrigger
+):
+	m_filename( _filename ),					// name of log file
+	m_bAppendLog( _bAppendLog ),				// true to append (and not overwrite) any existing log
+	m_bConsoleOutput( _bConsoleOutput ),		// true to provide a copy of output to console
+	m_saveLevel( _saveLevel ),					// level of messages to log to file
+	m_queueLevel( _queueLevel ),				// level of messages to log to queue
+	m_dumpTrigger( _dumpTrigger )				// dump queued messages when this level is seen
+{
+	string accessType;
+
+	// create an adjusted file name and timestamp string
+	string timeStr = GetTimeStampString();
+
+	if ( m_bAppendLog )
+	{
+		accessType = "a";
+	}
+	else
+	{
+		accessType = "w";
+	}
+
+	FILE* pFile;
+	if( !fopen_s( &pFile, _filename.c_str(), accessType.c_str() ) )
+	{
+		fprintf( pFile, "\nLogging started %s\n\n", timeStr.c_str() );
+		fclose( pFile );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::~LogImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+LogImpl::~LogImpl
+(
+)
+{
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Write>
+//	Write to the log
+//-----------------------------------------------------------------------------
+void LogImpl::Write
+( 
+	LogLevel _logLevel,
+	uint8 const _nodeId,
+	char const* _format, 
+	va_list _args
+)
+{
+	// create a timestamp string
+	string timeStr = GetTimeStampString();
+	string nodeStr = GetNodeString( _nodeId );
+
+	// handle this message
+	if( (_logLevel <= m_queueLevel) || (_logLevel == LogLevel_Internal) )	// we're going to do something with this message...
+	{
+		char lineBuf[1024];
+		if( !_format || ( _format[0] == 0 ) )
+		{
+			strcpy_s( lineBuf, 1024, "" );
+		}
+		else
+		{
+			vsprintf_s( lineBuf, sizeof(lineBuf), _format, _args );
+		}
+
+		// should this message be saved to file (and possibly written to console?)
+		if( (_logLevel <= m_saveLevel) || (_logLevel == LogLevel_Internal) )
+		{
+			// save to file
+			FILE* pFile;
+			if( !fopen_s( &pFile, m_filename.c_str(), "a" ) )
+			{
+				if( _logLevel != LogLevel_Internal )						// don't add a second timestamp to display of queued messages
+				{
+					fprintf( pFile, "%s%s", timeStr.c_str(), nodeStr.c_str() );
+					if( m_bConsoleOutput )
+					{
+						printf( "%s%s", timeStr.c_str(), nodeStr.c_str() );
+					}
+				}
+
+				// print message to file (and possibly screen)
+				fprintf( pFile, "%s", lineBuf );
+				if( m_bConsoleOutput )
+				{
+					printf( "%s", lineBuf );
+				}
+
+				// add a newline
+				fprintf( pFile, "\n" ); 
+				if( m_bConsoleOutput )
+				{
+					printf( "\n" );
+				}
+
+				fclose( pFile );
+			}
+		}
+
+		if( _logLevel != LogLevel_Internal )
+		{
+			char queueBuf[1024];
+			string threadStr = GetThreadId();
+			sprintf_s( queueBuf, sizeof(queueBuf), "%s%s%s", timeStr.c_str(), threadStr.c_str(), lineBuf );
+			Queue( queueBuf );
+		}
+	}
+
+	// now check to see if the _dumpTrigger has been hit
+	if( (_logLevel <= m_dumpTrigger) && (_logLevel != LogLevel_Internal) && (_logLevel != LogLevel_Always) )
+	{
+		QueueDump();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Queue>
+//	Write to the log queue
+//-----------------------------------------------------------------------------
+void LogImpl::Queue
+( 
+	char const* _buffer
+)
+{
+	string bufStr = _buffer;
+	m_logQueue.push_back( bufStr );
+
+	// rudimentary queue size management
+	if( m_logQueue.size() > 500 )
+	{
+		m_logQueue.pop_front();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::QueueDump>
+//	Dump the LogQueue to output device
+//-----------------------------------------------------------------------------
+void LogImpl::QueueDump
+( 
+)
+{
+	Log::Write( LogLevel_Internal, "\n\nDumping queued log messages\n");
+	list<string>::iterator it = m_logQueue.begin();
+	while( it != m_logQueue.end() )
+	{
+		string strTemp = *it;
+		Log::Write( LogLevel_Internal, strTemp.c_str() );
+		it++;
+	}
+	m_logQueue.clear();
+	Log::Write( LogLevel_Internal, "\nEnd of queued log message dump\n\n");
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Clear>
+//	Clear the LogQueue
+//-----------------------------------------------------------------------------
+void LogImpl::QueueClear
+( 
+)
+{
+	m_logQueue.clear();
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::SetLoggingState>
+//	Sets the various log state variables
+//-----------------------------------------------------------------------------
+void LogImpl::SetLoggingState
+(
+	LogLevel _saveLevel,
+	LogLevel _queueLevel,
+	LogLevel _dumpTrigger
+)
+{
+	m_saveLevel = _saveLevel;
+	m_queueLevel = _queueLevel;
+	m_dumpTrigger = _dumpTrigger;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetTimeStampAndThreadId>
+//	Generate a string with formatted current time
+//-----------------------------------------------------------------------------
+string LogImpl::GetTimeStampString
+( 
+)
+{
+	// Get a timestamp
+	SYSTEMTIME time;
+	::GetLocalTime( &time );
+
+	// create a time stamp string for the log message
+	char buf[100];
+	sprintf_s( buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d:%03d ", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds );
+	string str = buf;
+	return str;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetNodeString>
+//	Generate a string with formatted node id
+//-----------------------------------------------------------------------------
+string LogImpl::GetNodeString
+(
+	uint8 const _nodeId
+)
+{
+	if( _nodeId == 0 )
+	{
+		return "";
+	}
+	else
+		if( _nodeId == 255 ) // should make distinction between broadcast and controller better for SwitchAll broadcast
+		{
+			return "contrlr, ";
+		}
+		else
+		{
+			char buf[20];  
+			snprintf( buf, sizeof(buf), "Node%03d, ", _nodeId );
+			return buf;
+		}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetThreadId>
+//	Generate a string with formatted thread id
+//-----------------------------------------------------------------------------
+string LogImpl::GetThreadId
+( 
+)
+{
+	char buf[20];
+	DWORD dwThread = ::GetCurrentThreadId();
+	sprintf_s( buf, sizeof(buf), "%04d ", dwThread );
+	string str = buf;
+	return str;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::SetLogFileName>
+//	Provide a new log file name (applicable to future writes)
+//-----------------------------------------------------------------------------
+void LogImpl::SetLogFileName
+( 
+	string _filename
+)
+{
+	m_filename = _filename;
+}