Simplify conversions between values and QVariants

.gitignore

@@ -62,6 +62,7 @@ Ankh.NoLoad
 .vs
 out
 build
+build-bench
 CMakeSettings.json
 enc_temp_folder
 CMakeUserPresets.json

ApplicationLibCode/Application/Tools/RiaOptionItemFactory.h

@@ -20,6 +20,7 @@
 
 #include "RifEclipseSummaryAddressDefines.h"
 
+#include "cafPdmOptionItemInfo.h"
 #include "cafPdmUiItem.h"
 
 #include <QList>

ApplicationLibCode/Application/Tools/RiaQDateTimeTools.cpp

@@ -23,6 +23,7 @@
 #include <QString>
 #include <QTime>
 
+#include "cafPdmOptionItemInfo.h"
 #include "cafPdmUiItem.h"
 
 #include <cvfAssert.h>

ApplicationLibCode/Commands/3dView/RicApplyUserDefinedCameraFeature.cpp

@@ -94,7 +94,7 @@ void RicApplyUserDefinedCameraFeature::readCameraFromSettings( cvf::Vec3d& eye,
     QVariant upVariant  = settings.value( RicStoreUserDefinedCameraFeature::upName() );
     if ( eyeVariant.isNull() || vrpVariant.isNull() || upVariant.isNull() ) return;
 
-    caf::PdmValueFieldSpecialization<cvf::Vec3d>::setFromVariant( eyeVariant, eye );
-    caf::PdmValueFieldSpecialization<cvf::Vec3d>::setFromVariant( vrpVariant, vrp );
-    caf::PdmValueFieldSpecialization<cvf::Vec3d>::setFromVariant( upVariant, up );
+    caf::pdmFromVariant( eyeVariant, eye );
+    caf::pdmFromVariant( vrpVariant, vrp );
+    caf::pdmFromVariant( upVariant, up );
 }

ApplicationLibCode/Commands/3dView/RicStoreUserDefinedCameraFeature.cpp

@@ -104,13 +104,13 @@ void RicStoreUserDefinedCameraFeature::onActionTriggered( bool isChecked )
 
         camera->toLookAt( &eye, &vrp, &up );
 
-        QVariant eyeVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( eye );
+        QVariant eyeVariant = caf::pdmToVariant( eye );
         settings.setValue( RicStoreUserDefinedCameraFeature::eyeName(), eyeVariant );
 
-        QVariant vrpVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( vrp );
+        QVariant vrpVariant = caf::pdmToVariant( vrp );
         settings.setValue( RicStoreUserDefinedCameraFeature::viewReferencePointName(), vrpVariant );
 
-        QVariant upVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( up );
+        QVariant upVariant = caf::pdmToVariant( up );
         settings.setValue( RicStoreUserDefinedCameraFeature::upName(), upVariant );
 
         RiuMainWindow::instance()->refreshViewActions();

ApplicationLibCode/Commands/AnnotationCommands/RicTextAnnotation3dEditor.cpp

@@ -177,7 +177,7 @@ void RicTextAnnotation3dEditor::updatePoint( caf::PdmUiFieldHandle* uiField, con
 
     cvf::Vec3d domainPos   = dispXf->transformToDomainCoord( newPos );
     domainPos.z()          = -domainPos.z();
-    QVariant originVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( domainPos );
+    QVariant originVariant = caf::pdmToVariant( domainPos );
 
     caf::PdmUiCommandSystemProxy::instance()->setUiValueToField( uiField, originVariant );
 }

ApplicationLibCode/Commands/WellPathCommands/PointTangentManipulator/RicPolylineTarget3dEditor.cpp

@@ -142,7 +142,7 @@ void RicPolylineTarget3dEditor::slotUpdated( const cvf::Vec3d& origin, const cvf
 
     cvf::Vec3d domainOrigin = dispXf->transformToDomainCoord( origin );
     domainOrigin.z()        = -domainOrigin.z();
-    QVariant originVariant  = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( domainOrigin );
+    QVariant originVariant  = caf::pdmToVariant( domainOrigin );
 
     caf::PdmUiCommandSystemProxy::instance()->setUiValueToField( target->targetPointUiCapability(), originVariant );
 }

ApplicationLibCode/ProjectDataModel/RimDataSourceSteppingTools.h

@@ -20,6 +20,7 @@
 
 #include "RifEclipseSummaryAddressDefines.h"
 
+#include "cafPdmOptionItemInfo.h"
 #include "cafPdmUiItem.h"
 #include "cafPdmValueField.h"
 

ApplicationLibCode/ProjectDataModel/WellPath/RimWellPathGeometryDef.cpp

@@ -520,7 +520,7 @@ void RimWellPathGeometryDef::fieldChangedByUi( const caf::PdmFieldHandle* change
                               linkedDefs.end() );
 
             cvf::Vec3d oldPos;
-            caf::PdmValueFieldSpecialization<cvf::Vec3d>::setFromVariant( oldValue, oldPos );
+            caf::pdmFromVariant( oldValue, oldPos );
 
             auto delta = m_referencePointUtmXyd() - oldPos;
 

CMakeLists.txt

@@ -989,6 +989,9 @@ option(RESINSIGHT_INCLUDE_APPFWK_TESTS "Enable AppFwk Tests" OFF)
 mark_as_advanced(FORCE RESINSIGHT_INCLUDE_APPFWK_TESTS)
 
 if(RESINSIGHT_INCLUDE_APPFWK_TESTS)
+  # Compile-time benchmark
+  add_subdirectory(Fwk/AppFwk/cafProjectDataModel/cafPdm_CompileBench)
+
   # Unit Tests
   add_subdirectory(Fwk/AppFwk/cafProjectDataModel/cafProjectDataModel_UnitTests)
   add_subdirectory(
@@ -997,6 +1000,7 @@ if(RESINSIGHT_INCLUDE_APPFWK_TESTS)
   add_subdirectory(Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafPdmXml_UnitTests)
   add_subdirectory(Fwk/AppFwk/cafPdmScripting/cafPdmScripting_UnitTests)
   add_subdirectory(Fwk/AppFwk/cafUserInterface/cafUserInterface_UnitTests)
+  add_subdirectory(Fwk/AppFwk/cafPdmCvf/cafPdmCvf_UnitTests)
 
   # Executables
   add_subdirectory(Fwk/AppFwk/cafTests/cafTestApplication)
@@ -1010,6 +1014,7 @@ if(RESINSIGHT_INCLUDE_APPFWK_TESTS)
     cafPdmXml_UnitTests
     cafPdmScripting_UnitTests
     cafUserInterface_UnitTests
+    cafPdmCvf_UnitTests
     cafTestApplication
     cafTestCvfApplication
   )

Fwk/AppFwk/cafPdmCvf/cafPdmCoreColor3f.h

@@ -39,40 +39,31 @@
 #include "cvfBase.h"
 #include "cvfColor3.h"
 
-#include "cafInternalPdmValueFieldSpecializations.h"
+#include "cafPdmFieldTraits.h"
 #include "cafPdmXmlColor3f.h"
 
 #include <QColor>
 
 namespace caf
 {
-//==================================================================================================
-/// Partial specialization for PdmValueFieldSpecialization< cvf::Color3f >
-//==================================================================================================
 
-template <>
-class PdmValueFieldSpecialization<cvf::Color3f>
+inline QVariant pdmToVariant( const cvf::Color3f& value )
 {
-public:
-    static QVariant convert( const cvf::Color3f& value )
-    {
-        QColor col;
-        col.setRgbF( value.r(), value.g(), value.b() );
-
-        return col;
-    }
-
-    static void setFromVariant( const QVariant& variantValue, cvf::Color3f& value )
-    {
-        QColor col = variantValue.value<QColor>();
+    QColor col;
+    col.setRgbF( value.r(), value.g(), value.b() );
+    return col;
+}
 
-        value.set( col.redF(), col.greenF(), col.blueF() );
-    }
+inline void pdmFromVariant( const QVariant& v, cvf::Color3f& out )
+{
+    QColor col = v.value<QColor>();
+    out.set( col.redF(), col.greenF(), col.blueF() );
+}
 
-    static bool isEqual( const QVariant& variantValue, const QVariant& variantValue2 )
-    {
-        return variantValue == variantValue2;
-    }
+template <>
+struct PdmVariantEqualImpl<cvf::Color3f>
+{
+    static bool equal( const QVariant& a, const QVariant& b ) { return a.value<QColor>() == b.value<QColor>(); }
 };
 
 } // end namespace caf

Fwk/AppFwk/cafPdmCvf/cafPdmCoreMat4d.h

@@ -39,43 +39,34 @@
 #include "cvfBase.h"
 #include "cvfMatrix4.h"
 
-#include "cafInternalPdmValueFieldSpecializations.h"
+#include "cafPdmFieldTraits.h"
 
 #include "cafPdmXmlMat4d.h"
 
 #include <QTextStream>
 
 namespace caf
 {
-template <>
-class PdmValueFieldSpecialization<cvf::Mat4d>
-{
-public:
-    /// Convert the field value into a QVariant
-    static QVariant convert( const cvf::Mat4d& value )
-    {
-        QString str;
-
-        QTextStream textStream( &str );
-        textStream << value;
-
-        return QVariant( str );
-    }
-
-    /// Set the field value from a QVariant
-    static void setFromVariant( const QVariant& variantValue, cvf::Mat4d& value )
-    {
-        QString str = variantValue.toString();
 
-        QTextStream textStream( &str );
+inline QVariant pdmToVariant( const cvf::Mat4d& value )
+{
+    QString     str;
+    QTextStream textStream( &str );
+    textStream << value;
+    return QVariant( str );
+}
 
-        textStream >> value;
-    }
+inline void pdmFromVariant( const QVariant& v, cvf::Mat4d& out )
+{
+    QString     str = v.toString();
+    QTextStream textStream( &str );
+    textStream >> out;
+}
 
-    static bool isEqual( const QVariant& variantValue, const QVariant& variantValue2 )
-    {
-        return variantValue == variantValue2;
-    }
+template <>
+struct PdmVariantEqualImpl<cvf::Mat4d>
+{
+    static bool equal( const QVariant& a, const QVariant& b ) { return a.toString() == b.toString(); }
 };
 
 } // end namespace caf

Fwk/AppFwk/cafPdmCvf/cafPdmCoreVec3d.h

@@ -39,7 +39,7 @@
 #include "cvfBase.h"
 #include "cvfVector3.h"
 
-#include "cafInternalPdmValueFieldSpecializations.h"
+#include "cafPdmFieldTraits.h"
 
 #include "cafPdmXmlVec3d.h"
 
@@ -49,35 +49,26 @@ Q_DECLARE_METATYPE( cvf::Vec3d );
 
 namespace caf
 {
-template <>
-class PdmValueFieldSpecialization<cvf::Vec3d>
-{
-public:
-    /// Convert the field value into a QVariant
-    static QVariant convert( const cvf::Vec3d& value )
-    {
-        QString str;
-
-        QTextStream textStream( &str );
-        textStream << value;
-
-        return QVariant( str );
-    }
-
-    /// Set the field value from a QVariant
-    static void setFromVariant( const QVariant& variantValue, cvf::Vec3d& value )
-    {
-        QString str = variantValue.toString();
 
-        QTextStream textStream( &str );
+inline QVariant pdmToVariant( const cvf::Vec3d& value )
+{
+    QString     str;
+    QTextStream textStream( &str );
+    textStream << value;
+    return QVariant( str );
+}
 
-        textStream >> value;
-    }
+inline void pdmFromVariant( const QVariant& v, cvf::Vec3d& out )
+{
+    QString     str = v.toString();
+    QTextStream textStream( &str );
+    textStream >> out;
+}
 
-    static bool isEqual( const QVariant& variantValue, const QVariant& variantValue2 )
-    {
-        return variantValue == variantValue2;
-    }
+template <>
+struct PdmVariantEqualImpl<cvf::Vec3d>
+{
+    static bool equal( const QVariant& a, const QVariant& b ) { return a.toString() == b.toString(); }
 };
 
 } // end namespace caf

Fwk/AppFwk/cafPdmCvf/cafPdmCvf_UnitTests/cafPdmCoreColor3fTest.cpp

@@ -33,16 +33,30 @@ TEST( VariantTest, PdmCoreColor3f )
     float        b = 0.18f;
     cvf::Color3f myColor( r, g, b );
 
-    QVariant myVariant = caf::PdmValueFieldSpecialization<cvf::Color3f>::convert( myColor );
+    QVariant myVariant = caf::pdmToVariant( myColor );
 
     cvf::Color3f decoded;
-    caf::PdmValueFieldSpecialization<cvf::Color3f>::setFromVariant( myVariant, decoded );
+    caf::pdmFromVariant( myVariant, decoded );
 
     EXPECT_FLOAT_EQ( myColor.r(), decoded.r() );
     EXPECT_FLOAT_EQ( myColor.g(), decoded.g() );
     EXPECT_NEAR( myColor.b(), decoded.b(), 0.01 ); // For some reason, 0.18 is not close enough to use EXPECT_FLOAT_EQ
 }
 
+TEST( VariantEqualTest, PdmCoreColor3f )
+{
+    cvf::Color3f a( 0.4f, 0.2f, 0.18f );
+    cvf::Color3f b( 0.4f, 0.2f, 0.18f );
+    cvf::Color3f c( 0.4f, 0.2f, 0.5f );
+
+    QVariant va = caf::pdmToVariant( a );
+    QVariant vb = caf::pdmToVariant( b );
+    QVariant vc = caf::pdmToVariant( c );
+
+    EXPECT_TRUE( caf::pdmVariantEqual<cvf::Color3f>( va, vb ) );
+    EXPECT_FALSE( caf::pdmVariantEqual<cvf::Color3f>( va, vc ) );
+}
+
 TEST( SerializeSeveralTest, PdmCoreColor3f )
 {
     float        r = 0.4f;

Fwk/AppFwk/cafPdmCvf/cafPdmCvf_UnitTests/cafPdmCoreMat4dTest.cpp

@@ -53,10 +53,10 @@ TEST( VariantTest, PdmCoreMat4d )
 {
     cvf::Mat4d myMatrix = createMatrix();
 
-    QVariant myVariant = caf::PdmValueFieldSpecialization<cvf::Mat4d>::convert( myMatrix );
+    QVariant myVariant = caf::pdmToVariant( myMatrix );
 
     cvf::Mat4d decoded;
-    caf::PdmValueFieldSpecialization<cvf::Mat4d>::setFromVariant( myVariant, decoded );
+    caf::pdmFromVariant( myVariant, decoded );
 
     EXPECT_TRUE( decoded.equals( myMatrix ) );
 }

Fwk/AppFwk/cafPdmCvf/cafPdmCvf_UnitTests/cafPdmCoreVec3dTest.cpp

@@ -37,14 +37,28 @@ TEST( VariantTest, PdmCoreVec3d )
 
     cvf::Vec3d myVector( a, b, c );
 
-    QVariant myVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( myVector );
+    QVariant myVariant = caf::pdmToVariant( myVector );
 
     cvf::Vec3d decoded;
-    caf::PdmValueFieldSpecialization<cvf::Vec3d>::setFromVariant( myVariant, decoded );
+    caf::pdmFromVariant( myVariant, decoded );
 
     EXPECT_TRUE( decoded.equals( myVector ) );
 }
 
+TEST( VariantEqualTest, PdmCoreVec3d )
+{
+    cvf::Vec3d a( 1.0, 2.0, 3.0 );
+    cvf::Vec3d b( 1.0, 2.0, 3.0 );
+    cvf::Vec3d c( 1.0, 2.0, 4.0 );
+
+    QVariant va = caf::pdmToVariant( a );
+    QVariant vb = caf::pdmToVariant( b );
+    QVariant vc = caf::pdmToVariant( c );
+
+    EXPECT_TRUE( caf::pdmVariantEqual<cvf::Vec3d>( va, vb ) );
+    EXPECT_FALSE( caf::pdmVariantEqual<cvf::Vec3d>( va, vc ) );
+}
+
 TEST( SerializeSeveralTest, PdmCoreVec3d )
 {
     double a = 2.4;