ValueID.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  ValueID.h
//
//  Unique identifier for a Value object
//
//  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 _ValueID_H
#define _ValueID_H
 
#include <string>
#include <assert.h>
#include "Defs.h"
 
class TiXmlElement;
 
namespace OpenZWave
{
    class OPENZWAVE_EXPORT ValueID
    {
        friend class Manager;
        friend class Driver;
        friend class Node;
        friend class Group;
        friend class CommandClass;
        friend class Value;
        friend class ValueStore;
        friend class Notification;
        friend class ManufacturerSpecific;
 
    public:
        enum ValueGenre
        {
            ValueGenre_Basic = 0,       
            ValueGenre_User,            
            ValueGenre_Config,          
            ValueGenre_System,          
            ValueGenre_Count            
        };

        enum ValueType
        {
            ValueType_Bool = 0,         
            ValueType_Byte,             
            ValueType_Decimal,          
            ValueType_Int,              
            ValueType_List,             
            ValueType_Schedule,         
            ValueType_Short,            
            ValueType_String,           
            ValueType_Button,           
            ValueType_Raw,              
            ValueType_Max = ValueType_Raw       
        };

        uint32 GetHomeId()const{ return m_homeId; }

        uint8 GetNodeId()const{ return( (uint8)( (m_id & 0xff000000) >> 24 ) ); }

        ValueGenre GetGenre()const{ return( (ValueGenre)( (m_id & 0x00c00000) >> 22 ) ); }

        uint8 GetCommandClassId()const{ return( (uint8)( (m_id & 0x003fc000) >> 14 ) ); }

        uint8 GetInstance()const{ return( (uint8)( ( (m_id1 & 0xff000000) ) >> 24 ) ); }

        uint8 GetIndex()const{ return( (uint8)( (m_id & 0x00000ff0) >> 4 ) ); }

        ValueType GetType()const{ return( (ValueType)( m_id & 0x0000000f ) ); }

        uint64 GetId()const{ return (uint64) ( ( (uint64)m_id1 << 32 ) | m_id );}
 
        // Comparison Operators
        bool operator ==    ( ValueID const& _other )const{ return( ( m_homeId == _other.m_homeId ) && ( m_id == _other.m_id ) && ( m_id1 == _other.m_id1 ) ); }
        bool operator !=    ( ValueID const& _other )const{ return( ( m_homeId != _other.m_homeId ) || ( m_id != _other.m_id ) || ( m_id1 != _other.m_id1 ) ); }
        bool operator <     ( ValueID const& _other )const
        {
            if( m_homeId == _other.m_homeId )
            {
                if( m_id == _other.m_id )
                {
                    return( m_id1 < _other.m_id1 );
                }
                else
                {
                    return( m_id < _other.m_id );
                }
            }
            else
            {
                return( m_homeId < _other.m_homeId );
            }
        }
        bool operator >     ( ValueID const& _other )const
        {
            if( m_homeId == _other.m_homeId )
            {
                if( m_id == _other.m_id )
                {
                    return( m_id1 > _other.m_id1 );
                }
                else
                {
                    return( m_id > _other.m_id );
                }
            }
            else
            {
                return( m_homeId > _other.m_homeId );
            }
        }

        ValueID
        ( 
            uint32 const _homeId,
            uint8 const _nodeId,
            ValueGenre const _genre,
            uint8 const _commandClassId,
            uint8 const _instance,
            uint8 const _valueIndex,
            ValueType const _type
        ):
            m_homeId( _homeId )
        {
            m_id = (((uint32)_nodeId)<<24)
                 | (((uint32)_genre)<<22)
                 | (((uint32)_commandClassId)<<14)
                 | (((uint32)_valueIndex)<<4)
                 | ((uint32)_type);
            m_id1 = (((uint32)_instance)<<24);
        }
 
        /* construct a ValueID based on the HomeID and the unit64 returned from GetID
         * \param _homeId - The HomeID 
         * \param id - The ID returned from ValueID::GetID
         * \see ValueID::GetId
         */
        ValueID
        (
                uint32 _homeId,
                        uint64 id
        ):
                m_homeId(_homeId)
        {
                m_id = ((uint32)(id & 0xFFFFFFFF));
                m_id1 = (uint32)(id >> 32);
        }
    private:
        // Construct a value id for use in notifications
        ValueID( uint32 const _homeId, uint8 const _nodeId ): m_id1( 0 ),m_homeId( _homeId ){ m_id = ((uint32)_nodeId)<<24; }
        ValueID( uint32 const _homeId, uint8 const _nodeId, uint32 const _instance ): 
            m_homeId( _homeId )
            { 
                m_id = (((uint32)_nodeId)<<24);
                m_id1 = (((uint32)_instance)<<24);
            }
 
        // Default constructor
        ValueID():m_id(0),m_id1(0),m_homeId(0){}
 
        // Not all parts of the ValueID are necessary to uniquely identify the value.  In the case of a 
        // Node's ValueStore, we can ignore the home ID, node ID, genre and type and still be left with
        // a unique integer than can be used as a key to look up values.  The two GetValueStoreKey methods
        // below are helpers to enable command classes to easily access their values from the ValueStore.
 
        // Get the key from our own m_id
        uint32 GetValueStoreKey()const
        { 
            return ( ( m_id & 0x003ffff0 ) | ( m_id1 & 0xff000000 ) );
        }
 
        // Generate a key from its component parts
        static uint32 GetValueStoreKey( uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex )
        { 
 
            uint32 key = (((uint32)_instance)<<24)
                 | (((uint32)_commandClassId)<<14)
                 | (((uint32)_valueIndex)<<4);
            
            return key;
        }
 
        // ID Packing:
        // Bits
        // 24-31:   8 bits. Node ID of device
        // 22-23:   2 bits. genre of value (see ValueGenre enum).
        // 14-21:   8 bits. ID of command class that created and manages this value.
        // 12-13:   2 bits. Unused.
        // 04-11:   8 bits. Index of value within all the value created by the command class
        //                  instance (in configuration parameters, this is also the parameter ID).
        // 00-03:   4 bits. Type of value (bool, byte, string etc).
        uint32  m_id;
 
        // ID1 Packing:
        // Bits
        // 24-31    8 bits. Instance Index of the command class.
        uint32  m_id1;
 
        // Unique PC interface identifier
        uint32  m_homeId;
    };
 
} // namespace OpenZWave
 
#endif