.. _program_listing_file_src_knx_knx_value.cpp:

Program Listing for File knx_value.cpp
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_knx_knx_value.cpp>` (``src/knx/knx_value.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "knx_value.h"
   
   #include <cstring>
   #include <cstdlib>
   #include <ctime>
   
   KNXValue::KNXValue(bool value)
   {
       _value.boolValue = value;
       _type = BoolType;
   }
   
   KNXValue::KNXValue(uint8_t value)
   {
       _value.ucharValue = value;
       _type = UCharType;
   }
   
   KNXValue::KNXValue(uint16_t value)
   {
       _value.ushortValue = value;
       _type = UShortType;
   }
   
   KNXValue::KNXValue(uint32_t value)
   {
       _value.uintValue = value;
       _type = UIntType;
   }
   
   KNXValue::KNXValue(uint64_t value)
   {
       _value.ulongValue = value;
       _type = ULongType;
   }
   
   KNXValue::KNXValue(int8_t value)
   {
       _value.charValue = value;
       _type = CharType;
   }
   
   KNXValue::KNXValue(int16_t value)
   {
       _value.shortValue = value;
       _type = ShortType;
   }
   
   KNXValue::KNXValue(int32_t value)
   {
       _value.intValue = value;
       _type = IntType;
   }
   
   KNXValue::KNXValue(int64_t value)
   {
       _value.longValue = value;
       _type = LongType;
   }
   
   KNXValue::KNXValue(double value)
   {
       _value.doubleValue = value;
       _type = DoubleType;
   }
   
   KNXValue::KNXValue(const char* value)
   {
       _value.stringValue = value;
       _type = StringType;
   }
   
   KNXValue::KNXValue(struct tm value)
   {
       _value.timeValue = value;
       _type = TimeType;
   }
   
   KNXValue::operator bool() const
   {
       return boolValue();
   }
   
   KNXValue::operator uint8_t() const
   {
       return ucharValue();
   }
   
   KNXValue::operator uint16_t() const
   {
       return ushortValue();
   }
   
   KNXValue::operator uint32_t() const
   {
       return uintValue();
   }
   
   KNXValue::operator uint64_t() const
   {
       return ulongValue();
   }
   
   KNXValue::operator int8_t() const
   {
       return charValue();
   }
   
   KNXValue::operator int16_t() const
   {
       return shortValue();
   }
   
   KNXValue::operator int32_t() const
   {
       return intValue();
   }
   
   KNXValue::operator int64_t() const
   {
       return longValue();
   }
   
   KNXValue::operator double() const
   {
       return doubleValue();
   }
   
   KNXValue::operator const char* () const
   {
       return stringValue();
   }
   
   KNXValue::operator struct tm() const
   {
       return timeValue();
   }
   
   KNXValue& KNXValue::operator=(const bool value)
   {
       _value.boolValue = value;
       _type = BoolType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const uint8_t value)
   {
       _value.ucharValue = value;
       _type = UCharType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const uint16_t value)
   {
       _value.ushortValue = value;
       _type = UShortType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const uint32_t value)
   {
       _value.uintValue = value;
       _type = UIntType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const uint64_t value)
   {
       _value.ulongValue = value;
       _type = ULongType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const int8_t value)
   {
       _value.charValue = value;
       _type = CharType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const int16_t value)
   {
       _value.shortValue = value;
       _type = ShortType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const int32_t value)
   {
       _value.intValue = value;
       _type = IntType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const int64_t value)
   {
       _value.longValue = value;
       _type = LongType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const double value)
   {
       _value.doubleValue = value;
       _type = DoubleType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const char* value)
   {
       _value.stringValue = value;
       _type = StringType;
       return *this;
   }
   
   KNXValue& KNXValue::operator=(const struct tm value)
   {
       _value.timeValue = value;
       _type = TimeType;
       return *this;
   }
   
   bool KNXValue::boolValue() const
   {
       switch (_type)
       {
           case BoolType:
               return _value.boolValue;
   
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
           case TimeType:
               return longValue() != 0;
   
           case DoubleType:
               return _value.doubleValue != 0;
   
           case StringType:
               return strcmp(_value.stringValue, "true") == 0 || strcmp(_value.stringValue, "True") == 0 || longValue() != 0 || doubleValue() != 0;
       }
   
       return 0;
   }
   
   uint8_t KNXValue::ucharValue() const
   {
       switch (_type)
       {
           case UCharType:
               return _value.ucharValue;
   
           case BoolType:
           case UShortType:
           case UIntType:
           case ULongType:
           case TimeType:
               return (uint8_t)ulongValue();
   
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
               return (uint8_t)longValue();
       }
   
       return 0;
   }
   
   uint16_t KNXValue::ushortValue() const
   {
       switch (_type)
       {
           case UShortType:
               return _value.ushortValue;
   
           case BoolType:
           case UCharType:
           case UIntType:
           case ULongType:
           case TimeType:
               return (uint16_t)ulongValue();
   
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
               return (uint16_t)longValue();
       }
   
       return 0;
   }
   
   uint32_t KNXValue::uintValue() const
   {
       switch (_type)
       {
           case UIntType:
               return _value.uintValue;
   
           case BoolType:
           case UCharType:
           case UShortType:
           case ULongType:
           case TimeType:
               return (uint32_t)ulongValue();
   
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
               return (uint32_t)longValue();
       }
   
       return 0;
   }
   
   uint64_t KNXValue::ulongValue() const
   {
       switch (_type)
       {
           case ULongType:
               return _value.ulongValue;
   
           case BoolType:
               return _value.boolValue ? 1 : 0;
   
           case UCharType:
               return (uint64_t)_value.ucharValue;
   
           case UShortType:
               return (uint64_t)_value.ushortValue;
   
           case UIntType:
               return (uint64_t)_value.uintValue;
   
           case TimeType:
           {
               struct tm* timeptr = const_cast<struct tm*>(&_value.timeValue);
               return (uint64_t)mktime(timeptr);
           }
   
           case CharType:
               return (uint64_t)_value.charValue;
   
           case ShortType:
               return (uint64_t)_value.shortValue;
   
           case IntType:
               return (uint64_t)_value.intValue;
   
           case LongType:
               return (uint64_t)_value.longValue;
   
           case DoubleType:
               return (uint64_t)_value.doubleValue;
   
           case StringType:
   #ifndef KNX_NO_STRTOx_CONVERSION
               return (uint64_t)strtoul(_value.stringValue, NULL, 0);
   #else
               return 0;
   #endif
       }
   
       return 0;
   }
   
   int8_t KNXValue::charValue() const
   {
       switch (_type)
       {
           case CharType:
               return _value.charValue;
   
           case BoolType:
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case TimeType:
               return (int8_t)ulongValue();
   
           case ShortType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
               return (int8_t)longValue();
       }
   
       return 0;
   }
   
   int16_t KNXValue::shortValue() const
   {
       switch (_type)
       {
           case ShortType:
               return _value.shortValue;
   
           case BoolType:
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case TimeType:
               return (int16_t)ulongValue();
   
           case CharType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
               return (int16_t)longValue();
       }
   
       return 0;
   }
   
   int32_t KNXValue::intValue() const
   {
       switch (_type)
       {
           case IntType:
               return _value.ulongValue;
   
           case BoolType:
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case TimeType:
               return (int32_t)ulongValue();
   
           case CharType:
           case ShortType:
           case LongType:
           case DoubleType:
           case StringType:
               return (int32_t)longValue();
       }
   
       return 0;
   }
   
   int64_t KNXValue::longValue() const
   {
       switch (_type)
       {
           case LongType:
               return _value.longValue;
   
           case BoolType:
               return _value.boolValue ? 1 : 0;
   
           case UCharType:
               return (int64_t)_value.ucharValue;
   
           case UShortType:
               return (int64_t)_value.ushortValue;
   
           case UIntType:
               return (int64_t)_value.uintValue;
   
           case ULongType:
               return (int64_t)_value.uintValue;
   
           case TimeType:
               return (int64_t)ulongValue();
   
           case CharType:
               return (int64_t)_value.charValue;
   
           case ShortType:
               return (int64_t)_value.shortValue;
   
           case IntType:
               return (int64_t)_value.intValue;
   
           case DoubleType:
               return (int64_t)_value.doubleValue;
   
           case StringType:
   #ifndef KNX_NO_STRTOx_CONVERSION
               return strtol(_value.stringValue, NULL, 0);
   #else
               return 0;
   #endif
       }
   
       return 0;
   }
   
   double KNXValue::doubleValue() const
   {
       switch (_type)
       {
           case DoubleType:
               return _value.doubleValue;
   
           case BoolType:
               return _value.boolValue ? 1 : 0;
   
           case UCharType:
               return _value.ucharValue;
   
           case UShortType:
               return _value.ushortValue;
   
           case UIntType:
               return _value.uintValue;
   
           case ULongType:
               return _value.uintValue;
   
           case TimeType:
               return ulongValue();
   
           case CharType:
               return _value.charValue;
   
           case ShortType:
               return _value.shortValue;
   
           case IntType:
               return _value.intValue;
   
           case LongType:
               return _value.longValue;
   
           case StringType:
   #ifndef KNX_NO_STRTOx_CONVERSION
               return strtod(_value.stringValue, NULL);
   #else
               return 0;
   #endif
       }
   
       return 0;
   }
   
   const char* KNXValue::stringValue() const
   {
       switch (_type)
       {
           case DoubleType:
           case BoolType:
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case TimeType:
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
               return ""; // we would have to manage the memory for the string otherwise. Maybe later.
   
           case StringType:
               return _value.stringValue;
       }
   
       return 0;
   }
   
   struct tm KNXValue::timeValue() const
   {
       switch (_type)
       {
           case TimeType:
               return _value.timeValue;
   
           case BoolType:
           case UCharType:
           case UShortType:
           case UIntType:
           case ULongType:
           case CharType:
           case ShortType:
           case IntType:
           case LongType:
           case DoubleType:
           case StringType:
           {
               time_t timeVal = ulongValue();
               struct tm timeStruct;
               gmtime_r(&timeVal, &timeStruct);
               return timeStruct;
           }
       }
   
       struct tm tmp;
       memset(&tmp, 0, sizeof(tmp));
   
       return tmp;
   }
   
   KNXValue::KNXValue(float value)
   {
       _value.doubleValue = value;
       _type = DoubleType;
   }
   
   KNXValue& KNXValue::operator=(const float value)
   {
       _value.doubleValue = value;
       _type = DoubleType;
       return *this;
   }
   
   KNXValue::operator float() const
   {
       return doubleValue();
   }