HandlerStorage.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_HANDLERSTORAGE_HH_
#define GZ_TRANSPORT_HANDLERSTORAGE_HH_
 
#include <map>
#include <memory>
#include <string>
#include <utility>
 
#include "gz/transport/config.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 HandlerStorage
  {
    using UUIDHandler_M = std::map<std::string, std::shared_ptr<T>>;
    using UUIDHandler_Collection_M = std::map<std::string, UUIDHandler_M>;
 
    using TopicServiceCalls_M =
      std::map<std::string, UUIDHandler_Collection_M>;
 
    public: HandlerStorage() = default;
 
    public: virtual ~HandlerStorage() = default;
 
    public: bool Handlers(const std::string &_topic,
      std::map<std::string,
        std::map<std::string, std::shared_ptr<T> >> &_handlers) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      _handlers = this->data.at(_topic);
      return true;
    }
 
    public: bool FirstHandler(const std::string &_topic,
                              const std::string &_reqTypeName,
                              const std::string &_repTypeName,
                              std::shared_ptr<T> &_handler) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      const auto &m = this->data.at(_topic);
      for (const auto &node : m)
      {
        for (const auto &handler : node.second)
        {
          if (_reqTypeName == handler.second->ReqTypeName() &&
              _repTypeName == handler.second->RepTypeName())
          {
            _handler = handler.second;
            return true;
          }
        }
      }
      return false;
    }
 
    public: bool FirstHandler(const std::string &_topic,
                              const std::string &_msgTypeName,
                              std::shared_ptr<T> &_handler) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      const auto &m = this->data.at(_topic);
      for (const auto &node : m)
      {
        for (const auto &handler : node.second)
        {
          if (_msgTypeName == handler.second->TypeName() ||
              handler.second->TypeName() == kGenericMessageType)
          {
            _handler = handler.second;
            return true;
          }
        }
      }
      return false;
    }
 
    public: bool Handler(const std::string &_topic,
                         const std::string &_nUuid,
                         const std::string &_hUuid,
                         std::shared_ptr<T> &_handler) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      auto const &m = this->data.at(_topic);
      if (m.find(_nUuid) == m.end())
        return false;
 
      if (m.at(_nUuid).find(_hUuid) == m.at(_nUuid).end())
        return false;
 
      _handler = m.at(_nUuid).at(_hUuid);
      return true;
    }
 
    public: TopicServiceCalls_M &AllHandlers()
    {
      return this->data;
    }
 
    public: void AddHandler(const std::string &_topic,
                            const std::string &_nUuid,
                            const std::shared_ptr<T> &_handler)
    {
      // Create the topic entry.
      if (this->data.find(_topic) == this->data.end())
        this->data[_topic] = UUIDHandler_Collection_M();
 
      // Create the Node UUID entry.
      if (this->data[_topic].find(_nUuid) == this->data[_topic].end())
        this->data[_topic][_nUuid] = UUIDHandler_M();
 
      // Add/Replace the Req handler.
      this->data[_topic][_nUuid].insert(
        std::make_pair(_handler->HandlerUuid(), _handler));
    }
 
    public: bool HasHandlersForTopic(const std::string &_topic) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      return !this->data.at(_topic).empty();
    }
 
    public: bool HasHandlersForNode(const std::string &_topic,
                                    const std::string &_nUuid) const
    {
      if (this->data.find(_topic) == this->data.end())
        return false;
 
      return this->data.at(_topic).find(_nUuid) !=
             this->data.at(_topic).end();
    }
 
    public: bool RemoveHandler(const std::string &_topic,
                               const std::string &_nUuid,
                               const std::string &_reqUuid)
    {
      size_t counter = 0;
      if (this->data.find(_topic) != this->data.end())
      {
        if (this->data[_topic].find(_nUuid) != this->data[_topic].end())
        {
          counter = this->data[_topic][_nUuid].erase(_reqUuid);
          if (this->data[_topic][_nUuid].empty())
            this->data[_topic].erase(_nUuid);
          if (this->data[_topic].empty())
            this->data.erase(_topic);
        }
      }
 
      return counter > 0;
    }
 
    public: bool RemoveHandlersForNode(const std::string &_topic,
                                       const std::string &_nUuid)
    {
      size_t counter = 0;
      if (this->data.find(_topic) != this->data.end())
      {
        counter = this->data[_topic].erase(_nUuid);
        if (this->data[_topic].empty())
          this->data.erase(_topic);
      }
 
      return counter > 0;
    }
 
    private: TopicServiceCalls_M data;
  };
  }
}
 
#endif