ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------------
+//
+//	Log.h
+//
+//	Cross-platform 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/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _Log_H
+#define _Log_H
+
+#include <stdarg.h>
+#include <string>
+#include "Defs.h"
+
+namespace OpenZWave
+{
+	class Mutex;
+
+	enum LogLevel
+	{
+		LogLevel_None,		/**< Disable all logging */
+		LogLevel_Always,	/**< These messages should always be shown */
+		LogLevel_Fatal,		/**< A likely fatal issue in the library */
+		LogLevel_Error,		/**< A serious issue with the library or the network */
+		LogLevel_Warning,	/**< A minor issue from which the library should be able to recover */
+		LogLevel_Alert,		/**< Something unexpected by the library about which the controlling application should be aware */
+		LogLevel_Info,		/**< Everything's working fine...these messages provide streamlined feedback on each message */
+		LogLevel_Detail,	/**< Detailed information on the progress of each message */
+		LogLevel_Debug,		/**< Very detailed information on progress that will create a huge log file quickly
+									But this level (as others) can be queued and sent to the log only on an error or warning */
+		LogLevel_Internal	/**< Used only within the log class (uses existing timestamp, etc.) */
+	};
+
+	class i_LogImpl
+	{
+	public:
+		i_LogImpl() { } ;
+		virtual ~i_LogImpl() { } ;
+		virtual void Write( LogLevel _level, uint8 const _nodeId, char const* _format, va_list _args ) = 0;
+		virtual void QueueDump() = 0;
+		virtual void QueueClear() = 0;
+		virtual void SetLoggingState( LogLevel _saveLevel, LogLevel _queueLevel, LogLevel _dumpTrigger ) = 0;
+		virtual void SetLogFileName( string _filename ) = 0;
+	};
+
+	/** \brief Implements a platform-independent log...written to the console and, optionally, a file.
+	 */
+	class Log
+	{
+	public:
+		/**
+		 * Create a log.
+		 * Creates the cross-platform logging singleton.
+		 * Any previous log will be cleared.
+		 * \return a pointer to the logging object.
+		 * \see Destroy, Write
+		 */
+		static Log* Create( string const& _filename, bool const _bAppend, bool const _bConsoleOutput, LogLevel const _saveLevel, LogLevel const _queueLevel, LogLevel const _dumpTrigger );
+
+		/**
+		 * Create a log.
+		 * Creates the cross-platform logging singleton.
+		 * Any previous log will be cleared.
+		 * \param LogClass a Logging Class that inherits the i_LogImpl Class to use to Log
+		 * \return a pointer to the logging object.
+		 * \see Destroy, Write
+		 */
+
+		static Log* Create( i_LogImpl *LogClass );
+
+		/**
+		 * Destroys the log.
+		 * Destroys the logging singleton.  The log can no longer
+		 * be written to without another call to Create.
+		 * \see Create, Write
+		 */
+		static void Destroy();
+
+		/**
+		 * \brief Set the Logging Implmentation Class to replace the standard File/Console Loggin
+		 * \param LogClass A Logging Class that inherits the i_LogImpl Class used to Log to
+		 * \return Bool Value indicating success or failure
+		 */
+		static bool SetLoggingClass(i_LogImpl *LogClass );
+
+		/**
+		 * \brief Enable or disable library logging (retained for backward compatibility)
+		 * \param _dologging  If true, logging is enabled; if false, disabled
+		*/
+		static void SetLoggingState(bool _dologging);
+
+		/**
+		 * \brief Enable or disable library logging.  To disable, set _saveLevel and _queueLevel
+		 * to LogLevel_None.
+		 * \param _saveLevel	LogLevel of messages to write in real-time
+		 * \param _queueLevel	LogLevel of messages to queue to be dumped in case of an error
+		 * \param _dumpTrigger	LogLevel of message that triggers a queue dump (probably LogLevel_Error or LogLevel_Warning)
+		*/
+		static void SetLoggingState( LogLevel _saveLevel, LogLevel _queueLevel, LogLevel _dumpTrigger );
+
+		/**
+		 * \brief Determine whether logging is enabled or not (retained for backward compatibility)
+		 * \param _dologging  If true, logging is enabled; if false, disabled
+		*/
+		static bool GetLoggingState();
+
+		/**
+		 * \brief Obtain the various logging levels.
+		 * \param _saveLevel	LogLevel of messages to write in real-time
+		 * \param _queueLevel	LogLevel of messages to queue to be dumped in case of an error
+		 * \param _dumpTrigger	LogLevel of message that triggers a queue dump (probably LogLevel_Error or LogLevel_Warning)
+		*/
+		static void GetLoggingState( LogLevel* _saveLevel, LogLevel* _queueLevel, LogLevel* _dumpTrigger );
+
+		/**
+		 * \brief Change the log file name.  This will start a new log file (or potentially start appending
+		 * information to an existing one.  Developers might want to use this function, together with a timer
+		 * in the controlling application, to create timestamped log file names.
+		 * \param _filename Name of the new (or existing) file to use for log output.
+		*/
+		static void SetLogFileName( string _filename );
+
+		/**
+		 * Write an entry to the log.
+		 * Writes a formatted string to the log.
+		 * \param _level	Specifies the type of log message (Error, Warning, Debug, etc.)
+		 * \param _format.  A string formatted in the same manner as used with printf etc.
+		 * \param ... a variable number of arguments, to be included in the formatted string.
+		 * \see Create, Destroy
+		 */
+		static void Write( LogLevel _level, char const* _format, ... );
+
+		/**
+		 * Write an entry to the log.
+		 * Writes a formatted string to the log.
+		 * \param _level	Specifies the type of log message (Error, Warning, Debug, etc.)
+		 * \param _nodeId	Node Id this entry is about.
+		 * \param _format.  A string formatted in the same manner as used with printf etc.
+		 * \param ... a variable number of arguments, to be included in the formatted string.
+		 * \see Create, Destroy
+		 */
+		static void Write( LogLevel _level, uint8 const _nodeId, char const* _format, ... );
+
+		/**
+		 * Send the queued log messages to the log output.
+		 */
+		static void QueueDump();
+
+		/**
+		 * Clear the log message queue
+		 */
+		static void QueueClear();
+
+	private:
+		Log( string const& _filename, bool const _bAppend, bool const _bConsoleOutput, LogLevel _saveLevel, LogLevel _queueLevel, LogLevel _dumpTrigger );
+		~Log();
+
+		static i_LogImpl*	m_pImpl;		/**< Pointer to an object that encapsulates the platform-specific logging implementation. */
+		static Log*	s_instance;
+		Mutex*		m_logMutex;
+	};
+} // namespace OpenZWave
+
+#endif //_Log_H

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

@@ -0,0 +1,96 @@
+//-----------------------------------------------------------------------------
+//
+//	Mutex.cpp
+//
+//	Cross-platform mutex
+//
+//	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 "Mutex.h"
+#include "MutexImpl.h"	// Platform-specific implementation of a mutex
+
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<Mutex::Mutex>
+//	Constructor
+//-----------------------------------------------------------------------------
+Mutex::Mutex
+(
+):
+	m_pImpl( new MutexImpl() )
+{
+}
+
+//-----------------------------------------------------------------------------
+//	<Mutex::~Mutex>
+//	Destructor
+//-----------------------------------------------------------------------------
+Mutex::~Mutex
+(
+)
+{
+	delete m_pImpl;
+}
+
+//-----------------------------------------------------------------------------
+//	<Mutex::Lock>
+//	Lock the mutex
+//-----------------------------------------------------------------------------
+bool Mutex::Lock
+(
+	bool const _bWait // = true;
+)
+{
+	return m_pImpl->Lock( _bWait );
+}
+
+//-----------------------------------------------------------------------------
+//	<Mutex::Unlock>
+//	Release our lock on the mutex
+//-----------------------------------------------------------------------------
+void Mutex::Unlock
+(
+)
+{
+	m_pImpl->Unlock();
+
+	if( IsSignalled() )
+	{
+		// The mutex has no owners, so notify the watchers
+		Notify();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Mutex::IsSignalled>
+//	Test whether the event is set
+//-----------------------------------------------------------------------------
+bool Mutex::IsSignalled
+(
+)
+{
+	return m_pImpl->IsSignalled();
+}
+

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

@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+//
+//	Mutex.h
+//
+//	Cross-platform mutex
+//
+//	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 _Mutex_H
+#define _Mutex_H
+
+#include "Wait.h"
+
+namespace OpenZWave
+{
+	class MutexImpl;
+
+	/** \brief Implements a platform-independent mutex--for serializing access to a shared resource.
+	 */
+	class Mutex: public Wait
+	{
+	public:
+		/**
+		 * Constructor.
+		 * Creates a mutex object that can be used to serialize access to a shared resource.
+		 */
+		Mutex();
+
+		/**
+		 * Lock the mutex.
+		 * Attempts to lock the mutex.
+		 * There must be a matching call to Release for every call to Lock.
+		 * \param _bWait Defaults to true.  Set this argument to false if the method should return
+		 * immediately, even if the lock is not available.
+		 * \return True if the lock was obtained.
+		 * \see Release
+		 */
+		bool Lock( bool const _bWait = true );
+
+		/**
+		 * Releases the lock on the mutex.
+		 * There must be a matching call to Release for every call to Lock.
+		 * \see Lock
+		 */
+		void Unlock();
+
+	protected:
+		/**
+		 * Used by the Wait class to test whether the mutex is free.
+		 */
+		virtual bool IsSignalled();
+
+		/**
+		 * Destructor.
+		 * Destroys the mutex object.
+		 */
+		~Mutex();
+
+	private:
+		Mutex( Mutex const&	);					// prevent copy
+		Mutex& operator = ( Mutex const& );		// prevent assignment
+
+		MutexImpl*	m_pImpl;					// Pointer to an object that encapsulates the platform-specific implementation of a mutex.
+	};
+
+} // namespace OpenZWave
+
+#endif //_Mutex_H
+

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

@@ -0,0 +1,91 @@
+//-----------------------------------------------------------------------------
+//
+//  Ref.h
+//
+//  Reference counting for objects.
+//
+//	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 _Ref_H
+#define _Ref_H
+
+#pragma once
+
+#include "Defs.h"
+
+namespace OpenZWave
+{
+	/**
+	 * Provides reference counting for objects.
+	 * Any class wishing to include reference counting should be derived from Ref.
+	 * Derived classes must declare their destructor as protected virtual.
+	 * On construction, the reference count is set to one.  Calls to AddRef increment 
+	 * the count.  Calls to Release decrement the count.  When the count reaches
+	 * zero, the object is deleted.
+	 */
+	class Ref
+	{
+	public:
+		/**
+		 * Initializes the RefCount to one.  The object
+		 * can only be deleted through a call to Release.
+		 * \see AddRef, Release
+		 */
+		Ref(){ m_refs = 1; }
+
+		/**
+		 * Increases the reference count of the object.
+		 * Every call to AddRef requires a matching call
+		 * to Release before the object will be deleted.
+		 * \see Release
+		 */
+		void AddRef(){ ++m_refs; }
+
+		/**
+		 * Removes a reference to an object.
+		 * If this was the last reference to the message, the 
+		 * object is deleted.
+		 * \see AddRef
+		 */
+		int32 Release()
+		{
+			if( 0 >= ( --m_refs ) )
+			{
+				delete this;
+				return 0;
+			}
+			return m_refs;
+		}
+
+	protected:
+		virtual ~Ref(){}
+
+	private:
+		// Reference counting
+		int32	m_refs;
+
+	}; // class Ref
+
+} // namespace OpenZWave
+
+#endif // _Ref_H
+