.. _program_listing_file_src_knx_interface_object.cpp:

Program Listing for File interface_object.cpp
=============================================

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

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

.. code-block:: cpp

   #include <cstring>
   
   #include "interface_object.h"
   #include "data_property.h"
   
   InterfaceObject::~InterfaceObject()
   {
       if (_properties != nullptr)
           delete[] _properties;
   }
   
   void InterfaceObject::readPropertyDescription(uint8_t& propertyId, uint8_t& propertyIndex, bool& writeEnable, uint8_t& type, uint16_t& numberOfElements, uint8_t& access)
   {
       uint8_t count = _propertyCount;
   
       numberOfElements = 0;
   
       if (_properties == nullptr || count == 0)
           return;
   
       Property* prop = nullptr;
   
       // from KNX spec. 03.03.07 Application Layer (page 56) - 3.4.3.3  A_PropertyDescription_Read-service
       // Summary: either propertyId OR propertyIndex, but not both at the same time
       if (propertyId != 0)
       {
           for (uint8_t i = 0; i < count; i++)
           {
               Property* p = _properties[i];
   
               if (p->Id() != propertyId)
                   continue;
   
               prop = p;
               propertyIndex = i;
               break;
           }
       }
       else
       {
           // If propertyId is zero, propertyIndex shall be used.
           // Response: propertyIndex of received A_PropertyDescription_Read
           if (propertyIndex < count)
           {
               prop = _properties[propertyIndex];
           }
       }
   
       if (prop != nullptr)
       {
           propertyId = prop->Id();
           writeEnable = prop->WriteEnable();
           type = prop->Type();
           numberOfElements = prop->MaxElements();
           access = prop->Access();
       }
   }
   
   void InterfaceObject::masterReset(EraseCode eraseCode, uint8_t channel)
   {
       // every interface object shall implement this
       // However, for the time being we provide an empty default implementation
   }
   
   void InterfaceObject::readPropertyLength(PropertyID id, uint16_t& length)
   {
       uint8_t count = 1;
       uint16_t propval = 0;
       readProperty(id, 0, count, (uint8_t*)&propval);
   
       if (count == 0)
       {
           length = 0;
           return;
       }
   
       length = ntohs(propval);
   }
   
   void InterfaceObject::readProperty(PropertyID id, uint16_t start, uint8_t& count, uint8_t* data)
   {
       Property* prop = property(id);
   
       if (prop == nullptr)
       {
           count = 0;
           return;
       }
   
       count = prop->read(start, count, data);
   }
   
   void InterfaceObject::writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count)
   {
       Property* prop = property(id);
   
       if (prop == nullptr)
       {
           count = 0;
           return;
       }
   
       count = prop->write(start, count, data);
   }
   
   uint8_t InterfaceObject::propertySize(PropertyID id)
   {
       Property* prop = property(id);
   
       if (prop == nullptr)
       {
           return 0;
       }
   
       return prop->ElementSize();
   }
   
   void InterfaceObject::command(PropertyID id, uint8_t* data, uint8_t length, uint8_t* resultData, uint8_t& resultLength)
   {
       Property* prop = property(id);
   
       if (prop == nullptr)
       {
           resultLength = 0;
           return;
       }
   
       prop->command(data, length, resultData, resultLength);
   }
   
   void InterfaceObject::state(PropertyID id, uint8_t* data, uint8_t length, uint8_t* resultData, uint8_t& resultLength)
   {
       Property* prop = property(id);
   
       if (prop == nullptr)
       {
           resultLength = 0;
           return;
       }
   
       prop->state(data, length, resultData, resultLength);
   }
   
   void InterfaceObject::initializeProperties(size_t propertiesSize, Property** properties)
   {
       _propertyCount = propertiesSize / sizeof(Property*);
       _properties = new Property*[_propertyCount];
       memcpy(_properties, properties, propertiesSize);
   }
   
   
   Property* InterfaceObject::property(PropertyID id)
   {
       for (int i = 0; i < _propertyCount; i++)
           if (_properties[i]->Id() == id)
               return _properties[i];
   
       return nullptr;
   }
   
   
   uint8_t* InterfaceObject::save(uint8_t* buffer)
   {
       for (int i = 0; i < _propertyCount; i++)
       {
           Property* prop = _properties[i];
   
           if (!prop->WriteEnable())
               continue;
   
           buffer = prop->save(buffer);
       }
   
       return buffer;
   }
   
   
   const uint8_t* InterfaceObject::restore(const uint8_t* buffer)
   {
       for (int i = 0; i < _propertyCount; i++)
       {
           Property* prop = _properties[i];
   
           if (!prop->WriteEnable())
               continue;
   
           buffer = prop->restore(buffer);
       }
   
       return buffer;
   }
   
   
   uint16_t InterfaceObject::saveSize()
   {
       uint16_t size = 0;
   
       for (int i = 0; i < _propertyCount; i++)
       {
           Property* prop = _properties[i];
   
           if (!prop->WriteEnable())
               continue;
   
           size += prop->saveSize();
       }
   
       return size;
   }
   
   
   const Property* InterfaceObject::property(PropertyID id) const
   {
       for (int i = 0; i < _propertyCount; i++)
           if (_properties[i]->Id() == id)
               return _properties[i];
   
       return nullptr;
   }
   
   
   const uint8_t* InterfaceObject::propertyData(PropertyID id)
   {
       DataProperty* prop = (DataProperty*)property(id);
       return prop->data();
   }
   
   const uint8_t* InterfaceObject::propertyData(PropertyID id, uint16_t elementIndex)
   {
       DataProperty* prop = (DataProperty*)property(id);
       return prop->data(elementIndex);
   }