gz/transport/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 ignition
{
  namespace transport
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_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: 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