_GTestStructLooper.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#include "CbmStructLooper.h"
#include "gtest/gtest.h"
 
#include <unordered_map>
#include <unordered_set>
#include <vector>

class A {
 public:
  using Property_t = int;

  int GetStationId(uint16_t address) const { return (0xF0 & address) >> 4; }
 
  Property_t GetProperty() const { return fSomeProperty; }
  void SetProperty(Property_t property) { fSomeProperty = property; }
 
 private:
  Property_t fSomeProperty{};
};
 

class B {
 public:
  B(std::vector<int>&& stMap) : fModuleStationMap(std::move(stMap)) {}
 
  using Property_t = double;

  int GetStationId(uint16_t address) const { return fModuleStationMap[(0xF00 & address) >> 8]; }
 
  Property_t GetProperty() const { return fSomeProperty; }
  void SetProperty(Property_t property) { fSomeProperty = property; }
 
 private:
  std::vector<int> fModuleStationMap;
  Property_t fSomeProperty{};
};
 

class C {
 public:
  C(std::unordered_map<uint16_t, int>&& stMap) : fModuleStationMap(std::move(stMap)) {}
 
  using Property_t = float;

  int GetStationId(uint16_t address) const { return fModuleStationMap.at(address); }
 
  Property_t GetProperty() const { return fSomeProperty; }
  void SetProperty(Property_t property) { fSomeProperty = property; }
 
 private:
  std::unordered_map<uint16_t, int> fModuleStationMap;
  Property_t fSomeProperty{};
};
 
// NOTE: The classes A, B and C are non-polymorphic and even don't have a common interface (but use similar API)

struct Composite {
  template<class Visitor>
  void ForEachValue(Visitor&& visitor)
  {
    kLooper.ForEachValue(this, std::forward<Visitor>(visitor));
  }

  template<class Visitor>
  void ForEachValue(Visitor&& visitor) const
  {
    kLooper.ForEachValue(this, std::forward<Visitor>(visitor));
  }

  template<class Visitor>
  void ForEachVariable(Visitor&& visitor)
  {
    kLooper.ForEachVariable(this, std::forward<Visitor>(visitor));
  }

  template<class Visitor>
  void ForEachVariable(Visitor&& visitor) const
  {
    kLooper.ForEachVariable(this, std::forward<Visitor>(visitor));
  }
 
  std::optional<A> fA;
  std::optional<B> fB;
  std::optional<C> fC;
 
 private:
  static constexpr auto kLooper = cbm::util::StructLooper(&Composite::fA, &Composite::fB, &Composite::fC);
};

struct Hits {
  template<class Class>
  const auto& GetHitsFor() const
  {
    if constexpr (std::is_same_v<Class, A>) {
      return a;
    }
    else if constexpr (std::is_same_v<Class, B>) {
      return b;
    }
    else {
      return c;
    }
  }
 
  std::vector<uint16_t> a;
  std::vector<uint16_t> b;
  std::vector<uint16_t> c;
};

struct CompositeApplication {
  static int GetNofNonNullopt(const Composite& c)
  {
    int res{0};
    c.ForEachVariable([&res](const auto& var) {
      if (var.has_value()) ++res;
    });
    return res;
  }

  static void SetProperty(Composite& c, double number)
  {
    c.ForEachValue([number](auto&& val) { val.SetProperty(number); });
  }

  static int GetPropertySum(const Composite& c)
  {
    int res{0};
    c.ForEachValue([&res](const auto& val) { res += static_cast<int>(val.GetProperty()); });
    return res;
  }

  static int GetNumberOfStationsWithHits(const Composite& c, const Hits& hits)
  {
    int nTotSt{0};
    c.ForEachValue([&hits, &nTotSt](const auto& val) {
      using Value_t = typename std::remove_const_t<std::remove_reference_t<decltype(val)>>;
      std::unordered_set<int> uniqueStationIds;
      for (uint16_t address : hits.GetHitsFor<Value_t>())
        uniqueStationIds.insert(val.GetStationId(address));
      nTotSt += uniqueStationIds.size();
    });
    return nTotSt;
  }
};
 
static auto hits = Hits{
  .a = std::move(std::vector<uint16_t>{0x100, 0x200, 0x320, 0x110, 0x200, 0x300, 0x130, 0x220, 0x320}),  // 4 st,
  .b = std::move(std::vector<uint16_t>{0x051, 0x141, 0x491, 0x241, 0x551, 0x821, 0x131, 0x951, 0x241}),  // 3 st
  .c = std::move(std::vector<uint16_t>{0x012, 0x022, 0x032, 0x032, 0x012, 0x012, 0x022, 0x012, 0x022})   // 2 st
};
 
static auto compFull =
  Composite{.fA = std::move(A()),
            .fB = std::move(B(std::move(std::vector<int>({1, 1, 1, 1, 3, 3, 3, 3, 2, 2, 0, 0, 0, 0, 2, 2})))),
            .fC = std::move(C(std::move(std::unordered_map<uint16_t, int>({{0x12, 0}, {0x22, 0}, {0x32, 1}}))))};
 
static auto compPart =
  Composite{.fA = std::move(A()),
            .fB = std::nullopt,
            .fC = std::move(C(std::move(std::unordered_map<uint16_t, int>({{0x12, 0}, {0x22, 0}, {0x32, 1}}))))};
 
TEST(_GTestStructLooper, StructLooper_FullyDefinedComposite_LoopOverVariables)
{
  // Calculate number of nullopt values
  SCOPED_TRACE("StructLooper_FullyDefinedComposite_LoopOverVariables");
  EXPECT_EQ(CompositeApplication::GetNofNonNullopt(compFull), 3);
}
 
TEST(_GTestStructLooper, StructLooper_FullyDefinedComposite_LoopOverValues_1)
{
  // Set and get a property
  SCOPED_TRACE("StructLooper_FullyDefinedComposite_LoopOverValues_1");
  CompositeApplication::SetProperty(compFull, 42);
  EXPECT_EQ(CompositeApplication::GetPropertySum(compFull), 126);
}
 
TEST(_GTestStructLooper, StructLooper_FullyDefinedComposite_LoopOverValues_2)
{
  // Get number of stations with hits
  SCOPED_TRACE("StructLooper_FullyDefinedComposite_LoopOverValues_2");
  EXPECT_EQ(CompositeApplication::GetNumberOfStationsWithHits(compFull, hits), 9);
}
 
TEST(_GTestStructLooper, StructLooper_PartiallyDefinedComposite_LoopOverVariables)
{
  // Calculate number of nullopt values
  SCOPED_TRACE("StructLooper_PartiallyDefinedComposite_LoopOverVariables");
  EXPECT_EQ(CompositeApplication::GetNofNonNullopt(compPart), 2);
}
 
TEST(_GTestStructLooper, StructLooper_PartiallyDefinedComposite_LoopOverValues_1)
{
  // Set and get a property
  SCOPED_TRACE("StructLooper_PartiallyDefinedComposite_LoopOverValues_1");
  CompositeApplication::SetProperty(compPart, 42);
  EXPECT_EQ(CompositeApplication::GetPropertySum(compPart), 84);
}
 
TEST(_GTestStructLooper, StructLooper_PartiallyDefinedComposite_LoopOverValues_2)
{
  // Get number of stations with hits
  SCOPED_TRACE("StructLooper_PartiallyDefinedComposite_LoopOverValues_2");
  EXPECT_EQ(CompositeApplication::GetNumberOfStationsWithHits(compPart, hits), 6);
}