ros_primitives_typekit_plugin.cpp

Go to the documentation of this file.

/*
 * (C) 2010, Ruben Smits, ruben.smits@mech.kuleuven.be
 * (C) 2010, Steven Bellens, steven.bellens@mech.kuleuven.be
 * Department of Mechanical Engineering,
 * Katholieke Universiteit Leuven, Belgium.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "ros_primitives_typekit_plugin.hpp"

namespace ros_integration {

    double float_to_double( float val ) {return double(val);}
    float double_to_float( double val ) {return float(val);}
    int32_t float_to_int(float f) { return int32_t(f); }
    float int_to_float(int i) { return float(i); }
    int32_t double_to_int(double f) { return int32_t(f); }
    double int_to_double(int32_t i) { return double(i); }
    uint32_t int_to_uint(int32_t i) { return (uint32_t)(i); }
    int uint_to_int(uint32_t ui) { return int32_t(ui); }
    bool int_to_bool(int32_t i) { return bool(i); }

    template<class T,class R>
    R a_to_b( T t ) { return R(t); }

    struct string_ctor
        : public std::unary_function<int, const std::string&>
    {
        mutable boost::shared_ptr< std::string > ptr;
        typedef const std::string& (Signature)( int );
        string_ctor()
            : ptr( new std::string() ) {}
        const std::string& operator()( int size ) const
        {
            ptr->resize( size );
            return *(ptr);
        }
    };

    void loadTimeTypes();

    void loadUInt8Types();
    void loadInt8Types();

    void loadUInt16Types();
    void loadInt16Types();

    void loadUInt32Types();
    void loadInt32Types();

    void loadUInt64Types();
    void loadInt64Types();

    void loadFloat32Types();
    void loadFloat64Types();

    void loadStringTypes();

    std::string ROSPrimitivesTypekitPlugin::getName(){
        return "ros-primitives";
    }

    bool ROSPrimitivesTypekitPlugin::loadTypes() {
      loadTimeTypes();

      loadInt8Types();
      loadUInt8Types();

      loadInt16Types();
      loadUInt16Types();

      loadInt32Types();
      loadUInt32Types();

      loadInt64Types();
      loadUInt64Types();

      loadFloat32Types();
      loadFloat64Types();

      loadStringTypes();

            return true;
    }
    bool ROSPrimitivesTypekitPlugin::loadOperators() { return true; }
    bool ROSPrimitivesTypekitPlugin::loadConstructors() {
        types::TypeInfoRepository::shared_ptr ti = types::TypeInfoRepository::Instance();
        // x to float64
        ti->type("float64")->addConstructor( newConstructor( &float_to_double, true ));
        ti->type("float64")->addConstructor( newConstructor( &int_to_double, true ));

        // x to float
        ti->type("float")->addConstructor( newConstructor( &int_to_float, true ));
        ti->type("float")->addConstructor( newConstructor( &double_to_float, true ));

        // x to int
        ti->type("int32")->addConstructor( newConstructor( &float_to_int, false ));
        ti->type("int32")->addConstructor( newConstructor( &double_to_int, false ));

        // we certainly need int32/uint32 to 8/16 since the RTT parser only knows 32bit wide ints.

        // x to uint8_t (ROS' bool)
        ti->type("uint8")->addConstructor( newConstructor( &a_to_b<int8_t,uint8_t>, false ));
        ti->type("uint8")->addConstructor( newConstructor( &a_to_b<int16_t,uint8_t>, false ));
        ti->type("uint8")->addConstructor( newConstructor( &a_to_b<int32_t,uint8_t>, false ));
        ti->type("uint8")->addConstructor( newConstructor( &a_to_b<uint16_t,uint8_t>, false ));
        ti->type("uint8")->addConstructor( newConstructor( &a_to_b<uint32_t,uint8_t>, false ));

        ti->type("int8")->addConstructor( newConstructor( &a_to_b<uint8_t,int8_t>, false ));
        ti->type("int8")->addConstructor( newConstructor( &a_to_b<uint16_t,int8_t>, false ));
        ti->type("int8")->addConstructor( newConstructor( &a_to_b<uint32_t,int8_t>, false ));
        ti->type("int8")->addConstructor( newConstructor( &a_to_b<int16_t,int8_t>, false ));
        ti->type("int8")->addConstructor( newConstructor( &a_to_b<int32_t,int8_t>, false ));

        // x to uint16_t
        ti->type("uint16")->addConstructor( newConstructor( &a_to_b<int8_t,uint16_t>, false ));
        ti->type("uint16")->addConstructor( newConstructor( &a_to_b<int16_t,uint16_t>, false ));
        ti->type("uint16")->addConstructor( newConstructor( &a_to_b<int32_t,uint16_t>, false ));
        ti->type("uint16")->addConstructor( newConstructor( &a_to_b<uint8_t,uint16_t>, true ));
        ti->type("uint16")->addConstructor( newConstructor( &a_to_b<uint32_t,uint16_t>, false ));

        ti->type("int16")->addConstructor( newConstructor( &a_to_b<uint8_t,int16_t>, true ));
        ti->type("int16")->addConstructor( newConstructor( &a_to_b<uint16_t,int16_t>, false ));
        ti->type("int16")->addConstructor( newConstructor( &a_to_b<uint32_t,int16_t>, false ));
        ti->type("int16")->addConstructor( newConstructor( &a_to_b<int8_t,int16_t>, true ));
        ti->type("int16")->addConstructor( newConstructor( &a_to_b<int32_t,int16_t>, false ));

        // x to uint32_t
        ti->type("uint32")->addConstructor( newConstructor( &a_to_b<int8_t,uint32_t>, false ));
        ti->type("uint32")->addConstructor( newConstructor( &a_to_b<int16_t,uint32_t>, false ));
        ti->type("uint32")->addConstructor( newConstructor( &a_to_b<int32_t,uint32_t>, true ));
        ti->type("uint32")->addConstructor( newConstructor( &a_to_b<uint8_t,uint32_t>, true ));
        ti->type("uint32")->addConstructor( newConstructor( &a_to_b<uint16_t,uint32_t>, true ));

        ti->type("int32")->addConstructor( newConstructor( &a_to_b<uint8_t,int32_t>, true ));
        ti->type("int32")->addConstructor( newConstructor( &a_to_b<uint16_t,int32_t>, true ));
        ti->type("int32")->addConstructor( newConstructor( &a_to_b<uint32_t,int32_t>, true ));
        ti->type("int32")->addConstructor( newConstructor( &a_to_b<int8_t,int32_t>, true ));
        ti->type("int32")->addConstructor( newConstructor( &a_to_b<int16_t,int32_t>, true ));

        ti->type("string")->addConstructor( newConstructor( string_ctor() ) );
        ti->type("duration")->addConstructor( newConstructor ( &a_to_b<double,ros::Duration>, true));
        ti->type("time")->addConstructor( newConstructor ( &a_to_b<double,ros::Time>, true));
        return true;
    }
}

ORO_TYPEKIT_PLUGIN( ros_integration::ROSPrimitivesTypekitPlugin )