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 GZ_SIM_SERVERCONFIG_HH_
#define GZ_SIM_SERVERCONFIG_HH_
 
#include <chrono>
#include <list>
#include <memory>
#include <optional> // NOLINT(*)
#include <string>
#include <vector>
#include <sdf/Element.hh>
#include <sdf/Plugin.hh>
#include <sdf/Root.hh>
#include <gz/sim/config.hh>
#include <gz/sim/Export.hh>
 
namespace gz
{
  namespace sim
  {
    // Inline bracket to help doxygen filtering.
    inline namespace GZ_SIM_VERSION_NAMESPACE {
    // Forward declarations.
    class ServerConfigPrivate;
 
    class GZ_SIM_VISIBLE ServerConfig
    {
      public: enum class SourceType
      {
        // No source specified.
        kNone,
 
        // The source is an SDF Root object.
        kSdfRoot,
 
        // The source is an SDF file.
        kSdfFile,
 
        // The source is an SDF string.
        kSdfString,
      };
 
      public: enum class SdfErrorBehavior
      {
        EXIT_IMMEDIATELY,
        CONTINUE_LOADING
      };
 
      class PluginInfoPrivate;
      public: class GZ_SIM_VISIBLE PluginInfo
      {
        public: PluginInfo();
 
        public: ~PluginInfo();
 
        public: PluginInfo(const std::string &_entityName,
                           const std::string &_entityType,
                           const sdf::Plugin &_plugin);
 
        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 sdf::Plugin &Plugin() const;
 
        public: sdf::Plugin &Plugin();
 
        public: void SetPlugin(const sdf::Plugin &_plugin) const;
 
        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 SetSdfRoot(const sdf::Root &_root) const;
 
      public: std::optional<sdf::Root> &SdfRoot() const;
 
      public: void SetUpdateRate(const double &_hz);
 
      public: std::optional<double> UpdateRate() const;
 
      public: void SetInitialSimTime(const double &_initialSimTime) const;
 
      public: double InitialSimTime() 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: std::chrono::steady_clock::duration LogRecordPeriod() const;
 
      public: void SetLogRecordPeriod(
          const std::chrono::steady_clock::duration &_period);
 
      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 SetRenderEngineServerApiBackend(
                  const std::string &_apiBackend);
 
      const std::string &RenderEngineServerApiBackend() const;
 
      public: void SetRenderEngineGui(const std::string &_renderEngineGui);
 
      public: void SetRenderEngineGuiApiBackend(
                  const std::string &_apiBackend);
 
      public: const std::string &RenderEngineGuiApiBackend() const;
 
      public: void SetBehaviorOnSdfErrors(SdfErrorBehavior _behavior);
 
      public: SdfErrorBehavior BehaviorOnSdfErrors() const;
 
      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;
 
      public: SourceType Source() const;
 
      private: std::unique_ptr<ServerConfigPrivate> dataPtr;
    };
 
    std::list<ServerConfig::PluginInfo>
    GZ_SIM_VISIBLE
    parsePluginsFromFile(const std::string &_fname);
 
    std::list<ServerConfig::PluginInfo>
    GZ_SIM_VISIBLE
    parsePluginsFromString(const std::string &_str);
 
    //
    //
    std::list<ServerConfig::PluginInfo>
    GZ_SIM_VISIBLE
    loadPluginInfo(bool _isPlayback = false);
    }
  }
}
 
#endif