lookup.hpp

Go to the documentation of this file.

#pragma once

#include <cstddef>
#include <iterator>

#include "hebi.h"
#include "mac_address.hpp"
#include "group.hpp"

#include <memory> // For shared_ptr
#include <vector>

namespace hebi {

class Lookup final
{
  private:
    static const int32_t DEFAULT_TIMEOUT = 500;

    HebiLookupPtr lookup_;

    float initial_group_feedback_frequency_{100.0f};

    int32_t initial_group_command_lifetime_{250};

  public:
    Lookup();

    ~Lookup() noexcept; /* annotating specified destructor as noexcept is best-practice */

    std::shared_ptr<Group> getGroupFromNames(const std::vector<std::string>& families, const std::vector<std::string>& names, int32_t timeout_ms=DEFAULT_TIMEOUT);

    std::shared_ptr<Group> getGroupFromMacs(const std::vector<MacAddress>& addresses, int32_t timeout_ms=DEFAULT_TIMEOUT);

    std::shared_ptr<Group> getGroupFromFamily(const std::string& family, int32_t timeout_ms=DEFAULT_TIMEOUT);

    std::shared_ptr<Group> getConnectedGroupFromName(const std::string& family, const std::string& name, int32_t timeout_ms=DEFAULT_TIMEOUT);

    std::shared_ptr<Group> getConnectedGroupFromMac(const MacAddress& address, int32_t timeout_ms=DEFAULT_TIMEOUT);

    float getInitialGroupFeedbackFrequencyHz();
    void setInitialGroupFeedbackFrequencyHz(float frequency);

    int32_t getInitialGroupCommandLifetimeMs();
    void setInitialGroupCommandLifetimeMs(int32_t ms);
  
    class EntryList final
    {
      struct Entry final
      {
        std::string name_;
        std::string family_;
        MacAddress mac_address_;
      };

      private:
        HebiLookupEntryListPtr lookup_list_;

        class Iterator final
        {
          public:
            // Iterator traits (not from std::iterator to be C++17 compliant)
            using value_type = Entry;
            using difference_type = int;
            using pointer = Entry*;
            using reference = Entry;
            using iterator_category = std::bidirectional_iterator_tag;

            // Default constructable
            Iterator() = default;
            explicit Iterator(const EntryList& list, size_t current);

            // Dereferencable
            reference operator*() const;

            // Pre- and post-incrementable/decrementable
            Iterator& operator++();
            Iterator operator++(int);
            Iterator& operator--();
            Iterator operator--(int);

            // Equality / inequality
            bool operator==(const Iterator& rhs) const;
            bool operator!=(const Iterator& rhs) const;

          private:
            const EntryList& list_;
            size_t current_ { 0 };
        };

      public:

        EntryList(HebiLookupEntryListPtr lookup_list) : lookup_list_(lookup_list) {}

        ~EntryList() noexcept;

        Entry operator[](size_t index) const;

        size_t size() const;

        Iterator begin() const;
        Iterator end() const;

      private:
        HEBI_DISABLE_COPY_MOVE(EntryList)
    };

    std::shared_ptr<EntryList> getEntryList();
 
  private:
    HEBI_DISABLE_COPY_MOVE(Lookup)
};

} // namespace hebi