node.h

Go to the documentation of this file.

// Launch configuration for a single Node
// Author: Max Schwarz <max.schwarz@uni-bonn.de>
 
#ifndef ROSMON_LAUNCH_NODE_H
#define ROSMON_LAUNCH_NODE_H
 
#include <string>
#include <map>
#include <memory>
#include <vector>
 
#include <ros/time.h>
 
namespace rosmon
{
 
namespace launch
{
 
class Node
{
public:
        typedef std::shared_ptr<Node> Ptr;
        typedef std::shared_ptr<const Node> ConstPtr;
 
        Node(std::string name, std::string package, std::string type);
 
        void setRemappings(const std::map<std::string, std::string>& remappings);
        void addExtraArguments(const std::string& argString);
        void setNamespace(const std::string& ns);
        void setExtraEnvironment(const std::map<std::string, std::string>& env);
        void setCoredumpsEnabled(bool on);
 
        void setRespawn(bool respawn);
        void setRespawnDelay(const ros::WallDuration& respawnDelay);
        void setNumRespawnsAllowed(int numRespawnsAllowed);
        void setSpawnDelay(const ros::WallDuration& spawnDelay);
 
        void setLaunchPrefix(const std::string& launchPrefix);
 
        void setWorkingDirectory(const std::string& workingDirectory);
 
        void setClearParams(bool on);
 
        void setStopTimeout(double timeout);
 
        void setMemoryLimit(uint64_t memoryLimitByte);
 
        void setCPULimit(double cpuLimit);
 
        void setMuted(bool muted);
        void setStdoutDisplayed(bool showStdout);
 
        std::string name() const
        { return m_name; }
 
        std::string package() const
        { return m_package; }
 
        std::string type() const
        { return m_type; }
 
        std::string executable() const
        { return m_executable; }
 
        std::string namespaceString() const
        { return m_namespace; }
 
        std::map<std::string, std::string> remappings() const
        { return m_remappings; }
 
        std::vector<std::string> extraArguments() const
        { return m_extraArgs; }
 
        std::map<std::string, std::string> extraEnvironment() const
        { return m_extraEnvironment; }
 
        bool respawn() const
        { return m_respawn; }
 
        ros::WallDuration respawnDelay() const
        { return m_respawnDelay; }
 
        int numRespawnsAllowed() const
        { return m_numRespawnsAllowed; }
 
        ros::WallDuration spawnDelay() const
        { return m_spawnDelay; }
 
        void setRequired(bool required);
 
        bool required() const
        { return m_required; }
 
        std::vector<std::string> launchPrefix() const
        { return m_launchPrefix; }
 
        bool coredumpsEnabled() const
        { return m_coredumpsEnabled; }
 
        std::string workingDirectory() const
        { return m_workingDirectory; }
 
        bool clearParams() const
        { return m_clearParams; }
 
        double stopTimeout() const
        { return m_stopTimeout; }
 
        uint64_t memoryLimitByte() const
        { return m_memoryLimitByte;}
 
        double cpuLimit() const
        { return m_cpuLimit; }
 
        bool isMuted() const
        { return m_muted; }
 
        bool stdoutDisplayed() const
        { return m_stdoutDisplayed; }
private:
        std::string m_name;
        std::string m_package;
        std::string m_type;
 
        std::string m_executable;
 
        std::string m_namespace;
 
        std::map<std::string, std::string> m_remappings;
        std::vector<std::string> m_extraArgs;
 
        std::map<std::string, std::string> m_extraEnvironment;
 
        bool m_respawn;
        ros::WallDuration m_respawnDelay;
        int m_numRespawnsAllowed = 0;  // Will warn on any respawn by default
        ros::WallDuration m_spawnDelay;
 
        bool m_required;
 
        std::vector<std::string> m_launchPrefix;
 
        bool m_coredumpsEnabled;
 
        std::string m_workingDirectory;
 
        bool m_clearParams;
 
        double m_stopTimeout;
 
        uint64_t m_memoryLimitByte;
        double m_cpuLimit;
 
        bool m_muted;
        bool m_stdoutDisplayed;
};
 
}
 
}
 
#endif