moved to operators == and !=

include/gnss_utils/observations.h

@@ -69,6 +69,7 @@ public:
                                      Observations&       common_obs_2);
 
   bool operator==(const Observations& other_obs) const;
+  bool operator !=(const Observations &other_obs) const;
 
 private:
   // Private objects
@@ -133,5 +134,10 @@ inline bool Observations::hasSatellite(const unsigned char& i) const
   return sat_2_idx_.count(i) != 0;
 }
 
+inline bool Observations::operator !=(const Observations &other_obs) const
+{
+    return !(*this == other_obs);
+}
+
 }  // namespace GnssUtils
 #endif // INCLUDE_GNSS_UTILS_OBSERVATIONS_H_

include/gnss_utils/utils/utils.h

@@ -37,10 +37,16 @@ bool equalArray(const T* array1, const T* array2, const int& size1, const int& s
   return true;
 }
 
-bool equalTime(const gtime_t& time1, const gtime_t& time2);
-bool equalObservations(const obsd_t& obs1, const obsd_t& obs2);
-bool equalObservations(const obs_t& obs1, const obs_t& obs2);
-
 }  // namespace GnssUtils
 
+//bool equalTime(const gtime_t& time1, const gtime_t& time2);
+bool operator==(const gtime_t& time1, const gtime_t& time2);
+bool operator!=(const gtime_t& time1, const gtime_t& time2);
+//bool equalObservations(const obsd_t& obs1, const obsd_t& obs2);
+bool operator==(const obsd_t& obs1, const obsd_t& obs2);
+bool operator!=(const obsd_t& obs1, const obsd_t& obs2);
+//bool equalObservations(const obs_t& obs1, const obs_t& obs2);
+bool operator==(const obs_t& obs1, const obs_t& obs2);
+bool operator!=(const obs_t& obs1, const obs_t& obs2);
+
 #endif // INCLUDE_GNSS_UTILS_UTILS_UTILS_H_

src/observations.cpp

@@ -221,6 +221,7 @@ void Observations::findCommonObservations(const Observations& obs_1,
 
 bool Observations::operator ==(const Observations &other_obs) const
 {
+
     if (sat_2_idx_ != other_obs.sat_2_idx_)
         return false;
 
@@ -228,7 +229,7 @@ bool Observations::operator ==(const Observations &other_obs) const
         return false;
 
     for (auto i = 0; i < obs_.size(); i++)
-        if (!equalObservations(obs_.at(i), other_obs.obs_.at(i)))
+        if (obs_.at(i) != other_obs.obs_.at(i))
             return false;
 
     return true;

src/utils/utils.cpp

@@ -61,60 +61,59 @@ void printArray(std::string _name, float* _array, int size)
   }
 }
 
-bool equalTime(const gtime_t& time1, const gtime_t& time2)
+}  // namespace GnssUtils
+
+bool operator==(const gtime_t& time1, const gtime_t& time2)
+//bool equalTime(const gtime_t& time1, const gtime_t& time2)
 {
   return (difftime(time1.time, time2.time) == 0.0 && time1.sec == time2.sec);
 }
 
-bool equalObservations(const obsd_t& obs1, const obsd_t& obs2)
+bool operator!=(const gtime_t& time1, const gtime_t& time2)
+{
+  return not (time1 == time2);
+}
+
+bool operator==(const obsd_t& obs1, const obsd_t& obs2)
+//bool equalObservations(const obsd_t& obs1, const obsd_t& obs2)
 {
-  if (!equalTime(obs1.time, obs2.time))
-    return false;
-  if (!equalTime(obs1.eventime, obs2.eventime))
-    return false;
-  if (obs1.timevalid != obs2.timevalid)
-    return false;
-  if (obs1.sat != obs2.sat)
-    return false;
-  if (obs1.rcv != obs2.rcv)
-    return false;
-  if (memcmp(obs1.SNR, obs2.SNR, sizeof(obs1.SNR)) != 0)
-    return false;
-  if (memcmp(obs1.LLI, obs2.LLI, sizeof(obs1.LLI)) != 0)
-    return false;
-  if (memcmp(obs1.code, obs2.code, sizeof(obs1.code)) != 0)
-    return false;
-  if (memcmp(obs1.qualL, obs2.qualL, sizeof(obs1.qualL)) != 0)
-    return false;
-  if (memcmp(obs1.qualP, obs2.qualP, sizeof(obs1.qualP)) != 0)
-    return false;
-  if (obs1.freq != obs2.freq)
-    return false;
-  if (!equalArray<double>(obs1.L, obs2.L, sizeof(obs1.L) / sizeof(obs1.L[0]), sizeof(obs2.L) / sizeof(obs2.L[0])))
-    return false;
-  if (!equalArray<double>(obs1.P, obs2.P, sizeof(obs1.P) / sizeof(obs1.P[0]), sizeof(obs2.P) / sizeof(obs2.P[0])))
-    return false;
-  if (!equalArray<float>(obs1.D, obs2.D, sizeof(obs1.D) / sizeof(obs1.D[0]), sizeof(obs2.D) / sizeof(obs2.D[0])))
-    return false;
+  std::cout <<"operator==\n";
+
+  return obs1.time == obs2.time &&
+         obs1.eventime == obs2.eventime &&
+         obs1.timevalid == obs2.timevalid &&
+         obs1.sat == obs2.sat &&
+         obs1.rcv == obs2.rcv &&
+         memcmp(obs1.SNR, obs2.SNR, sizeof(obs1.SNR)) == 0 &&
+         memcmp(obs1.LLI, obs2.LLI, sizeof(obs1.LLI)) == 0 &&
+         memcmp(obs1.code, obs2.code, sizeof(obs1.code)) == 0 &&
+         memcmp(obs1.qualL, obs2.qualL, sizeof(obs1.qualL)) == 0 &&
+         memcmp(obs1.qualP, obs2.qualP, sizeof(obs1.qualP)) == 0 &&
+         obs1.freq == obs2.freq &&
+         GnssUtils::equalArray<double>(obs1.L, obs2.L, sizeof(obs1.L) / sizeof(obs1.L[0]), sizeof(obs2.L) / sizeof(obs2.L[0])) &&
+         GnssUtils::equalArray<double>(obs1.P, obs2.P, sizeof(obs1.P) / sizeof(obs1.P[0]), sizeof(obs2.P) / sizeof(obs2.P[0])) &&
+         GnssUtils::equalArray<float>(obs1.D, obs2.D, sizeof(obs1.D) / sizeof(obs1.D[0]), sizeof(obs2.D) / sizeof(obs2.D[0]));
+}
 
-  return true;
+bool operator!=(const obsd_t& obs1, const obsd_t& obs2)
+{
+  return not (obs1 == obs2);
 }
 
-bool equalObservations(const obs_t& obs1, const obs_t& obs2)
+bool operator==(const obs_t& obs1, const obs_t& obs2)
+//bool equalObservations(const obs_t& obs1, const obs_t& obs2)
 {
-  if (obs1.n != obs2.n)
-    return false;
-  if (obs1.nmax != obs2.nmax)
-    return false;
-  if (obs1.flag != obs2.flag)
-    return false;
-  if (obs1.rcvcount != obs2.rcvcount)
-    return false;
-  if (obs1.tmcount != obs2.tmcount)
-    return false;
-  if (!equalObservations(*(obs1.data), *(obs2.data)))
-    return false;
+    std::cout <<"operator==\n";
+    return obs1.n == obs2.n &&
+           obs1.nmax == obs2.nmax &&
+           obs1.flag == obs2.flag &&
+           obs1.rcvcount == obs2.rcvcount &&
+           obs1.tmcount == obs2.tmcount &&
+           *(obs1.data) == *(obs2.data);
+}
 
-  return true;
+bool operator!=(const obs_t& obs1, const obs_t& obs2)
+{
+  return not (obs1 == obs2);
 }
-}  // namespace GnssUtils
+

test/gtest_observations.cpp

@@ -32,7 +32,7 @@ TEST(ObservationsTest, AddClearObservation)
   for (int ii = 0; ii < obs.n; ++ii)
   {
     observations.addObservation(obs.data[ii]);
-    ASSERT_TRUE(equalObservations(obs.data[ii], observations.getObservations()[ii]));
+    ASSERT_TRUE(obs.data[ii] == observations.getObservations()[ii]);
   }
 
   ASSERT_TRUE(obs.n == observations.getObservations().size());
@@ -44,7 +44,7 @@ TEST(ObservationsTest, AddClearObservation)
 
   // Add duplicated observation (has to crash)
   observations.addObservation(obs.data[0]);
-  //ASSERT_DEATH(observations.addObservation(obs.data[0]),"");
+  ASSERT_DEATH(observations.addObservation(obs.data[0]),"");
 }
 
 TEST(ObservationsTest, LoadFromRinex)
@@ -62,7 +62,7 @@ TEST(ObservationsTest, LoadFromRinex)
   ASSERT_TRUE(obs.n == observations.getObservations().size());
   for (int ii = 0; ii < obs.n; ++ii)
   {
-    ASSERT_TRUE(equalObservations(obs.data[ii], observations.getObservations()[ii]));
+    ASSERT_TRUE(obs.data[ii] == observations.getObservations()[ii]);
   }
 
   free(obs.data);
@@ -77,7 +77,7 @@ TEST(ObservationsTest, GetObservationBySat)
 
   for (int ii = 0; ii < obs.n; ++ii)
   {
-    ASSERT_TRUE(equalObservations(obs.data[ii], observations.getObservationBySat(obs.data[ii].sat)));
+    ASSERT_TRUE(obs.data[ii] == observations.getObservationBySat(obs.data[ii].sat));
   }
 }
 
@@ -91,7 +91,7 @@ TEST(ObservationsTest, GetObservationByIdx)
   for (int ii = 0; ii < obs.n; ++ii)
   {
     // We do this check like this because both loading functions load the rinex file and then sort the observations
-    ASSERT_TRUE(equalObservations(obs.data[ii], observations.getObservationByIdx(ii)));
+    ASSERT_TRUE( obs.data[ii] == observations.getObservationByIdx(ii));
   }
 }
 
@@ -105,7 +105,7 @@ TEST(ObservationsTest, data)
   for (int ii = 0; ii < obs.n; ++ii)
   {
     // We do this check like this because both loading functions load the rinex file and then sort the observations
-    ASSERT_TRUE(equalObservations(obs.data[ii], observations.data()[ii]));
+    ASSERT_TRUE( obs.data[ii] == observations.data()[ii]);
   }
 }
 
@@ -187,8 +187,8 @@ TEST(ObservationsTest, FindCommonObservationsChangeTime)
       const obsd_t& obs1 = common1.getObservationBySat(obs->sat);
       const obsd_t& obs2 = common2.getObservationBySat(obs->sat);
 
-      ASSERT_FALSE(equalTime(obs1.time, obs2.time));
-      ASSERT_TRUE(equalTime(obs1.eventime, obs2.eventime));
+      ASSERT_FALSE(obs1.time == obs2.time);
+      ASSERT_TRUE(obs1.eventime == obs2.eventime);
       ASSERT_TRUE(obs1.timevalid == obs2.timevalid);
       ASSERT_TRUE(obs1.sat == obs2.sat);
       ASSERT_TRUE(obs1.rcv == obs2.rcv);