converter.hpp

Go to the documentation of this file.

/*
 * Copyright 2015 Aldebaran
 *
 * 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 CONVERTER_HPP
#define CONVERTER_HPP
 
#include <string>
 
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
 
#include <ros/ros.h>
#include <naoqi_driver/message_actions.h>
 
namespace naoqi
{
namespace converter
{
 
 
class Converter
{
 
public:
 
  template<typename T>
  Converter( T conv ):
    convPtr_( boost::make_shared<ConverterModel<T> >(conv) )
  {}
 
  std::string name() const
  {
    return convPtr_->name();
  }
 
  float frequency() const
  {
    return convPtr_->frequency();
  }
 
  void reset()
  {
    convPtr_->reset();
  }
 
  void callAll( const std::vector<message_actions::MessageAction>& actions )
  {
    if ( actions.size() > 0 )
    {
      convPtr_->callAll(actions);
    }
 
    ros::Time after = ros::Time::now();
    lapse_time = after - before;
    before = after;
  }
 
  ros::Duration lapseTime() const
  {
    return lapse_time;
  }
 
  friend bool operator==( const Converter& lhs, const Converter& rhs )
  {
    // decision made for OR-comparison since we want to be more restrictive
    if ( lhs.name() == rhs.name() )
      return true;
    return false;
  }
 
private:
 
  ros::Time before;
  ros::Duration lapse_time;
 
  struct ConverterConcept
  {
    virtual ~ConverterConcept(){}
    virtual std::string name() const = 0;
    virtual float frequency() const = 0;
    virtual void reset() = 0;
    virtual void callAll( const std::vector<message_actions::MessageAction>& actions ) = 0;
  };
 
 
  template<typename T>
  struct ConverterModel : public ConverterConcept
  {
    ConverterModel( const T& other ):
      converter_( other )
    {}
 
    std::string name() const
    {
      return converter_->name();
    }
 
    float frequency() const
    {
      return converter_->frequency();
    }
    
    void reset()
    {
      converter_->reset();
    }
 
    void callAll( const std::vector<message_actions::MessageAction>& actions )
    {
      converter_->callAll( actions );
    }
 
    T converter_;
  };
 
  boost::shared_ptr<ConverterConcept> convPtr_;
 
}; // class converter
 
} //converter
} //naoqi
 
#endif