TopicUtils.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_TOPICUTILS_HH_
#define GZ_TRANSPORT_TOPICUTILS_HH_
 
#include <cstdint>
#include <string>
#include <optional>
#include <vector>
 
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
 
namespace gz::transport
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_TRANSPORT_VERSION_NAMESPACE {
  //
  class GZ_TRANSPORT_VISIBLE TopicUtils
  {
    public: static bool IsValidNamespace(const std::string &_ns);
 
    public: static bool IsValidPartition(const std::string &_partition);
 
    public: static bool IsValidTopic(const std::string &_topic);
 
    public: static bool FullyQualifiedName(const std::string &_partition,
                                           const std::string &_ns,
                                           const std::string &_topic,
                                           std::string &_name);
 
    public: static bool DecomposeFullyQualifiedTopic(
      const std::string &_fullyQualifiedName,
      std::string &_partition,
      std::string &_namespaceAndTopic);
 
    public: static bool DecomposeLivelinessTokenHelper(
      const std::string &_token,
      std::string &_prefix,
      std::string &_partition,
      std::string &_namespaceAndTopic,
      std::string &_pUUID,
      std::string &_nUUID,
      std::string &_entityType,
      std::string &_remainingToken);
 
    public: static bool DecomposeLivelinessToken(
      const std::string &_token,
      std::string &_prefix,
      std::string &_partition,
      std::string &_namespaceAndTopic,
      std::string &_pUUID,
      std::string &_nUUID,
      std::string &_entityType,
      std::string &_typeName);
 
    public: static bool DecomposeLivelinessToken(
      const std::string &_token,
      std::string &_prefix,
      std::string &_partition,
      std::string &_namespaceAndTopic,
      std::string &_pUUID,
      std::string &_nUUID,
      std::string &_entityType,
      std::string &_reqType,
      std::string &_repType);
 
    public: static std::string CreateLivelinessTokenHelper(
      const std::string &_fullyQualifiedTopic,
      const std::string &_pUuid,
      const std::string &_nUuid,
      const std::string &_entityType);
 
    public: static std::string CreateLivelinessToken(
      const std::string &_fullyQualifiedTopic,
      const std::string &_pUuid,
      const std::string &_nUuid,
      const std::string &_entityType,
      const std::string &_typeName);
 
    public: static std::string CreateLivelinessToken(
      const std::string &_fullyQualifiedTopic,
      const std::string &_pUuid,
      const std::string &_nUuid,
      const std::string &_entityType,
      const std::string &_reqTypeName,
      const std::string &_repTypeName);
 
    public: static std::string AsValidTopic(const std::string &_topic);
 
    public: static std::string MangleName(const std::string &_input);
 
    public: static std::string DemangleName(const std::string &_input);
 
    public: static bool MangleType(const std::vector<std::string> &_input,
                                   std::string &_output);
 
    public: static bool DemangleType(const std::string &_input,
                                     std::vector<std::string> &_output);
 
    public: static const uint16_t kMaxNameLength = 65535;
 
    public: static const char kTokenSeparator[];
 
    public: static const char kTypeSeparator[];
 
    public: static const char kTokenPrefix[];
 
    public: static const char kSlashReplacement;
  };
 
 
  class FullyQualifiedTopic
  {
    public: FullyQualifiedTopic(const std::string &_partition,
                                const std::string &_ns,
                                const std::string &_topic)
        : partition(_partition), ns(_ns), topic(_topic)
    {
      this->fullTopic.emplace();
      if (!TopicUtils::FullyQualifiedName(_partition, _ns, _topic,
                                          *this->fullTopic))
      {
        this->fullTopic.reset();
      }
    }
    const std::string &Partition() const
    {
      return this->partition;
    }
    const std::string &Namespace() const
    {
      return this->ns;
    }
    const std::string &Topic() const
    {
      return this->topic;
    }
    std::optional<std::string> FullTopic() const
    {
      return this->fullTopic;
    }
 
    private: const std::string partition;
 
    private: const std::string ns;
 
    private: const std::string topic;
 
    private: std::optional<std::string> fullTopic;
  };
  }
}
 
#endif