ServerConfig.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2018 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 IGNITION_GAZEBO_SERVERCONFIG_HH_
#define IGNITION_GAZEBO_SERVERCONFIG_HH_

#include <chrono>
#include <list>
#include <memory>
#include <optional> // NOLINT(*)
#include <string>
#include <vector>
#include <sdf/Element.hh>
#include <ignition/gazebo/config.hh>
#include <ignition/gazebo/Export.hh>

namespace ignition
{
  namespace gazebo
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
    // Forward declarations.
    class ServerConfigPrivate;

    class IGNITION_GAZEBO_VISIBLE ServerConfig
    {
      class PluginInfoPrivate;
      public: class IGNITION_GAZEBO_VISIBLE PluginInfo
      {
        public: PluginInfo();

        public: ~PluginInfo();

        public: PluginInfo(const std::string &_entityName,
                           const std::string &_entityType,
                           const std::string &_filename,
                           const std::string &_name,
                           const sdf::ElementPtr &_sdf);

        public: PluginInfo(const PluginInfo &_info);

        public: PluginInfo &operator=(const PluginInfo &_info);

        public: const std::string &EntityName() const;

        public: void SetEntityName(const std::string &_entityName);

        public: const std::string &EntityType() const;

        public: void SetEntityType(const std::string &_entityType);

        public: const std::string &Filename() const;

        public: void SetFilename(const std::string &_filename);

        public: const std::string &Name() const;

        public: void SetName(const std::string &_name);

        public: const sdf::ElementPtr &Sdf() const;

        public: void SetSdf(const sdf::ElementPtr &_sdf);

        private: std::unique_ptr<ServerConfig::PluginInfoPrivate> dataPtr;
      };

      public: ServerConfig();

      public: ServerConfig(const ServerConfig &_config);

      public: ~ServerConfig();

      public: bool SetSdfFile(const std::string &_file);

      public: std::string SdfFile() const;

      public: bool SetSdfString(const std::string &_sdfString);

      public: std::string SdfString() const;

      public: void SetUpdateRate(const double &_hz);

      public: std::optional<double> UpdateRate() const;

      public: bool UseLevels() const;

      public: void SetUseLevels(const bool _levels);

      public: bool UseDistributedSimulation() const;

      public: void SetNetworkSecondaries(unsigned int _secondaries);

      public: unsigned int NetworkSecondaries() const;

      public: void SetNetworkRole(const std::string &_role);

      public: std::string NetworkRole() const;

      public: bool UseLogRecord() const;

      public: void SetUseLogRecord(const bool _record);

      public: const std::string LogRecordPath() const;

      public: void SetLogRecordPath(const std::string &_recordPath);

      public: void AddLogRecordTopic(const std::string &_topic);

      public: void ClearLogRecordTopics();

      public: const std::vector<std::string> &LogRecordTopics() const;

      public: const std::string LogPlaybackPath() const;

      public: void SetLogPlaybackPath(const std::string &_playbackPath);

      public: bool LogRecordResources() const;

      public: void SetLogRecordResources(bool _recordResources);

      public: std::string LogRecordCompressPath() const;

      public: void SetLogRecordCompressPath(const std::string &_path);

      public: unsigned int Seed() const;

      public: void SetSeed(unsigned int _seed);

      public: std::optional<std::chrono::steady_clock::duration>
              UpdatePeriod() const;

      public: const std::string &ResourceCache() const;

      public: void SetResourceCache(const std::string &_path);

      public: const std::string &PhysicsEngine() const;

      public: void SetPhysicsEngine(const std::string &_physicsEngine);

      public: const std::string &RenderEngineServer() const;

      public: const std::string &RenderEngineGui() const;

      public: void SetHeadlessRendering(const bool _headless);

      public: bool HeadlessRendering() const;

      public: void SetRenderEngineServer(
                  const std::string &_renderEngineServer);

      public: void SetRenderEngineGui(const std::string &_renderEngineGui);

      public: void AddPlugin(const PluginInfo &_info);

      public: void AddPlugins(const std::list<PluginInfo> &_plugins);

      public: PluginInfo LogRecordPlugin() const;

      public: PluginInfo LogPlaybackPlugin() const;

      public: const std::list<PluginInfo> &Plugins() const;

      public: ServerConfig &operator=(const ServerConfig &_cfg);

      public: const std::chrono::time_point<std::chrono::system_clock> &
              Timestamp() const;

      private: std::unique_ptr<ServerConfigPrivate> dataPtr;
    };

    std::list<ServerConfig::PluginInfo>
    IGNITION_GAZEBO_VISIBLE
    parsePluginsFromFile(const std::string &_fname);

    std::list<ServerConfig::PluginInfo>
    IGNITION_GAZEBO_VISIBLE
    parsePluginsFromString(const std::string &_str);

    //
    //
    std::list<ServerConfig::PluginInfo>
    IGNITION_GAZEBO_VISIBLE
    loadPluginInfo(bool _isPlayback = false);
    }
  }
}

#endif