Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Use std::ranges::subrange instead of boost::iterator_range

Browse Source
This commit is contained in:
Siarhei Fedartsou 2024-07-14 15:58:02 +02:00
parent 2faaeb7756
commit 8a31f2f5e3
18 changed files with 66 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/engine/api/nearest_api.hpp
View File

@ -136,7 +136,7 @@ class NearestAPI final : public BaseAPI
forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
auto osm_node_id =
facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position]);
to_node = static_cast<std::uint64_t>(osm_node_id);
}
@ -146,14 +146,14 @@ class NearestAPI final : public BaseAPI
const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
auto osm_node_id =
facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
facade.GetOSMNodeIDOfNode(geometry[phantom_node.fwd_segment_position + 1]);
from_node = static_cast<std::uint64_t>(osm_node_id);
}
else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
{
// In the case of one way, rely on forward segment only
auto osm_node_id =
facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position - 1]);
from_node = static_cast<std::uint64_t>(osm_node_id);
}

21
include/engine/datafacade/datafacade_base.hpp
View File

@ -29,13 +29,11 @@
#include "util/typedefs.hpp"
#include "osrm/coordinate.hpp"
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/any_range.hpp>
#include <cstddef>
#include <engine/bearing.hpp>
#include <optional>
#include <ranges>
#include <string>
#include <string_view>
#include <utility>
@ -50,20 +48,21 @@ class BaseDataFacade
using RTreeLeaf = extractor::EdgeBasedNodeSegment;
using NodeForwardRange =
boost::iterator_range<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
std::ranges::subrange<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
using NodeReverseRange = std::ranges::reverse_view<NodeForwardRange>;
using WeightForwardRange =
boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
std::ranges::subrange<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
using WeightReverseRange = std::ranges::reverse_view<WeightForwardRange>;
using DurationForwardRange =
boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
std::ranges::subrange<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
using DurationReverseRange = std::ranges::reverse_view<DurationForwardRange>;
using DatasourceForwardRange =
boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
std::ranges::subrange<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
using DatasourceReverseRange = std::ranges::reverse_view<DatasourceForwardRange>;
BaseDataFacade() {}
virtual ~BaseDataFacade() {}

4
include/engine/geospatial_query.hpp
View File

@ -394,7 +394,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
alias_cast<EdgeDuration>(forward_durations[data.fwd_segment_position]);
EdgeDistance forward_distance =
to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position]),
point_on_segment));
const auto reverse_weight_offset = alias_cast<EdgeWeight>(
@ -426,7 +426,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
EdgeDistance reverse_distance =
to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
point_on_segment,
datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1))));
datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position + 1])));
ratio = std::min(1.0, std::max(0.0, ratio));
if (data.forward_segment_id.id != SPECIAL_SEGMENTID)

8
include/engine/guidance/assemble_geometry.hpp
View File

@ -61,7 +61,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id;
const auto source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id);
geometry.node_ids.push_back(source_geometry(source_segment_start_coordinate));
geometry.node_ids.push_back(source_geometry[source_segment_start_coordinate]);
auto cumulative_distance = 0.;
auto current_distance = 0.;
@ -142,7 +142,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
LegGeometry::Annotation{current_distance,
duration,
weight,
forward_datasources(target_node.fwd_segment_position)});
forward_datasources[target_node.fwd_segment_position]});
}
else
{
@ -154,7 +154,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
from_alias<double>(reversed_target ? target_node.reverse_weight
: target_node.forward_weight) /
facade.GetWeightMultiplier(),
forward_datasources(target_node.fwd_segment_position)});
forward_datasources[target_node.fwd_segment_position]});
}
geometry.segment_offsets.push_back(geometry.locations.size());
@ -168,7 +168,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
const auto target_segment_end_coordinate =
target_node.fwd_segment_position + (reversed_target ? 0 : 1);
const auto target_geometry = facade.GetUncompressedForwardGeometry(target_geometry_id);
geometry.node_ids.push_back(target_geometry(target_segment_end_coordinate));
geometry.node_ids.push_back(target_geometry[target_segment_end_coordinate]);
BOOST_ASSERT(geometry.segment_distances.size() == geometry.segment_offsets.size() - 1);
BOOST_ASSERT(geometry.locations.size() > geometry.segment_distances.size());

2
include/extractor/node_restriction_map.hpp
View File

@ -5,8 +5,6 @@
#include "restriction_graph.hpp"
#include "util/typedefs.hpp"
#include <boost/range/adaptor/filtered.hpp>
#include <unordered_map>
#include <utility>
#include <vector>

38
include/extractor/segment_data_container.hpp
View File

@ -7,11 +7,9 @@
#include "storage/shared_memory_ownership.hpp"
#include "storage/tar_fwd.hpp"
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/iterator_range.hpp>
#include <filesystem>
#include <iostream>
#include <ranges>
#include <string>
#include <unordered_map>
#include <vector>
@ -79,12 +77,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = nodes.begin() + index[id];
const auto end = nodes.begin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseGeometry(const DirectionalGeometryID id)
{
return boost::adaptors::reverse(GetForwardGeometry(id));
return GetForwardGeometry(id) | std::views::reverse;
}
auto GetForwardDurations(const DirectionalGeometryID id)
@ -92,7 +90,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_durations.begin() + index[id] + 1;
const auto end = fwd_durations.begin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseDurations(const DirectionalGeometryID id)
@ -100,7 +98,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_durations.begin() + index[id];
const auto end = rev_durations.begin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetForwardWeights(const DirectionalGeometryID id)
@ -108,7 +106,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_weights.begin() + index[id] + 1;
const auto end = fwd_weights.begin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseWeights(const DirectionalGeometryID id)
@ -116,7 +114,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_weights.begin() + index[id];
const auto end = rev_weights.begin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetForwardDatasources(const DirectionalGeometryID id)
@ -124,7 +122,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_datasources.begin() + index[id] + 1;
const auto end = fwd_datasources.begin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseDatasources(const DirectionalGeometryID id)
@ -132,7 +130,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_datasources.begin() + index[id];
const auto end = rev_datasources.begin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetForwardGeometry(const DirectionalGeometryID id) const
@ -140,12 +138,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = nodes.cbegin() + index[id];
const auto end = nodes.cbegin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseGeometry(const DirectionalGeometryID id) const
{
return boost::adaptors::reverse(GetForwardGeometry(id));
return GetForwardGeometry(id) | std::views::reverse;
}
auto GetForwardDurations(const DirectionalGeometryID id) const
@ -153,7 +151,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_durations.cbegin() + index[id] + 1;
const auto end = fwd_durations.cbegin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseDurations(const DirectionalGeometryID id) const
@ -161,7 +159,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_durations.cbegin() + index[id];
const auto end = rev_durations.cbegin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetForwardWeights(const DirectionalGeometryID id) const
@ -169,7 +167,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_weights.cbegin() + index[id] + 1;
const auto end = fwd_weights.cbegin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseWeights(const DirectionalGeometryID id) const
@ -177,7 +175,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_weights.cbegin() + index[id];
const auto end = rev_weights.cbegin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetForwardDatasources(const DirectionalGeometryID id) const
@ -185,7 +183,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = fwd_datasources.cbegin() + index[id] + 1;
const auto end = fwd_datasources.cbegin() + index[id + 1];
return boost::make_iterator_range(begin, end);
return std::ranges::subrange(begin, end);
}
auto GetReverseDatasources(const DirectionalGeometryID id) const
@ -193,7 +191,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
const auto begin = rev_datasources.cbegin() + index[id];
const auto end = rev_datasources.cbegin() + index[id + 1] - 1;
return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
return std::ranges::subrange(begin, end) | std::views::reverse;
}
auto GetNumberOfGeometries() const { return index.size() - 1; }

2
include/partitioner/cell_storage.hpp
View File

@ -14,8 +14,6 @@
#include "customizer/cell_metric.hpp"
#include <boost/iterator/iterator_facade.hpp>
#include <boost/range/iterator_range.hpp>
#include <ranges>
#include <tbb/parallel_sort.h>

4
include/partitioner/multi_level_partition.hpp
View File

@ -18,7 +18,7 @@
#include <numeric>
#include <vector>
#include <boost/range/adaptor/reversed.hpp>
#include <ranges>
namespace osrm::partitioner
{
@ -281,7 +281,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
// top down assign new cell ids
LevelID level = partitions.size();
for (const auto &partition : boost::adaptors::reverse(partitions))
for (const auto &partition : std::ranges::reverse_view(partitions))
{
BOOST_ASSERT(permutation.size() > 0);
CellID last_cell_id = partition[permutation.front()];

2
include/util/packed_vector.hpp
View File

@ -340,6 +340,8 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
{
}
ReferenceT operator[](difference_type n) const { return container->operator[](index + n); }
private:
void increment() { ++index; }
void decrement() { --index; }

2
include/util/vector_view.hpp
View File

@ -42,6 +42,8 @@ class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<Data
explicit VectorViewIterator() : m_value(nullptr) {}
explicit VectorViewIterator(DataT *x) : m_value(x) {}
reference operator[](difference_type n) const { return m_value[n]; }
private:
void increment() { ++m_value; }
void decrement() { --m_value; }

1
src/engine/guidance/post_processing.cpp
View File

@ -13,7 +13,6 @@
#include <boost/assert.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/range/iterator_range.hpp>
#include <algorithm>
#include <cmath>

7
src/engine/plugins/tile.cpp
View File

@ -482,9 +482,10 @@ void encodeVectorTile(const DataFacadeBase &facade,
reverse_duration_range[reverse_duration_range.size() -
edge.fwd_segment_position - 1];
const auto forward_datasource_idx =
forward_datasource_range(edge.fwd_segment_position);
const auto reverse_datasource_idx = reverse_datasource_range(
reverse_datasource_range.size() - edge.fwd_segment_position - 1);
forward_datasource_range[edge.fwd_segment_position];
const auto reverse_datasource_idx =
reverse_datasource_range[reverse_datasource_range.size() -
edge.fwd_segment_position - 1];
const auto is_startpoint = edge.is_startpoint;

2
src/partitioner/bisection_to_partition.cpp
View File

@ -124,7 +124,7 @@ bisectionToPartition(const std::vector<BisectionID> &node_to_bisection_id,
std::vector<std::uint32_t> num_cells(max_cell_sizes.size());
int level_idx = max_cell_sizes.size() - 1;
for (auto max_cell_size : boost::adaptors::reverse(max_cell_sizes))
for (auto max_cell_size : std::ranges::reverse_view(max_cell_sizes))
{
BOOST_ASSERT(level_idx >= 0);
partitionLevel(node_to_bisection_id, max_cell_size, permutation, cells);

10
src/updater/updater.cpp
View File

@ -252,11 +252,11 @@ updateSegmentData(const UpdaterConfig &config,
// In this case we want it oriented from in forward directions
auto rev_weights_range =
boost::adaptors::reverse(segment_data.GetReverseWeights(geometry_id));
segment_data.GetReverseWeights(geometry_id) | std::views::reverse;
auto rev_durations_range =
boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
auto rev_datasources_range =
boost::adaptors::reverse(segment_data.GetReverseDatasources(geometry_id));
segment_data.GetReverseDatasources(geometry_id) | std::views::reverse;
bool rev_was_updated = false;
for (const auto segment_offset :
@ -337,11 +337,11 @@ updateSegmentData(const UpdaterConfig &config,
auto new_fwd_durations_range = segment_data.GetForwardDurations(geometry_id);
auto new_fwd_datasources_range = segment_data.GetForwardDatasources(geometry_id);
auto new_rev_durations_range =
boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
auto new_rev_datasources_range = segment_data.GetReverseDatasources(geometry_id);
auto old_fwd_durations_range = segment_data_backup->GetForwardDurations(geometry_id);
auto old_rev_durations_range =
boost::adaptors::reverse(segment_data_backup->GetReverseDurations(geometry_id));
segment_data_backup->GetReverseDurations(geometry_id) | std::views::reverse;
for (const auto segment_offset :
util::irange<std::size_t>(0, new_fwd_durations_range.size()))

12
unit_tests/engine/offline_facade.cpp
View File

@ -4,6 +4,7 @@
#include "util/integer_range.hpp"
#include <boost/test/unit_test.hpp>
#include <ranges>
namespace osrm::engine
{
@ -71,20 +72,17 @@ struct ExternalCellStorage
{
auto GetOutWeight(NodeID /*node*/) const
{
return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
}
auto GetInWeight(NodeID /*node*/) const
{
return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
}
auto GetSourceNodes() const { return boost::make_iterator_range((NodeID *)0, (NodeID *)0); }
auto GetSourceNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
auto GetDestinationNodes() const
{
return boost::make_iterator_range((NodeID *)0, (NodeID *)0);
}
auto GetDestinationNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
};
using Cell = CellImpl;

2
unit_tests/mocks/mock_datafacade.hpp
View File

@ -54,7 +54,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
{
static NodeID data[] = {0, 1, 2, 3};
static extractor::SegmentDataView::SegmentNodeVector nodes(data, 4);
return boost::make_iterator_range(nodes.cbegin(), nodes.cend());
return std::ranges::subrange(nodes.cbegin(), nodes.cend());
}
NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override
{

86
unit_tests/util/packed_vector.cpp
View File

@ -3,14 +3,11 @@
#include "common/range_tools.hpp"
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/any_range.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/test/unit_test.hpp>
#include <algorithm>
#include <boost/test/unit_test.hpp>
#include <numeric>
#include <random>
#include <ranges>
BOOST_AUTO_TEST_SUITE(packed_vector_test)
@ -84,22 +81,22 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
}
BOOST_CHECK_EQUAL(vec_idx, packed_vec.size());
auto range = boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend());
auto range = std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend());
BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
{
BOOST_CHECK_EQUAL(packed_vec[idx], range[idx]);
}
auto reverse_range = boost::adaptors::reverse(
boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend()));
auto reverse_range =
std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend()) | std::views::reverse;
BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
{
BOOST_CHECK_EQUAL(packed_vec[packed_vec.size() - 1 - idx], reverse_range[idx]);
}
auto mut_range = boost::make_iterator_range(packed_vec.begin(), packed_vec.end());
auto mut_range = std::ranges::subrange(packed_vec.begin(), packed_vec.end());
BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
{
@ -107,7 +104,7 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
}
auto mut_reverse_range =
boost::adaptors::reverse(boost::make_iterator_range(packed_vec.begin(), packed_vec.end()));
std::ranges::subrange(packed_vec.begin(), packed_vec.end()) | std::views::reverse;
BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
{
@ -205,73 +202,4 @@ BOOST_AUTO_TEST_CASE(packed_vector_33bit_continious)
}
}
BOOST_AUTO_TEST_CASE(packed_weights_container_with_type_erasure)
{
using Vector = PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS>;
using WeightsAnyRange = boost::any_range<SegmentWeight,
boost::random_access_traversal_tag,
const typename Vector::internal_reference,
std::ptrdiff_t>;
PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS> vector(7);
std::iota(vector.begin(), vector.end(), SegmentWeight{0});
auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6);
auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
CHECK_EQUAL_RANGE(forward,
SegmentWeight{1},
SegmentWeight{2},
SegmentWeight{3},
SegmentWeight{4},
SegmentWeight{5});
CHECK_EQUAL_RANGE(forward_any,
SegmentWeight{1},
SegmentWeight{2},
SegmentWeight{3},
SegmentWeight{4},
SegmentWeight{5});
auto reverse = boost::adaptors::reverse(forward);
auto reverse_any = WeightsAnyRange(reverse);
CHECK_EQUAL_RANGE(reverse,
SegmentWeight{5},
SegmentWeight{4},
SegmentWeight{3},
SegmentWeight{2},
SegmentWeight{1});
CHECK_EQUAL_RANGE(reverse_any,
SegmentWeight{5},
SegmentWeight{4},
SegmentWeight{3},
SegmentWeight{2},
SegmentWeight{1});
}
BOOST_AUTO_TEST_CASE(packed_weights_view_with_type_erasure)
{
using View = PackedVectorView<SegmentWeight, SEGMENT_WEIGHT_BITS>;
using PackedDataWord = std::uint64_t; // PackedVectorView<>::WordT
using WeightsAnyRange = boost::any_range<SegmentWeight,
boost::random_access_traversal_tag,
const typename View::internal_reference,
std::ptrdiff_t>;
PackedDataWord data[] = {0x200000400000, 0xc, 0};
View view(vector_view<PackedDataWord>(data, 3), 7);
auto forward = boost::make_iterator_range(view.begin() + 1, view.begin() + 4);
auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
CHECK_EQUAL_RANGE(forward, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
CHECK_EQUAL_RANGE(forward_any, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
auto reverse = boost::adaptors::reverse(forward);
auto reverse_any = WeightsAnyRange(reverse);
CHECK_EQUAL_RANGE(reverse, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
CHECK_EQUAL_RANGE(reverse_any, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
}
BOOST_AUTO_TEST_SUITE_END()

2
unit_tests/util/vector_view.cpp
View File

@ -1,8 +1,6 @@
#include "util/vector_view.hpp"
#include "util/typedefs.hpp"
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/test/unit_test.hpp>
#include <algorithm>