ansible4ozw 0.0.2 → 0.0.3

data/lib/ansible/zwave/openzwave/src/platform/TimeStamp.h

@@ -0,0 +1,85 @@
+//-----------------------------------------------------------------------------
+//
+//	TimeStamp.h
+//
+//	Cross-platform TimeStamp
+//
+//	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 _TimeStamp_H
+#define _TimeStamp_H
+
+#include "Defs.h"
+
+namespace OpenZWave
+{
+	class TimeStampImpl;
+
+	/** \brief Implements a platform-independent TimeStamp.
+	 */
+	class TimeStamp
+	{
+	public:
+		/**
+		 * Constructor.
+		 * Creates a TimeStamp object.
+		 */
+		TimeStamp();
+
+		/**
+		 * Destructor.
+		 * Destroys the TimeStamp object.
+		 */
+		~TimeStamp();
+
+		/**
+		 * SetTime.  Sets the timestamp to now, plus the offset in milliseconds.
+		 * \param _milliseconds optional positive or negative offset from 
+		 * now in milliseconds.  Defaults to zero.
+		 */
+		void SetTime( int32 _milliseconds = 0 );
+
+		/**
+		 * TimeRemaining.  Gets the difference between now and the timestamp
+		 * time in milliseconds.
+		 * \return milliseconds remaining until we reach the timestamp.  The 
+		 * return value is negative if the timestamp is in the past.
+		 */
+		int32 TimeRemaining();
+
+		/**
+		 * Overload the subtract operator to get the difference between
+		 * two timestamps in milliseconds.
+		 */
+		int32 operator- ( TimeStamp const& _other );
+
+	private:
+		TimeStamp( TimeStamp const&	);				// prevent copy
+		TimeStamp& operator = ( TimeStamp const& );	// prevent assignment
+
+		TimeStampImpl*	m_pImpl;					// Pointer to an object that encapsulates the platform-specific implementation of the TimeStamp.
+	};
+
+} // namespace OpenZWave
+
+#endif //_TimeStamp_H
+

data/lib/ansible/zwave/openzwave/src/platform/Wait.cpp

@@ -0,0 +1,176 @@
+//-----------------------------------------------------------------------------
+//
+//	Wait.cpp
+//
+//	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"	// Platform-specific implementation of a Wait object
+#include "Event.h"
+#include "Log.h"
+
+using namespace OpenZWave;
+
+void WaitMultipleCallback( void* _context );
+
+//-----------------------------------------------------------------------------
+//	<Wait::Wait>
+//	Constructor
+//-----------------------------------------------------------------------------
+Wait::Wait
+(
+)
+{
+	m_pImpl = new WaitImpl( this );
+}
+
+//-----------------------------------------------------------------------------
+//	<Wait::~Wait>
+//	Destructor
+//-----------------------------------------------------------------------------
+Wait::~Wait
+(
+)
+{
+	delete m_pImpl;
+}
+
+//-----------------------------------------------------------------------------
+//	<Wait::AddWatcher>
+//	Add a watcher to our object.
+//-----------------------------------------------------------------------------
+void Wait::AddWatcher
+( 
+	pfnWaitNotification_t _callback, 
+	void* _context
+)
+{
+	if( !_callback )
+	{
+		assert(0);
+		return;
+	}
+
+	// Add a ref so our object cannot disappear while being watched
+	AddRef();
+
+	// Add the watcher (platform specific code required here for thread safety)
+	m_pImpl->AddWatcher( _callback, _context );
+}
+
+//-----------------------------------------------------------------------------
+//	<Wait::RemoveWatcher>
+//	Remove a watcher from our object.
+//-----------------------------------------------------------------------------
+void Wait::RemoveWatcher
+( 
+	pfnWaitNotification_t _callback, 
+	void* _context
+)
+{
+	if( m_pImpl->RemoveWatcher( _callback, _context ) )
+	{
+		Release();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Wait::Notify>
+//	Notify all the watchers that the object has become signalled
+//-----------------------------------------------------------------------------
+void Wait::Notify
+(
+)
+{
+	m_pImpl->Notify();
+}
+
+//-----------------------------------------------------------------------------
+//	<Wait::Multiple>
+//	Wait for one of multiple objects to become signalled.
+//-----------------------------------------------------------------------------
+int32 Wait::Multiple
+(
+	Wait** _objects,
+	uint32 _numObjects,
+	int32 _timeout // = -1
+)
+{
+	uint32 i;
+
+	// Create an event that will be set when any of the objects in the list becomes signalled.
+	Event* waitEvent = new Event();
+ 
+	// Add a watcher to each object in the list, passing in the event as the context.
+	for( i=0; i<_numObjects; ++i )
+	{
+		_objects[i]->AddWatcher( WaitMultipleCallback, waitEvent ); 
+	}
+
+	int32 res = -1;	// Default to timeout result
+	string str = "";
+	if( waitEvent->Wait( _timeout ) )
+	{
+		// An object was signalled.  Run through the list 
+		// and see which one it was.
+		for( i=0; i<_numObjects; ++i )
+		{
+			if( _objects[i]->IsSignalled() )
+			{
+				if( res == -1 )
+					res = (int32)i;
+				char buf[15];
+				snprintf(buf, sizeof(buf), "%d, ", i);
+				str += buf;
+			}
+		}
+	}
+	Log::Write( LogLevel_Debug, "Wait::Multiple res=%d num=%d >%s", res, _numObjects, str.c_str() );
+
+	// Remove the watchers
+	for( i=0; i<_numObjects; ++i )
+	{
+		_objects[i]->RemoveWatcher( WaitMultipleCallback, waitEvent ); 
+	}
+
+	// We're done with the event now
+	waitEvent->Release();
+	return res;
+}
+
+
+//-----------------------------------------------------------------------------
+//	<WaitMultipleCallback>
+//	Callback handler for the watchers added during WaitImpl::Multiple
+//-----------------------------------------------------------------------------
+void WaitMultipleCallback
+(
+	void* _context
+)
+{
+	Event* waitEvent = (Event*)_context;
+	waitEvent->Set();
+}
+

data/lib/ansible/zwave/openzwave/src/platform/Wait.h

@@ -0,0 +1,113 @@
+//-----------------------------------------------------------------------------
+//
+//	Wait.h
+//
+//	Cross-platform 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/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _Wait_H
+#define _Wait_H
+
+#include <list>
+#include "Ref.h"
+
+namespace OpenZWave
+{
+	class WaitImpl;
+
+	/** \brief Platform-independent definition of Wait objects.
+	 */
+	class Wait: public Ref
+	{
+		friend class WaitImpl;
+		friend class ThreadImpl;
+
+	public:
+		enum
+		{
+			Timeout_Immediate = 0,
+			Timeout_Infinite = -1
+		};
+
+		typedef void (*pfnWaitNotification_t)( void* _context );
+
+		/**
+		 * Add a watcher to our object.  The watcher will be triggered
+		 * by the derived class, when it enters a certain state.
+		 * \param _callback pointer to the function that will be called when the wait is over.
+		 * \param _context pointer to custom data that will be sent with the callback.
+		 */
+		void AddWatcher( pfnWaitNotification_t _callback, void* _context );
+
+		/**
+		 * Remove a watcher from our object.  Both the _callback and _context pointers 
+		 * must match those used in a previous call to AddWatcher.
+		 * \param _callback pointer to the function that will be called when the wait is over.
+		 * \param _context pointer to custom data that will be sent with the callback.
+		 */
+		void RemoveWatcher( pfnWaitNotification_t _callback, void* _context );
+
+		/**
+		 * Wait for a single object to become signalled.
+		 * \param _object pointer to the object to wait on.
+		 * \param _timeout optional maximum time to wait.  Defaults to -1, which means wait forever.
+		 * \return zero if the object was signalled, -1 if the wait timed out.
+		 */												 
+		static int32 Single( Wait* _object, int32 _timeout = -1 ){ return Multiple( &_object, 1, _timeout ); }
+
+		/**
+		 * Wait for one of multiple objects to become signalled.  If more than one object is in
+		 * a signalled state, the lowest array index will be returned.
+		 * \param _objects array of pointers to objects to wait on.
+		 * \param _numObjects number of objects in the array.
+		 * \param _timeout optional maximum time to wait.  Defaults to -1, which means wait forever.
+		 * \return index into the array of the object that was signalled, -1 if the wait timed out.
+		 */												 
+		static int32 Multiple( Wait** _objects, uint32 _numObjects, int32 _timeout = -1 );
+
+	protected:
+		Wait();
+		virtual ~Wait();
+
+		/**
+		 * Notify the watchers that the object is signalled.
+		 */
+		void Notify();
+
+		/**
+		 * Test whether an object is signalled.
+		 */
+		virtual bool IsSignalled() = 0;
+
+	private:
+		Wait( Wait const&	);					// prevent copy
+		Wait& operator = ( Wait const& );		// prevent assignment
+	
+		WaitImpl*	m_pImpl;					// Pointer to an object that encapsulates the platform-specific implementation of a Wait object.
+	};
+
+} // namespace OpenZWave
+
+#endif //_Wait_H
+

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

@@ -0,0 +1,262 @@
+//-----------------------------------------------------------------------------
+//
+//	EventImpl.cpp
+//
+//	POSIX implementation of a cross-platform event
+//
+//	Copyright (c) 2010, Greg Satz <satz@iranger.com>
+//	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 "EventImpl.h"
+
+#include <stdio.h>
+#include <sys/time.h>
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::EventImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+EventImpl::EventImpl
+(
+):
+	m_manualReset( true ),
+	m_isSignaled( false ),
+	m_waitingThreads( 0 )
+{
+	pthread_mutexattr_t ma;
+	pthread_mutexattr_init( &ma );
+	pthread_mutexattr_settype( &ma, PTHREAD_MUTEX_ERRORCHECK );
+	pthread_mutex_init( &m_lock, &ma );
+	pthread_mutexattr_destroy( &ma );
+	
+	pthread_condattr_t ca;
+	pthread_condattr_init( &ca );
+	pthread_condattr_setpshared( &ca, PTHREAD_PROCESS_PRIVATE );
+	pthread_cond_init( &m_condition, &ca );
+	pthread_condattr_destroy( &ca );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::~EventImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+EventImpl::~EventImpl
+(
+)
+{
+	pthread_mutex_destroy( &m_lock );
+	pthread_cond_destroy( &m_condition );
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Set>
+//	Set the event to signalled
+//-----------------------------------------------------------------------------
+void EventImpl::Set
+(
+)
+{
+	int err = pthread_mutex_lock( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr,  "EventImpl::Set lock error %d (%d)\n", errno, err );
+		assert( 0 );
+	}
+	if( m_manualReset )
+	{
+		m_isSignaled = true;
+		err = pthread_cond_broadcast( &m_condition );
+		if( err != 0 )
+		{
+			fprintf(stderr,  "EventImpl::Set cond broadcast error %d (%s)\n", errno, err );
+			assert( 0 );
+		}
+	}
+	else
+	{
+		if( !m_waitingThreads )
+		{
+			m_isSignaled = true;
+		}
+		else
+		{
+			err = pthread_cond_signal( &m_condition );
+			if( err != 0 )
+			{
+				fprintf(stderr,  "EventImpl::Set cond signal error %d (%d)\n", errno, err );
+				assert( 0 );
+			}
+		}
+	}
+	err = pthread_mutex_unlock( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr,  "EventImpl::Set unlock error %d (%d)\n", errno, err );
+		assert( 0 );
+	} 
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Reset>
+//	Set the event to not signalled
+//-----------------------------------------------------------------------------
+void EventImpl::Reset
+(
+)
+{
+	int err = pthread_mutex_lock ( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr,  "EventImpl::Reset lock error %d (%d)\n", errno, err );
+		assert( 0 );
+	}
+	m_isSignaled = false;
+	err = pthread_mutex_unlock( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr, "EventImpl::Reset unlock error %d (%d)\n", errno, err );
+		assert( 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::IsSignalled>
+//	Test whether the event is set
+//-----------------------------------------------------------------------------
+bool EventImpl::IsSignalled
+(
+)
+{
+	return m_isSignaled;
+}
+
+//-----------------------------------------------------------------------------
+//	<EventImpl::Wait>
+//	Wait for the event to become signalled
+//-----------------------------------------------------------------------------
+bool EventImpl::Wait
+(
+	int32 const _timeout /* milliseconds */
+)
+{
+	bool result = true;
+
+	int err = pthread_mutex_lock( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr,  "EventImpl::Wait lock error %d (%d)\n", errno, err );
+		assert( 0 );
+	}
+	if( m_isSignaled )
+	{
+		if ( !m_manualReset )
+		{
+			m_isSignaled = false;
+		}
+	}
+	else
+	{
+		++m_waitingThreads;
+	        if( _timeout == 0 )
+       		{
+			result = m_isSignaled;
+	        }
+	        else if( _timeout > 0 )
+		{
+			struct timeval now;
+			struct timespec abstime;
+
+			gettimeofday(&now, NULL);
+            
+			abstime.tv_sec = now.tv_sec + (_timeout / 1000);
+
+			// Now add the remainder of our timeout to the microseconds part of 'now'
+			now.tv_usec += (_timeout % 1000) * 1000;
+
+			// Careful now! Did it wrap?
+			while( now.tv_usec >= ( 1000 * 1000 ) )
+			{
+				// Yes it did so bump our seconds and subtract
+				now.tv_usec -= (1000 * 1000);
+				abstime.tv_sec++;
+			}
+            
+			abstime.tv_nsec = now.tv_usec * 1000;
+            
+			while( !m_isSignaled )
+			{
+				int oldstate;
+				pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
+
+				err = pthread_cond_timedwait( &m_condition, &m_lock, &abstime );
+
+				pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
+
+				if( err == ETIMEDOUT )
+				{
+					result = false;
+					break;
+				}
+				else
+					if( err == 0 )
+					{
+						result = true;
+					}
+					else
+					{
+						fprintf(stderr,   "EventImpl::Wait cond timedwait error %d (%d)\n", errno, err );
+						assert( 0 );
+					}
+			}
+		}
+		else
+		{
+			while( !m_isSignaled )
+			{
+				int oldstate;
+				pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
+
+				err = pthread_cond_wait( &m_condition, &m_lock );
+
+				pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
+
+				if( err != 0 )
+				{
+					fprintf(stderr,  "EventImpl::Wait cond wait error %d (%d)\n", errno, err );
+					assert( 0 );
+				}
+			}
+		}
+		--m_waitingThreads;
+	}
+
+	err = pthread_mutex_unlock( &m_lock );
+	if( err != 0 )
+	{
+		fprintf(stderr, "EventImpl::Wait unlock error %d (%d)\n", errno, err );
+		assert( 0 );
+	}
+	return result;
+}
+