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