ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,135 @@
+//-----------------------------------------------------------------------------
+//
+//	Stream.h
+//
+//	Cross-platform circular buffer with signalling
+//
+//	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 _Stream_H
+#define _Stream_H
+
+#include "Defs.h"
+#include "Wait.h"
+
+#include <string>
+
+namespace OpenZWave
+{
+	class Mutex;
+
+	/** \brief Platform-independent definition of a circular buffer.
+	 */
+	class Stream: public Wait
+	{
+		friend class Wait;
+
+	public:
+		/**
+		 * Constructor.
+		 * Creates a cross-platform ring buffer object
+		 */
+		Stream( uint32 _bufferSize );
+
+		/**
+		 * Set the number of bytes the buffer must contain before it becomes signalled.
+		 * Once the threshold is set, the application can use Wait::Single or Wait::Multiple
+		 * to wait until the buffer has been filled with the desired amount of data.
+		 * \param _size the amoutn of data in bytes that the buffer must contain for it to become signalled.
+		 * \see Wait::Single, Wait::Multiple
+		 */
+		void SetSignalThreshold( uint32 _size );
+
+
+		/**
+		 * Copies the requested amount of data from the stream, removing it from the stream as it does so.
+		 * If there is insufficient data available, the method returns false, and no data is transferred.
+		 * \param _buffer pointer to a block of memory that will be filled with the stream data.
+		 * \param _size the amount of data in bytes to copy from the stream.
+		 * \return true if all the requested data has been copied.  False if there was not enough data in
+		 * the stream.
+		 * \see GetDataSize, Put
+		 */
+		bool Get( uint8* _buffer, uint32 _size );
+
+		/**
+		 * Copies the requested amount of data from the buffer into the stream.
+		 * If there is insufficient room available in the stream's circular buffer, and no data is transferred.
+		 * \param _buffer pointer to a block of memory that will be copied into the stream.
+		 * \param _size the amount of data in bytes to copy to the stream.
+		 * \return true if all the requested data has been copied.  False if there was not enough space in
+		 * the stream's circular buffer.
+		 * \see Get, GetDataSize
+		 */
+		bool Put( uint8* _buffer, uint32 _size );
+
+ 		/**
+		 * Returns the amount of data in bytes that is stored in the stream.
+		 * \return the number of bytes of data in the stream.
+		 * \see Get, GetDataSize
+		 */
+		uint32 GetDataSize()const{ return m_dataSize; }
+
+ 		/**
+		 * Empties the stream bytes held in the buffer.  
+		 * This is called when the library gets out of sync with the controller and sends a "NAK" 
+		 * to the controller.
+		 */
+		void Purge();
+
+	protected:
+		/**
+		 * Formats stream buffer data for output to the log.
+		 * \param _buffer pointer to the stream buffer "head" location
+		 * \param _size number of valid bytes currently in the buffer
+		 * \param _function string containing text to display before the data
+		 */
+		void LogData( uint8* _buffer, uint32 _size, string _function );
+
+		/**
+		 * Used by the Wait class to test whether the buffer contains sufficient data.
+		 */
+		virtual bool IsSignalled();
+
+		/**
+		 * Destructor.
+		 * Destroys the ring buffer object.
+		 */
+		~Stream();
+
+	private:
+		Stream( Stream const&	);					// prevent copy
+		Stream& operator = ( Stream const& );		// prevent assignment
+
+		uint8*	m_buffer;
+		uint32	m_bufferSize;
+		uint32	m_signalSize;
+		uint32	m_dataSize;
+		uint32	m_head;
+		uint32	m_tail;
+ 		Mutex*	m_mutex;
+	};
+
+} // namespace OpenZWave
+
+#endif //_Event_H
+

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

@@ -0,0 +1,118 @@
+//-----------------------------------------------------------------------------
+//
+//	Thread.cpp
+//
+//	Cross-platform threads
+//
+//	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 "Event.h"
+#include "Thread.h"
+#include "ThreadImpl.h"	// Platform-specific implementation of a thread
+
+using namespace OpenZWave;
+
+
+//-----------------------------------------------------------------------------
+//	<Thread::Thread>
+//	Constructor
+//-----------------------------------------------------------------------------
+Thread::Thread
+(
+	string const& _name
+)
+{
+	m_exitEvent = new Event();
+	m_pImpl = new ThreadImpl( this, _name );
+}
+
+//-----------------------------------------------------------------------------
+//	<Thread::~Thread>
+//	Destructor
+//-----------------------------------------------------------------------------
+Thread::~Thread
+(
+)
+{
+	delete m_pImpl;
+	m_exitEvent->Release();
+}
+
+//-----------------------------------------------------------------------------
+//	<Thread::Start>
+//	Start a function running on this thread
+//-----------------------------------------------------------------------------
+bool Thread::Start
+(
+	pfnThreadProc_t _pfnThreadProc, 
+	void* _context 
+)
+{
+	return( m_pImpl->Start( _pfnThreadProc, m_exitEvent, _context ) );
+}
+
+//-----------------------------------------------------------------------------
+//	<Thread::Stop>
+//	Stop a function running on this thread
+//-----------------------------------------------------------------------------
+bool Thread::Stop
+(
+)
+{
+	int32 timeout = 2000;	// Give the thread 2 seconds to exit
+	m_exitEvent->Set();
+	
+	if( Wait::Single( this, timeout ) < 0 )
+	{
+		// Timed out
+	        m_pImpl->Terminate();
+		return false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<Thread::Sleep>
+//	Causes the thread to sleep for the specified number of milliseconds.
+//-----------------------------------------------------------------------------
+void Thread::Sleep
+(
+	uint32 _milliseconds
+) 
+{
+	return( m_pImpl->Sleep( _milliseconds ) );
+}
+
+//-----------------------------------------------------------------------------
+//	<Thread::IsSignalled>
+//	Test whether the event is set
+//-----------------------------------------------------------------------------
+bool Thread::IsSignalled
+(
+)
+{
+	return m_pImpl->IsSignalled();
+}
+
+

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

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------------
+//
+//	Thread.h
+//
+//	Cross-platform threads
+//
+//	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 _Thread_H
+#define _Thread_H
+
+#include <string>
+#include "Defs.h"
+#include "Wait.h"
+
+namespace OpenZWave
+{
+	class ThreadImpl;
+	class Event;
+
+	/** \brief Implements a platform-independent thread management class.
+	 */
+	class Thread: public Wait
+	{
+	public:
+		typedef void (*pfnThreadProc_t)( Event* _exitEvent, void* _context );
+
+		/**
+		 * Constructor.
+		 * Creates a thread object that can be used to serialize access to a shared resource.
+		 */
+		Thread( string const& _name );
+
+		/**
+		 * Start running a function on this thread.  
+		 * Attempts to start a function running on this thread.  The call will fail if another 
+		 * function is already running.
+		 * \param _pThreadProc pointer to the function to be run.  The function must take a 
+		 * single void pointer as its only argument, and return void.  On entry, the pointer 
+		 * will be set to the context provided to this Start method. 
+		 * \param _context pointer allowing any relevant data to be passed to the thread function.
+		 * \return True if the function was successfully started.
+		 * \see Stop, IsRunning
+		 */
+		bool Start( pfnThreadProc_t _pfnThreadProc, void* _context );
+
+		/**
+		 * Stop a function running on this thread.  
+		 * Attempts to stop a function running on this thread.  The call will fail if no 
+		 * function is running.
+		 * \return True if the function was successfully stopped.
+		 * \see Start, IsRunning
+		 */
+		bool Stop();
+
+		/**
+		 * Causes the thread to sleep for the specified number of milliseconds.
+		 * \param _millisecs Number of milliseconds to sleep.
+		 */
+		void Sleep( uint32 _millisecs );
+
+	protected:
+		/**
+		 * Used by the Wait class to test whether the thread has been completed.
+		 */
+		virtual bool IsSignalled();
+
+		/**
+		 * Destructor.
+		 * Destroys the Thread object.
+		 */
+		virtual ~Thread();
+
+	private:
+		ThreadImpl*	m_pImpl;	// Pointer to an object that encapsulates the platform-specific implementation of a thread.
+		Event*		m_exitEvent;
+	};
+
+} // namespace OpenZWave
+
+#endif //_Thread_H
+

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

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------------
+//
+//	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/>.
+//
+//-----------------------------------------------------------------------------
+#include "Defs.h"
+#include "TimeStamp.h"
+
+#include "TimeStampImpl.h"	// Platform-specific implementation of a TimeStamp
+
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<TimeStamp::TimeStamp>
+//	Constructor
+//-----------------------------------------------------------------------------
+TimeStamp::TimeStamp
+(
+):
+	m_pImpl( new TimeStampImpl() )
+{
+}
+
+//-----------------------------------------------------------------------------
+//	<TimeStamp::~TimeStamp>
+//	Destructor
+//-----------------------------------------------------------------------------
+TimeStamp::~TimeStamp
+(
+)
+{
+	delete m_pImpl;
+}
+
+//-----------------------------------------------------------------------------
+//	<TimeStamp::SetTime>
+//	Sets the timestamp to now, plus an offset in milliseconds
+//-----------------------------------------------------------------------------
+void TimeStamp::SetTime
+(
+	int32 _milliseconds	// = 0
+)
+{
+	m_pImpl->SetTime( _milliseconds );
+}
+
+//-----------------------------------------------------------------------------
+//	<TimeStamp::TimeRemaining>
+//	Gets the difference between now and the timestamp time in milliseconds
+//-----------------------------------------------------------------------------
+int32 TimeStamp::TimeRemaining
+(
+)
+{
+	return m_pImpl->TimeRemaining();
+}
+
+//-----------------------------------------------------------------------------
+//	<TimeStamp::operator->
+//	Overload the subtract operator to get the difference between two 
+//	timestamps in milliseconds
+//-----------------------------------------------------------------------------
+int32 TimeStamp::operator- 
+(
+	TimeStamp const& _other
+)
+{
+	return (int32)(m_pImpl - _other.m_pImpl);
+}