Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: mockingbirdnest/Principia
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: d047406986bc
Choose a base ref
...
head repository: mockingbirdnest/Principia
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: b50bf9ce80ec
Choose a head ref
  • 4 commits
  • 10 files changed
  • 1 contributor

Commits on Oct 7, 2021

  1. Segment iterator.

    pleroy committed Oct 7, 2021
    Copy the full SHA
    8d6f41b View commit details
  2. Cleanup.

    pleroy committed Oct 7, 2021
    Copy the full SHA
    9f6a8dc View commit details
  3. Copy the full SHA
    003a571 View commit details

Commits on Oct 8, 2021

  1. Merge pull request #3141 from pleroy/SegmentIterator

    DiscreteTrajectorySegmentIterator
    pleroy authored Oct 8, 2021
    Copy the full SHA
    b50bf9c View commit details
6 changes: 2 additions & 4 deletions physics/discrete_trajectory_iterator.hpp
Original file line number Diff line number Diff line change
@@ -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
30 changes: 23 additions & 7 deletions physics/discrete_trajectory_segment.hpp
Original file line number Diff line number Diff line change
@@ -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"
29 changes: 29 additions & 0 deletions physics/discrete_trajectory_segment_body.hpp
Original file line number Diff line number Diff line change
@@ -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
47 changes: 33 additions & 14 deletions physics/discrete_trajectory_segment_iterator.hpp
Original file line number Diff line number Diff line change
@@ -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"
78 changes: 78 additions & 0 deletions physics/discrete_trajectory_segment_iterator_body.hpp
Original file line number Diff line number Diff line change
@@ -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
77 changes: 77 additions & 0 deletions physics/discrete_trajectory_segment_iterator_test.cpp
Original file line number Diff line number Diff line change
@@ -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
6 changes: 4 additions & 2 deletions physics/discrete_trajectory_types.hpp
Original file line number Diff line number Diff line change
@@ -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 {

30 changes: 30 additions & 0 deletions physics/mock_discrete_trajectory_segment.hpp
Original file line number Diff line number Diff line change
@@ -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
Loading