Add caf::VecIjk0 and caf::VecIjk1.

ApplicationLibCode/UnitTests/CMakeLists.txt

@@ -119,6 +119,7 @@ set(SOURCE_UNITTEST_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RifSurfio-Test.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RifRmsWellPathReader-Test.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RiaAngleUtils-Test.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/cafVecIjk-Test.cpp
 )
 
 if(RESINSIGHT_ENABLE_GRPC)

ApplicationLibCode/UnitTests/cafVecIjk-Test.cpp

@@ -0,0 +1,121 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2025     Equinor ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "gtest/gtest.h"
+
+#include "cafVecIjk.h"
+
+using namespace caf;
+
+TEST( VecIjk0Test, Construction )
+{
+    VecIjk0 vec0( 0, 1, 2 );
+
+    EXPECT_EQ( 0u, vec0.i() );
+    EXPECT_EQ( 1u, vec0.j() );
+    EXPECT_EQ( 2u, vec0.k() );
+}
+
+TEST( VecIjk0Test, ToOneBased )
+{
+    VecIjk0 vec0( 0, 1, 2 );
+    VecIjk1 vec1 = vec0.toOneBased();
+
+    EXPECT_EQ( 1u, vec1.i() );
+    EXPECT_EQ( 2u, vec1.j() );
+    EXPECT_EQ( 3u, vec1.k() );
+}
+
+TEST( VecIjk0Test, ToString )
+{
+    VecIjk0 vec0( 5, 10, 15 );
+    EXPECT_EQ( "5, 10, 15", vec0.toString() );
+}
+
+TEST( VecIjk1Test, Construction )
+{
+    VecIjk1 vec1( 1, 2, 3 );
+
+    EXPECT_EQ( 1u, vec1.i() );
+    EXPECT_EQ( 2u, vec1.j() );
+    EXPECT_EQ( 3u, vec1.k() );
+}
+
+TEST( VecIjk1Test, ToZeroBased )
+{
+    VecIjk1 vec1( 1, 2, 3 );
+    VecIjk0 vec0 = vec1.toZeroBased();
+
+    EXPECT_EQ( 0u, vec0.i() );
+    EXPECT_EQ( 1u, vec0.j() );
+    EXPECT_EQ( 2u, vec0.k() );
+}
+
+TEST( VecIjk1Test, ToString )
+{
+    VecIjk1 vec1( 10, 20, 30 );
+    EXPECT_EQ( "10, 20, 30", vec1.toString() );
+}
+
+TEST( VecIjkConversionTest, RoundTrip0to1to0 )
+{
+    VecIjk0 original( 5, 10, 15 );
+    VecIjk1 asOne      = original.toOneBased();
+    VecIjk0 backToZero = asOne.toZeroBased();
+
+    EXPECT_EQ( original.i(), backToZero.i() );
+    EXPECT_EQ( original.j(), backToZero.j() );
+    EXPECT_EQ( original.k(), backToZero.k() );
+}
+
+TEST( VecIjkConversionTest, RoundTrip1to0to1 )
+{
+    VecIjk1 original( 5, 10, 15 );
+    VecIjk0 asZero    = original.toZeroBased();
+    VecIjk1 backToOne = asZero.toOneBased();
+
+    EXPECT_EQ( original.i(), backToOne.i() );
+    EXPECT_EQ( original.j(), backToOne.j() );
+    EXPECT_EQ( original.k(), backToOne.k() );
+}
+
+TEST( VecIjkConversionTest, ZeroBasedConversion )
+{
+    VecIjk0 vec0( 0, 0, 0 );
+    VecIjk1 vec1 = vec0.toOneBased();
+
+    EXPECT_EQ( 1u, vec1.i() );
+    EXPECT_EQ( 1u, vec1.j() );
+    EXPECT_EQ( 1u, vec1.k() );
+}
+
+TEST( VecIjkConversionTest, LargeValues )
+{
+    size_t  large = 1000000;
+    VecIjk0 vec0( large, large + 1, large + 2 );
+    VecIjk1 vec1 = vec0.toOneBased();
+
+    EXPECT_EQ( large + 1, vec1.i() );
+    EXPECT_EQ( large + 2, vec1.j() );
+    EXPECT_EQ( large + 3, vec1.k() );
+
+    VecIjk0 backToZero = vec1.toZeroBased();
+    EXPECT_EQ( large, backToZero.i() );
+    EXPECT_EQ( large + 1, backToZero.j() );
+    EXPECT_EQ( large + 2, backToZero.k() );
+}

Fwk/AppFwk/CommonCode/cafVecIjk.cpp

@@ -36,54 +36,16 @@
 
 #include "cafVecIjk.h"
 
+#include "cafAssert.h"
+
 namespace caf
 {
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
 VecIjk::VecIjk( size_t i, size_t j, size_t k )
+    : cvf::Vec3st( i, j, k )
 {
-    m_values = { { i, j, k } };
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-caf::VecIjk VecIjk::toOneBased() const
-{
-    return VecIjk( i() + 1, j() + 1, k() + 1 );
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-caf::VecIjk VecIjk::toZeroBased() const
-{
-    return VecIjk( i() - 1, j() - 1, k() - 1 );
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-size_t VecIjk::i() const
-{
-    return m_values[0];
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-size_t VecIjk::j() const
-{
-    return m_values[1];
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-size_t VecIjk::k() const
-{
-    return m_values[2];
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -94,4 +56,39 @@ std::string VecIjk::toString() const
     return std::to_string( i() ) + ", " + std::to_string( j() ) + ", " + std::to_string( k() );
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+VecIjk0::VecIjk0( size_t i, size_t j, size_t k )
+    : VecIjk( i, j, k )
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+VecIjk1 VecIjk0::toOneBased() const
+{
+    return VecIjk1( i() + 1, j() + 1, k() + 1 );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+VecIjk1::VecIjk1( size_t i, size_t j, size_t k )
+    : VecIjk( i, j, k )
+{
+    CAF_ASSERT( i > 0 );
+    CAF_ASSERT( j > 0 );
+    CAF_ASSERT( k > 0 );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+VecIjk0 VecIjk1::toZeroBased() const
+{
+    return VecIjk0( i() - 1, j() - 1, k() - 1 );
+}
+
 }; // namespace caf

Fwk/AppFwk/CommonCode/cafVecIjk.h

@@ -36,28 +36,37 @@
 
 #pragma once
 
-#include <array>
+#include "cvfVector3.h"
+
 #include <cstddef>
 #include <string>
 
 namespace caf
 {
-class VecIjk
+class VecIjk0;
+class VecIjk1;
+
+class VecIjk : public cvf::Vec3st
 {
 public:
-    VecIjk( size_t i, size_t j, size_t k );
-
-    VecIjk toOneBased() const;
-    VecIjk toZeroBased() const;
-
-    size_t i() const;
-    size_t j() const;
-    size_t k() const;
-
     std::string toString() const;
 
-private:
-    std::array<size_t, 3> m_values;
+protected:
+    VecIjk( size_t i, size_t j, size_t k );
+};
+
+class VecIjk0 : public VecIjk
+{
+public:
+    VecIjk0( size_t i, size_t j, size_t k );
+    VecIjk1 toOneBased() const;
+};
+
+class VecIjk1 : public VecIjk
+{
+public:
+    VecIjk1( size_t i, size_t j, size_t k );
+    VecIjk0 toZeroBased() const;
 };
 
 } // namespace caf