"using" directives are no longer used in global namespaces (#219)

simulation/frc_gazebo_plugins/clock/src/clock.cpp

@@ -11,7 +11,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Clock)
 
-void Clock::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Clock::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
@@ -27,18 +27,18 @@ void Clock::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
-  pub = node->Advertise<msgs::Float64>(topic);
+  pub = node->Advertise<gazebo::msgs::Float64>(topic);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Clock::Update, this, _1));
 }
 
-void Clock::Update(const common::UpdateInfo& info) {
-  msgs::Float64 msg;
+void Clock::Update(const gazebo::common::UpdateInfo& info) {
+  gazebo::msgs::Float64 msg;
   msg.set_data(info.simTime.Double());
   pub->Publish(msg);
 }

simulation/frc_gazebo_plugins/clock/src/clock.h

@@ -15,8 +15,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for publishing the simulation time.
  *
@@ -34,19 +32,27 @@ using namespace gazebo;
  *
  * \todo Make WorldPlugin?
  */
-class Clock : public ModelPlugin {
+class Clock : public gazebo::ModelPlugin {
  public:
   /// \brief Load the clock and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out time each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
-  std::string topic;        ///< \brief Publish the time on this topic.
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::PublisherPtr pub;  ///< \brief Publisher handle.
+  /// \brief Publish the time on this topic.
+  std::string topic;
+
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Publisher handle.
+  gazebo::transport::PublisherPtr pub;
 };

simulation/frc_gazebo_plugins/dc_motor/src/dc_motor.cpp

@@ -11,7 +11,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(DCMotor)
 
-void DCMotor::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void DCMotor::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
   signal = 0;
 
@@ -36,21 +36,21 @@ void DCMotor::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
   sub = node->Subscribe(topic, &DCMotor::Callback, this);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&DCMotor::Update, this, _1));
 }
 
-void DCMotor::Update(const common::UpdateInfo& info) {
+void DCMotor::Update(const gazebo::common::UpdateInfo& info) {
   joint->SetForce(0, signal * multiplier);
 }
 
-void DCMotor::Callback(const msgs::ConstFloat64Ptr& msg) {
+void DCMotor::Callback(const gazebo::msgs::ConstFloat64Ptr& msg) {
   signal = msg->data();
   if (signal < -1) {
     signal = -1;

simulation/frc_gazebo_plugins/dc_motor/src/dc_motor.h

@@ -15,8 +15,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for controlling a joint with a DC motor.
  *
@@ -37,13 +35,13 @@ using namespace gazebo;
  * - `topic`: Optional. Message type should be gazebo.msgs.Float64.
  * - `multiplier`: Optional. Defaults to 1.
  */
-class DCMotor : public ModelPlugin {
+class DCMotor : public gazebo::ModelPlugin {
  public:
   /// \brief Load the dc motor and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Update the torque on the joint from the dc motor each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Topic to read control signal from.
@@ -56,14 +54,20 @@ class DCMotor : public ModelPlugin {
   double multiplier;
 
   /// \brief The joint that this dc motor drives.
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
 
   /// \brief Callback for receiving msgs and storing the signal.
-  void Callback(const msgs::ConstFloat64Ptr& msg);
+  void Callback(const gazebo::msgs::ConstFloat64Ptr& msg);
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::SubscriberPtr sub;  ///< \brief Subscriber handle.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer toe the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Subscriber handle.
+  gazebo::transport::SubscriberPtr sub;
 };

simulation/frc_gazebo_plugins/encoder/src/encoder.cpp

@@ -11,7 +11,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Encoder)
 
-void Encoder::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Encoder::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
@@ -38,20 +38,20 @@ void Encoder::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
   command_sub = node->Subscribe(topic + "/control", &Encoder::Callback, this);
-  pos_pub = node->Advertise<msgs::Float64>(topic + "/position");
-  vel_pub = node->Advertise<msgs::Float64>(topic + "/velocity");
+  pos_pub = node->Advertise<gazebo::msgs::Float64>(topic + "/position");
+  vel_pub = node->Advertise<gazebo::msgs::Float64>(topic + "/velocity");
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Encoder::Update, this, _1));
 }
 
-void Encoder::Update(const common::UpdateInfo& info) {
-  msgs::Float64 pos_msg, vel_msg;
+void Encoder::Update(const gazebo::common::UpdateInfo& info) {
+  gazebo::msgs::Float64 pos_msg, vel_msg;
   if (stopped) {
     pos_msg.set_data(stop_value);
     pos_pub->Publish(pos_msg);
@@ -65,7 +65,7 @@ void Encoder::Update(const common::UpdateInfo& info) {
   }
 }
 
-void Encoder::Callback(const msgs::ConstStringPtr& msg) {
+void Encoder::Callback(const gazebo::msgs::ConstStringPtr& msg) {
   std::string command = msg->data();
   if (command == "reset") {
     zero = GetAngle();

simulation/frc_gazebo_plugins/encoder/src/encoder.h

@@ -15,8 +15,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for reading the speed and relative angle of a joint.
  *
@@ -45,13 +43,13 @@ using namespace gazebo;
  * (gazebo.msgs.String)
  * - `units`: Optional. Defaults to radians.
  */
-class Encoder : public ModelPlugin {
+class Encoder : public gazebo::ModelPlugin {
  public:
   /// \brief Load the encoder and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out the encoder reading each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Root topic for subtopics on this topic.
@@ -70,10 +68,10 @@ class Encoder : public ModelPlugin {
   double stop_value;
 
   /// \brief The joint that this encoder measures
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
 
   /// \brief Callback for handling control data
-  void Callback(const msgs::ConstStringPtr& msg);
+  void Callback(const gazebo::msgs::ConstStringPtr& msg);
 
   /// \brief Gets the current angle, taking into account whether to
   ///        return radians or degrees.
@@ -83,10 +81,18 @@ class Encoder : public ModelPlugin {
   ///        return radians/second or degrees/second.
   double GetVelocity();
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::SubscriberPtr command_sub;      ///< \brief Subscriber handle.
-  transport::PublisherPtr pos_pub, vel_pub;  ///< \brief Publisher handles.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Subscriber handle.
+  gazebo::transport::SubscriberPtr command_sub;
+
+  /// \brief Publisher handles.
+  gazebo::transport::PublisherPtr pos_pub, vel_pub;
 };

simulation/frc_gazebo_plugins/gyro/src/gyro.cpp

@@ -11,7 +11,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Gyro)
 
-void Gyro::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Gyro::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
@@ -41,27 +41,27 @@ void Gyro::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
   command_sub = node->Subscribe(topic + "/control", &Gyro::Callback, this);
-  pos_pub = node->Advertise<msgs::Float64>(topic + "/position");
-  vel_pub = node->Advertise<msgs::Float64>(topic + "/velocity");
+  pos_pub = node->Advertise<gazebo::msgs::Float64>(topic + "/position");
+  vel_pub = node->Advertise<gazebo::msgs::Float64>(topic + "/velocity");
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Gyro::Update, this, _1));
 }
 
-void Gyro::Update(const common::UpdateInfo& info) {
-  msgs::Float64 pos_msg, vel_msg;
+void Gyro::Update(const gazebo::common::UpdateInfo& info) {
+  gazebo::msgs::Float64 pos_msg, vel_msg;
   pos_msg.set_data(Limit(GetAngle() - zero));
   pos_pub->Publish(pos_msg);
   vel_msg.set_data(GetVelocity());
   vel_pub->Publish(vel_msg);
 }
 
-void Gyro::Callback(const msgs::ConstStringPtr& msg) {
+void Gyro::Callback(const gazebo::msgs::ConstStringPtr& msg) {
   std::string command = msg->data();
   if (command == "reset") {
     zero = GetAngle();

simulation/frc_gazebo_plugins/gyro/src/gyro.h

@@ -15,8 +15,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /// \brief The axis about which to measure rotation.
 typedef enum { Roll /*X*/, Pitch /*Y*/, Yaw /*Z*/ } ROTATION;
 
@@ -44,13 +42,13 @@ typedef enum { Roll /*X*/, Pitch /*Y*/, Yaw /*Z*/ } ROTATION;
  * (gazebo.msgs.String)
  * - `units`; Optional, defaults to radians.
  */
-class Gyro : public ModelPlugin {
+class Gyro : public gazebo::ModelPlugin {
  public:
   /// \brief Load the gyro and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out the gyro reading each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Publish the angle on this topic.
@@ -66,10 +64,10 @@ class Gyro : public ModelPlugin {
   double zero;
 
   /// \brief The link that this gyro measures
-  physics::LinkPtr link;
+  gazebo::physics::LinkPtr link;
 
   /// \brief Callback for handling control data
-  void Callback(const msgs::ConstStringPtr& msg);
+  void Callback(const gazebo::msgs::ConstStringPtr& msg);
 
   /// \brief Gets the current angle, taking into account whether to
   ///        return radians or degrees.
@@ -83,10 +81,18 @@ class Gyro : public ModelPlugin {
   ///       depending on whether or radians or degrees are being used.
   double Limit(double value);
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::SubscriberPtr command_sub;      ///< \brief Subscriber handle.
-  transport::PublisherPtr pos_pub, vel_pub;  ///< \brief Publisher handles.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Subscriber handle.
+  gazebo::transport::SubscriberPtr command_sub;
+
+  /// \brief Publisher handles.
+  gazebo::transport::PublisherPtr pos_pub, vel_pub;
 };

simulation/frc_gazebo_plugins/limit_switch/src/external_limit_switch.cpp

@@ -10,8 +10,8 @@
 #include <string>
 
 ExternalLimitSwitch::ExternalLimitSwitch(sdf::ElementPtr sdf) {
-  sensor = std::dynamic_pointer_cast<sensors::ContactSensor>(
-      sensors::get_sensor(sdf->Get<std::string>("sensor")));
+  sensor = std::dynamic_pointer_cast<gazebo::sensors::ContactSensor>(
+      gazebo::sensors::get_sensor(sdf->Get<std::string>("sensor")));
 
   gzmsg << "\texternal limit switch: "
         << " sensor=" << sensor->Name() << std::endl;

simulation/frc_gazebo_plugins/limit_switch/src/external_limit_switch.h

@@ -17,8 +17,6 @@
 #include <Winsock2.h>
 #endif
 
-using namespace gazebo;
-
 class ExternalLimitSwitch : public Switch {
  public:
   explicit ExternalLimitSwitch(sdf::ElementPtr sdf);
@@ -27,5 +25,5 @@ class ExternalLimitSwitch : public Switch {
   virtual bool Get();
 
  private:
-  sensors::ContactSensorPtr sensor;
+  gazebo::sensors::ContactSensorPtr sensor;
 };

simulation/frc_gazebo_plugins/limit_switch/src/internal_limit_switch.cpp

@@ -9,7 +9,7 @@
 
 #include <string>
 
-InternalLimitSwitch::InternalLimitSwitch(physics::ModelPtr model,
+InternalLimitSwitch::InternalLimitSwitch(gazebo::physics::ModelPtr model,
                                          sdf::ElementPtr sdf) {
   joint = model->GetJoint(sdf->Get<std::string>("joint"));
   min = sdf->Get<double>("min");

simulation/frc_gazebo_plugins/limit_switch/src/internal_limit_switch.h

@@ -16,17 +16,15 @@
 #include <Winsock2.h>
 #endif
 
-using namespace gazebo;
-
 class InternalLimitSwitch : public Switch {
  public:
-  InternalLimitSwitch(physics::ModelPtr model, sdf::ElementPtr sdf);
+  InternalLimitSwitch(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Returns true when the switch is triggered.
   virtual bool Get();
 
  private:
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
   double min, max;
   bool radians;
 };

simulation/frc_gazebo_plugins/limit_switch/src/limit_switch.cpp

@@ -11,7 +11,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(LimitSwitch)
 
-void LimitSwitch::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void LimitSwitch::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
@@ -36,18 +36,18 @@ void LimitSwitch::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
-  pub = node->Advertise<msgs::Bool>(topic);
+  pub = node->Advertise<gazebo::msgs::Bool>(topic);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&LimitSwitch::Update, this, _1));
 }
 
-void LimitSwitch::Update(const common::UpdateInfo& info) {
-  msgs::Bool msg;
+void LimitSwitch::Update(const gazebo::common::UpdateInfo& info) {
+  gazebo::msgs::Bool msg;
   msg.set_data(ls->Get());
   pub->Publish(msg);
 }

simulation/frc_gazebo_plugins/limit_switch/src/limit_switch.h

@@ -18,8 +18,6 @@
 #include "simulation/gz_msgs/msgs.h"
 #include "switch.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for reading limit switches.
  *
@@ -66,13 +64,13 @@ using namespace gazebo;
  * External
  * - `sensor`: Name of the contact sensor that this limit switch uses.
  */
-class LimitSwitch : public ModelPlugin {
+class LimitSwitch : public gazebo::ModelPlugin {
  public:
   /// \brief Load the limit switch and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out the limit switch reading each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Publish the limit switch value on this topic.
@@ -81,9 +79,15 @@ class LimitSwitch : public ModelPlugin {
   /// \brief LimitSwitch object, currently internal or external.
   Switch* ls;
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::PublisherPtr pub;  ///< \brief Publisher handle.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Publisher handle.
+  gazebo::transport::PublisherPtr pub;
 };

simulation/frc_gazebo_plugins/pneumatic_piston/src/pneumatic_piston.cpp

@@ -19,7 +19,8 @@
 
 GZ_REGISTER_MODEL_PLUGIN(PneumaticPiston)
 
-void PneumaticPiston::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void PneumaticPiston::Load(gazebo::physics::ModelPtr model,
+                           sdf::ElementPtr sdf) {
   this->model = model;
   signal = 0;
 
@@ -48,21 +49,21 @@ void PneumaticPiston::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
   sub = node->Subscribe(topic, &PneumaticPiston::Callback, this);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&PneumaticPiston::Update, this, _1));
 }
 
-void PneumaticPiston::Update(const common::UpdateInfo& info) {
+void PneumaticPiston::Update(const gazebo::common::UpdateInfo& info) {
   joint->SetForce(0, signal);
 }
 
-void PneumaticPiston::Callback(const msgs::ConstFloat64Ptr& msg) {
+void PneumaticPiston::Callback(const gazebo::msgs::ConstFloat64Ptr& msg) {
   if (msg->data() < -0.001) {
     signal = -reverse_force;
   } else if (msg->data() > 0.001) {

simulation/frc_gazebo_plugins/pneumatic_piston/src/pneumatic_piston.h

@@ -13,8 +13,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for controlling a joint with a pneumatic piston.
  *
@@ -49,13 +47,13 @@ using namespace gazebo;
  *
  * \todo Signal should probably be made a tri-state message.
  */
-class PneumaticPiston : public ModelPlugin {
+class PneumaticPiston : public gazebo::ModelPlugin {
  public:
   /// \brief Load the pneumatic piston and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Updat the force the piston applies on the joint.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Topic to read control signal from.
@@ -68,14 +66,20 @@ class PneumaticPiston : public ModelPlugin {
   double forward_force, reverse_force;
 
   /// \brief The joint that this pneumatic piston actuates.
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
 
   /// \brief Callback for receiving msgs and updating the torque.
-  void Callback(const msgs::ConstFloat64Ptr& msg);
+  void Callback(const gazebo::msgs::ConstFloat64Ptr& msg);
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::SubscriberPtr sub;  ///< \brief Subscriber handle.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Subscriber handle.
+  gazebo::transport::SubscriberPtr sub;
 };

simulation/frc_gazebo_plugins/potentiometer/src/potentiometer.cpp

@@ -19,7 +19,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Potentiometer)
 
-void Potentiometer::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Potentiometer::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
@@ -43,19 +43,19 @@ void Potentiometer::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
-  pub = node->Advertise<msgs::Float64>(topic);
+  pub = node->Advertise<gazebo::msgs::Float64>(topic);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Potentiometer::Update, this, _1));
 }
 
-void Potentiometer::Update(const common::UpdateInfo& info) {
+void Potentiometer::Update(const gazebo::common::UpdateInfo& info) {
   joint->GetAngle(0).Normalize();
-  msgs::Float64 msg;
+  gazebo::msgs::Float64 msg;
   if (radians) {
     msg.set_data(joint->GetAngle(0).Radian());
   } else {

simulation/frc_gazebo_plugins/potentiometer/src/potentiometer.h

@@ -13,8 +13,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for reading the angle of a joint.
  *
@@ -34,13 +32,13 @@ using namespace gazebo;
  * - `topic`: Optional. Message will be published as a gazebo.msgs.Float64.
  * - `units`: Optional. Defaults to radians.
  */
-class Potentiometer : public ModelPlugin {
+class Potentiometer : public gazebo::ModelPlugin {
  public:
   /// \brief Load the potentiometer and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out the potentiometer reading each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Publish the angle on this topic.
@@ -50,11 +48,17 @@ class Potentiometer : public ModelPlugin {
   bool radians;
 
   /// \brief The joint that this potentiometer measures
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::PublisherPtr pub;  ///< \brief Publisher handle.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Publisher handle.
+  gazebo::transport::PublisherPtr pub;
 };

simulation/frc_gazebo_plugins/rangefinder/src/rangefinder.cpp

@@ -20,12 +20,12 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Rangefinder)
 
-void Rangefinder::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Rangefinder::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
 
   // Parse SDF properties
-  sensor = std::dynamic_pointer_cast<sensors::SonarSensor>(
-      sensors::get_sensor(sdf->Get<std::string>("sensor")));
+  sensor = std::dynamic_pointer_cast<gazebo::sensors::SonarSensor>(
+      gazebo::sensors::get_sensor(sdf->Get<std::string>("sensor")));
   if (sdf->HasElement("topic")) {
     topic = sdf->Get<std::string>("topic");
   } else {
@@ -39,18 +39,18 @@ void Rangefinder::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
-  pub = node->Advertise<msgs::Float64>(topic);
+  pub = node->Advertise<gazebo::msgs::Float64>(topic);
 
   // Connect to the world update event.
   // This will trigger the Update function every Gazebo iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Rangefinder::Update, this, _1));
 }
 
-void Rangefinder::Update(const common::UpdateInfo& info) {
-  msgs::Float64 msg;
+void Rangefinder::Update(const gazebo::common::UpdateInfo& info) {
+  gazebo::msgs::Float64 msg;
   msg.set_data(sensor->Range());
   pub->Publish(msg);
 }

simulation/frc_gazebo_plugins/rangefinder/src/rangefinder.h

@@ -13,8 +13,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for reading the range of obstacles.
  *
@@ -32,24 +30,30 @@ using namespace gazebo;
  * - `sensor`: Name of the sonar sensor that this rangefinder uses.
  * - `topic`: Optional. Message will be published as a gazebo.msgs.Float64.
  */
-class Rangefinder : public ModelPlugin {
+class Rangefinder : public gazebo::ModelPlugin {
  public:
   /// \brief Load the rangefinder and configures it according to the sdf.
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Sends out the rangefinder reading each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Publish the range on this topic.
   std::string topic;
 
   /// \brief The sonar sensor that this rangefinder uses
-  sensors::SonarSensorPtr sensor;
+  gazebo::sensors::SonarSensorPtr sensor;
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to.
-  event::ConnectionPtr
-      updateConn;           ///< \brief Pointer to the world update function.
-  transport::NodePtr node;  ///< \brief The node we're advertising on.
-  transport::PublisherPtr pub;  ///< \brief Publisher handle.
+  /// \brief The model to which this is attached.
+  gazebo::physics::ModelPtr model;
+
+  /// \brief Pointer to the world update function.
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising.
+  gazebo::transport::NodePtr node;
+
+  /// \brief Publisher handle.
+  gazebo::transport::PublisherPtr pub;
 };

simulation/frc_gazebo_plugins/servo/src/servo.cpp

@@ -19,7 +19,7 @@
 
 GZ_REGISTER_MODEL_PLUGIN(Servo)
 
-void Servo::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
+void Servo::Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf) {
   this->model = model;
   signal = 0;
 
@@ -44,17 +44,17 @@ void Servo::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
   std::string scoped_name =
       model->GetWorld()->GetName() + "::" + model->GetScopedName();
   boost::replace_all(scoped_name, "::", "/");
-  node = transport::NodePtr(new transport::Node());
+  node = gazebo::transport::NodePtr(new gazebo::transport::Node());
   node->Init(scoped_name);
   sub = node->Subscribe(topic, &Servo::Callback, this);
 
   // connect to the world update event
   // this will call update every iteration
-  updateConn = event::Events::ConnectWorldUpdateBegin(
+  updateConn = gazebo::event::Events::ConnectWorldUpdateBegin(
       boost::bind(&Servo::Update, this, _1));
 }
 
-void Servo::Update(const common::UpdateInfo& info) {
+void Servo::Update(const gazebo::common::UpdateInfo& info) {
   // torque is in kg*cm
   // joint->SetAngle(0,signal*180);
   if (joint->GetAngle(0) < signal) {
@@ -65,7 +65,7 @@ void Servo::Update(const common::UpdateInfo& info) {
   joint->SetForce(0, 0);
 }
 
-void Servo::Callback(const msgs::ConstFloat64Ptr& msg) {
+void Servo::Callback(const gazebo::msgs::ConstFloat64Ptr& msg) {
   signal = msg->data();
   if (signal < -1) {
     signal = -1;

simulation/frc_gazebo_plugins/servo/src/servo.h

@@ -13,8 +13,6 @@
 
 #include "simulation/gz_msgs/msgs.h"
 
-using namespace gazebo;
-
 /**
  * \brief Plugin for controlling a servo.
  *
@@ -34,13 +32,13 @@ using namespace gazebo;
  * - `link`: Name of the link the servo is attached to.
  * - `topic`: Optional. Message type should be gazebo.msgs.Float64.
  */
-class Servo : public ModelPlugin {
+class Servo : public gazebo::ModelPlugin {
  public:
   /// \brief load the servo and configure it according to the sdf
-  void Load(physics::ModelPtr model, sdf::ElementPtr sdf);
+  void Load(gazebo::physics::ModelPtr model, sdf::ElementPtr sdf);
 
   /// \brief Update the torque on the joint from the dc motor each timestep.
-  void Update(const common::UpdateInfo& info);
+  void Update(const gazebo::common::UpdateInfo& info);
 
  private:
   /// \brief Topic to read control signal from.
@@ -53,14 +51,20 @@ class Servo : public ModelPlugin {
   double torque;
 
   /// \brief the joint that this servo moves
-  physics::JointPtr joint;
+  gazebo::physics::JointPtr joint;
 
   /// \brief Callback for receiving msgs and storing the signal
-  void Callback(const msgs::ConstFloat64Ptr& msg);
+  void Callback(const gazebo::msgs::ConstFloat64Ptr& msg);
 
-  physics::ModelPtr model;  ///< \brief The model that this is attached to
-  event::ConnectionPtr
-      updateConn;           ///< \brief The Pointer to the world update function
-  transport::NodePtr node;  ///< \brief The node we're advertising torque on
-  transport::SubscriberPtr sub;  ///< \brief the Subscriber for the pwm signal
+  /// \brief The model to which this is attached
+  gazebo::physics::ModelPtr model;
+
+  /// \brief The pointer to the world update function
+  gazebo::event::ConnectionPtr updateConn;
+
+  /// \brief The node on which we're advertising torque
+  gazebo::transport::NodePtr node;
+
+  /// \brief The subscriber for the PWM signal
+  gazebo::transport::SubscriberPtr sub;
 };