Merge pull request #3141 from pleroy/SegmentIterator

pleroy · web-flow · commit b50bf9ce80ec · 2021-10-08T16:10:29.000+02:00
DiscreteTrajectorySegmentIterator
diff --git a/physics/discrete_trajectory_iterator.hpp b/physics/discrete_trajectory_iterator.hpp
@@ -33,15 +33,13 @@ class DiscreteTrajectoryIterator {
  private:
   using Timeline = internal_discrete_trajectory_types::Timeline<Frame>;
 
-  DiscreteTrajectorySegmentIterator segment_;
+  DiscreteTrajectorySegmentIterator<Frame> segment_;
   Timeline::const_iterator point_;
 };
 
 }  // namespace internal_discrete_trajectory_iterator
 
-template<typename Frame>
-using DiscreteTrajectoryIterator =
-    internal_discrete_trajectory_iterator::DiscreteTrajectoryIterator;
+using internal_discrete_trajectory_iterator::DiscreteTrajectoryIterator;
 
 }  // namespace physics
 }  // namespace principia
diff --git a/physics/discrete_trajectory_segment.hpp b/physics/discrete_trajectory_segment.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+
 #include "absl/container/btree_map.h"
 #include "absl/container/btree_set.h"
 #include "geometry/named_quantities.hpp"
@@ -19,6 +21,7 @@ template<typename Frame>
 class DiscreteTrajectorySegment {
  public:
   DiscreteTrajectorySegment() = default;
+  virtual ~DiscreteTrajectorySegment() = default;
 
   // Moveable.
   DiscreteTrajectorySegment(DiscreteTrajectorySegment&&) = default;
@@ -38,29 +41,42 @@ class DiscreteTrajectorySegment {
   DiscreteTrajectoryIterator<Frame> lower_bound(Instant const& t) const;
   DiscreteTrajectoryIterator<Frame> upper_bound(Instant const& t) const;
 
- private:
+  bool empty() const;
+  virtual std::int64_t size() const;
+
+ protected:
+  // For mocking.
   using Timeline = internal_discrete_trajectory_types::Timeline<Frame>;
 
+ private:
   void Append(Instant const& t,
               DegreesOfFreedom<Frame> const& degrees_of_freedom);
 
   void ForgetAfter(Instant const& t);
-  void ForgetAfter(Timeline::const_iterator begin);
+  void ForgetAfter(typename Timeline::const_iterator begin);
 
   void ForgetBefore(Instant const& t);
-  void ForgetBefore(Timeline::const_iterator end);
+  void ForgetBefore(typename Timeline::const_iterator end);
 
-  DiscreteTrajectorySegmentIterator<Frame> that_;
+  virtual typename Timeline::const_iterator timeline_begin() const;
+  virtual typename Timeline::const_iterator timeline_end() const;
+
+  DiscreteTrajectorySegmentIterator<Frame> self_;
 
   Timeline timeline_;
   absl::btree_set<Instant> dense_points_;
+
+  template<typename F>
+  friend class internal_discrete_trajectory_iterator::
+      DiscreteTrajectoryIterator;
+  friend class physics::DiscreteTrajectoryIteratorTest;
 };
 
 }  // namespace internal_discrete_trajectory_segment
 
-template<typename Frame>
-using DiscreteTrajectorySegment =
-    internal_discrete_trajectory_segment::DiscreteTrajectorySegment;
+using internal_discrete_trajectory_segment::DiscreteTrajectorySegment;
 
 }  // namespace physics
 }  // namespace principia
+
+#include "physics/discrete_trajectory_segment_body.hpp"
diff --git a/physics/discrete_trajectory_segment_body.hpp b/physics/discrete_trajectory_segment_body.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "glog/logging.h"
+#include "physics/discrete_trajectory_segment.hpp"
+
+namespace principia {
+namespace physics {
+namespace internal_discrete_trajectory_segment {
+
+template<typename Frame>
+typename DiscreteTrajectorySegment<Frame>::Timeline::const_iterator
+DiscreteTrajectorySegment<Frame>::timeline_begin() const {
+  LOG(FATAL) << "NYI";
+}
+
+template<typename Frame>
+typename DiscreteTrajectorySegment<Frame>::Timeline::const_iterator
+DiscreteTrajectorySegment<Frame>::timeline_end() const {
+  LOG(FATAL) << "NYI";
+}
+
+template<typename Frame>
+std::int64_t DiscreteTrajectorySegment<Frame>::size() const {
+  LOG(FATAL) << "NYI";
+}
+
+}  // namespace internal_discrete_trajectory_segment
+}  // namespace physics
+}  // namespace principia
diff --git a/physics/discrete_trajectory_segment_iterator.hpp b/physics/discrete_trajectory_segment_iterator.hpp
@@ -1,23 +1,26 @@
 #pragma once
 
-#include <list>
-#include <memory>
-
 #include "absl/container/btree_map.h"
-#include "geometry/named_quantities.hpp"
-#include "physics/degrees_of_freedom.hpp"
+#include "base/macros.hpp"
+#include "base/not_null.hpp"
 #include "physics/discrete_trajectory_types.hpp"
 
 namespace principia {
 namespace physics {
 
-template<typename Frame>
-class DiscreteTrajectorySegment;
+FORWARD_DECLARE_FROM(discrete_trajectory_iterator,
+                     TEMPLATE(typename Frame) class,
+                     DiscreteTrajectoryIterator);
+FORWARD_DECLARE_FROM(discrete_trajectory_segment,
+                     TEMPLATE(typename Frame) class,
+                     DiscreteTrajectorySegment);
+
+class DiscreteTrajectoryIteratorTest;
+class DiscreteTrajectorySegmentIteratorTest;
 
 namespace internal_discrete_trajectory_segment_iterator {
 
-using geometry::Instant;
-using physics::DegreesOfFreedom;
+using base::not_null;
 
 template<typename Frame>
 class DiscreteTrajectorySegmentIterator {
@@ -32,18 +35,34 @@ class DiscreteTrajectorySegmentIterator {
   DiscreteTrajectorySegment<Frame> const& operator*() const;
   DiscreteTrajectorySegment<Frame> const* operator->() const;
 
+  bool operator==(DiscreteTrajectorySegmentIterator const& other) const;
+  bool operator!=(DiscreteTrajectorySegmentIterator const& other) const;
+
  private:
   using Segments = internal_discrete_trajectory_types::Segments<Frame>;
 
-  Segments::const_iterator segment_;
+  DiscreteTrajectorySegmentIterator(not_null<Segments const*> segments,
+                                    typename Segments::const_iterator iterator);
+
+  DiscreteTrajectorySegmentIterator begin() const;
+  DiscreteTrajectorySegmentIterator end() const;
+
+  // Not not_null<> to be default-constructible.
+  Segments const* segments_ = nullptr;
+  typename Segments::const_iterator iterator_;
+
+  template<typename Frame>
+  friend class DiscreteTrajectoryIterator;
+  friend class DiscreteTrajectoryIteratorTest;
+  friend class DiscreteTrajectorySegmentIteratorTest;
 };
 
 }  // namespace internal_discrete_trajectory_segment_iterator
 
-template<typename Frame>
-using DiscreteTrajectorySegmentIterator =
-    internal_discrete_trajectory_segment_iterator::
-        DiscreteTrajectorySegmentIterator;
+using internal_discrete_trajectory_segment_iterator::
+      DiscreteTrajectorySegmentIterator;
 
 }  // namespace physics
 }  // namespace principia
+
+#include "physics/discrete_trajectory_segment_iterator_body.hpp"
diff --git a/physics/discrete_trajectory_segment_iterator_body.hpp b/physics/discrete_trajectory_segment_iterator_body.hpp
@@ -0,0 +1,78 @@
+#include "physics/discrete_trajectory_segment_iterator.hpp"
+
+namespace principia {
+namespace physics {
+namespace internal_discrete_trajectory_segment_iterator {
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>&
+DiscreteTrajectorySegmentIterator<Frame>::operator++() {
+  ++iterator_;
+  return *this;
+}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>&
+DiscreteTrajectorySegmentIterator<Frame>::operator--() {
+  --iterator_;
+  return *this;
+}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>
+DiscreteTrajectorySegmentIterator<Frame>::operator++(int) {  // NOLINT
+  return DiscreteTrajectorySegmentIterator(segments_, iterator_++);
+}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>
+DiscreteTrajectorySegmentIterator<Frame>::operator--(int) {  // NOLINT
+  return DiscreteTrajectorySegmentIterator(segments_, iterator_--);
+}
+
+template<typename Frame>
+internal_discrete_trajectory_segment::DiscreteTrajectorySegment<Frame> const&
+DiscreteTrajectorySegmentIterator<Frame>::operator*() const {
+  return **iterator_;
+}
+
+template<typename Frame>
+internal_discrete_trajectory_segment::DiscreteTrajectorySegment<Frame> const*
+DiscreteTrajectorySegmentIterator<Frame>::operator->() const {
+  return iterator_->get();
+}
+
+template<typename Frame>
+bool DiscreteTrajectorySegmentIterator<Frame>::operator==(
+    DiscreteTrajectorySegmentIterator const& other) const {
+  return segments_ == other.segments_ && iterator_ == other.iterator_;
+}
+
+template<typename Frame>
+bool DiscreteTrajectorySegmentIterator<Frame>::operator!=(
+    DiscreteTrajectorySegmentIterator const& other) const {
+  return !operator==(other);
+}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>::DiscreteTrajectorySegmentIterator(
+    not_null<Segments const*> const segments,
+    typename Segments::const_iterator iterator)
+    : segments_(segments),
+      iterator_(iterator) {}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>
+DiscreteTrajectorySegmentIterator<Frame>::begin() const {
+  return DiscreteTrajectorySegmentIterator(segments_, segments_->begin());
+}
+
+template<typename Frame>
+DiscreteTrajectorySegmentIterator<Frame>
+DiscreteTrajectorySegmentIterator<Frame>::end() const {
+  return DiscreteTrajectorySegmentIterator(segments_, segments_->end());
+}
+
+}  // namespace internal_discrete_trajectory_segment_iterator
+}  // namespace physics
+}  // namespace principia
diff --git a/physics/discrete_trajectory_segment_iterator_test.cpp b/physics/discrete_trajectory_segment_iterator_test.cpp
@@ -0,0 +1,77 @@
+#include "physics/discrete_trajectory_segment_iterator.hpp"
+
+#include <memory>
+#include <vector>
+
+#include "base/not_null.hpp"
+#include "geometry/frame.hpp"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "physics/discrete_trajectory_types.hpp"
+#include "physics/mock_discrete_trajectory_segment.hpp"
+
+namespace principia {
+namespace physics {
+
+using base::check_not_null;
+using base::not_null;
+using geometry::Frame;
+using ::testing::Return;
+
+// We use a mock segment in this test to avoid having to go through a
+// complicated setup just to test the iterator.
+class DiscreteTrajectorySegmentIteratorTest : public ::testing::Test {
+ protected:
+  using World = Frame<enum class WorldTag>;
+
+  using Segments = internal_discrete_trajectory_types::Segments<World>;
+
+  DiscreteTrajectorySegmentIterator<World> MakeIterator(
+      not_null<Segments const*> const segments,
+      Segments::const_iterator const iterator) {
+    return DiscreteTrajectorySegmentIterator<World>(segments, iterator);
+  }
+};
+
+TEST_F(DiscreteTrajectorySegmentIteratorTest, Basic) {
+  auto owned_mock1 = std::make_unique<MockDiscreteTrajectorySegment<World>>();
+  auto owned_mock2 = std::make_unique<MockDiscreteTrajectorySegment<World>>();
+  auto owned_mock3 = std::make_unique<MockDiscreteTrajectorySegment<World>>();
+  auto const& mock1 = *owned_mock1;
+  auto const& mock2 = *owned_mock2;
+  auto const& mock3 = *owned_mock3;
+
+  Segments segments;
+  segments.push_back(std::move(owned_mock1));
+  segments.push_back(std::move(owned_mock2));
+  segments.push_back(std::move(owned_mock3));
+
+  EXPECT_CALL(mock1, size()).WillRepeatedly(Return(5));
+  EXPECT_CALL(mock2, size()).WillRepeatedly(Return(1));
+  EXPECT_CALL(mock3, size()).WillRepeatedly(Return(3));
+
+  {
+    auto iterator = MakeIterator(check_not_null(&segments), segments.begin());
+    EXPECT_EQ(5, iterator->size());
+    auto const current = ++iterator;
+    EXPECT_EQ(1, iterator->size());
+    EXPECT_EQ(1, current->size());
+    auto const previous = iterator++;
+    EXPECT_EQ(3, iterator->size());
+    EXPECT_EQ(1, previous->size());
+  }
+  {
+    auto iterator = MakeIterator(check_not_null(&segments), segments.end());
+    --iterator;
+    EXPECT_EQ(3, (*iterator).size());
+    auto const current = --iterator;
+    EXPECT_EQ(1, (*iterator).size());
+    EXPECT_EQ(1, (*current).size());
+    auto const previous = iterator--;
+    EXPECT_EQ(5, (*iterator).size());
+    EXPECT_EQ(1, (*previous).size());
+  }
+}
+
+}  // namespace physics
+}  // namespace principia
diff --git a/physics/discrete_trajectory_types.hpp b/physics/discrete_trajectory_types.hpp
@@ -4,6 +4,7 @@
 #include <memory>
 
 #include "absl/container/btree_map.h"
+#include "base/macros.hpp"
 #include "geometry/named_quantities.hpp"
 #include "physics/degrees_of_freedom.hpp"
 
@@ -12,8 +13,9 @@
 namespace principia {
 namespace physics {
 
-template<typename Frame>
-class DiscreteTrajectorySegment;
+FORWARD_DECLARE_FROM(discrete_trajectory_segment,
+                     TEMPLATE(typename Frame) class,
+                     DiscreteTrajectorySegment);
 
 namespace internal_discrete_trajectory_types {
 
diff --git a/physics/mock_discrete_trajectory_segment.hpp b/physics/mock_discrete_trajectory_segment.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+
+#include "gmock/gmock.h"
+#include "physics/discrete_trajectory_iterator.hpp"
+#include "physics/discrete_trajectory_segment.hpp"
+
+namespace principia {
+namespace physics {
+
+template<typename Frame>
+class MockDiscreteTrajectorySegment : public DiscreteTrajectorySegment<Frame> {
+ public:
+  MockDiscreteTrajectorySegment() = default;
+
+  MOCK_METHOD((typename internal_discrete_trajectory_types::Timeline<Frame>::
+                  const_iterator),
+              timeline_begin, (),
+              (const override));
+  MOCK_METHOD((typename internal_discrete_trajectory_types::Timeline<Frame>::
+                  const_iterator),
+              timeline_end, (),
+              (const override));
+
+  MOCK_METHOD(std::int64_t, size, (), (const override));
+};
+
+}  // namespace physics
+}  // namespace principia
diff --git a/physics/physics.vcxproj b/physics/physics.vcxproj
diff --git a/physics/physics.vcxproj.filters b/physics/physics.vcxproj.filters
