TopicStorage.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_TRANSPORT_TOPICSTORAGE_HH_
#define GZ_TRANSPORT_TOPICSTORAGE_HH_
 
#include <algorithm>
#include <map>
#include <string>
#include <vector>
 
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
#include "gz/transport/Publisher.hh"
#include "gz/transport/TransportTypes.hh"
 
namespace gz::transport
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_TRANSPORT_VERSION_NAMESPACE {
  //
  template<typename T> class TopicStorage
  {
    public: TopicStorage() = default;
 
    public: virtual ~TopicStorage() = default;
 
    public: bool AddPublisher(const T &_publisher)
    {
      // The topic does not exist.
      if (this->data.find(_publisher.Topic()) == this->data.end())
      {
        // VS2013 is buggy with initializer list here {}
        this->data[_publisher.Topic()] =
          std::map<std::string, std::vector<T>>();
      }
 
      // Check if the process uuid exists.
      auto &m = this->data[_publisher.Topic()];
      if (m.find(_publisher.PUuid()) != m.end())
      {
        // Check that the Publisher does not exist.
        auto &v = m[_publisher.PUuid()];
        auto found = std::find_if(v.begin(), v.end(),
          [&](const T &_pub)
          {
            return _pub.Addr()  == _publisher.Addr() &&
                   _pub.NUuid() == _publisher.NUuid();
          });
 
        // The publisher was already existing, just exit.
        if (found != v.end())
          return false;
      }
 
      // Add a new Publisher entry.
      m[_publisher.PUuid()].push_back(T(_publisher));
      return true;
    }
 
    public: bool HasTopic(const std::string &_topic) const
    {
      return this->data.find(_topic) != this->data.end();
    }
 
    public: bool HasTopic(const std::string &_topic,
                          const std::string &_type) const
    {
      if (!this->HasTopic(_topic))
        return false;
 
      // m is {pUUID=>std::vector<Publisher>}.
      auto &m = this->data.at(_topic);
 
      for (auto const &procs : m)
      {
        // Vector of publishers for a given topic and pUuid.
        auto &v = procs.second;
        auto found = std::find_if(v.begin(), v.end(),
          [&](const T &_pub)
          {
            return _pub.MsgTypeName() == _type ||
                   _pub.MsgTypeName() == kGenericMessageType;
          });
 
        // Type found!
        if (found != v.end())
          return true;
      }
 
      return false;
    }
 
    public: bool HasAnyPublishers(const std::string &_topic,
                                  const std::string &_pUuid) const
    {
      if (!this->HasTopic(_topic))
        return false;
 
      return this->data.at(_topic).find(_pUuid) !=
             this->data.at(_topic).end();
    }
 
    public: bool HasPublisher(const std::string &_addr) const
    {
      for (auto const &topic : this->data)
      {
        for (auto const &proc : topic.second)
        {
          for (auto const &pub : proc.second)
          {
            if (pub.Addr() == _addr)
              return true;
          }
        }
      }
      return false;
    }
 
    public: bool Publisher(const std::string &_topic,
                           const std::string &_pUuid,
                           const std::string &_nUuid,
                           T &_publisher) const
    {
      // Topic not found.
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      // m is {pUUID=>Publisher}.
      auto &m = this->data.at(_topic);
 
      // pUuid not found.
      if (m.find(_pUuid) == m.end())
        return false;
 
      // Vector of 0MQ known addresses for a given topic and pUuid.
      auto &v = m.at(_pUuid);
      auto found = std::find_if(v.begin(), v.end(),
        [&](const T &_pub)
        {
          return _pub.NUuid() == _nUuid;
        });
      // Address found!
      if (found != v.end())
      {
        _publisher = *found;
        return true;
      }
 
      // nUuid not found.
      return false;
    }
 
    public: bool Publishers(const std::string &_topic,
                           std::map<std::string, std::vector<T>> &_info) const
    {
      if (!this->HasTopic(_topic))
        return false;
 
      _info = this->data.at(_topic);
      return true;
    }
 
    public: bool DelPublisherByNode(const std::string &_topic,
                                    const std::string &_pUuid,
                                    const std::string &_nUuid)
    {
      size_t counter = 0;
 
      // Iterate over all the topics.
      if (this->data.find(_topic) != this->data.end())
      {
        // m is {pUUID=>Publisher}.
        auto &m = this->data[_topic];
 
        // The pUuid exists.
        if (m.find(_pUuid) != m.end())
        {
          // Vector of 0MQ known addresses for a given topic and pUuid.
          auto &v = m[_pUuid];
          auto priorSize = v.size();
          v.erase(std::remove_if(v.begin(), v.end(),
            [&](const T &_pub)
            {
              return _pub.NUuid() == _nUuid;
            }),
            v.end());
          counter = priorSize - v.size();
 
          if (v.empty())
            m.erase(_pUuid);
 
          if (m.empty())
            this->data.erase(_topic);
        }
      }
 
      return counter > 0;
    }
 
    public: bool DelPublishersByProc(const std::string &_pUuid)
    {
      size_t counter = 0;
 
      // Iterate over all the topics.
      for (auto it = this->data.begin(); it != this->data.end();)
      {
        // m is {pUUID=>Publisher}.
        auto &m = it->second;
        counter += m.erase(_pUuid);
        if (m.empty())
          this->data.erase(it++);
        else
          ++it;
      }
 
      return counter > 0;
    }
 
    public: void PublishersByProc(const std::string &_pUuid,
                           std::map<std::string, std::vector<T>> &_pubs) const
    {
      _pubs.clear();
 
      // Iterate over all the topics.
      for (auto const &topic : this->data)
      {
        // m is {pUUID=>Publisher}.
        auto &m = topic.second;
        if (m.find(_pUuid) != m.end())
        {
          auto &v = m.at(_pUuid);
          for (auto const &pub : v)
          {
            _pubs[pub.NUuid()].push_back(T(pub));
          }
        }
      }
    }
 
    public: void PublishersByNode(const std::string &_pUuid,
                                  const std::string &_nUuid,
                                  std::vector<T> &_pubs) const
    {
      _pubs.clear();
 
      // Iterate over all the topics.
      for (auto const &topic : this->data)
      {
        // m is {pUUID=>Publisher}.
        auto const &m = topic.second;
        if (m.find(_pUuid) != m.end())
        {
          auto const &v = m.at(_pUuid);
          for (auto const &pub : v)
          {
            if (pub.NUuid() == _nUuid)
            {
              _pubs.push_back(T(pub));
            }
          }
        }
      }
    }
 
    public: void TopicList(std::vector<std::string> &_topics) const
    {
      for (auto const &topic : this->data)
        _topics.push_back(topic.first);
    }
 
    public: void Print() const
    {
      std::cout << "---" << std::endl;
      for (auto const &topic : this->data)
      {
        std::cout << "[" << topic.first << "]" << std::endl;
        auto &m = topic.second;
        for (auto const &proc : m)
        {
          std::cout << "\tProc. UUID: " << proc.first << std::endl;
          auto &v = proc.second;
          for (auto const &publisher : v)
          {
            std::cout << publisher;
          }
        }
      }
    }
 
    public: void Clear()
    {
      this->data.clear();
    }
 
    private: std::map<std::string,
                      std::map<std::string, std::vector<T>>> data;
  };
  }
}
 
#endif