Skip to content

Commit

Permalink
iox-#605 Remove superfluous namespace and extend release note entry
Browse files Browse the repository at this point in the history 
Signed-off-by: Simon Hoinkis <[email protected]>
  • Loading branch information
@mossmaurice
mossmaurice committed Sep 29, 2022
1 parent 5885e26 commit ad37b6b
Show file tree
Hide file tree
Showing 2 changed files with 56 additions and 58 deletions.
4 changes: 2 additions & 2 deletions doc/website/release-notes/iceoryx-unreleased.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -403,12 +403,12 @@
}
```

21. Renamed `BaseRelativePointer` to `UntypedRelativePointer`
21. Renamed `BaseRelativePointer` to `UntypedRelativePointer` and moved it from namespace `rp::` to `memory::`

```cpp
// before
#include "iceoryx_hoofs/internal/memory/base_relative_pointer.hpp"
iox::memory::BaseRelativePointer myUntypedRelativePointer;
iox::rp::BaseRelativePointer myUntypedRelativePointer;

// after
#include "iceoryx_hoofs/memory/relative_pointer.hpp"
Expand Down
110 changes: 54 additions & 56 deletions iceoryx_hoofs/test/moduletests/test_relative_pointer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -78,13 +78,11 @@ TYPED_TEST(RelativePointer_test, ConstrTests)
::testing::Test::RecordProperty("TEST_ID", "cae7b4d4-86eb-42f6-b938-90a76f01bea5");
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(iox::memory::segment_id_t{1U},
reinterpret_cast<TypeParam*>(this->memoryPartition[0]),
SHARED_MEMORY_SIZE),
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(
segment_id_t{1U}, reinterpret_cast<TypeParam*>(this->memoryPartition[0]), SHARED_MEMORY_SIZE),
true);
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(iox::memory::segment_id_t{2U},
reinterpret_cast<TypeParam*>(this->memoryPartition[1]),
SHARED_MEMORY_SIZE),
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(
segment_id_t{2U}, reinterpret_cast<TypeParam*>(this->memoryPartition[1]), SHARED_MEMORY_SIZE),
true);
// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)

Expand Down Expand Up @@ -190,10 +188,10 @@ TYPED_TEST(RelativePointer_test, AssignmentOperatorTests)
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(
iox::memory::segment_id_t{1U}, reinterpret_cast<TypeParam*>(ptr0), SHARED_MEMORY_SIZE),
segment_id_t{1U}, reinterpret_cast<TypeParam*>(ptr0), SHARED_MEMORY_SIZE),
true);
EXPECT_EQ(RelativePointer<TypeParam>::registerPtrWithId(
iox::memory::segment_id_t{2U}, reinterpret_cast<TypeParam*>(ptr1), SHARED_MEMORY_SIZE),
segment_id_t{2U}, reinterpret_cast<TypeParam*>(ptr1), SHARED_MEMORY_SIZE),
true);
// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)

Expand Down Expand Up @@ -289,8 +287,8 @@ TYPED_TEST(RelativePointer_test, IdAndOffsetAreTranslatedToRawPointerCorrectly)
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(ptr));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
EXPECT_EQ(rp1.getOffset(), reinterpret_cast<std::ptrdiff_t>(typedPtr));
Expand All @@ -300,7 +298,7 @@ TYPED_TEST(RelativePointer_test, IdAndOffsetAreTranslatedToRawPointerCorrectly)
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)
auto* addressAtOffset = reinterpret_cast<TypeParam*>(ptr + offset);
RelativePointer<TypeParam> rp2(addressAtOffset, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp2(addressAtOffset, segment_id_t{1U});
EXPECT_EQ(rp2.getOffset(), offset);
EXPECT_EQ(rp2.getId(), 1U);
EXPECT_EQ(rp2.get(), addressAtOffset);
Expand All @@ -313,16 +311,16 @@ TYPED_TEST(RelativePointer_test, GetOffsetReturnsCorrectOffset)
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(ptr));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(UntypedRelativePointer::getOffset(iox::memory::segment_id_t{1U}, typedPtr), 0U);
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(UntypedRelativePointer::getOffset(segment_id_t{1U}, typedPtr), 0U);

int offset = SHARED_MEMORY_SIZE / 2U;
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)
auto* addressAtOffset = reinterpret_cast<TypeParam*>(ptr + offset);
RelativePointer<TypeParam> rp2(addressAtOffset, iox::memory::segment_id_t{1U});
EXPECT_EQ(UntypedRelativePointer::getOffset(iox::memory::segment_id_t{1U}, addressAtOffset), offset);
RelativePointer<TypeParam> rp2(addressAtOffset, segment_id_t{1U});
EXPECT_EQ(UntypedRelativePointer::getOffset(segment_id_t{1U}, addressAtOffset), offset);
}

TYPED_TEST(RelativePointer_test, GetPtrReturnsAddressWithCorrectOffset)
Expand All @@ -331,16 +329,16 @@ TYPED_TEST(RelativePointer_test, GetPtrReturnsAddressWithCorrectOffset)
auto* ptr = this->partitionPtr(0U);
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));
RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(UntypedRelativePointer::getPtr(iox::memory::segment_id_t{1U}, 0), typedPtr);
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(UntypedRelativePointer::getPtr(segment_id_t{1U}, 0), typedPtr);

uint64_t offset = SHARED_MEMORY_SIZE / 2U;
// NOLINTJUSTIFICATION Pointer arithmetic needed for tests
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast)
auto* addressAtOffset = reinterpret_cast<TypeParam*>(ptr + offset);
RelativePointer<TypeParam> rp2(addressAtOffset, iox::memory::segment_id_t{1});
EXPECT_EQ(UntypedRelativePointer::getPtr(iox::memory::segment_id_t{1U}, offset), addressAtOffset);
RelativePointer<TypeParam> rp2(addressAtOffset, segment_id_t{1});
EXPECT_EQ(UntypedRelativePointer::getPtr(segment_id_t{1U}, offset), addressAtOffset);
}

TYPED_TEST(RelativePointer_test, RegisteringAndUnregisteringRelativePointerWorks)
Expand All @@ -349,12 +347,12 @@ TYPED_TEST(RelativePointer_test, RegisteringAndUnregisteringRelativePointerWorks
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});

EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), false);
EXPECT_EQ(rp1.unregisterPtr(iox::memory::segment_id_t{1U}), true);
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), false);
EXPECT_EQ(rp1.unregisterPtr(segment_id_t{1U}), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
}


Expand All @@ -365,11 +363,11 @@ TYPED_TEST(RelativePointer_test, UnRegisteringOneRelativePointerWorks)
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(ptr));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});

rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr);
EXPECT_EQ(rp1.unregisterPtr(iox::memory::segment_id_t{1U}), true);
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true);
rp1.registerPtrWithId(segment_id_t{1U}, typedPtr);
EXPECT_EQ(rp1.unregisterPtr(segment_id_t{1U}), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true);
}

TYPED_TEST(RelativePointer_test, UnregisteringAllRelativePointerWorks)
Expand All @@ -380,14 +378,14 @@ TYPED_TEST(RelativePointer_test, UnregisteringAllRelativePointerWorks)
auto* typedPtr0 = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));
auto* typedPtr1 = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(1U)));

RelativePointer<TypeParam> rp1(typedPtr0, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp2(typedPtr1, iox::memory::segment_id_t{9999U});
RelativePointer<TypeParam> rp1(typedPtr0, segment_id_t{1U});
RelativePointer<TypeParam> rp2(typedPtr1, segment_id_t{9999U});

EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{9999U}, typedPtr1), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{9999U}, typedPtr1), true);
UntypedRelativePointer::unregisterAll();
EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{9999U}, typedPtr1), true);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{9999U}, typedPtr1), true);
}

TYPED_TEST(RelativePointer_test, RegisterPtrWithIdFailsWhenTooLarge)
Expand All @@ -397,11 +395,11 @@ TYPED_TEST(RelativePointer_test, RegisterPtrWithIdFailsWhenTooLarge)
auto* typedPtr0 = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));
auto* typedPtr1 = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(1U)));

RelativePointer<TypeParam> rp1(typedPtr0, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp2(typedPtr1, iox::memory::segment_id_t{10000U});
RelativePointer<TypeParam> rp1(typedPtr0, segment_id_t{1U});
RelativePointer<TypeParam> rp2(typedPtr1, segment_id_t{10000U});

EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{10000U}, typedPtr1), false);
EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true);
EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{10000U}, typedPtr1), false);
}

TYPED_TEST(RelativePointer_test, BasePointerIsSameAfterRegistering)
Expand All @@ -410,10 +408,10 @@ TYPED_TEST(RelativePointer_test, BasePointerIsSameAfterRegistering)
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
EXPECT_EQ(rp1.getBasePtr(iox::memory::segment_id_t{1U}), nullptr);
rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr);
EXPECT_EQ(typedPtr, rp1.getBasePtr(iox::memory::segment_id_t{1U}));
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});
EXPECT_EQ(rp1.getBasePtr(segment_id_t{1U}), nullptr);
rp1.registerPtrWithId(segment_id_t{1U}, typedPtr);
EXPECT_EQ(typedPtr, rp1.getBasePtr(segment_id_t{1U}));
}

TYPED_TEST(RelativePointer_test, AssignmentOperatorResultsInSameBasePointerIdAndOffset)
Expand All @@ -422,7 +420,7 @@ TYPED_TEST(RelativePointer_test, AssignmentOperatorResultsInSameBasePointerIdAnd
// No pointer arithmetic involved hence reinterpret_cast can be avoided
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));

RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});
// NOLINTJUSTIFICATION Copy needed for tests
// NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
RelativePointer<TypeParam> rp2 = rp1;
Expand All @@ -439,7 +437,7 @@ TYPED_TEST(RelativePointer_test, DereferencingOperatorResultsInSameValue)
auto* typedPtr = static_cast<TypeParam*>(static_cast<void*>(this->partitionPtr(0U)));

*typedPtr = static_cast<TypeParam>(88);
RelativePointer<TypeParam> rp1(typedPtr, iox::memory::segment_id_t{1U});
RelativePointer<TypeParam> rp1(typedPtr, segment_id_t{1U});

EXPECT_EQ(*rp1, *typedPtr);
*typedPtr = static_cast<TypeParam>(99);
Expand Down Expand Up @@ -484,13 +482,13 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks)
EXPECT_EQ(*adr1, 12);
EXPECT_EQ(*adr2, 21);

EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{1U}, base1), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{2U}, base2), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{1U}, base1), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{2U}, base2), true);

{
// the relative pointers point to base 1 and base 2l
RelativePointer<uint8_t> rp1(base1, iox::memory::segment_id_t{1U});
RelativePointer<uint8_t> rp2(base2, iox::memory::segment_id_t{2U});
RelativePointer<uint8_t> rp1(base1, segment_id_t{1U});
RelativePointer<uint8_t> rp2(base2, segment_id_t{2U});

EXPECT_EQ(rp1.getId(), 1U);
EXPECT_EQ(rp2.getId(), 2U);
Expand All @@ -504,8 +502,8 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks)

{
// now test with a type that is larger than 1 byte
RelativePointer<int> rp1(adr1, iox::memory::segment_id_t{1U});
RelativePointer<int> rp2(adr2, iox::memory::segment_id_t{2U});
RelativePointer<int> rp1(adr1, segment_id_t{1U});
RelativePointer<int> rp2(adr2, segment_id_t{2U});

EXPECT_EQ(rp1.getId(), 1U);
EXPECT_EQ(rp2.getId(), 2U);
Expand All @@ -519,11 +517,11 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks)
EXPECT_EQ(*rp2, 21);

// simulate a remapping, index 1 now refers to base 2 and vice versa ...
EXPECT_EQ(UntypedRelativePointer::unregisterPtr(iox::memory::segment_id_t{1U}), true);
EXPECT_EQ(UntypedRelativePointer::unregisterPtr(iox::memory::segment_id_t{2U}), true);
EXPECT_EQ(UntypedRelativePointer::unregisterPtr(segment_id_t{1U}), true);
EXPECT_EQ(UntypedRelativePointer::unregisterPtr(segment_id_t{2U}), true);

EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{1}, base2), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{2}, base1), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{1}, base2), true);
EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{2}, base1), true);

// which, despite the relative pointer objects not having changed themselves,
// leads to them referencing the respective other value now (compared to *** above)
Expand Down

0 comments on commit ad37b6b

Please sign in to comment.