AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Review fixes.

Browse source
This commit is contained in:
Yuri Gorshenin 2016-04-22 18:34:40 +03:00
parent f48c3e6a6a
commit bdc06eada4
16 changed files with 275 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
generator/search_index_builder.cpp
View file

@ -261,9 +261,11 @@ public:
void operator() (FeatureType const & f, uint32_t index) const
{
using namespace search;
feature::TypesHolder types(f);
static search::TypesSkipper skipIndex;
static TypesSkipper skipIndex;
skipIndex.SkipTypes(types);
if (types.Empty())
@ -284,10 +286,10 @@ public:
// See OSM TagInfo or Wiki about modern postcodes format. The average number of tokens is less
// than two.
buffer_vector<strings::UniString, 2> tokens;
SplitUniString(search::NormalizeAndSimplifyString(postcode), MakeBackInsertFunctor(tokens),
search::Delimiters());
SplitUniString(NormalizeAndSimplifyString(postcode), MakeBackInsertFunctor(tokens),
Delimiters());
for (auto const & token : tokens)
inserter.AddToken(search::kCategoriesLang, search::PostcodeToString(token));
inserter.AddToken(kPostcodesLang, PostcodeToString(token));
}
// Skip types for features without names.
@ -303,7 +305,7 @@ public:
// add names of categories of the feature
for (uint32_t t : categoryTypes)
inserter.AddToken(search::kCategoriesLang, search::FeatureTypeToString(c.GetIndexForType(t)));
inserter.AddToken(kCategoriesLang, FeatureTypeToString(c.GetIndexForType(t)));
}
};

83
search/feature_offset_match.hpp
View file

@ -3,6 +3,7 @@
#include "search/search_index_values.hpp"
#include "search/search_query.hpp"
#include "search/search_query_params.hpp"
#include "search/v2/token_slice.hpp"
#include "indexer/trie.hpp"
@ -103,6 +104,25 @@ bool CheckMatchString(strings::UniChar const * rootPrefix, size_t rootPrefixSize
return false;
}
template <typename TValue>
bool FindLangIndex(trie::Iterator<ValueList<TValue>> const & trieRoot, uint8_t lang, uint32_t & langIx)
{
ASSERT_LESS(trieRoot.m_edge.size(), numeric_limits<uint32_t>::max(), ());
uint32_t const numLangs = static_cast<uint32_t>(trieRoot.m_edge.size());
for (uint32_t i = 0; i < numLangs; ++i)
{
auto const & edge = trieRoot.m_edge[i].m_label;
ASSERT_GREATER_OR_EQUAL(edge.size(), 1, ());
if (edge[0] == lang)
{
langIx = i;
return true;
}
}
return false;
}
} // namespace
template <typename TValue, typename TF>
@ -222,7 +242,7 @@ public:
toDo(value);
}
};
} // namespace search::impl
} // impl
template <typename TValue>
struct TrieRootPrefix
@ -345,27 +365,23 @@ template <typename TValue, typename THolder>
bool MatchCategoriesInTrie(SearchQueryParams const & params,
trie::Iterator<ValueList<TValue>> const & trieRoot, THolder && holder)
{
ASSERT_LESS(trieRoot.m_edge.size(), numeric_limits<uint32_t>::max(), ());
uint32_t const numLangs = static_cast<uint32_t>(trieRoot.m_edge.size());
for (uint32_t langIx = 0; langIx < numLangs; ++langIx)
{
auto const & edge = trieRoot.m_edge[langIx].m_label;
ASSERT_GREATER_OR_EQUAL(edge.size(), 1, ());
if (edge[0] == search::kCategoriesLang)
{
auto const catRoot = trieRoot.GoToEdge(langIx);
MatchTokensInTrie(params.m_tokens, TrieRootPrefix<TValue>(*catRoot, edge), holder);
uint32_t langIx = 0;
if (!impl::FindLangIndex(trieRoot, search::kCategoriesLang, langIx))
return false;
// Last token's prefix is used as a complete token here, to
// limit the number of features in the last bucket of a
// holder. Probably, this is a false optimization.
holder.Resize(params.m_tokens.size() + 1);
holder.SwitchTo(params.m_tokens.size());
MatchTokenInTrie(params.m_prefixTokens, TrieRootPrefix<TValue>(*catRoot, edge), holder);
return true;
}
}
return false;
auto const & edge = trieRoot.m_edge[langIx].m_label;
ASSERT_GREATER_OR_EQUAL(edge.size(), 1, ());
auto const catRoot = trieRoot.GoToEdge(langIx);
MatchTokensInTrie(params.m_tokens, TrieRootPrefix<TValue>(*catRoot, edge), holder);
// Last token's prefix is used as a complete token here, to limit
// the number of features in the last bucket of a holder. Probably,
// this is a false optimization.
holder.Resize(params.m_tokens.size() + 1);
holder.SwitchTo(params.m_tokens.size());
MatchTokenInTrie(params.m_prefixTokens, TrieRootPrefix<TValue>(*catRoot, edge), holder);
return true;
}
// Calls toDo with trie root prefix and language code on each language
@ -427,4 +443,29 @@ void MatchFeaturesInTrie(SearchQueryParams const & params,
intersecter.ForEachResult(forward<ToDo>(toDo));
}
template <typename TValue, typename TFilter, typename ToDo>
void MatchPostcodesInTrie(v2::TokenSlice const & slice,
trie::Iterator<ValueList<TValue>> const & trieRoot,
TFilter const & filter, ToDo && toDo)
{
uint32_t langIx = 0;
if (!impl::FindLangIndex(trieRoot, search::kPostcodesLang, langIx))
return;
auto const & edge = trieRoot.m_edge[langIx].m_label;
auto const postcodesRoot = trieRoot.GoToEdge(langIx);
impl::OffsetIntersecter<TFilter, TValue> intersecter(filter);
for (size_t i = 0; i < slice.Size(); ++i)
{
if (slice.IsPrefix(i))
MatchTokenPrefixInTrie(slice.Get(i), TrieRootPrefix<TValue>(*postcodesRoot, edge), intersecter);
else
MatchTokenInTrie(slice.Get(i), TrieRootPrefix<TValue>(*postcodesRoot, edge), intersecter);
intersecter.NextStep();
}
intersecter.ForEachResult(forward<ToDo>(toDo));
}
} // namespace search

164
search/retrieval.cpp
View file

@ -7,6 +7,7 @@
#include "search_trie.hpp"
#include "v2/mwm_context.hpp"
#include "v2/token_slice.hpp"
#include "indexer/feature.hpp"
#include "indexer/feature_algo.hpp"
@ -29,8 +30,65 @@ using osm::Editor;
namespace search
{
namespace v2
{
namespace
{
class FeaturesCollector
{
public:
FeaturesCollector(my::Cancellable const & cancellable, vector<uint64_t> & features)
: m_cancellable(cancellable), m_features(features), m_counter(0)
{
}
template <typename TValue>
void operator()(TValue const & value)
{
if ((++m_counter & 0xFF) == 0)
BailIfCancelled(m_cancellable);
m_features.push_back(value.m_featureId);
}
inline void operator()(uint32_t feature) { m_features.push_back(feature); }
inline void operator()(uint64_t feature) { m_features.push_back(feature); }
private:
my::Cancellable const & m_cancellable;
vector<uint64_t> & m_features;
uint32_t m_counter;
};
class EditedFeaturesHolder
{
public:
EditedFeaturesHolder(MwmSet::MwmId const & id)
{
Editor & editor = Editor::Instance();
m_deleted = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Deleted);
m_modified = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Modified);
m_created = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Created);
}
bool ModifiedOrDeleted(uint32_t featureIndex) const
{
return binary_search(m_deleted.begin(), m_deleted.end(), featureIndex) ||
binary_search(m_modified.begin(), m_modified.end(), featureIndex);
}
template <typename TFn>
void ForEachModifiedOrCreated(TFn & fn)
{
for_each(m_modified.begin(), m_modified.end(), fn);
for_each(m_created.begin(), m_created.end(), fn);
}
private:
vector<uint32_t> m_deleted;
vector<uint32_t> m_modified;
vector<uint32_t> m_created;
};
unique_ptr<coding::CompressedBitVector> SortFeaturesAndBuildCBV(vector<uint64_t> && features)
{
@ -89,6 +147,13 @@ bool MatchFeatureByName(FeatureType const & ft, SearchQueryParams const & params
return matched;
}
bool MatchFeatureByPostcode(FeatureType const & ft, v2::TokenSlice const & slice)
{
string const postcode = ft.GetMetadata().Get(feature::Metadata::FMD_POSTCODE);
// TODO(@y): implement this.
return false;
}
// Retrieves from the search index corresponding to |value| all
// features matching to |params|.
template <typename TValue>
@ -96,16 +161,7 @@ unique_ptr<coding::CompressedBitVector> RetrieveAddressFeaturesImpl(
MwmSet::MwmId const & id, MwmValue & value, my::Cancellable const & cancellable,
SearchQueryParams const & params)
{
// Exclude from search all deleted/modified features and match all edited/created features separately.
Editor & editor = Editor::Instance();
auto const deleted = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Deleted);
auto const modified = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Modified);
auto const filter = [&](uint32_t featureIndex) -> bool
{
return (!binary_search(deleted.begin(), deleted.end(), featureIndex) &&
!binary_search(modified.begin(), modified.end(), featureIndex));
};
EditedFeaturesHolder holder(id);
serial::CodingParams codingParams(trie::GetCodingParams(value.GetHeader().GetDefCodingParams()));
ModelReaderPtr searchReader = value.m_cont.GetReader(SEARCH_INDEX_FILE_TAG);
@ -116,17 +172,16 @@ unique_ptr<coding::CompressedBitVector> RetrieveAddressFeaturesImpl(
// TODO (@y, @m): This code may be optimized in the case where
// bit vectors are sorted in the search index.
vector<uint64_t> features;
uint32_t counter = 0;
auto const collector = [&](TValue const & value)
{
if ((++counter & 0xFF) == 0)
BailIfCancelled(cancellable);
features.push_back(value.m_featureId);
};
FeaturesCollector collector(cancellable, features);
MatchFeaturesInTrie(params, *trieRoot, filter, collector);
MatchFeaturesInTrie(params, *trieRoot, [&holder](uint32_t featureIndex)
{
return !holder.ModifiedOrDeleted(featureIndex);
},
collector);
// Match all edited/created features separately.
Editor & editor = Editor::Instance();
auto const matcher = [&](uint32_t featureIndex)
{
FeatureType ft;
@ -136,9 +191,47 @@ unique_ptr<coding::CompressedBitVector> RetrieveAddressFeaturesImpl(
features.push_back(featureIndex);
};
for_each(modified.begin(), modified.end(), matcher);
auto const created = editor.GetFeaturesByStatus(id, Editor::FeatureStatus::Created);
for_each(created.begin(), created.end(), matcher);
holder.ForEachModifiedOrCreated(matcher);
return SortFeaturesAndBuildCBV(move(features));
}
template <typename TValue>
unique_ptr<coding::CompressedBitVector> RetrievePostcodeFeaturesImpl(
MwmSet::MwmId const & id, MwmValue & value, my::Cancellable const & cancellable,
TokenSlice const & slice)
{
EditedFeaturesHolder holder(id);
serial::CodingParams codingParams(trie::GetCodingParams(value.GetHeader().GetDefCodingParams()));
ModelReaderPtr searchReader = value.m_cont.GetReader(SEARCH_INDEX_FILE_TAG);
auto const trieRoot = trie::ReadTrie<SubReaderWrapper<Reader>, ValueList<TValue>>(
SubReaderWrapper<Reader>(searchReader.GetPtr()), SingleValueSerializer<TValue>(codingParams));
// TODO (@y, @m): This code may be optimized in the case where
// bit vectors are sorted in the search index.
vector<uint64_t> features;
FeaturesCollector collector(cancellable, features);
MatchPostcodesInTrie(slice, *trieRoot, [&holder](uint32_t featureIndex)
{
return !holder.ModifiedOrDeleted(featureIndex);
},
collector);
// Match all edited/created features separately.
Editor & editor = Editor::Instance();
auto const matcher = [&](uint32_t featureIndex)
{
FeatureType ft;
VERIFY(editor.GetEditedFeature(id, featureIndex, ft), ());
// TODO(AlexZ): Should we match by some feature's metafields too?
if (MatchFeatureByPostcode(ft, slice))
features.push_back(featureIndex);
};
holder.ForEachModifiedOrCreated(matcher);
return SortFeaturesAndBuildCBV(move(features));
}
@ -149,16 +242,11 @@ unique_ptr<coding::CompressedBitVector> RetrieveGeometryFeaturesImpl(
v2::MwmContext const & context, my::Cancellable const & cancellable,
covering::IntervalsT const & coverage, int scale)
{
uint32_t counter = 0;
vector<uint64_t> features;
context.ForEachIndex(coverage, scale, [&](uint64_t featureId)
{
if ((++counter & 0xFF) == 0)
BailIfCancelled(cancellable);
features.push_back(featureId);
});
FeaturesCollector collector(cancellable, features);
context.ForEachIndex(coverage, scale, collector);
return SortFeaturesAndBuildCBV(move(features));
}
@ -172,6 +260,16 @@ struct RetrieveAddressFeaturesAdaptor
}
};
template <typename T>
struct RetrievePostcodeFeaturesAdaptor
{
template <typename... TArgs>
unique_ptr<coding::CompressedBitVector> operator()(TArgs &&... args)
{
return RetrievePostcodeFeaturesImpl<T>(forward<TArgs>(args)...);
}
};
template <template <typename> class T>
struct Selector
{
@ -198,8 +296,6 @@ struct Selector
};
} // namespace
namespace v2
{
unique_ptr<coding::CompressedBitVector> RetrieveAddressFeatures(
MwmSet::MwmId const & id, MwmValue & value, my::Cancellable const & cancellable,
SearchQueryParams const & params)
@ -208,6 +304,14 @@ unique_ptr<coding::CompressedBitVector> RetrieveAddressFeatures(
return selector(id, value, cancellable, params);
}
unique_ptr<coding::CompressedBitVector> RetrievePostcodeFeatures(
MwmSet::MwmId const & id, MwmValue & value, my::Cancellable const & cancellable,
TokenSlice const & slice)
{
Selector<RetrievePostcodeFeaturesAdaptor> selector;
return selector(id, value, cancellable, slice);
}
unique_ptr<coding::CompressedBitVector> RetrieveGeometryFeatures(
MwmContext const & context, my::Cancellable const & cancellable,
m2::RectD const & rect, int scale)

7
search/retrieval.hpp
View file

@ -21,6 +21,7 @@ namespace search
namespace v2
{
class MwmContext;
class TokenSlice;
// Retrieves from the search index corresponding to |value| all
// features matching to |params|.
@ -29,6 +30,12 @@ unique_ptr<coding::CompressedBitVector> RetrieveAddressFeatures(MwmSet::MwmId co
my::Cancellable const & cancellable,
SearchQueryParams const & params);
// Retrieves from the search index corresponding to |value| all
// postcodes matching to |slice|.
unique_ptr<coding::CompressedBitVector> RetrievePostcodeFeatures(
MwmSet::MwmId const & id, MwmValue & value, my::Cancellable const & cancellable,
TokenSlice const & slice);
// Retrieves from the geometry index corresponding to |value| all features belonging to |rect|.
unique_ptr<coding::CompressedBitVector> RetrieveGeometryFeatures(
MwmContext const & context, my::Cancellable const & cancellable, m2::RectD const & rect,

4
search/search.pro
View file

@ -63,7 +63,7 @@ HEADERS += \
v2/search_query_v2.hpp \
v2/stats_cache.hpp \
v2/street_vicinity_loader.hpp \
v2/tokens_slice.hpp \
v2/token_slice.hpp \
SOURCES += \
approximate_string_match.cpp \
@ -109,4 +109,4 @@ SOURCES += \
v2/search_model.cpp \
v2/search_query_v2.cpp \
v2/street_vicinity_loader.cpp \
v2/tokens_slice.cpp \
v2/token_slice.cpp \

31
search/search_integration_tests/search_query_v2_test.cpp
View file

@ -1,10 +1,15 @@
#include "testing/testing.hpp"
#include "search/retrieval.hpp"
#include "search/search_integration_tests/helpers.hpp"
#include "search/search_tests_support/test_feature.hpp"
#include "search/search_tests_support/test_mwm_builder.hpp"
#include "search/search_tests_support/test_results_matching.hpp"
#include "search/search_tests_support/test_search_request.hpp"
#include "search/v2/token_slice.hpp"
#include "indexer/feature.hpp"
#include "indexer/index.hpp"
#include "geometry/point2d.hpp"
#include "geometry/rect2d.hpp"
@ -377,6 +382,32 @@ UNIT_CLASS_TEST(SearchQueryV2Test, TestPostcodes)
builder.Add(street);
builder.Add(building);
});
// Tests that postcode is added to the search index.
{
auto handle = m_engine.GetMwmHandleById(countryId);
TEST(handle.IsAlive(), ());
my::Cancellable cancellable;
SearchQueryParams params;
params.m_tokens.emplace_back();
params.m_tokens.back().push_back(PostcodeToString(strings::MakeUniString("141701")));
auto * value = handle.GetValue<MwmValue>();
auto features = v2::RetrievePostcodeFeatures(countryId, *value, cancellable,
TokenSlice(params, 0, params.m_tokens.size()));
TEST_EQUAL(1, features->PopCount(), ());
uint64_t index = 0;
while (!features->GetBit(index))
++index;
Index::FeaturesLoaderGuard loader(m_engine, countryId);
FeatureType ft;
loader.GetFeatureByIndex(index, ft);
auto rule = ExactMatch(countryId, building);
TEST(rule->Matches(ft), ());
}
{
TRules rules{ExactMatch(countryId, building)};
TEST(ResultsMatch("Долгопрудный первомайская 28а", "ru" /* locale */, rules), ());

4
search/search_query.cpp
View file

@ -12,7 +12,7 @@
#include "search/v2/pre_ranking_info.hpp"
#include "search/v2/ranking_info.hpp"
#include "search/v2/ranking_utils.hpp"
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
#include "storage/country_info_getter.hpp"
#include "storage/index.hpp"
@ -622,7 +622,7 @@ class PreResult2Maker
info.m_nameScore = v2::NAME_SCORE_ZERO;
v2::TokensSliceNoCategories slice(m_params, preInfo.m_startToken, preInfo.m_endToken);
v2::TokenSliceNoCategories slice(m_params, preInfo.m_startToken, preInfo.m_endToken);
for (auto const & lang : m_params.m_langs)
{

4
search/search_tests/postcodes_matcher_tests.cpp
View file

@ -2,7 +2,7 @@
#include "search/search_query_params.hpp"
#include "search/v2/postcodes_matcher.hpp"
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
#include "indexer/search_delimiters.hpp"
#include "indexer/search_string_utils.hpp"
@ -42,7 +42,7 @@ bool LooksLikePostcode(string const & s, bool checkPrefix)
params.m_tokens.back().push_back(token);
}
return LooksLikePostcode(TokensSlice(params, 0, numTokens));
return LooksLikePostcode(TokenSlice(params, 0, numTokens));
}
UNIT_TEST(PostcodesMatcher_Smoke)

4
search/search_tests/ranking_tests.cpp
View file

@ -2,7 +2,7 @@
#include "search/search_query_params.hpp"
#include "search/v2/ranking_utils.hpp"
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
#include "indexer/search_delimiters.hpp"
#include "indexer/search_string_utils.hpp"
@ -33,7 +33,7 @@ NameScore GetScore(string const & name, string const & query, size_t startToken,
params.m_prefixTokens.swap(params.m_tokens.back());
params.m_tokens.pop_back();
}
return GetNameScore(name, TokensSlice(params, startToken, endToken));
return GetNameScore(name, TokenSlice(params, startToken, endToken));
}
UNIT_TEST(NameTest_Smoke)

1
search/search_tests_support/test_feature.hpp
View file

@ -19,6 +19,7 @@ public:
bool Matches(FeatureType const & feature) const;
inline void SetPostcode(string const & postcode) { m_postcode = postcode; }
inline uint64_t GetId() const { return m_id; }
inline string const & GetName() const { return m_name; }
virtual void Serialize(FeatureBuilder1 & fb) const;

2
search/search_trie.hpp
View file

@ -5,8 +5,8 @@
namespace search
{
static const uint8_t kPostcodeLang = 127;
static const uint8_t kCategoriesLang = 128;
static const uint8_t kPostcodesLang = 129;
static const uint8_t kPointCodingBits = 20;
} // namespace search

6
search/v2/locality_scorer.cpp
View file

@ -1,6 +1,6 @@
#include "search/v2/locality_scorer.hpp"
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
#include "std/algorithm.hpp"
@ -101,8 +101,8 @@ void LocalityScorer::SortByName(vector<ExLocality> & ls) const
auto score = NAME_SCORE_ZERO;
for (auto const & name : names)
{
score = max(score, GetNameScore(name, v2::TokensSlice(m_params, l.m_locality.m_startToken,
l.m_locality.m_endToken)));
score = max(score, GetNameScore(name, v2::TokenSlice(m_params, l.m_locality.m_startToken,
l.m_locality.m_endToken)));
}
l.m_nameScore = score;
}

15
search/v2/postcodes_matcher.cpp
View file

@ -1,6 +1,6 @@
#include "search/v2/postcodes_matcher.hpp"
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
#include "indexer/search_delimiters.hpp"
#include "indexer/search_string_utils.hpp"
@ -24,7 +24,8 @@ namespace v2
namespace
{
// Top patterns for postcodes. See
// search/search_quality/clusterize_postcodes.lisp for details.
// search/search_quality/clusterize_postcodes.lisp for details how
// these patterns were constructed.
char const * const g_patterns[] = {
"aa nnnn", "aa nnnnn", "aaa nnnn", "aan", "aan naa", "aana naa", "aann",
"aann naa", "aannaa", "aannnaa", "aannnn", "an naa", "ana naa", "ana nan",
@ -90,6 +91,8 @@ struct Node
DISALLOW_COPY(Node);
};
// This class puts all strings from g_patterns to a trie with a low
// branching factor and matches queries against these patterns.
class PostcodesMatcher
{
public:
@ -100,7 +103,11 @@ public:
AddString(MakeUniString(pattern), delimiters);
}
bool HasString(TokensSlice const & slice) const
// Checks that given tokens match to at least one of postcodes
// patterns.
//
// Complexity: O(total length of tokens in |slice|).
bool HasString(TokenSlice const & slice) const
{
Node const * cur = &m_root;
for (size_t i = 0; i < slice.Size() && cur; ++i)
@ -154,7 +161,7 @@ PostcodesMatcher const & GetPostcodesMatcher()
}
} // namespace
bool LooksLikePostcode(TokensSlice const & slice) { return GetPostcodesMatcher().HasString(slice); }
bool LooksLikePostcode(TokenSlice const & slice) { return GetPostcodesMatcher().HasString(slice); }
size_t GetMaxNumTokensInPostcode() { return GetPostcodesMatcher().GetMaxNumTokensInPostcode(); }
} // namespace v2

4
search/v2/postcodes_matcher.hpp
View file

@ -6,9 +6,9 @@ namespace search
{
namespace v2
{
class TokensSlice;
class TokenSlice;
bool LooksLikePostcode(TokensSlice const & slice);
bool LooksLikePostcode(TokenSlice const & slice);
size_t GetMaxNumTokensInPostcode();
} // namespace v2

8
search/v2/tokens_slice.cpp → search/v2/token_slice.cpp
View file

@ -1,17 +1,17 @@
#include "search/v2/tokens_slice.hpp"
#include "search/v2/token_slice.hpp"
namespace search
{
namespace v2
{
TokensSlice::TokensSlice(SearchQueryParams const & params, size_t startToken, size_t endToken)
TokenSlice::TokenSlice(SearchQueryParams const & params, size_t startToken, size_t endToken)
: m_params(params), m_offset(startToken), m_size(endToken - startToken)
{
ASSERT_LESS_OR_EQUAL(startToken, endToken, ());
}
TokensSliceNoCategories::TokensSliceNoCategories(SearchQueryParams const & params,
size_t startToken, size_t endToken)
TokenSliceNoCategories::TokenSliceNoCategories(SearchQueryParams const & params, size_t startToken,
size_t endToken)
: m_params(params)
{
ASSERT_LESS_OR_EQUAL(startToken, endToken, ());

8
search/v2/tokens_slice.hpp → search/v2/token_slice.hpp
View file

@ -11,10 +11,10 @@ namespace search
{
namespace v2
{
class TokensSlice
class TokenSlice
{
public:
TokensSlice(SearchQueryParams const & params, size_t startToken, size_t endToken);
TokenSlice(SearchQueryParams const & params, size_t startToken, size_t endToken);
inline SearchQueryParams::TSynonymsVector const & Get(size_t i) const
{
@ -38,10 +38,10 @@ private:
size_t const m_size;
};
class TokensSliceNoCategories
class TokenSliceNoCategories
{
public:
TokensSliceNoCategories(SearchQueryParams const & params, size_t startToken, size_t endToken);
TokenSliceNoCategories(SearchQueryParams const & params, size_t startToken, size_t endToken);
inline SearchQueryParams::TSynonymsVector const & Get(size_t i) const
{