Notification.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  Notification.h
//
//  Contains details of a Z-Wave event reported to the user
//
//  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 _Notification_H
#define _Notification_H

#include <iostream>

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

namespace OpenZWave
{
    namespace Internal
    {
        namespace CC
        {
            class ApplicationStatus;
            class Basic;
            class ManufacturerSpecific;
            class NodeNaming;
            class SceneActivation;
            class WakeUp;
        }
        namespace VC
        {
            class Value;
            class ValueStore;
        }
        class ManufacturerSpecificDB;
    }
    class OPENZWAVE_EXPORT Notification
    {
            friend class Manager;
            friend class Driver;
            friend class Node;
            friend class Group;
            friend class Internal::VC::Value;
            friend class Internal::VC::ValueStore;
            friend class Internal::CC::Basic;
            friend class Internal::CC::ManufacturerSpecific;
            friend class Internal::CC::NodeNaming;
            friend class Internal::CC::SceneActivation;
            friend class Internal::CC::WakeUp;
            friend class Internal::CC::ApplicationStatus;
            friend class Internal::ManufacturerSpecificDB;
            /* allow us to Stream a Notification */
            //friend std::ostream &operator<<(std::ostream &os, const Notification &dt);

        public:
            enum NotificationType
            {
                Type_ValueAdded = 0, 
                Type_ValueRemoved, 
                Type_ValueChanged, 
                Type_ValueRefreshed, 
                Type_Group, 
                Type_NodeNew, 
                Type_NodeAdded, 
                Type_NodeRemoved, 
                Type_NodeProtocolInfo, 
                Type_NodeNaming, 
                Type_NodeEvent, 
                Type_PollingDisabled, 
                Type_PollingEnabled, 
                Type_SceneEvent, 
                Type_CreateButton, 
                Type_DeleteButton, 
                Type_ButtonOn, 
                Type_ButtonOff, 
                Type_DriverReady, 
                Type_DriverFailed, 
                Type_DriverReset, 
                Type_EssentialNodeQueriesComplete, 
                Type_NodeQueriesComplete, 
                Type_AwakeNodesQueried, 
                Type_AllNodesQueriedSomeDead, 
                Type_AllNodesQueried, 
                Type_Notification, 
                Type_DriverRemoved, 
                Type_ControllerCommand, 
                Type_NodeReset, 
                Type_UserAlerts, 
                Type_ManufacturerSpecificDBReady 
            };

            enum NotificationCode
            {
                Code_MsgComplete = 0, 
                Code_Timeout, 
                Code_NoOperation, 
                Code_Awake, 
                Code_Sleep, 
                Code_Dead, 
                Code_Alive 
            };

            enum UserAlertNotification
            {
                Alert_None, 
                Alert_ConfigOutOfDate, 
                Alert_MFSOutOfDate, 
                Alert_ConfigFileDownloadFailed, 
                Alert_DNSError, 
                Alert_NodeReloadRequired, 
                Alert_UnsupportedController, 
                Alert_ApplicationStatus_Retry, 
                Alert_ApplicationStatus_Queued, 
                Alert_ApplicationStatus_Rejected, 
            };

            NotificationType GetType() const
            {
                return m_type;
            }

            uint32 GetHomeId() const
            {
                return m_valueId.GetHomeId();
            }

            uint8 GetNodeId() const
            {
                return m_valueId.GetNodeId();
            }

            ValueID const& GetValueID() const
            {
                return m_valueId;
            }

            uint8 GetGroupIdx() const
            {
                assert(Type_Group == m_type);
                return m_byte;
            }

            uint8 GetEvent() const
            {
                assert((Type_NodeEvent == m_type) || (Type_ControllerCommand == m_type));
                return m_event;
            }

            uint8 GetButtonId() const
            {
                assert(Type_CreateButton == m_type || Type_DeleteButton == m_type || Type_ButtonOn == m_type || Type_ButtonOff == m_type);
                return m_byte;
            }

            DEPRECATED uint8 GetSceneId() const
            {
                assert(Type_SceneEvent == m_type);
                return m_byte;
            }

            uint8 GetNotification() const
            {
                assert((Type_Notification == m_type) || (Type_ControllerCommand == m_type));
                return m_byte;
            }

            uint8 GetCommand() const
            {
                assert(Type_ControllerCommand == m_type);
                return m_command;
            }

            uint8 GetByte() const
            {
                return m_byte;
            }

            uint8 GetRetry() const
            {
                assert((Type_UserAlerts == m_type) && (Alert_ApplicationStatus_Retry == m_useralerttype));
                return m_byte;
            }

            string GetAsString() const;

            UserAlertNotification GetUserAlertType() const
            {
                return m_useralerttype;
            }
            ;

            string GetComPort() const
            {
                return m_comport;
            }
            ;

        private:
            Notification(NotificationType _type) :
                    m_type(_type), m_byte(0), m_event(0), m_command(0), m_useralerttype(Alert_None)
            {
            }
            ~Notification()
            {
            }

            void SetHomeAndNodeIds(uint32 const _homeId, uint8 const _nodeId)
            {
                m_valueId = ValueID(_homeId, _nodeId);
            }
            void SetHomeNodeIdAndInstance(uint32 const _homeId, uint8 const _nodeId, uint32 const _instance)
            {
                m_valueId = ValueID(_homeId, _nodeId, _instance);
            }
            void SetValueId(ValueID const& _valueId)
            {
                m_valueId = _valueId;
            }
            void SetGroupIdx(uint8 const _groupIdx)
            {
                assert(Type_Group == m_type);
                m_byte = _groupIdx;
            }
            void SetEvent(uint8 const _event)
            {
                assert(Type_NodeEvent == m_type || Type_ControllerCommand == m_type);
                m_event = _event;
            }
            void SetSceneId(uint8 const _sceneId)
            {
                assert(Type_SceneEvent == m_type);
                m_byte = _sceneId;
            }
            void SetButtonId(uint8 const _buttonId)
            {
                assert(Type_CreateButton == m_type || Type_DeleteButton == m_type || Type_ButtonOn == m_type || Type_ButtonOff == m_type);
                m_byte = _buttonId;
            }
            void SetNotification(uint8 const _noteId)
            {
                assert((Type_Notification == m_type) || (Type_ControllerCommand == m_type));
                m_byte = _noteId;
            }
            void SetUserAlertNotification(UserAlertNotification const alerttype)
            {
                assert(Type_UserAlerts == m_type);
                m_useralerttype = alerttype;
            }
            void SetCommand(uint8 const _command)
            {
                assert(Type_ControllerCommand == m_type);
                m_command = _command;
            }
            void SetComPort(string comport)
            {
                assert(Type_DriverFailed == m_type);
                m_comport = comport;
            }
            void SetRetry(uint8 const timeout)
            {
                assert(Type_UserAlerts == m_type);
                m_byte = timeout;
            }

            NotificationType m_type;
            ValueID m_valueId;
            uint8 m_byte;
            uint8 m_event;
            uint8 m_command;
            UserAlertNotification m_useralerttype;
            string m_comport;
    };

} //namespace OpenZWave

std::ostream& operator<<(std::ostream &os, const OpenZWave::Notification &dt);
std::ostream& operator<<(std::ostream &os, const OpenZWave::Notification *dt);

#endif //_Notification_H