Event.hh

Go to the documentation of this file.

/*
 * Copyright 2012 Nate Koenig
 *
 * 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 _EVENT_HH_
#define _EVENT_HH_

#include <gazebo/gazebo_config.h>
#include <gazebo/common/Time.hh>
#include <gazebo/common/CommonTypes.hh>

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>

#include <iostream>
#include <vector>

namespace gazebo
{
  namespace event
  {

    class Event
    {
      public: virtual ~Event() {}

      public: virtual void Disconnect(ConnectionPtr _c) = 0;

      public: virtual void Disconnect(int _id) = 0;
    };

    class Connection
    {
      public: Connection() :event(NULL), id(-1) {}

      public: Connection(Event *_e, int _i);

      public: ~Connection();

      public: int GetId() const;

      private: Event *event;

      private: int id;

      private: static int counter;

      private: common::Time creationTime;

      public: template<typename T> friend class EventT;
    };

    template< typename T>
    class EventT : public Event
    {
      public: virtual ~EventT();

      public: ConnectionPtr Connect(const boost::function<T> &_subscriber);

      public: virtual void Disconnect(ConnectionPtr _c);

      public: virtual void Disconnect(int _id);

      public: void operator()()
              {this->Signal();}

      public: void Signal()
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])();
                }
              }

      public: template< typename P >
              void operator()(const P &_p)
              { this->Signal(_p); }

      public: template< typename P1, typename P2 >
              void operator()(const P1 &_p1, const P2 &_p2)
              { this->Signal(_p1, _p2); }

      public: template< typename P1, typename P2, typename P3 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3)
              { this->Signal(_p1, _p2, _p3); }

      public: template< typename P1, typename P2, typename P3, typename P4 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4)
              { this->Signal(_p1, _p2, _p3, _p4); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5)
              { this->Signal(_p1, _p2, _p3, _p4, _p5); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8, const P9 &_p9)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9, typename P10 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8, const P9 &_p9,
                              const P10 &_p10)
              {
                this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10);
              }

      public: template< typename P >
              void Signal(const P &_p)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p);
                }
              }

      public: template< typename P1, typename P2 >
              void Signal(const P1 &_p1, const P2 &_p2)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2);
                }
              }

      public: template< typename P1, typename P2, typename P3 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                          const P4 &_p4)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3, _p4);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                          const P4 &_p4, const P5 &_p5)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3, _p4, _p5);
                }
              }


      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3, _p4, _p5, _p6);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6, typename P7>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3, _p4, _p5, _p6, _p7);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6, typename P7, typename P8>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8)
           {
             for (unsigned int i = 0; i < connections.size(); i++)
             {
               (*this->connections[i])(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8);
             }
           }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8, const P9 &_p9)
          {
            for (unsigned int i = 0; i < connections.size(); i++)
            {
          (*this->connections[i])(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9);
            }
          }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9, typename P10 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8, const P9 &_p9, const P10 &_p10)
              {
                for (unsigned int i = 0; i < connections.size(); i++)
                {
                  (*this->connections[i])(_p1, _p2, _p3, _p4, _p5,
                      _p6, _p7, _p8, _p9, _p10);
                }
              }

      private: std::vector<boost::function<T> *> connections;

      private: std::vector<int> connectionIds;

      private: boost::mutex lock;
    };

    template<typename T>
    EventT<T>::~EventT()
    {
      for (unsigned int i = 0; i < this->connections.size(); i++)
        delete this->connections[i];
      this->connections.clear();
      this->connectionIds.clear();
    }

    template<typename T>
    ConnectionPtr EventT<T>::Connect(const boost::function<T> &_subscriber)
    {
      int index = this->connections.size();
      this->connections.push_back(new boost::function<T>(_subscriber));
      this->connectionIds.push_back(index);
      return ConnectionPtr(new Connection(this, index));
    }

    template<typename T>
    void EventT<T>::Disconnect(ConnectionPtr _c)
    {
      this->Disconnect(_c->GetId());
      _c->event = NULL;
      _c->id = -1;
    }

    template<typename T>
    void EventT<T>::Disconnect(int _id)
    {
      // search for index of the connection based on id
      for (unsigned int i = 0; i < this->connectionIds.size(); i++)
      {
        if (_id == this->connectionIds[i])
        {
          this->connectionIds.erase(this->connectionIds.begin()+i);
          this->connections.erase(this->connections.begin()+i);
          break;
        }
      }
    }
  }
}
#endif