Events.hh

Go to the documentation of this file.

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

#include <string>
#include <sdf/sdf.hh>

#include "gazebo/common/Console.hh"
#include "gazebo/common/UpdateInfo.hh"
#include "gazebo/common/Event.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace event
  {

    class GZ_COMMON_VISIBLE Events
    {
      public: template<typename T>
              static ConnectionPtr ConnectPause(T _subscriber)
              { return pause.Connect(_subscriber); }

      public: static void DisconnectPause(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { pause.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectStep(T _subscriber)
              { return step.Connect(_subscriber); }
      public: static void DisconnectStep(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { step.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectStop(T _subscriber)
              { return stop.Connect(_subscriber); }
      public: static void DisconnectStop(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { stop.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectWorldCreated(T _subscriber)
              { return worldCreated.Connect(_subscriber); }
      public: static void DisconnectWorldCreated(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { worldCreated.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectCreateEntity(T _subscriber)
              { return entityCreated.Connect(_subscriber); }
      public: static void DisconnectCreateEntity(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { entityCreated.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectSetSelectedEntity(T _subscriber)
              { return setSelectedEntity.Connect(_subscriber); }
      public: static void DisconnectSetSelectedEntity(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { setSelectedEntity.Disconnect(_subscriber->Id()); }
      public: template<typename T>
              static ConnectionPtr ConnectDeleteEntity(T _subscriber)
              { return deleteEntity.Connect(_subscriber); }
      public: static void DisconnectDeleteEntity(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { deleteEntity.Disconnect(_subscriber->Id()); }
      public: template<typename T>
              static ConnectionPtr ConnectAddEntity(T _subscriber)
              { return addEntity.Connect(_subscriber); }
      public: static void DisconnectAddEntity(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { addEntity.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectWorldUpdateBegin(T _subscriber)
              { return worldUpdateBegin.Connect(_subscriber); }

      public: static void DisconnectWorldUpdateBegin(
                  ConnectionPtr _subscriber) GAZEBO_DEPRECATED(8.0);

      public: template<typename T>
              static ConnectionPtr ConnectBeforePhysicsUpdate(T _subscriber)
              { return beforePhysicsUpdate.Connect(_subscriber); }

      public: static void DisconnectBeforePhysicsUpdate(
                ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { beforePhysicsUpdate.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectWorldUpdateEnd(T _subscriber)
              { return worldUpdateEnd.Connect(_subscriber); }
      public: static void DisconnectWorldUpdateEnd(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { worldUpdateEnd.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectWorldReset(T _subscriber)
              { return worldReset.Connect(_subscriber); }

      public: static void DisconnectWorldReset(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { worldReset.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectTimeReset(T _subscriber)
              { return timeReset.Connect(_subscriber); }

      public: static void DisconnectTimeReset(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { timeReset.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectRemoveSensor(T _subscriber)
              { return removeSensor.Connect(_subscriber); }

      public: static void DisconnectRemoveSensor(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { removeSensor.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectCreateSensor(T _subscriber)
              { return createSensor.Connect(_subscriber); }

      public: static void DisconnectCreateSensor(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { createSensor.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectPreRender(T _subscriber)
              { return preRender.Connect(_subscriber); }
      public: static void DisconnectPreRender(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { preRender.Disconnect(_subscriber->Id()); }
      public: template<typename T>
              static ConnectionPtr ConnectRender(T _subscriber)
              { return render.Connect(_subscriber); }
      public: static void DisconnectRender(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { render.Disconnect(_subscriber->Id()); }
      public: template<typename T>
              static ConnectionPtr ConnectPostRender(T _subscriber)
              { return postRender.Connect(_subscriber); }
      public: static void DisconnectPostRender(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { postRender.Disconnect(_subscriber->Id()); }
      public: template<typename T>
              static ConnectionPtr ConnectDiagTimerStart(T _subscriber)
              { return diagTimerStart.Connect(_subscriber); }
      public: static void DisconnectDiagTimerStart(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { diagTimerStart.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectDiagTimerStop(T _subscriber)
              { return diagTimerStop.Connect(_subscriber); }
      public: static void DisconnectDiagTimerStop(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { diagTimerStop.Disconnect(_subscriber->Id()); }

      public: template<typename T>
              static ConnectionPtr ConnectSigInt(T _subscriber)
              { return sigInt.Connect(_subscriber); }
      public: static void DisconnectSigInt(ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { sigInt.Disconnect(_subscriber->Id()); }

      public: static EventT<void (bool)> pause;

      public: static EventT<void ()> step;

      public: static EventT<void ()> stop;

      public: static EventT<void ()> sigInt;

      public: static EventT<void (std::string)> worldCreated;

      public: static EventT<void (std::string)> entityCreated;

      public: static EventT<void (std::string, std::string)> setSelectedEntity;

      public: static EventT<void (std::string)> addEntity;

      public: static EventT<void (std::string)> deleteEntity;

      public: static EventT<void (const common::UpdateInfo &)> worldUpdateBegin;

      public: static EventT<void (const common::UpdateInfo &)>
                beforePhysicsUpdate;

      public: static EventT<void ()> worldUpdateEnd;

      public: static EventT<void ()> worldReset;

      public: static EventT<void ()> timeReset;

      public: static EventT<void ()> preRender;

      public: static EventT<void ()> render;

      public: static EventT<void ()> postRender;

      public: static EventT<void (std::string)> diagTimerStart;

      public: static EventT<void (std::string)> diagTimerStop;

      public: static EventT<void (std::string)> removeSensor;

      public: static EventT<void (sdf::ElementPtr,
                  const std::string &,
                  const std::string &,
                  const uint32_t)> createSensor;
    };
  }
}
#endif