lookup.hpp

Go to the documentation of this file.

#pragma once
 
#include "hebi.h"
 
#include <cstddef>
#include <iterator>
#include <memory> // For shared_ptr
#include <vector>
 
#include "group.hpp"
#include "mac_address.hpp"
 
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);
 
  double getLookupFrequencyHz() const;
 
  bool setLookupFrequencyHz(double frequency);
 
  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