some explicit markers;

some convenience type casts for pointers;
removed overloads: they were more trouble than they were worth

diff --git a/src/elambinary.h b/src/elambinary.h
index 6166f45..f0972bc 100644 (file)
--- a/src/elambinary.h
+++ b/src/elambinary.h
@@ -24,6 +24,14 @@ class Engine;
 \returns the result of the operation*/
 typedef std::function<QVariant(const QVariant&op1,const QVariant&op2,Engine&engine)>BinaryOperatorCall;
 
+/** Helper type to select the correct overload from several variants.
+If your compiler complains that it cannot resolve an overloaded pointer when calling BinaryOperator::setCallback then cast to this type to help the compiler:
+\code
+myBinaryOp.setCallback(BinaryOperatorCall_FP(myFunction),type1,type2);
+\endcode
+*/
+typedef QVariant(*BinaryOperatorCall_FP)(const QVariant&op1,const QVariant&op2,Engine&engine);
+
 /** \brief Wraps a particular binary operator.
 
 You can use the methods of this class to change the routines that handle the operator and the types on which it operates. Instances of this class are implicitly shared - meaning calls on a copy of an instance are also visible on the original and all other copies.
@@ -49,13 +57,6 @@ class BinaryOperator
                */
                void setCallback(BinaryOperatorCall callback,int type1,int type2);
                
-               ///convenience override to make the use of overloaded function pointers easier
-               void setCallback(QVariant(*fp)(const QVariant&,const QVariant&,Engine&),QString type1,QString type2)
-               {setCallback(BinaryOperatorCall(fp),type1,type2);}
-               ///convenience override to make the use of overloaded function pointers easier
-               void setCallback(QVariant(*fp)(const QVariant&,const QVariant&,Engine&),int type1,int type2)
-               {setCallback(BinaryOperatorCall(fp),type1,type2);}
-               
                /**returns the callback function attached to the type or NULL if there is none*/
                BinaryOperatorCall getCallback(QString type1,QString type2)const;
                /**returns the callback function attached to the type or NULL if there is none*/

diff --git a/src/elamengine.h b/src/elamengine.h
index 76c4d86..c849338 100644 (file)
--- a/src/elamengine.h
+++ b/src/elamengine.h
@@ -35,6 +35,14 @@ Functions must check their arguments for validity before they start calculating.
 */
 typedef std::function<QVariant(const QList<QVariant>&args,Engine&engine)>Function;
 
+/** Helper type to select the correct overload from several variants.
+If your compiler complains that it cannot resolve an overloaded pointer when calling Engine::setFunction then cast to this type to help the compiler:
+\code
+myEngine.setFunction("hellofunc",Function_FP(myFunction));
+\endcode
+*/
+typedef QVariant(*Function_FP)(const QList<QVariant>&args,Engine&engine);
+
 
 /**wraps the parser routine for a literal
 \param expr the original expression string
@@ -48,12 +56,28 @@ If the parser does not find a valid literal according to its rules it must retur
 */
 typedef std::function<QPair<QString,QVariant>(const QString&expr,Engine&engine,int start)>LiteralParser;
 
+/** Helper type to select the correct overload from several variants.
+If your compiler complains that it cannot resolve an overloaded pointer when calling Engine::setLiteralParser then cast to this type to help the compiler:
+\code
+myEngine.setLiteralParser(Function_FP(myDecimal),"123456789");
+\endcode
+*/
+typedef QPair<QString,QVariant>(*LiteralParser_FP)(const QString&expr,Engine&engine,int start);
+
 /**Wraps a cast function to convert various types into another type.
 \param orig the original value of any type
 \param engine the engine calling the cast
 \returns the converted value that conforms to the expected type*/
 typedef std::function<QVariant(const QVariant&orig,const Engine&engine)>TypeCast;
 
+/** Helper type to select the correct overload from several variants.
+If your compiler complains that it cannot resolve an overloaded pointer when calling Engine::setAutoCast then cast to this type to help the compiler:
+\code
+myEngine.setAutoCast(targetType,QList<int>()<<origintype,TypeCast_FP(myCast));
+\endcode
+*/
+typedef QVariant(*TypeCast_FP)(const QVariant&orig,const Engine&engine);
+
 /**The calculation engine of .
 
 Instances of this class can be configured to represent a specific system of functions and operators.
@@ -66,7 +90,7 @@ class Engine:public QObject
        DECLARE_DPTR(d);
        public:
                ///instantiates an engine object
-               Engine(QObject*parent=0);
+               explicit Engine(QObject*parent=0);
                
                ///true if the named variable exists in this engine
                Q_INVOKABLE virtual bool hasVariable(QString)const;

diff --git a/src/elamexpression.h b/src/elamexpression.h
index 7b16286..b804a05 100644 (file)
--- a/src/elamexpression.h
+++ b/src/elamexpression.h
@@ -71,7 +71,7 @@ class Token
                        IgnoredTokenMask=0xf0000000,
                };
                ///creates an empty/invalid token
-               Token(Position pos=Position(-1,-1));
+               explicit Token(Position pos=Position(-1,-1));
                ///creates a token from a parsed piece of string, only generic types can be used
                Token(QString,Type,Position pos=Position(-1,-1));
                ///creates a literal token

diff --git a/src/elamfloatengine.cpp b/src/elamfloatengine.cpp
index 0216b0d..cca26a8 100644 (file)
--- a/src/elamfloatengine.cpp
+++ b/src/elamfloatengine.cpp
@@ -148,7 +148,7 @@ void FloatEngine::configureFloatEngine(ELAM::Engine& eng)
        int iid=QVariant::LongLong;
        eng.setAutoCast(fid, QList<int>()<<QVariant::Int<<QVariant::LongLong<<QVariant::UInt<<QVariant::ULongLong, fltCast, 30);
        //unary
-       eng.unaryOperator("-").setCallback(floatMinus,fid);
+       eng.unaryOperator("-").setCallback(UnaryOperatorCall_FP(floatMinus),fid);
        eng.unaryOperator("+").setCallback(floatPlus,fid);
        //binary
         eng.binaryOperator("==",60).setCallback(fltEq,fid,fid);
@@ -169,9 +169,9 @@ void FloatEngine::configureFloatEngine(ELAM::Engine& eng)
         eng.binaryOperator(">",60).setCallback(fltGt,fid,fid);
         eng.binaryOperator(">").setCallback(fltGt,iid,fid);
         eng.binaryOperator(">").setCallback(fltGt,fid,iid);
-       eng.binaryOperator("-",80).setCallback(floatMinus,fid,fid);
-       eng.binaryOperator("-").setCallback(floatMinus,iid,fid);
-       eng.binaryOperator("-").setCallback(floatMinus,fid,iid);
+       eng.binaryOperator("-",80).setCallback(BinaryOperatorCall_FP(floatMinus),fid,fid);
+       eng.binaryOperator("-").setCallback(BinaryOperatorCall_FP(floatMinus),iid,fid);
+       eng.binaryOperator("-").setCallback(BinaryOperatorCall_FP(floatMinus),fid,iid);
        eng.binaryOperator("+",80).setCallback(floatAdd,fid,fid);
        eng.binaryOperator("+").setCallback(floatAdd,iid,fid);
        eng.binaryOperator("+").setCallback(floatAdd,fid,iid);

diff --git a/src/elamintengine.cpp b/src/elamintengine.cpp
index f050df9..f4e329e 100644 (file)
--- a/src/elamintengine.cpp
+++ b/src/elamintengine.cpp
@@ -144,7 +144,7 @@ void IntEngine::configureIntEngine(ELAM::Engine& eng)
        //cast
        eng.setFunction("int",intFunc);
        //unaries
-       eng.unaryOperator("-").setCallback(intMinus,iid);
+       eng.unaryOperator("-").setCallback(UnaryOperatorCall_FP(intMinus),iid);
        eng.unaryOperator("+").setCallback(intPlus,iid);
        eng.unaryOperator("~").setCallback(intNot,iid);
        //binaries
@@ -154,7 +154,7 @@ void IntEngine::configureIntEngine(ELAM::Engine& eng)
         eng.binaryOperator(">=",60).setCallback(intGe,iid,iid);
         eng.binaryOperator("<",60).setCallback(intLt,iid,iid);
         eng.binaryOperator(">",60).setCallback(intGt,iid,iid);
-       eng.binaryOperator("-",80).setCallback(intMinus,iid,iid);
+       eng.binaryOperator("-",80).setCallback(BinaryOperatorCall_FP(intMinus),iid,iid);
        eng.binaryOperator("+",80).setCallback(intAdd,iid,iid);
        eng.binaryOperator("*",90).setCallback(intMult,iid,iid);
        eng.binaryOperator("/",90).setCallback(intDiv,iid,iid);

diff --git a/src/elamunary.h b/src/elamunary.h
index 387e288..f79af2c 100644 (file)
--- a/src/elamunary.h
+++ b/src/elamunary.h
@@ -23,6 +23,14 @@ class Engine;
 \returns the result of the operation*/
 typedef std::function<QVariant(const QVariant&op,Engine&engine)>UnaryOperatorCall;
 
+/** Helper type to select the correct overload from several variants.
+If your compiler complains that it cannot resolve an overloaded pointer when calling UnaryOperator::setCallback then cast to this type to help the compiler:
+\code
+myUnaryOp.setCallback(UnaryOperatorCall_FP(myFunction),type);
+\endcode
+*/
+typedef QVariant(*UnaryOperatorCall_FP)(const QVariant&op,Engine&engine);
+
 /** \brief Wraps a particular unary operator.
 
 You can use the methods of this class to change the routines that handle the operator and the types on which it operates. Instances of this class are implicitly shared - meaning calls on a copy of an instance are also visible on the original and all other copies.
@@ -53,12 +61,6 @@ class UnaryOperator
                */
                void setCallback(UnaryOperatorCall callback,int type);
 
-               ///convenience overload to make the use of overloaded function pointers easier
-               void setCallback(QVariant(*fp)(const QVariant&,Engine&),int type)
-               {setCallback(UnaryOperatorCall(fp),type);}
-               ///convenience overload to make the use of overloaded function pointers easier
-               void setCallback(QVariant(*fp)(const QVariant&,Engine&),QString type)
-               {setCallback(UnaryOperatorCall(fp),type);}
                /**returns the callback function attached to the type or NULL if there is none*/
                UnaryOperatorCall getCallback(QString type)const;
                /**returns the callback function attached to the type or NULL if there is none*/