localloop.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================

#ifndef HF_APP_LOCALLOOP_H
#define HF_APP_LOCALLOOP_H

#include "hanfun.h"

namespace
{
   struct Link: public HF::Transport::AbstractLink
   {
      HF::Transport::AbstractLayer &recv_tsp;

      HF::UID::UID_T               *_uid;
      HF::Transport::Layer         *tsp;

      Link                         *other;

      Link(HF::Transport::AbstractLayer &_recv_tsp,
           HF::UID::UID_T *uid = new HF::UID::NONE(),
           HF::Transport::Layer *tsp = nullptr):
         recv_tsp(_recv_tsp), _uid(uid), tsp(tsp), other(nullptr)
      {}

      virtual ~Link()
      {
         delete _uid;
      }

      void send(HF::Common::ByteArray &array)
      {
         recv_tsp.receive(other, array);
      }

      const HF::UID::UID uid() const
      {
         return HF::UID::UID(_uid);
      }

      HF::Transport::Layer const *transport() const
      {
         return tsp;
      }
   };

   class Localloop
   {
      protected:

      HF::Devices::Concentrator::Transport base_tsp;

      std::vector<HF::Devices::Node::Transport *> devices_tsp;

      public: ~Localloop()
      {
         base_tsp.destroy();

         while (!devices_tsp.empty())
         {
            auto tsp = devices_tsp.back();
            tsp->destroy();
            devices_tsp.pop_back();
            delete tsp;
         }
      }

      void set_base(HF::IDevice *base)
      {
         base_tsp.destroy();
         base_tsp.add(base);
      }

      void add_node(HF::IDevice *node, std::string uid)
      {
         HF::Devices::Node::Transport *dev_tsp = new HF::Devices::Node::Transport();
         dev_tsp->add(node);

         Link *dev_link  = new Link(base_tsp, new HF::UID::URI("base"));
         Link *base_link = new Link(*dev_tsp, new HF::UID::URI(uid));

         dev_link->other  = base_link;
         base_link->other = dev_link;

         dev_tsp->add(dev_link);
         base_tsp.add(base_link);

         devices_tsp.push_back(dev_tsp);
      }
   };

}  // namespace

#if HF_GROUP_SUPPORT
namespace HF
{
   namespace Transport
   {
      namespace Group
      {
         HF::Common::Result create(Endpoint &ep, uint16_t group)
         {
            UNUSED(ep);
            UNUSED(group);
            return HF::Common::Result::FAIL_SUPPORT;
         }

         HF::Common::Result add(Endpoint &ep, uint16_t group, uint16_t device)
         {
            UNUSED(ep);
            UNUSED(group);
            UNUSED(device);

            return HF::Common::Result::FAIL_SUPPORT;
         }

         void remove(Endpoint &ep, uint16_t group, uint16_t device)
         {
            UNUSED(ep);
            UNUSED(group);
            UNUSED(device);
         }

         void remove(Endpoint &ep, uint16_t group)
         {
            UNUSED(ep);
            UNUSED(group);
         }

      } // namespace Group

   } // namespace Transport

}  // namespace HF

#endif /* HF_GROUP_SUPPORT */

#endif /* HF_APP_LOCALLOOP_H */