base.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_APP_BASE_H
#define HF_APP_BASE_H

#include "hanfun.h"

#include "common.h"

#include "json/json.h"

// =============================================================================
// Base
// =============================================================================

namespace DeviceManagement
{
   struct Entries: public HF::Core::DeviceManagement::Entries
   {
      typedef HF::Core::DeviceManagement::Device Device;
      typedef HF::Core::DeviceManagement::DevicePtr DevicePtr;

      HF::Common::Result save(const Device &device);

      HF::Common::Result destroy(const Device &device);

      void insert(const Device &device);
   };

   struct Server: public HF::Core::DeviceManagement::Server<Entries>
   {
      Server(HF::Core::Unit0 &unit):
         HF::Core::DeviceManagement::Server<Entries>(unit),
         _next_address(HF::Protocol::BROADCAST_ADDR)
      {}

      virtual ~Server() {}

      uint16_t next_address(uint16_t addr)
      {
         _next_address = addr;
         return _next_address;
      }

      bool available(uint16_t address);

      bool deregister(uint16_t address);

      void save(Json::Value &root);

      void restore(Json::Value root);

      protected:

      using HF::Core::DeviceManagement::Server<Entries>::deregister;

      uint16_t _next_address;

      uint16_t next_address();
   };

}     // namespace DeviceManagement

namespace BindManagement
{
   struct Entries: public HF::Core::BindManagement::Entries
   {
      typedef HF::Core::BindManagement::Entry Entry;
      typedef HF::Core::BindManagement::EntryPtr EntryPtr;

      HF::Common::Result save(const Entry &entry);

      HF::Common::Result destroy(const Entry &entry);

      void insert(Entry &entry);
   };

   struct Server: public HF::Core::BindManagement::Server<Entries>
   {
      Server(HF::Devices::Concentrator::IUnit0 &unit):
         HF::Core::BindManagement::Server<Entries>(unit)
      {}

      void save(Json::Value &root);

      void restore(Json::Value root);
   };

}  // namespace BindManagement

// =============================================================================
// Helper Units.
// =============================================================================

namespace Events
{
   struct Alert: public HF::Interfaces::Alert::Client
   {
      void status(HF::Protocol::Address &source, HF::Interfaces::Alert::Message &message);
   };

   struct LevelControl: public HF::Interfaces::LevelControl::Server
   {
      void level_change(HF::Protocol::Address &source, uint8_t old_level, uint8_t new_level);
   };

   struct OnOff: public HF::Interfaces::OnOff::Server
   {
      void on(HF::Protocol::Address &source);

      void off(HF::Protocol::Address &source);

      void toggle(HF::Protocol::Address &source);
   };

   struct SimplePowerMeter: public HF::Interfaces::SimplePowerMeter::Client
   {
      void report(HF::Protocol::Address &source, HF::Interfaces::SimplePowerMeter::Report &report);
   };

   struct Unit: public HF::Units::Unit<HF::Profiles::GenericApplicationLogic, Alert,
                                       LevelControl, OnOff, SimplePowerMeter>
   {
      Unit(uint8_t id, HF::IDevice &device):
         HF::Units::Unit<HF::Profiles::GenericApplicationLogic, Alert, LevelControl,
                         OnOff, SimplePowerMeter>(id, device)
      {}
   };

}  // namespace Listeners

namespace Commands
{
   typedef HF::Interfaces::Alert::Server Alert;
   typedef HF::Interfaces::LevelControl::Client LevelControl;
   typedef HF::Interfaces::OnOff::Client OnOff;
   typedef HF::Interfaces::SimplePowerMeter::Server SimplePowerMeter;

   struct Unit: public HF::Units::Unit<HF::Profiles::GenericApplicationLogic, Alert,
                                       LevelControl, OnOff, SimplePowerMeter>
   {
      Unit(uint8_t id, HF::IDevice &device):
         HF::Units::Unit<HF::Profiles::GenericApplicationLogic, Alert, LevelControl,
                         OnOff, SimplePowerMeter>(id, device)
      {}

      Alert &alert()
      {
         return *const_cast<Alert *>(get<0>());
      }

      LevelControl &level_control()
      {
         return *const_cast<LevelControl *>(get<1>());
      }

      OnOff &on_off()
      {
         return *const_cast<OnOff *>(get<2>());
      }

      SimplePowerMeter &simple_power_meter()
      {
         return *const_cast<SimplePowerMeter *>(get<3>());
      }

      HF::Common::Result handle(HF::Protocol::Packet &packet, HF::Common::ByteArray &payload,
                                uint16_t offset);
   };

}  // namespace

// =============================================================================
// Concentrator.
// =============================================================================

typedef HF::Devices::Concentrator::Unit0<HF::Core::DeviceInformation::Server,
                                         ::DeviceManagement::Server,
                                         HF::Core::AttributeReporting::Server,
#if HF_TIME_SUPPORT
                                         HF::Core::Time::Server,
#endif
#if HF_BATCH_PROGRAM_SUPPORT
                                         HF::Core::BatchProgramManagement::DefaultServer,
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
                                         HF::Core::Scheduling::Event::DefaultServer,
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
                                         HF::Core::Scheduling::Weekly::DefaultServer,
#endif
#if HF_GROUP_SUPPORT
                                         HF::Core::GroupTable::DefaultServer,
                                         HF::Core::GroupManagement::DefaultServer,
#endif
                                         ::BindManagement::Server> Unit0;

struct Base: public HF::Devices::Concentrator::Abstract<Unit0>
{
   Events::Unit   events;
   Commands::Unit commands;

   Base():        HF::Devices::Concentrator::Abstract<Unit0>(),
      events(1, *this), commands(2, *this)
   {}

   virtual ~Base()
   {}

   void receive(HF::Protocol::Packet &packet, HF::Common::ByteArray &payload, uint16_t offset);

   using HF::Devices::Concentrator::Abstract<Unit0>::link;

   std::forward_list<HF::Transport::Link *> &links()
   {
      return _links;
   }

   bool has_bind(uint16_t dev_addr_1, uint16_t dev_addr_2);

   uint8_t bind(uint16_t dev_addr_1, uint16_t dev_addr_2);

   bool unbind(uint16_t dev_addr_1, uint16_t dev_addr_2);
};

// =============================================================================
// Helper Functions
// =============================================================================

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(const HF::Common::Interface &interface, Json::Value &node);

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(HF::UID::UID *uid, Json::Value &node);

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(const HF::Core::DeviceManagement::Unit &unit, Json::Value &node);

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(const HF::Core::DeviceManagement::Device &device, Json::Value &node);

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(const HF::Protocol::Address &address, Json::Value &node);

// =============================================================================
// to_json
// =============================================================================
// =============================================================================
void to_json(const HF::Core::BindManagement::Entry &entry, Json::Value &node);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::Common::Interface &interface);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::UID::UID * &uid);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::Core::DeviceManagement::Unit &unit);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::Core::DeviceManagement::Device &device);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::Protocol::Address &address);

// =============================================================================
// from_json
// =============================================================================
// =============================================================================
void from_json(Json::Value &node, HF::Core::BindManagement::Entry &entry);

#endif /* HF_APP_BASE_H */