//-----------------------------------------------------------------------------
//
//	Manager.h
//
//	The main public interface to OpenZWave.
//
//	Copyright (c) 2010 Mal Lansell <openzwave@lansell.org>
//
//	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 _Manager_H
#define _Manager_H

#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <list>
#include <deque>

#include "Defs.h"
#include "Driver.h"
#include "value_classes/ValueID.h"

namespace OpenZWave
{
	class Options;
	class Node;
	class Msg;
	class Value;
	class Event;
	class Mutex;
	class SerialPort;
	class Thread;
	class Notification;
	class ValueBool;
	class ValueByte;
	class ValueDecimal;
	class ValueInt;
	class ValueList;
	class ValueShort;
	class ValueString;
	class ValueRaw;

	/** \brief
	 *   The main public interface to OpenZWave.
	 *
	 *	 \nosubgrouping
	 *   A singleton class providing the main public interface to OpenZWave.
	 *   The Manager class exposes all the functionality required to add
	 *   Z-Wave support to an application.  It handles the sending and receiving
	 *   of Z-Wave messages as well as the configuration of a Z-Wave network
	 *   and its devices, freeing the library user from the burden of learning
	 *   the low-level details of the Z-Wave protocol.
	 *   <p>
	 *   All Z-Wave functionality is accessed via the Manager class.  While this
	 *   does not make for the most efficient code structure, it does enable
	 *   the library to handle potentially complex and hard-to-debug issues
	 *   such as multi-threading and object lifespans behind the scenes.
	 *   Application development is therefore simplified and less prone to bugs.
	 *   <p>
	 *   There can be only one instance of the Manager class, and all applications
	 *   will start by calling Manager::Create static method to create that instance.
	 *   From then on, a call to the Manager::Get static method will return the
	 *   pointer to the Manager object.  On application exit, Manager::Destroy
	 *   should be called to allow OpenZWave to clean up and delete any other
	 *   objects it has created.
	 *   <p>
	 *   Once the Manager has been created, a call should be made to Manager::AddWatcher
	 *   to install a notification callback handler.  This handler will receive
	 *   notifications of Z-Wave network changes and updates to device values, and is
	 *   an essential element of OpenZWave.
 	 *   <p>
	 *   Next, a call should be made to Manager::AddDriver for each Z-Wave controller
	 *   attached to the PC.  Each Driver will handle the sending and receiving of
	 *   messages for all the devices in its controller's Z-Wave network.  The Driver
	 *   will read any previously saved configuration and then query the Z-Wave controller
	 *   for any missing information.  Once that process is complete, a DriverReady
	 *   notification callback will be sent containing the Home ID of the controller,
	 *   which is required by most of the other Manager class methods.
	 *	 <p>
	 *	 [After the DriverReady notification is sent, the Driver will poll each node on
	 *   the network to update information about each node.  After all "awake" nodes
	 *   have been polled, an "AllAwakeNodesQueried" notification is sent.  This is when
	 *   a client application can expect all of the node information (both static
	 *   information, like the physical device's capabilities, session information
	 *   (like [associations and/or names] and dynamic information (like temperature or
	 *   on/off state) to be available.  Finally, after all nodes (whether listening or
	 *   sleeping) have been polled, an "AllNodesQueried" notification is sent.]
	 */
	class OPENZWAVE_EXPORT Manager
	{
		friend class Driver;
		friend class CommandClass;
		friend class Group;
		friend class Node;
		friend class Value;
		friend class ValueStore;
		friend class ValueButton;

	public:
		typedef void (*pfnOnNotification_t)( Notification const* _pNotification, void* _context );

	//-----------------------------------------------------------------------------
	// Construction
	//-----------------------------------------------------------------------------
	/** \name Construction
	 *  For creating and destroying the Manager singleton.
	 */
	/*@{*/
	public:
   		/**
		 * \brief Creates the Manager singleton object.
		 * The Manager provides the public interface to OpenZWave, exposing all the functionality required
		 * to add Z-Wave support to an application. There can be only one Manager in an OpenZWave application.
		 * An Options object must be created and Locked first, otherwise the call to Manager::Create will
		 * fail. Once the Manager has been created, call AddWatcher to install a notification callback handler,
		 * and then call the AddDriver method for each attached PC Z-Wave controller in turn.
		 * \param _options a locked Options object containing all the application's configurable option values.
		 * \return a pointer to the newly created Manager object, or NULL if creation failed.
		 * \see Options, Get, Destroy, AddWatcher, AddDriver
		 */
		static Manager* Create();

		/**
		 * \brief Gets a pointer to the Manager object.
		 * \return pointer to the Manager object, or NULL if Create has not yet been called.
		 * \see Create, Destroy
		 */
		static Manager* Get(){ return s_instance; }

		/**
		 * \brief Deletes the Manager and cleans up any associated objects.
		 * \see Create, Get
		 */
		static void Destroy();

		/**
		 * \brief Get the Version Number of OZW as a string
		 * \return a String representing the version number as MAJOR.MINOR.REVISION
		 */
		static std::string getVersionAsString();

		/**
		 * \brief Get the Version Number as the Version Struct (Only Major/Minor returned)
		 * \return the version struct representing the version
		 */
		static ozwversion getVersion();
	/*@}*/

	private:
		Manager();															// Constructor, to be called only via the static Create method.
		virtual ~Manager();													// Destructor, to be called only via the static Destroy method.

		bool					m_exit;										// Flag indicating that program exit is in progress.
		static Manager*			s_instance;									// Pointer to the instance of the Manager singleton.

	//-----------------------------------------------------------------------------
	// Configuration
	//-----------------------------------------------------------------------------
	/** \name Configuration
	 *  For saving the Z-Wave network configuration so that the entire network does not need to be
	 *  polled every time the application starts.
	 */
	/*@{*/
	public:
		/**
		 * \brief Saves the configuration of a PC Controller's Z-Wave network to the application's user data folder.
		 * This method does not normally need to be called, since OpenZWave will save the state automatically
		 * during the shutdown process.  It is provided here only as an aid to development.
		 * The configuration of each PC Controller's Z-Wave network is stored in a separate file.  The filename
		 * consists of the 8 digit hexadecimal version of the controller's Home ID, prefixed with the string 'zwcfg_'.
		 * This convention allows OpenZWave to find the correct configuration file for a controller, even if it is
		 * attached to a different serial port, USB device path, etc.
		 * \param _homeId The Home ID of the Z-Wave controller to save.
		 */
		void WriteConfig( uint32 const _homeId );

		/**
		 * \brief Gets a pointer to the locked Options object.
		 * \return pointer to the Options object.
		 * \see Create
		 */
		Options* GetOptions()const{ return m_options; }
	/*@}*/

	private:
		Options*	m_options;			// Pointer to the locked Options object that was passed in during creation.

	//-----------------------------------------------------------------------------
	//	Drivers
	//-----------------------------------------------------------------------------
	/** \name Drivers
	 *  Methods for adding and removing drivers and obtaining basic controller information.
	 */
	/*@{*/
	public:
		/**
		 * \brief Creates a new driver for a Z-Wave controller.
		 * This method creates a Driver object for handling communications with a single Z-Wave controller.  In the background, the
		 * driver first tries to read configuration data saved during a previous run.  It then queries the controller directly for any
		 * missing information, and a refresh of the list of nodes that it controls.  Once this information
		 * has been received, a DriverReady notification callback is sent, containing the Home ID of the controller.  This Home ID is
		 * required by most of the OpenZWave Manager class methods.
		 * @param _controllerPath The string used to open the controller.  On Windows this might be something like
		 * "\\.\COM3", or on Linux "/dev/ttyUSB0".
		 * \return True if a new driver was created, false if a driver for the controller already exists.
		 * \see Create, Get, RemoveDriver
		 */
		bool AddDriver( string const& _controllerPath, Driver::ControllerInterface const& _interface = Driver::ControllerInterface_Serial);

		/**
		 * \brief Removes the driver for a Z-Wave controller, and closes the controller.
		 * Drivers do not need to be explicitly removed before calling Destroy - this is handled automatically.
		 * \warning You should NOT call any Manager methods that require the Driver Reference (eg, in response to
		 * Notifications recieved about NodeRemoved etc) once you call this, as your application will most likely
		 * break
		 * @param _controllerPath The same string as was passed in the original call to AddDriver.
		 * @returns True if the driver was removed, false if it could not be found.
		 * @see Destroy, AddDriver
		 */
		bool RemoveDriver( string const& _controllerPath );

		/**
		 * \brief Get the node ID of the Z-Wave controller.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return the node ID of the Z-Wave controller.
		 */
		uint8 GetControllerNodeId( uint32 const _homeId );

		/**
		 * \brief Get the node ID of the Static Update Controller.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return the node ID of the Z-Wave controller.
		 */
		uint8 GetSUCNodeId( uint32 const _homeId );

		/**
		 * \brief Query if the controller is a primary controller.
		 * The primary controller is the main device used to configure and control a Z-Wave network.
		 * There can only be one primary controller - all other controllers are secondary controllers.
		 * <p>
		 * The only difference between a primary and secondary controller is that the primary is the
		 * only one that can be used to add or remove other devices.  For this reason, it is usually
		 * better for the promary controller to be portable, since most devices must be added when
		 * installed in their final location.
		 * <p>
		 * Calls to BeginControllerCommand will fail if the controller is not the primary.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return true if it is a primary controller, false if not.
		 */
		bool IsPrimaryController( uint32 const _homeId );

		/**
		 * \brief Query if the controller is a static update controller.
		 * A Static Update Controller (SUC) is a controller that must never be moved in normal operation
		 * and which can be used by other nodes to receive information about network changes.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return true if it is a static update controller, false if not.
		 */
		bool IsStaticUpdateController( uint32 const _homeId );

		/**
		 * \brief Query if the controller is using the bridge controller library.
		 * A bridge controller is able to create virtual nodes that can be associated
		 * with other controllers to enable events to be passed on.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return true if it is a bridge controller, false if not.
		 */
		bool IsBridgeController( uint32 const _homeId );

		/**
		 * \brief Get the version of the Z-Wave API library used by a controller.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return a string containing the library version. For example, "Z-Wave 2.48".
		 */
		string GetLibraryVersion( uint32 const _homeId );

		/**
		 * \brief Get a string containing the Z-Wave API library type used by a controller.
		 * The possible library types are:
		 * - Static Controller
		 * - Controller
		 * - Enhanced Slave
		 * - Slave
		 * - Installer
		 * - Routing Slave
		 * - Bridge Controller
		 * - Device Under Test
		 * The controller should never return a slave library type.
		 * For a more efficient test of whether a controller is a Bridge Controller, use
		 * the IsBridgeController method.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return a string containing the library type.
		 * \see GetLibraryVersion, IsBridgeController
		 */
		string GetLibraryTypeName( uint32 const _homeId );

		/**
		 * \brief Get count of messages in the outgoing send queue.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return a integer message count
		 */
		int32 GetSendQueueCount( uint32 const _homeId );

		/**
		 * \brief Send current driver statistics to the log file
		 * \param _homeId The Home ID of the Z-Wave controller.
		 */
		void LogDriverStatistics( uint32 const _homeId );

		/**
		 * \brief Obtain controller interface type
		 * \param _homeId The Home ID of the Z-Wave controller.
		 */
		Driver::ControllerInterface GetControllerInterfaceType( uint32 const _homeId );

		/**
		 * \brief Obtain controller interface name
		 * \param _homeId The Home ID of the Z-Wave controller.
		 */
		string GetControllerPath( uint32 const _homeId );
	/*@}*/

	private:
		Driver* GetDriver( uint32 const _homeId );	/**< Get a pointer to a Driver object from the HomeID.  Only to be used by OpenZWave. */
		void SetDriverReady( Driver* _driver, bool success );		/**< Indicate that the Driver is ready to be used, and send the notification callback. */

OPENZWAVE_EXPORT_WARNINGS_OFF
		list<Driver*>		m_pendingDrivers;		/**< Drivers that are in the process of reading saved data and querying their Z-Wave network for basic information. */
		map<uint32,Driver*>	m_readyDrivers;			/**< Drivers that are ready to be used by the application. */
OPENZWAVE_EXPORT_WARNINGS_ON

	//-----------------------------------------------------------------------------
	//	Polling Z-Wave devices
	//-----------------------------------------------------------------------------
	/** \name Polling Z-Wave devices
	 *  Methods for controlling the polling of Z-Wave devices.  Modern devices will not
	 *  require polling.  Some old devices need to be polled as the only way to detect
	 *  status changes.
	 */
	/*@{*/
	public:
		/**
		 * \brief Get the time period between polls of a node's state.
		 */
		int32 GetPollInterval();

		/**
		 * \brief Set the time period between polls of a node's state.
		 * Due to patent concerns, some devices do not report state changes automatically to the controller.
		 * These devices need to have their state polled at regular intervals.  The length of the interval
		 * is the same for all devices.  To even out the Z-Wave network traffic generated by polling, OpenZWave
		 * divides the polling interval by the number of devices that have polling enabled, and polls each
		 * in turn.  It is recommended that if possible, the interval should not be set shorter than the
		 * number of polled devices in seconds (so that the network does not have to cope with more than one
		 * poll per second).
		 * \param _seconds The length of the polling interval in seconds.
		 */
		void SetPollInterval( int32 _milliseconds, bool _bIntervalBetweenPolls );

		/**
		 * \brief Enable the polling of a device's state.
		 * \param _valueId The ID of the value to start polling.
		 * \return True if polling was enabled.
		 */
		bool EnablePoll( ValueID const &_valueId, uint8 const _intensity = 1 );

		/**
		 * \brief Disable the polling of a device's state.
		 * \param _valueId The ID of the value to stop polling.
		 * \return True if polling was disabled.
		 */
		bool DisablePoll( ValueID const &_valueId );

		/**
		 * \brief Determine the polling of a device's state.
		 * \param _valueId The ID of the value to check polling.
		 * \return True if polling is active.
		 */
		bool isPolled( ValueID const &_valueId );

		/**
		 * \brief Set the frequency of polling (0=none, 1=every time through the list, 2-every other time, etc)
		 * \param _valueId The ID of the value whose intensity should be set
		 */
		void SetPollIntensity( ValueID const &_valueId, uint8 const _intensity );

		/**
		 * \brief Get the polling intensity of a device's state.
		 * \param _valueId The ID of the value to check polling.
		 * \return Intensity, number of polling for one polling interval.
		 */
		uint8 GetPollIntensity( ValueID const &_valueId );

	/*@}*/

	//-----------------------------------------------------------------------------
	//	Node information
	//-----------------------------------------------------------------------------
	/** \name Node information
	 *  Methods for accessing information on indivdual nodes.
	 */
	/*@{*/
	public:
		/**
		 * \brief Trigger the fetching of fixed data about a node.
		 * Causes the node's data to be obtained from the Z-Wave network in the same way as if it had just been added.
		 * This method would normally be called automatically by OpenZWave, but if you know that a node has been
		 * changed, calling this method will force a refresh of all of the data held by the library.  This can be especially
		 * useful for devices that were asleep when the application was first run. This is the
		 * same as the query state starting from the beginning.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the request was sent successfully.
		 */
		bool RefreshNodeInfo( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Trigger the fetching of dynamic value data for a node.
		 * Causes the node's values to be requested from the Z-Wave network. This is the
		 * same as the query state starting from the associations state.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the request was sent successfully.
		 */
		bool RequestNodeState( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Trigger the fetching of just the dynamic value data for a node.
		 * Causes the node's values to be requested from the Z-Wave network. This is the
		 * same as the query state starting from the dynamic state.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the request was sent successfully.
		 */
		bool RequestNodeDynamic( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node is a listening device that does not go to sleep
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if it is a listening node.
		 */
		bool IsNodeListeningDevice( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node is a frequent listening device that goes to sleep but
		 * can be woken up by a beam. Useful to determine node and controller consistency.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if it is a frequent listening node.
		 */
		bool IsNodeFrequentListeningDevice( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node is a beam capable device.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if it is a beam capable node.
		 */
		bool IsNodeBeamingDevice( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node is a routing device that passes messages to other nodes
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the node is a routing device
		 */
		bool IsNodeRoutingDevice( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the security attribute for a node. True if node supports security features.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return true if security features implemented.
		 */
		bool IsNodeSecurityDevice( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the maximum baud rate of a node's communications
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the baud rate in bits per second.
		 */
		uint32 GetNodeMaxBaudRate( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the version number of a node
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the node's version number
		 */
		uint8 GetNodeVersion( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the security byte of a node
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the node's security byte
		 */
		uint8 GetNodeSecurity( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the basic type of a node.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the node's basic type.
		 */
		uint8 GetNodeBasic( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the generic type of a node.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the node's generic type.
		 */
		uint8 GetNodeGeneric( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the specific type of a node.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return the node's specific type.
		 */
		uint8 GetNodeSpecific( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get a human-readable label describing the node
		 * The label is taken from the Z-Wave specific, generic or basic type, depending on which of those values are specified by the node.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the label text.
		 */
		string GetNodeType( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the bitmap of this node's neighbors
		 *
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _nodeNeighbors An array of 29 uint8s to hold the neighbor bitmap
		 */
		uint32 GetNodeNeighbors( uint32 const _homeId, uint8 const _nodeId, uint8** _nodeNeighbors );

		/**
		 * \brief Get the manufacturer name of a device
		 * The manufacturer name would normally be handled by the Manufacturer Specific commmand class,
		 * taking the manufacturer ID reported by the device and using it to look up the name from the
		 * manufacturer_specific.xml file in the OpenZWave config folder.
		 * However, there are some devices that do not support the command class, so to enable the user
		 * to manually set the name, it is stored with the node data and accessed via this method rather
		 * than being reported via a command class Value object.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's manufacturer name.
		 * \see SetNodeManufacturerName, GetNodeProductName, SetNodeProductName
		 */
		string GetNodeManufacturerName( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the product name of a device
		 * The product name would normally be handled by the Manufacturer Specific commmand class,
		 * taking the product Type and ID reported by the device and using it to look up the name from the
		 * manufacturer_specific.xml file in the OpenZWave config folder.
		 * However, there are some devices that do not support the command class, so to enable the user
		 * to manually set the name, it is stored with the node data and accessed via this method rather
		 * than being reported via a command class Value object.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's product name.
		 * \see SetNodeProductName, GetNodeManufacturerName, SetNodeManufacturerName
		 */
		string GetNodeProductName( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the name of a node
		 * The node name is a user-editable label for the node that would normally be handled by the
		 * Node Naming commmand class, but many devices do not support it.  So that a node can always
		 * be named, OpenZWave stores it with the node data, and provides access through this method
		 * and SetNodeName, rather than reporting it via a command class Value object.
		 * The maximum length of a node name is 16 characters.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's name.
		 * \see SetNodeName, GetNodeLocation, SetNodeLocation
		 */
		string GetNodeName( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the location of a node
		 * The node location is a user-editable string that would normally be handled by the Node Naming
		 * commmand class, but many devices do not support it.  So that a node can always report its
		 * location, OpenZWave stores it with the node data, and provides access through this method
		 * and SetNodeLocation, rather than reporting it via a command class Value object.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's location.
		 * \see SetNodeLocation, GetNodeName, SetNodeName
		 */
		string GetNodeLocation( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the manufacturer ID of a device
		 * The manufacturer ID is a four digit hex code and would normally be handled by the Manufacturer
		 * Specific commmand class, but not all devices support it.  Although the value reported by this
		 * method will be an empty string if the command class is not supported and cannot be set by the
		 * user, the manufacturer ID is still stored with the node data (rather than being reported via a
		 * command class Value object) to retain a consistent approach with the other manufacturer specific data.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's manufacturer ID, or an empty string if the manufactuer
		 * specific command class is not supported by the device.
		 * \see GetNodeProductType, GetNodeProductId, GetNodeManufacturerName, GetNodeProductName
		 */
		string GetNodeManufacturerId( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the product type of a device
		 * The product type is a four digit hex code and would normally be handled by the Manufacturer Specific
		 * commmand class, but not all devices support it.  Although the value reported by this method will
		 * be an empty string if the command class is not supported and cannot be set by the user, the product
		 * type is still stored with the node data (rather than being reported via a command class Value object)
		 * to retain a consistent approach with the other manufacturer specific data.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's product type, or an empty string if the manufactuer
		 * specific command class is not supported by the device.
		 * \see GetNodeManufacturerId, GetNodeProductId, GetNodeManufacturerName, GetNodeProductName
		 */
		string GetNodeProductType( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get the product ID of a device
		 * The product ID is a four digit hex code and would normally be handled by the Manufacturer Specific
		 * commmand class, but not all devices support it.  Although the value reported by this method will
		 * be an empty string if the command class is not supported and cannot be set by the user, the product
		 * ID is still stored with the node data (rather than being reported via a command class Value object)
		 * to retain a consistent approach with the other manufacturer specific data.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return A string containing the node's product ID, or an empty string if the manufactuer
		 * specific command class is not supported by the device.
		 * \see GetNodeManufacturerId, GetNodeProductType, GetNodeManufacturerName, GetNodeProductName
		 */
		string GetNodeProductId( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Set the manufacturer name of a device
		 * The manufacturer name would normally be handled by the Manufacturer Specific commmand class,
		 * taking the manufacturer ID reported by the device and using it to look up the name from the
		 * manufacturer_specific.xml file in the OpenZWave config folder.
		 * However, there are some devices that do not support the command class, so to enable the user
		 * to manually set the name, it is stored with the node data and accessed via this method rather
		 * than being reported via a command class Value object.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _manufacturerName	A string containing the node's manufacturer name.
		 * \see GetNodeManufacturerName, GetNodeProductName, SetNodeProductName
		 */
		void SetNodeManufacturerName( uint32 const _homeId, uint8 const _nodeId, string const& _manufacturerName );

		/**
		 * \brief Set the product name of a device
		 * The product name would normally be handled by the Manufacturer Specific commmand class,
		 * taking the product Type and ID reported by the device and using it to look up the name from the
		 * manufacturer_specific.xml file in the OpenZWave config folder.
		 * However, there are some devices that do not support the command class, so to enable the user
		 * to manually set the name, it is stored with the node data and accessed via this method rather
		 * than being reported via a command class Value object.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _productName A string containing the node's product name.
		 * \see GetNodeProductName, GetNodeManufacturerName, SetNodeManufacturerName
		 */
		void SetNodeProductName( uint32 const _homeId, uint8 const _nodeId, string const& _productName );

		/**
		 * \brief Set the name of a node
		 * The node name is a user-editable label for the node that would normally be handled by the
		 * Node Naming commmand class, but many devices do not support it.  So that a node can always
		 * be named, OpenZWave stores it with the node data, and provides access through this method
		 * and GetNodeName, rather than reporting it via a command class Value object.
		 * If the device does support the Node Naming command class, the new name will be sent to the node.
		 * The maximum length of a node name is 16 characters.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _nodeName A string containing the node's name.
		 * \see GetNodeName, GetNodeLocation, SetNodeLocation
		 */
		void SetNodeName( uint32 const _homeId, uint8 const _nodeId, string const& _nodeName );

		/**
		 * \brief Set the location of a node
		 * The node location is a user-editable string that would normally be handled by the Node Naming
		 * commmand class, but many devices do not support it.  So that a node can always report its
		 * location, OpenZWave stores it with the node data, and provides access through this method
		 * and GetNodeLocation, rather than reporting it via a command class Value object.
		 * If the device does support the Node Naming command class, the new location will be sent to the node.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _location A string containing the node's location.
		 * \see GetNodeLocation, GetNodeName, SetNodeName
		 */
		void SetNodeLocation( uint32 const _homeId, uint8 const _nodeId, string const& _location );

		/**
		 * \brief Turns a node on
		 * This is a helper method to simplify basic control of a node.  It is the equivalent of
		 * changing the level reported by the node's Basic command class to 255, and will generate a
		 * ValueChanged notification from that class.  This command will turn on the device at its
		 * last known level, if supported by the device, otherwise it will turn	it on at 100%.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to be changed.
		 * \see SetNodeOff, SetNodeLevel
		 */
		void SetNodeOn( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Turns a node off
		 * This is a helper method to simplify basic control of a node.  It is the equivalent of
		 * changing the level reported by the node's Basic command class to zero, and will generate
		 * a ValueChanged notification from that class.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to be changed.
		 * \see SetNodeOn, SetNodeLevel
		 */
		void SetNodeOff( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Sets the basic level of a node
		 * This is a helper method to simplify basic control of a node.  It is the equivalent of
		 * changing the value reported by the node's Basic command class and will generate a
		 * ValueChanged notification from that class.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to be changed.
		 * \param _level The level to set the node.  Valid values are 0-99 and 255.  Zero is off and
		 * 99 is fully on.  255 will turn on the device at its last known level (if supported).
		 * \see SetNodeOn, SetNodeOff
		 */
		void SetNodeLevel( uint32 const _homeId, uint8 const _nodeId, uint8 const _level );

		/**
		 * \brief Get whether the node information has been received
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the node information has been received yet
		 */
		bool IsNodeInfoReceived( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node has the defined class available or not
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \param _commandClassId Id of the class to test for
		 * \return True if the node does have the class instantiated, will return name & version
		 */
		bool GetNodeClassInformation( uint32 const _homeId, uint8 const _nodeId, uint8 const _commandClassId,
					      string *_className = NULL, uint8 *_classVersion = NULL);
		/**
		 * \brief Get whether the node is awake or asleep
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the node is awake
		 */
		bool IsNodeAwake( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node is working or has failed
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return True if the node has failed and is no longer part of the network
		 */
		bool IsNodeFailed( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Get whether the node's query stage as a string
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to query.
		 * \return name of current query stage as a string.
		 */
		string GetNodeQueryStage( uint32 const _homeId, uint8 const _nodeId );

	/*@}*/

	//-----------------------------------------------------------------------------
	// Values
	//-----------------------------------------------------------------------------
	/** \name Values
	 *  Methods for accessing device values.  All the methods require a ValueID, which will have been provided
	 *  in the ValueAdded Notification callback when the the value was first discovered by OpenZWave.
	 */
	/*@{*/
	public:
		/**
		 * \brief Gets the user-friendly label for the value.
		 * \param _id The unique identifier of the value.
		 * \return The value label.
		 * \see ValueID
		 */
		string GetValueLabel( ValueID const& _id );

		/**
		 * \brief Sets the user-friendly label for the value.
		 * \param _id The unique identifier of the value.
		 * \param _value The new value of the label.
		 * \see ValueID
		 */
		void SetValueLabel( ValueID const& _id, string const& _value );

		/**
		 * \brief Gets the units that the value is measured in.
		 * \param _id The unique identifier of the value.
		 * \return The value units.
		 * \see ValueID
		 */
		string GetValueUnits( ValueID const& _id );

		/**
		 * \brief Sets the units that the value is measured in.
		 * \param _id The unique identifier of the value.
		 * \param _value The new value of the units.
		 * \see ValueID
		 */
		void SetValueUnits( ValueID const& _id, string const& _value );

		/**
		 * \brief Gets a help string describing the value's purpose and usage.
		 * \param _id The unique identifier of the value.
		 * \return The value help text.
		 * \see ValueID
		 */
		string GetValueHelp( ValueID const& _id );

		/**
		 * \brief Sets a help string describing the value's purpose and usage.
		 * \param _id The unique identifier of the value.
		 * \param _value The new value of the help text.
		 * \see ValueID
		 */
		void SetValueHelp( ValueID const& _id, string const& _value );

		/**
		 * \brief Gets the minimum that this value may contain.
		 * \param _id The unique identifier of the value.
		 * \return The value minimum.
		 * \see ValueID
		 */
		int32 GetValueMin( ValueID const& _id );

		/**
		 * \brief Gets the maximum that this value may contain.
		 * \param _id The unique identifier of the value.
		 * \return The value maximum.
		 * \see ValueID
		 */
		int32 GetValueMax( ValueID const& _id );

		/**
		 * \brief Test whether the value is read-only.
		 * \param _id The unique identifier of the value.
		 * \return true if the value cannot be changed by the user.
		 * \see ValueID
		 */
		bool IsValueReadOnly( ValueID const& _id );

		/**
		 * \brief Test whether the value is write-only.
		 * \param _id The unique identifier of the value.
		 * \return true if the value can only be written to and not read.
		 * \see ValueID
		 */
		bool IsValueWriteOnly( ValueID const& _id );

		/**
		 * \brief Test whether the value has been set.
		 * \param _id The unique identifier of the value.
		 * \return true if the value has actually been set by a status message from the device, rather than simply being the default.
		 * \see ValueID
		 */
		bool IsValueSet( ValueID const& _id );

		/**
		 * \brief Test whether the value is currently being polled.
		 * \param _id The unique identifier of the value.
		 * \return true if the value is being polled, otherwise false.
		 * \see ValueID
		 */
		bool IsValuePolled( ValueID const& _id );

		/**
		 * \brief Gets a value as a bool.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a bool that will be filled with the value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Bool. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsBool( ValueID const& _id, bool* o_value );

		/**
		 * \brief Gets a value as an 8-bit unsigned integer.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a uint8 that will be filled with the value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Byte. The type can be tested with a call to ValueID::GetType
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsByte( ValueID const& _id, uint8* o_value );

		/**
		 * \brief Gets a value as a float.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a float that will be filled with the value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Decimal. The type can be tested with a call to ValueID::GetType
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsFloat( ValueID const& _id, float* o_value );

		/**
		 * \brief Gets a value as a 32-bit signed integer.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to an int32 that will be filled with the value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Int. The type can be tested with a call to ValueID::GetType
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsInt( ValueID const& _id, int32* o_value );

		/**
		 * \brief Gets a value as a 16-bit signed integer.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to an int16 that will be filled with the value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Short. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsString, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsShort( ValueID const& _id, int16* o_value );

		/**
		 * \brief Gets a value as a string.
		 * Creates a string representation of a value, regardless of type.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a string that will be filled with the value.
		 * \return true if the value was obtained.</returns>
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsString( ValueID const& _id, string* o_value );

		/**
		 * \brief Gets a value as a collection of bytes.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a uint8* that will be filled with the value. This return value will need to be freed as it was dynamically allocated.
		 * \param o_length Pointer to a uint8 that will be fill with the data length.
		 * \return true if the value was obtained. Returns false if the value is not a ValueID::ValueType_Raw. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueListSelection, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueAsRaw( ValueID const& _id, uint8** o_value, uint8* o_length );

		/**
		 * \brief Gets the selected item from a list (as a string).
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a string that will be filled with the selected item.
		 * \return True if the value was obtained.  Returns false if the value is not a ValueID::ValueType_List. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueListSelection( ValueID const& _id, string* o_value );

		/**
		 * \brief Gets the selected item from a list (as an integer).
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to an integer that will be filled with the selected item.
		 * \return True if the value was obtained.  Returns false if the value is not a ValueID::ValueType_List. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListItems, GetValueAsRaw
		 */
		bool GetValueListSelection( ValueID const& _id, int32* o_value );

		/**
		 * \brief Gets the list of items from a list value.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a vector of strings that will be filled with list items. The vector will be cleared before the items are added.
		 * \return true if the list items were obtained.  Returns false if the value is not a ValueID::ValueType_List. The type can be tested with a call to ValueID::GetType.
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsFloat, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueAsRaw
		 */
		bool GetValueListItems( ValueID const& _id, vector<string>* o_value );

		/**
		 * \brief Gets a float value's precision.
		 * \param _id The unique identifier of the value.
		 * \param o_value Pointer to a uint8 that will be filled with the precision value.
		 * \return true if the value was obtained.  Returns false if the value is not a ValueID::ValueType_Decimal. The type can be tested with a call to ValueID::GetType
		 * \see ValueID::GetType, GetValueAsBool, GetValueAsByte, GetValueAsInt, GetValueAsShort, GetValueAsString, GetValueListSelection, GetValueListItems
		 */
		bool GetValueFloatPrecision( ValueID const& _id, uint8* o_value );

		/**
		 * \brief Sets the state of a bool.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the bool value.
		 * \param _value The new value of the bool.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Bool. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, bool const _value );

		/**
		 * \brief Sets the value of a byte.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the byte value.
		 * \param _value The new value of the byte.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Byte. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, uint8 const _value );

		/**
		 * \brief Sets the value of a decimal.
		 * It is usually better to handle decimal values using strings rather than floats, to avoid floating point accuracy issues.
		 * Due to the possibility of a device being asleep, the command is assumed to succeed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the decimal value.
		 * \param _value The new value of the decimal.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Decimal. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, float const _value );

		/**
		 * \brief Sets the value of a 32-bit signed integer.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the integer value.
		 * \param _value The new value of the integer.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Int. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, int32 const _value );

		/**
		 * \brief Sets the value of a 16-bit signed integer.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the integer value.
		 * \param _value The new value of the integer.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Short. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, int16 const _value );

		/**
		 * \brief Sets the value of a collection of bytes.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the raw value.
		 * \param _value The new collection of bytes.
		 * \return true if the value was set.  Returns false if the value is not a ValueID::ValueType_Raw. The type can be tested with a call to ValueID::GetType.
		 */
		bool SetValue( ValueID const& _id, uint8 const* _value, uint8 const _length );

		/**
		 * \brief Sets the value from a string, regardless of type.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the integer value.
		 * \param _value The new value of the string.
		 * \return true if the value was set.  Returns false if the value could not be parsed into the correct type for the value.
		 */
		bool SetValue( ValueID const& _id, string const& _value );

		/**
		 * \brief Sets the selected item in a list.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the value
		 * held by the node is updated directly.  This will be reverted by a future status message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _id The unique identifier of the list value.
		 * \param _selectedItem A string matching the new selected item in the list.
		 * \return true if the value was set.  Returns false if the selection is not in the list, or if the value is not a ValueID::ValueType_List.
		 * The type can be tested with a call to ValueID::GetType
		 */
		bool SetValueListSelection( ValueID const& _id, string const& _selectedItem );

		/**
		 * \brief Refreshes the specified value from the Z-Wave network.
		 * A call to this function causes the library to send a message to the network to retrieve the current value
		 * of the specified ValueID (just like a poll, except only one-time, not recurring).
		 * \param _id The unique identifier of the value to be refreshed.
		 * \return true if the driver and node were found; false otherwise
		 */
		bool RefreshValue( ValueID const& _id);

		/**
		 * \brief Sets a flag indicating whether value changes noted upon a refresh should be verified.  If so, the
		 * library will immediately refresh the value a second time whenever a change is observed.  This helps to filter
		 * out spurious data reported occasionally by some devices.
		 * \param _id The unique identifier of the value whose changes should or should not be verified.
		 * \param _verify if true, verify changes; if false, don't verify changes.
		 */
		void SetChangeVerified( ValueID const& _id, bool _verify );

		/**
		 * \brief Starts an activity in a device.
		 * Since buttons are write-only values that do not report a state, no notification callbacks are sent.
		 * \param _id The unique identifier of the integer value.
		 * \return true if the activity was started.  Returns false if the value is not a ValueID::ValueType_Button. The type can be tested with a call to ValueID::GetType.
		 */
		bool PressButton( ValueID const& _id );

		/**
		 * \brief Stops an activity in a device.
		 * Since buttons are write-only values that do not report a state, no notification callbacks are sent.
		 * \param _id The unique identifier of the integer value.
		 * \return true if the activity was stopped.  Returns false if the value is not a ValueID::ValueType_Button. The type can be tested with a call to ValueID::GetType.
		 */
		bool ReleaseButton( ValueID const& _id );
	/*@}*/

	//-----------------------------------------------------------------------------
	// Climate Control Schedules
	//-----------------------------------------------------------------------------
	/** \name Climate Control Schedules
	 *  Methods for accessing schedule values.  All the methods require a ValueID, which will have been provided
	 *  in the ValueAdded Notification callback when the the value was first discovered by OpenZWave.
	 *  <p>The ValueType_Schedule is a specialized Value used to simplify access to the switch point schedule
	 *  information held by a setback thermostat that supports the Climate Control Schedule command class.
	 *  Each schedule contains up to nine switch points for a single day, consisting of a time in
	 *  hours and minutes (24 hour clock) and a setback in tenths of a degree Celsius.  The setback value can
	 *  range from -128 (-12.8C) to 120 (12.0C).  There are two special setback values - 121 is used to set
	 *  Frost Protection mode, and 122 is used to set Energy Saving mode.
	 *  <p>The switch point methods only modify OpenZWave's copy of the schedule information.  Once all changes
	 *  have been made, they are sent to the device by calling SetSchedule.
	 */
	/*@{*/

		/**
		 * \brief Get the number of switch points defined in a schedule.
		 * \param _id The unique identifier of the schedule value.
		 * \return the number of switch points defined in this schedule.  Returns zero if the value is not a ValueID::ValueType_Schedule. The type can be tested with a call to ValueID::GetType.
		 */
		uint8 GetNumSwitchPoints( ValueID const& _id );

		/**
		 * \brief Set a switch point in the schedule.
		 * Inserts a new switch point into the schedule, unless a switch point already exists at the specified
		 * time in which case that switch point is updated with the new setback value instead.
		 * A maximum of nine switch points can be set in the schedule.
		 * \param _id The unique identifier of the schedule value.
		 * \param _hours The hours part of the time when the switch point will trigger.  The time is set using
		 * the 24-hour clock, so this value must be between 0 and 23.
		 * \param _minutes The minutes part of the time when the switch point will trigger.  This value must be
		 * between 0 and 59.
		 * \param _setback The setback in tenths of a degree Celsius.  The setback value can range from -128 (-12.8C)
		 * to 120 (12.0C).  There are two special setback values - 121 is used to set Frost Protection mode, and
		 * 122 is used to set Energy Saving mode.
		 * \return true if successful.  Returns false if the value is not a ValueID::ValueType_Schedule. The type can be tested with a call to ValueID::GetType.
		 * \see GetNumSwitchPoints, RemoveSwitchPoint, ClearSwitchPoints
		 */
		bool SetSwitchPoint( ValueID const& _id, uint8 const _hours, uint8 const _minutes, int8 const _setback );

		/**
		 * \brief Remove a switch point from the schedule.
		 * Removes the switch point at the specified time from the schedule.
		 * \param _id The unique identifier of the schedule value.
		 * \param _hours The hours part of the time when the switch point will trigger.  The time is set using
		 * the 24-hour clock, so this value must be between 0 and 23.
		 * \param _minutes The minutes part of the time when the switch point will trigger.  This value must be
		 * between 0 and 59.
		 * \return true if successful.  Returns false if the value is not a ValueID::ValueType_Schedule or if there
		 * is not switch point with the specified time values. The type can be tested with a call to ValueID::GetType.
		 * \see GetNumSwitchPoints, SetSwitchPoint, ClearSwitchPoints
		 */
		bool RemoveSwitchPoint( ValueID const& _id, uint8 const _hours, uint8 const _minutes );

		/**
		 * \brief Clears all switch points from the schedule.
		 * \param _id The unique identifier of the schedule value.
		 * \see GetNumSwitchPoints, SetSwitchPoint, RemoveSwitchPoint
		 */
		void ClearSwitchPoints( ValueID const& _id );

		/**
		 * \brief Gets switch point data from the schedule.
		 * Retrieves the time and setback values from a switch point in the schedule.
		 * \param _id The unique identifier of the schedule value.
		 * \param _idx The index of the switch point, between zero and one less than the value
		 * returned by GetNumSwitchPoints.
		 * \param o_hours a pointer to a uint8 that will be filled with the hours part of the switch point data.
		 * \param o_minutes a pointer to a uint8 that will be filled with the minutes part of the switch point data.
		 * \param o_setback a pointer to an int8 that will be filled with the setback value.  This can range from -128
		 * (-12.8C)to 120 (12.0C).  There are two special setback values - 121 is used to set Frost Protection mode, and
		 * 122 is used to set Energy Saving mode.
		 * \return true if successful.  Returns false if the value is not a ValueID::ValueType_Schedule. The type can be tested with a call to ValueID::GetType.
		 * \see GetNumSwitchPoints
		 */
		bool GetSwitchPoint( ValueID const& _id, uint8 const _idx, uint8* o_hours, uint8* o_minutes, int8* o_setback );

	/*@}*/

	//-----------------------------------------------------------------------------
	// SwitchAll
	//-----------------------------------------------------------------------------
	/** \name SwitchAll
	 *  Methods for switching all devices on or off together.  The devices must support
	 *	the SwitchAll command class.  The command is first broadcast to all nodes, and
	 *	then followed up with individual commands to each node (because broadcasts are
	 *	not routed, the message might not otherwise reach all the nodes).
	 */
	/*@{*/

		/**
		 * \brief Switch all devices on.
		 * All devices that support the SwitchAll command class will be turned on.
		 */
		void SwitchAllOn( uint32 const _homeId );

		/**
		 * \brief Switch all devices off.
		 * All devices that support the SwitchAll command class will be turned off.
		 */
		void SwitchAllOff( uint32 const _homeId );

	/*@}*/

	//-----------------------------------------------------------------------------
	// Configuration Parameters
	//-----------------------------------------------------------------------------
	/** \name Configuration Parameters
	 *  Methods for accessing device configuration parameters.
	 *  Configuration parameters are values that are managed by the Configuration command class.
	 *	The values are device-specific and are not reported by the devices. Information on parameters
	 *  is provided only in the device user manual.
	 *  <p>An ongoing task for the OpenZWave project is to create XML files describing the available
	 *  parameters for every Z-Wave.  See the config folder in the project source code for examples.
	 */
	/*@{*/
	public:
		/**
		 * \brief Set the value of a configurable parameter in a device.
		 * Some devices have various parameters that can be configured to control the device behaviour.
		 * These are not reported by the device over the Z-Wave network, but can usually be found in
		 * the device's user manual.
		 * This method returns immediately, without waiting for confirmation from the device that the
		 * change has been made.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to configure.
		 * \param _param The index of the parameter.
		 * \param _value The value to which the parameter should be set.
		 * \param _size Is an optional number of bytes to be sent for the paramter _value. Defaults to 2.
		 * \return true if the a message setting the value was sent to the device.
		 * \see RequestConfigParam
		 */
		bool SetConfigParam( uint32 const _homeId, uint8 const _nodeId, uint8 const _param, int32 _value, uint8 const _size = 2 );

		/**
		 * \brief Request the value of a configurable parameter from a device.
		 * Some devices have various parameters that can be configured to control the device behaviour.
		 * These are not reported by the device over the Z-Wave network, but can usually be found in
		 * the device's user manual.
		 * This method requests the value of a parameter from the device, and then returns immediately,
		 * without waiting for a response.  If the parameter index is valid for this device, and the
		 * device is awake, the value will eventually be reported via a ValueChanged notification callback.
		 * The ValueID reported in the callback will have an index set the same as _param and a command class
		 * set to the same value as returned by a call to Configuration::StaticGetCommandClassId.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to configure.
		 * \param _param The index of the parameter.
		 * \see SetConfigParam, ValueID, Notification
		 */
		void RequestConfigParam( uint32 const _homeId, uint8 const _nodeId, uint8 const _param );

		/**
		 * \brief Request the values of all known configurable parameters from a device.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node to configure.
		 * \see SetConfigParam, ValueID, Notification
		 */
		void RequestAllConfigParams( uint32 const _homeId, uint8 const _nodeId );
	/*@}*/

	//-----------------------------------------------------------------------------
	// Groups (wrappers for the Node methods)
	//-----------------------------------------------------------------------------
	/** \name Groups
	 *  Methods for accessing device association groups.
	 */
	/*@{*/
	public:
		/**
		 * \brief Gets the number of association groups reported by this node
		 * In Z-Wave, groups are numbered starting from one.  For example, if a call to GetNumGroups returns 4, the _groupIdx
		 * value to use in calls to GetAssociations, AddAssociation and RemoveAssociation will be a number between 1 and 4.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose groups we are interested in.
		 * \return The number of groups.
		 * \see GetAssociations, GetMaxAssociations, AddAssociation, RemoveAssociation
		 */
		uint8 GetNumGroups( uint32 const _homeId, uint8 const _nodeId );

		/**
		 * \brief Gets the associations for a group.
		 * Makes a copy of the list of associated nodes in the group, and returns it in an array of uint8's.
		 * The caller is responsible for freeing the array memory with a call to delete [].
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose associations we are interested in.
		 * \param _groupIdx One-based index of the group (because Z-Wave product manuals use one-based group numbering).
		 * \param o_associations If the number of associations returned is greater than zero, o_associations will be set to point to an array containing the IDs of the associated nodes.
		 * \return The number of nodes in the associations array.  If zero, the array will point to NULL, and does not need to be deleted.
		 * \see GetNumGroups, AddAssociation, RemoveAssociation, GetMaxAssociations
		 */
		uint32 GetAssociations( uint32 const _homeId, uint8 const _nodeId, uint8 const _groupIdx, uint8** o_associations );

		/**
		 * \brief Gets the maximum number of associations for a group.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose associations we are interested in.
		 * \param _groupIdx one-based index of the group (because Z-Wave product manuals use one-based group numbering).
		 * \return The maximum number of nodes that can be associated into the group.
		 * \see GetNumGroups, AddAssociation, RemoveAssociation, GetAssociations
		 */
		uint8 GetMaxAssociations( uint32 const _homeId, uint8 const _nodeId, uint8 const _groupIdx );

		/**
		 * \brief Returns a label for the particular group of a node.
		 * This label is populated by the device specific configuration files.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose associations are to be changed.
		 * \param _groupIdx One-based index of the group (because Z-Wave product manuals use one-based group numbering).
		 * \see GetNumGroups, GetAssociations, GetMaxAssociations, AddAssociation
		 */
		string GetGroupLabel( uint32 const _homeId, uint8 const _nodeId, uint8 const _groupIdx );

		/**
		 * \brief Adds a node to an association group.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the association data
		 * held in this class is updated directly.  This will be reverted by a future Association message from the device
		 * if the Z-Wave message actually failed to get through.  Notification callbacks will be sent in both cases.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose associations are to be changed.
		 * \param _groupIdx One-based index of the group (because Z-Wave product manuals use one-based group numbering).
		 * \param _targetNodeId Identifier for the node that will be added to the association group.
		 * \see GetNumGroups, GetAssociations, GetMaxAssociations, RemoveAssociation
		 */
		void AddAssociation( uint32 const _homeId, uint8 const _nodeId, uint8 const _groupIdx, uint8 const _targetNodeId );

		/**
		 * \brief Removes a node from an association group.
		 * Due to the possibility of a device being asleep, the command is assumed to suceed, and the association data
		 * held in this class is updated directly.  This will be reverted by a future Association message from the device
		 * if the Z-Wave message actually failed to get through.   Notification callbacks will be sent in both cases.
		 * \param _homeId The Home ID of the Z-Wave controller that manages the node.
		 * \param _nodeId The ID of the node whose associations are to be changed.
		 * \param _groupIdx One-based index of the group (because Z-Wave product manuals use one-based group numbering).
		 * \param _targetNodeId Identifier for the node that will be removed from the association group.
		 * \see GetNumGroups, GetAssociations, GetMaxAssociations, AddAssociation
		 */
		void RemoveAssociation( uint32 const _homeId, uint8 const _nodeId, uint8 const _groupIdx, uint8 const _targetNodeId );

	/*@}*/

	//-----------------------------------------------------------------------------
	//	Notifications
	//-----------------------------------------------------------------------------
	/** \name Notifications
	 *  For notification of changes to the Z-Wave network or device values and associations.
	 */
	/*@{*/
	public:
		/**
		 * \brief Add a notification watcher.
		 * In OpenZWave, all feedback from the Z-Wave network is sent to the application via callbacks.
		 * This method allows the application to add a notification callback handler, known as a "watcher" to OpenZWave.
		 * An application needs only add a single watcher - all notifications will be reported to it.
		 * \param _watcher pointer to a function that will be called by the notification system.
		 * \param _context pointer to user defined data that will be passed to the watcher function with each notification.
		 * \return true if the watcher was successfully added.
		 * \see RemoveWatcher, Notification
		 */
		bool AddWatcher( pfnOnNotification_t _watcher, void* _context );

		/**
		 * \brief Remove a notification watcher.
		 * \param _watcher pointer to a function that must match that passed to a previous call to AddWatcher
		 * \param _context pointer to user defined data that must match the one passed in that same previous call to AddWatcher.
		 * \return true if the watcher was successfully removed.
		 * \see AddWatcher, Notification
		 */
		bool RemoveWatcher( pfnOnNotification_t _watcher, void* _context );
	/*@}*/

	private:
		void NotifyWatchers( Notification* _notification );					// Passes the notifications to all the registered watcher callbacks in turn.

		struct Watcher
		{
			pfnOnNotification_t	m_callback;
			void*				m_context;

			Watcher
			(
				pfnOnNotification_t _callback,
				void* _context
			):
				m_callback( _callback ),
				m_context( _context )
			{
			}
		};

OPENZWAVE_EXPORT_WARNINGS_OFF
		list<Watcher*>		m_watchers;										// List of all the registered watchers.
OPENZWAVE_EXPORT_WARNINGS_ON
		Mutex*				m_notificationMutex;

	//-----------------------------------------------------------------------------
	// Controller commands
	//-----------------------------------------------------------------------------
	/** \name Controller Commands
	 *  Commands for Z-Wave network management using the PC Controller.
	 */
	/*@{*/
	public:
		/**
		 * \brief Hard Reset a PC Z-Wave Controller.
		 * Resets a controller and erases its network configuration settings.  The controller becomes a primary controller ready to add devices to a new network.
		 * \param _homeId The Home ID of the Z-Wave controller to be reset.
		 * \see SoftReset
		 */
		void ResetController( uint32 const _homeId );

		/**
		 * \brief Soft Reset a PC Z-Wave Controller.
		 * Resets a controller without erasing its network configuration settings.
		 * \param _homeId The Home ID of the Z-Wave controller to be reset.
		 * \see SoftReset
		 */
		void SoftReset( uint32 const _homeId );

		/**
		 * \brief Start a controller command process.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \param _command The command to be sent to the controller.
		 * \param _callback pointer to a function that will be called at various stages during the command process
		 * to notify the user of progress or to request actions on the user's part.  Defaults to NULL.
		 * \param _context pointer to user defined data that will be passed into to the callback function.  Defaults to NULL.
		 * \param _highPower used only with the AddDevice, AddController, RemoveDevice and RemoveController commands.
		 * Usually when adding or removing devices, the controller operates at low power so that the controller must
		 * be physically close to the device for security reasons.  If _highPower is true, the controller will
		 * operate at normal power levels instead.  Defaults to false.
		 * \param _nodeId is the node ID used by the command if necessary.
		 * \param _arg is an optional argument, usually another node ID, that is used by the command.
		 * \return true if the command was accepted and has queued to be executed.
		 * \see CancelControllerCommand, HasNodeFailed, RemoveFailedNode, Driver::ControllerCommand, Driver::pfnControllerCallback_t,
		 * <p> Commands
		 * - Driver::ControllerCommand_AddDevice - Add a new device or controller to the Z-Wave network.
		 * - Driver::ControllerCommand_CreateNewPrimary - Create a new primary controller when old primary fails. Requires SUC.
		 * - Driver::ControllerCommand_ReceiveConfiguration - Receive network configuration information from primary controller. Requires secondary.
		 * - Driver::ControllerCommand_RemoveDevice - Remove a device or controller from the Z-Wave network.
 		 * - Driver::ControllerCommand_RemoveFailedNode - Remove a node from the network. The node must not be responding
		 * and be on the controller's failed node list.
		 * - Driver::ControllerCommand_HasNodeFailed - Check whether a node is in the controller's failed nodes list.
		 * - Driver::ControllerCommand_ReplaceFailedNode - Replace a failed device with another. If the node is not in
		 * the controller's failed nodes list, or the node responds, this command will fail.
		 * - Driver:: ControllerCommand_TransferPrimaryRole - Add a new controller to the network and
		 * make it the primary.  The existing primary will become a secondary controller.
		 * - Driver::ControllerCommand_RequestNetworkUpdate - Update the controller with network information from the SUC/SIS.
		 * - Driver::ControllerCommand_RequestNodeNeighborUpdate - Get a node to rebuild its neighbour list.  This method also does RequestNodeNeighbors afterwards.
		 * - Driver::ControllerCommand_AssignReturnRoute - Assign a network return route to a device.
		 * - Driver::ControllerCommand_DeleteAllReturnRoutes - Delete all network return routes from a device.
		 * - Driver::ControllerCommand_SendNodeInformation - Send a node information frame.
		 * - Driver::ControllerCommand_ReplicationSend - Send information from primary to secondary
		 * - Driver::ControllerCommand_CreateButton - Create a handheld button id.
		 * - Driver::ControllerCommand_DeleteButton - Delete a handheld button id.
		 * <p> Callbacks
		 * - Driver::ControllerState_Starting, the controller command has begun
		 * - Driver::ControllerState_Waiting, the controller is waiting for a user action.  A notice should be displayed
		 * to the user at this point, telling them what to do next.
		 * For the add, remove, replace and transfer primary role commands, the user needs to be told to press the
		 * inclusion button on the device that  is going to be added or removed.  For ControllerCommand_ReceiveConfiguration,
		 * they must set their other controller to send its data, and for ControllerCommand_CreateNewPrimary, set the other
		 * controller to learn new data.
		 * - Driver::ControllerState_InProgress - the controller is in the process of adding or removing the chosen node.  It is now too late to cancel the command.
		 * - Driver::ControllerState_Complete - the controller has finished adding or removing the node, and the command is complete.
		 * - Driver::ControllerState_Failed - will be sent if the command fails for any reason.
		 */
		bool BeginControllerCommand( uint32 const _homeId, Driver::ControllerCommand _command, Driver::pfnControllerCallback_t _callback = NULL, void* _context = NULL, bool _highPower = false, uint8 _nodeId = 0xff, uint8 _arg = 0 );

		/**
		 * \brief Cancels any in-progress command running on a controller.
		 * \param _homeId The Home ID of the Z-Wave controller.
		 * \return true if a command was running and was cancelled.
		 * \see BeginControllerCommand
		 */
		bool CancelControllerCommand( uint32 const _homeId );
	/*@}*/

	//-----------------------------------------------------------------------------
	// Network commands
	//-----------------------------------------------------------------------------
	/** \name Network Commands
	 *  Commands for Z-Wave network for testing, routing and other internal
	 *  operations.
	 */
	/*@{*/
	public:
		/**
		 * \brief Test network node.
		 * Sends a series of messages to a network node for testing network reliability.
		 * \param _homeId The Home ID of the Z-Wave controller to be reset.
		 * \param _count This is the number of test messages to send.
		 * \see TestNetwork
		 */
		void TestNetworkNode( uint32 const _homeId, uint8 const _nodeId, uint32 const _count );

		/**
		 * \brief Test network.
		 * Sends a series of messages to every node on the network for testing network reliability.
		 * \param _homeId The Home ID of the Z-Wave controller to be reset.
		 * \param _count This is the number of test messages to send.
		 * \see TestNetwork
		 */
		void TestNetwork( uint32 const _homeId, uint32 const _count );

 		/**
		 * \brief Heal network node by requesting the node rediscover their neighbors.
		 * Sends a ControllerCommand_RequestNodeNeighborUpdate to the node.
		 * \param _homeId The Home ID of the Z-Wave network to be healed.
		 * \param _nodeId The node to heal.
		 * \param _doRR Whether to perform return routes initialization.
		 */
		void HealNetworkNode( uint32 const _homeId, uint8 const _nodeId, bool _doRR );

 		/**
		 * \brief Heal network by requesting node's rediscover their neighbors.
		 * Sends a ControllerCommand_RequestNodeNeighborUpdate to every node.
		 * Can take a while on larger networks.
		 * \param _homeId The Home ID of the Z-Wave network to be healed.
		 * \param _doRR Whether to perform return routes initialization.
		 */
		void HealNetwork( uint32 const _homeId, bool _doRR );

	/*@}*/

	//-----------------------------------------------------------------------------
	// Scene commands
	//-----------------------------------------------------------------------------
	/** \name Scene Commands
	 *  Commands for Z-Wave scene interface.
	 */
	/*@{*/
	public:
		/**
		 * \brief Gets the number of scenes that have been defined.
		 * \return The number of scenes.
		 * \see GetAllScenes, RemoveAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		uint8 GetNumScenes( );

		/**
		 * \brief Gets a list of all the SceneIds.
		 * \param _sceneIds is a pointer to an array of integers.
		 * \return The number of scenes. If zero, _sceneIds will be NULL and doesn't need to be freed.
		 * \see GetNumScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		uint8 GetAllScenes( uint8** _sceneIds );

		/**
		 * \brief Remove all the SceneIds.
		 * \param _homeId The Home ID of the Z-Wave controller. 0 for all devices from all scenes.
		 * \see GetAllScenes, GetNumScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		void RemoveAllScenes( uint32 const _homeId );

		/**
		 * \brief Create a new Scene passing in Scene ID
		 * \return uint8 Scene ID used to reference the scene. 0 is failure result.
		 * \see GetNumScenes, GetAllScenes, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene

		 */
		uint8 CreateScene();

		/**
		 * \brief Remove an existing Scene.
		 * \param _sceneId is an integer representing the unique Scene ID to be removed.
		 * \return true if scene was removed.
		 * \see GetNumScenes, GetAllScenes, CreateScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool RemoveScene( uint8 const _sceneId );

		/**
		 * \brief Add a bool Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the bool value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, bool const _value );

		/**
		 * \brief Add a byte Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the byte value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, uint8 const _value );

		/**
		 * \brief Add a decimal Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the float value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, float const _value );

		/**
		 * \brief Add a 32-bit signed integer Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the int32 value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, int32 const _value );

		/**
		 * \brief Add a 16-bit signed integer Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the int16 value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, int16 const _value );

		/**
		 * \brief Add a string Value ID to an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the string value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValue( uint8 const _sceneId, ValueID const& _valueId, string const& _value );

		/**
		 * \brief Add the selected item list Value ID to an existing scene (as a string).
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the string value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValueListSelection( uint8 const _sceneId, ValueID const& _valueId, string const& _value );

		/**
		 * \brief Add the selected item list Value ID to an existing scene (as a integer).
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the integer value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool AddSceneValueListSelection( uint8 const _sceneId, ValueID const& _valueId, int32 const _value );

		/**
		 * \brief Remove the Value ID from an existing scene.
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be removed.
		 * \return true if Value ID was removed.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool RemoveSceneValue( uint8 const _sceneId, ValueID const& _valueId );

		/**
		 * \brief Retrieves the scene's list of values.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param o_value Pointer to an array of ValueIDs if return is non-zero.
		 * \return The number of nodes in the o_value array. If zero, the array will point to NULL and does not need to be deleted.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		int SceneGetValues( uint8 const _sceneId, vector<ValueID>* o_value );

		/**
		 * \brief Retrieves a scene's value as a bool.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a bool that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsBool( uint8 const _sceneId, ValueID const& _valueId, bool* o_value );

		/**
		 * \brief Retrieves a scene's value as an 8-bit unsigned integer.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a uint8 that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsByte( uint8 const _sceneId, ValueID const& _valueId, uint8* o_value );

		/**
		 * \brief Retrieves a scene's value as a float.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a float that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsFloat( uint8 const _sceneId, ValueID const& _valueId, float* o_value );

		/**
		 * \brief Retrieves a scene's value as a 32-bit signed integer.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a int32 that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsInt( uint8 const _sceneId, ValueID const& _valueId, int32* o_value );

		/**
		 * \brief Retrieves a scene's value as a 16-bit signed integer.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a int16 that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsShort( uint8 const _sceneId, ValueID const& _valueId, int16* o_value );

		/**
		 * \brief Retrieves a scene's value as a string.
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a string that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueAsString( uint8 const _sceneId, ValueID const& _valueId, string* o_value );

		/**
		 * \brief Retrieves a scene's value as a list (as a string).
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a string that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueListSelection( uint8 const _sceneId, ValueID const& _valueId, string* o_value );

		/**
		 * \brief Retrieves a scene's value as a list (as a integer).
		 * \param _sceneId The Scene ID of the scene to retrieve the value from.
		 * \param _valueId The Value ID of the value to retrieve.
		 * \param o_value Pointer to a integer that will be filled with the returned value.
		 * \return true if the value was obtained.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SceneGetValueListSelection( uint8 const _sceneId, ValueID const& _valueId, int32* o_value );

		/**
		 * \brief Set a bool Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the bool value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, bool const _value );

		/**
		 * \brief Set a byte Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the byte value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, uint8 const _value );

		/**
		 * \brief Set a decimal Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the float value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, float const _value );

		/**
		 * \brief Set a 32-bit signed integer Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the int32 value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, int32 const _value );

		/**
		 * \brief Set a 16-bit integer Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the int16 value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, int16 const _value );

		/**
		 * \brief Set a string Value ID to an existing scene's ValueID
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the string value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValue( uint8 const _sceneId, ValueID const& _valueId, string const& _value );

		/**
		 * \brief Set the list selected item Value ID to an existing scene's ValueID (as a string).
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the string value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValueListSelection( uint8 const _sceneId, ValueID const& _valueId, string const& _value );

		/**
		 * \brief Set the list selected item Value ID to an existing scene's ValueID (as a integer).
		 * \param _sceneId is an integer representing the unique Scene ID.
		 * \param _valueId is the Value ID to be added.
		 * \param _value is the integer value to be saved.
		 * \return true if Value ID was added.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists, ActivateScene
		 */
		bool SetSceneValueListSelection( uint8 const _sceneId, ValueID const& _valueId, int32 const _value );

		/**
		 * \brief Returns a label for the particular scene.
		 * \param _sceneId The Scene ID
		 * \return The label string.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, SetSceneLabel, SceneExists, ActivateScene
		 */
		string GetSceneLabel( uint8 const _sceneId );

		/**
		 * \brief Sets a label for the particular scene.
		 * \param _sceneId The Scene ID
		 * \param _value The new value of the label.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SceneExists, ActivateScene
		 */
		void SetSceneLabel( uint8 const _sceneId, string const& _value );

		/**
		 * \brief Check if a Scene ID is defined.
		 * \param _sceneId The Scene ID.
		 * \return true if Scene ID exists.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, ActivateScene
		 */
		bool SceneExists( uint8 const _sceneId );

		/**
		 * \brief Activate given scene to perform all its actions.
		 * \param _sceneId The Scene ID.
		 * \return true if it is successful.
		 * \see GetNumScenes, GetAllScenes, CreateScene, RemoveScene, AddSceneValue, RemoveSceneValue, SceneGetValues, SceneGetValueAsBool, SceneGetValueAsByte, SceneGetValueAsFloat, SceneGetValueAsInt, SceneGetValueAsShort, SceneGetValueAsString, SetSceneValue, GetSceneLabel, SetSceneLabel, SceneExists
		 */
		bool ActivateScene( uint8 const _sceneId );

	/*@}*/

	//-----------------------------------------------------------------------------
	// Statistics interface
	//-----------------------------------------------------------------------------
	/** \name Statistics retrieval interface
	 *  Commands for Z-Wave statistics interface.
	 */
	/*@{*/
	public:
		/**
		 * \brief Retrieve statistics from driver
		 * \param _homeId The Home ID of the driver to obtain counters
		 * \param _data Pointer to structure DriverData to return values
		 */
		void GetDriverStatistics( uint32 const _homeId, Driver::DriverData* _data );

		/**
		 * \brief Retrieve statistics per node
		 * \param _homeId The Home ID of the driver for the node
		 * \param _nodeId The node number
		 * \param _data Pointer to structure NodeData to return values
		 */
		void GetNodeStatistics( uint32 const _homeId, uint8 const _nodeId, Node::NodeData* _data );

	};
	/*@}*/
} // namespace OpenZWave

#endif // _Manager_H