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 "ValueIDIndexes.h"
#include "Defs.h"

class TiXmlElement;

namespace OpenZWave
{

    namespace Internal
    {
        namespace VC
        {
            class Value;
            class ValueStore;
        }
        ;
    }
    ;

    class OPENZWAVE_EXPORT ValueID
    {
        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_BitSet, 
                ValueType_Max = ValueType_BitSet 
            };

            uint32 GetHomeId() const
            {
                return m_homeId;
            }

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

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

            string GetGenreAsString() const;

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

            uint8 GetInstance() const
            {
                return ((uint8) (((m_id & 0xff0)) >> 4));
            }

            uint16 GetIndex() const
            {
                return ((uint16) ((m_id1 & 0xFFFF0000) >> 16));
            }

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

            string GetTypeAsString() const;

            uint64 GetId() const
            {
                return (uint64) (((uint64) m_id1 << 32) | m_id);
            }
            string const GetAsString() const;

            // 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, uint16 const _valueIndex, ValueType const _type) :
                    m_homeId(_homeId)
            {
                m_id = (((uint32) _nodeId) << 24) | (((uint32) _genre) << 22) | (((uint32) _commandClassId) << 14) | (((uint32) (_instance & 0xFF)) << 4) | ((uint32) _type);
                m_id1 = (((uint32) _valueIndex) << 16);
            }

            /* 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);
            }

            // 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) | (((uint32) _instance) << 4);
                m_id1 = 0;
            }

            // 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
            {
                /* 0xIIIICCii
                 * I = Index
                 * C = CC
                 * i = Instance
                 */
                /*                  CC                             Index                       Instance */
                return (((m_id & 0x003fc000) >> 6) | (m_id1 & 0xffff0000) | ((m_id & 0xFF0) >> 4));
            }

            // Generate a key from its component parts
            static uint32 GetValueStoreKey(uint8 const _commandClassId, uint8 const _instance, uint16 const _valueIndex)
            {

                uint32 key = (((uint32) _instance)) | (((uint32) _commandClassId) << 8) | (((uint32) (_valueIndex & 0xFFFF)) << 16);

                return key;
            }

        private:

            // 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    Unused.
            // 04-11:   8 bits. Instance of the Value
            // 00-03:   4 bits. Type of value (bool, byte, string etc).
            uint32 m_id;

            // ID1 Packing:
            // Bits
            // 16-31    16 bits. Instance Index of the command class.
            uint32 m_id1;

            // Unique PC interface identifier
            uint32 m_homeId;
    };

} // namespace OpenZWave

#endif