Commit 9fe407a7 authored by Flavien Bridault's avatar Flavien Bridault
Browse files

New upstream version 0.8.2

parent 6990764c

.gitignore

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ qtc-gdbmacros/ 
*.o

*.a

moc_*

build/



*.cmake

CMakeFiles/

cmake/Config.cmake

+1 −1
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
# setup version numbers

set(VERSION_MAJOR 0)

set(VERSION_MINOR 8)

set(VERSION_PATCH 1)

set(VERSION_PATCH 2)

set(VERSION_STR "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")

message("Project version: ${VERSION_STR}")

include/camp/qt/qtfunction.hpp

+17 −17
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ public: 


            case 1:

            {

                QVariant arg1 = QtHelper::valueToVariant(args[0]);

                const auto arg1 = QtHelper::argumentToVariant(args[0], m_metaMethod.parameterType(0));

                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret

                                  , QGenericArgument(arg1.typeName(), arg1.data()));

                break;
@@ -94,8 +94,8 @@ public: 


            case 2:

            {

                QVariant arg1 = QtHelper::valueToVariant(args[0]);

                QVariant arg2 = QtHelper::valueToVariant(args[1]);

                const auto arg1 = QtHelper::argumentToVariant(args[0], m_metaMethod.parameterType(0));

                const auto arg2 = QtHelper::argumentToVariant(args[1], m_metaMethod.parameterType(1));

                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret

                                  , QGenericArgument(arg1.typeName(), arg1.data())

                                  , QGenericArgument(arg2.typeName(), arg2.data()));
@@ -104,9 +104,9 @@ public: 


            case 3:

            {

                QVariant arg1 = QtHelper::valueToVariant(args[0]);

                QVariant arg2 = QtHelper::valueToVariant(args[1]);

                QVariant arg3 = QtHelper::valueToVariant(args[2]);

                const auto arg1 = QtHelper::argumentToVariant(args[0], m_metaMethod.parameterType(0));

                const auto arg2 = QtHelper::argumentToVariant(args[1], m_metaMethod.parameterType(1));

                const auto arg3 = QtHelper::argumentToVariant(args[2], m_metaMethod.parameterType(2));

                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret

                                  , QGenericArgument(arg1.typeName(), arg1.data())

                                  , QGenericArgument(arg2.typeName(), arg2.data())
@@ -116,10 +116,10 @@ public: 


            case 4:

            {

                QVariant arg1 = QtHelper::valueToVariant(args[0]);

                QVariant arg2 = QtHelper::valueToVariant(args[1]);

                QVariant arg3 = QtHelper::valueToVariant(args[2]);

                QVariant arg4 = QtHelper::valueToVariant(args[3]);

                const auto arg1 = QtHelper::argumentToVariant(args[0], m_metaMethod.parameterType(0));

                const auto arg2 = QtHelper::argumentToVariant(args[1], m_metaMethod.parameterType(1));

                const auto arg3 = QtHelper::argumentToVariant(args[2], m_metaMethod.parameterType(2));

                const auto arg4 = QtHelper::argumentToVariant(args[3], m_metaMethod.parameterType(3));

                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret

                                  , QGenericArgument(arg1.typeName(), arg1.data())

                                  , QGenericArgument(arg2.typeName(), arg2.data())
@@ -130,11 +130,11 @@ public: 


            case 5:

            {

                QVariant arg1 = QtHelper::valueToVariant(args[0]);

                QVariant arg2 = QtHelper::valueToVariant(args[1]);

                QVariant arg3 = QtHelper::valueToVariant(args[2]);

                QVariant arg4 = QtHelper::valueToVariant(args[3]);

                QVariant arg5 = QtHelper::valueToVariant(args[4]);

                const auto arg1 = QtHelper::argumentToVariant(args[0], m_metaMethod.parameterType(0));

                const auto arg2 = QtHelper::argumentToVariant(args[1], m_metaMethod.parameterType(1));

                const auto arg3 = QtHelper::argumentToVariant(args[2], m_metaMethod.parameterType(2));

                const auto arg4 = QtHelper::argumentToVariant(args[3], m_metaMethod.parameterType(3));

                const auto arg5 = QtHelper::argumentToVariant(args[4], m_metaMethod.parameterType(4));

                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret

                                  , QGenericArgument(arg1.typeName(), arg1.data())

                                  , QGenericArgument(arg2.typeName(), arg2.data())

include/camp/qt/qthelper.hpp

+43 −5
Original line number Diff line number Diff line
@@ -105,11 +105,11 @@ public: 
            case QMetaType::QString:      return QVariant::String;

            case QMetaType::QByteArray:   return QVariant::ByteArray;

            case QMetaType::VoidStar:     return QVariant::Invalid;

            case QMetaType::Long:         return QVariant::Int;

            case QMetaType::Long:         return (sizeof(int) == sizeof(long)) ? QVariant::Int : QVariant::LongLong;

            case QMetaType::LongLong:     return QVariant::LongLong;

            case QMetaType::Short:        return QVariant::Int;

            case QMetaType::Char:         return QVariant::Char;

            case QMetaType::ULong:        return QVariant::UInt;

            case QMetaType::ULong:        return (sizeof(int) == sizeof(long)) ? QVariant::UInt : QVariant::ULongLong;

            case QMetaType::ULongLong:    return QVariant::ULongLong;

            case QMetaType::UShort:       return QVariant::UInt;

            case QMetaType::UChar:        return QVariant::Char;
@@ -166,12 +166,18 @@ public: 
     */

    static QVariant valueToVariant(const camp::Value& value)

    {

        auto toInt = [](const camp::Value& value)

        {

            return value.to<long>() > static_cast<long>(std::numeric_limits<int>::max())

                    ? QVariant(value.to<long long>())

                    : QVariant(value.to<int>());

        };

        switch (value.type())

        {

            default:

            case camp::noType:     return QVariant();

            case camp::boolType:   return QVariant(value.to<bool>());

            case camp::intType:    return QVariant(value.to<int>());

            case camp::intType:    return toInt(value);

            case camp::realType:   return QVariant(value.to<double>());

            case camp::stringType: return QVariant(value.to<QString>());

            case camp::enumType:   return QVariant(value.to<int>());
@@ -179,6 +185,38 @@ public: 
        }

    }



    /**

     * \brief Convert a CAMP value to a QGenericArgument

     *

     * \param value Source camp::Value to convert

     *

     * \return \a value converted to a QGenericArgument

     */

    static QVariant argumentToVariant(const camp::Value& value, int metaType)

    {

        switch (metaType)

        {

            default:

            case QMetaType::Void:         return QVariant();

            case QMetaType::Bool:         return value.to<bool>();

            case QMetaType::Int:          return value.to<int>();

            case QMetaType::UInt:         return value.to<unsigned int>();

            case QMetaType::Double:       return value.to<double>();

            case QMetaType::QChar:        return value.to<char>();

            case QMetaType::QString:      return value.to<QString>();

            case QMetaType::Long:         return sizeof(int) == sizeof(long) ? value.to<int>(): value.to<long long>();

            case QMetaType::LongLong:     return value.to<long long>();

            case QMetaType::Short:        return value.to<short>();

            case QMetaType::Char:         return value.to<char>();

            case QMetaType::ULong:        return sizeof(int) == sizeof(long) ? value.to<unsigned int>(): value.to<unsigned long long>();

            case QMetaType::ULongLong:    return value.to<unsigned long long>();;

            case QMetaType::UShort:       return value.to<unsigned short>();;

            case QMetaType::UChar:        return value.to<unsigned char>();;

            case QMetaType::Float:        return value.to<float>();

        }

    }





    /**

     * \brief Convert a QVariant to a CAMP value

     *

include/camp/valuemapper.hpp

+50 −34
Original line number Diff line number Diff line
@@ -40,8 +40,8 @@ 
#include <camp/arraymapper.hpp>

#include <camp/errors.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/type_traits.hpp>

#include <boost/utility/enable_if.hpp>



#include <type_traits>





namespace camp_ext
@@ -124,7 +124,9 @@ struct ValueMapper 
    static camp::UserObject to(const T& source) {return camp::UserObject(source);}



    static T from(bool)                           {CAMP_ERROR(camp::BadType(camp::boolType,   camp::mapType<T>()));}

    static T from(int)                            {CAMP_ERROR(camp::BadType(camp::intType,    camp::mapType<T>()));}

    static T from(long)                           {CAMP_ERROR(camp::BadType(camp::intType,    camp::mapType<T>()));}

    static T from(long long)                      {CAMP_ERROR(camp::BadType(camp::intType,    camp::mapType<T>()));}

    static T from(double)                         {CAMP_ERROR(camp::BadType(camp::realType,   camp::mapType<T>()));}

    static T from(const std::string&)             {CAMP_ERROR(camp::BadType(camp::stringType, camp::mapType<T>()));}

    static T from(const camp::EnumObject&)        {CAMP_ERROR(camp::BadType(camp::enumType,   camp::mapType<T>()));}
@@ -135,7 +137,7 @@ struct ValueMapper 
 * Specialization of ValueMapper for abstract types

 */

template <typename T>

struct ValueMapper<T, typename boost::enable_if<boost::is_abstract<T> >::type>

struct ValueMapper<T, typename std::enable_if<std::is_abstract<T>::value >::type>

{

    static const int type = camp::userType;

    static camp::UserObject to(const T& source) {return camp::UserObject(source);}
@@ -152,6 +154,7 @@ struct ValueMapper<bool> 


    static bool from(bool source)                    {return source;}

    static bool from(long source)                    {return source != 0;}

    static bool from(long long source)               {return source != 0;}

    static bool from(double source)                  {return source != 0.;}

    static bool from(const std::string& source)

    {
@@ -178,16 +181,18 @@ struct ValueMapper<bool> 
 * Specialization of ValueMapper for integers

 */

template <typename T>

struct ValueMapper<T, typename boost::enable_if_c<boost::is_integral<T>::value

                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

struct ValueMapper<T, typename std::enable_if<std::is_integral<T>::value

                                          && !std::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                          && !std::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

                                         >::type>

{

    static const int type = camp::intType;

    static long to(T source) {return static_cast<long>(source);}



    static T from(bool source)                    {return static_cast<T>(source);}

    static T from(int source)                     {return static_cast<T>(source);}

    static T from(long source)                    {return static_cast<T>(source);}

    static T from(long long )                     {CAMP_ERROR(camp::BadType(camp::userType, camp::intType));}

    static T from(double source)                  {return static_cast<T>(source);}

    static T from(const std::string& source)      {return boost::lexical_cast<T>(source);}

    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}
@@ -198,16 +203,19 @@ struct ValueMapper<T, typename boost::enable_if_c<boost::is_integral<T>::value 
 * Specialization of ValueMapper for reals

 */

template <typename T>

struct ValueMapper<T, typename boost::enable_if_c<boost::is_float<T>::value

                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

struct ValueMapper<T, typename std::enable_if<std::is_floating_point<T>::value

                                          && !std::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                          && !std::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

                                         >::type>

{

    static const int type = camp::realType;

    static double to(T source) {return static_cast<double>(source);}



    static T from(bool source)                    {return static_cast<T>(source);}

    static T from(int source)                     {return static_cast<T>(source);}

    static T from(long source)                    {return static_cast<T>(source);}

    static T from(long long source)               {return static_cast<T>(source);}

    static T from(float source)                   {return static_cast<T>(source);}

    static T from(double source)                  {return static_cast<T>(source);}

    static T from(const std::string& source)      {return boost::lexical_cast<T>(source);}

    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}
@@ -224,7 +232,9 @@ struct ValueMapper<std::string> 
    static const std::string& to(const std::string& source) {return source;}



    static std::string from(bool source)                    {return boost::lexical_cast<std::string>(source);}

    static std::string from(int source)                     {return boost::lexical_cast<std::string>(source);}

    static std::string from(long source)                    {return boost::lexical_cast<std::string>(source);}

    static std::string from(long long source)               {return boost::lexical_cast<std::string>(source);}

    static std::string from(double source)                  {return boost::lexical_cast<std::string>(source);}

    static std::string from(const std::string& source)      {return source;}

    static std::string from(const camp::EnumObject& source) {return source.name();}
@@ -238,9 +248,9 @@ struct ValueMapper<std::string> 
 * Warning: special case for char[] and const char[], they are strings not arrays

 */

template <typename T>

struct ValueMapper<T, typename boost::enable_if_c<camp::detail::IsArray<T>::value

                                                  && !boost::is_same<typename camp_ext::ArrayMapper<T>::ElementType, char>::value

                                                  && !boost::is_same<typename camp_ext::ArrayMapper<T>::ElementType, const char>::value

struct ValueMapper<T, typename std::enable_if<camp::detail::IsArray<T>::value

                                              && !std::is_same<typename camp_ext::ArrayMapper<T>::ElementType, char>::value

                                              && !std::is_same<typename camp_ext::ArrayMapper<T>::ElementType, const char>::value

                                             >::type>

{

    static const int type = camp::arrayType;
@@ -267,16 +277,18 @@ struct ValueMapper<const char[N]> 
 * Specialization of ValueMapper for enum types

 */

template <typename T>

struct ValueMapper<T, typename boost::enable_if_c<boost::is_enum<T>::value

                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

struct ValueMapper<T, typename std::enable_if<std::is_enum<T>::value

                                              && !std::is_const<T>::value // to avoid conflict with ValueMapper<const T>

                                              && !std::is_reference<T>::value // to avoid conflict with ValueMapper<T&>

                                             >::type>

{

    static const int type = camp::enumType;

    static camp::EnumObject to(T source) {return camp::EnumObject(source);}



    static T from(bool source)                    {return static_cast<T>(static_cast<long>(source));}

    static T from(int source)                     {return static_cast<T>(source);}

    static T from(long source)                    {return static_cast<T>(source);}

    static T from(long long source)               {return static_cast<T>(source);}

    static T from(double source)                  {return static_cast<T>(static_cast<long>(source));}

    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}

    static T from(const camp::UserObject&)        {CAMP_ERROR(camp::BadType(camp::userType, camp::enumType));}
@@ -313,7 +325,9 @@ struct ValueMapper<camp::EnumObject> 
    static const camp::EnumObject& from(const camp::EnumObject& source) {return source;}



    static camp::UserObject from(bool)                    {CAMP_ERROR(camp::BadType(camp::boolType,     camp::enumType));}

    static camp::UserObject from(int)                     {CAMP_ERROR(camp::BadType(camp::intType,      camp::enumType));}

    static camp::UserObject from(long)                    {CAMP_ERROR(camp::BadType(camp::intType,      camp::enumType));}

    static camp::UserObject from(long long)               {CAMP_ERROR(camp::BadType(camp::intType,      camp::enumType));}

    static camp::UserObject from(double)                  {CAMP_ERROR(camp::BadType(camp::realType,     camp::enumType));}

    static camp::UserObject from(const std::string&)      {CAMP_ERROR(camp::BadType(camp::stringType,   camp::enumType));}

    static camp::UserObject from(const camp::UserObject&) {CAMP_ERROR(camp::BadType(camp::enumType,     camp::enumType));}
@@ -330,7 +344,9 @@ struct ValueMapper<camp::UserObject> 
    static const camp::UserObject& from(const camp::UserObject& source) {return source;}



    static camp::UserObject from(bool)                    {CAMP_ERROR(camp::BadType(camp::boolType,     camp::userType));}

    static camp::UserObject from(int)                     {CAMP_ERROR(camp::BadType(camp::intType,      camp::userType));}

    static camp::UserObject from(long)                    {CAMP_ERROR(camp::BadType(camp::intType,      camp::userType));}

    static camp::UserObject from(long long)               {CAMP_ERROR(camp::BadType(camp::intType,      camp::userType));}

    static camp::UserObject from(double)                  {CAMP_ERROR(camp::BadType(camp::realType,     camp::userType));}

    static camp::UserObject from(const std::string&)      {CAMP_ERROR(camp::BadType(camp::stringType,   camp::userType));}

    static camp::UserObject from(const camp::EnumObject&) {CAMP_ERROR(camp::BadType(camp::enumType,     camp::userType));}