kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[search] [assessment-tool] Renamed Edits to ResultsEdits.

Browse source
This commit is contained in:
Maxim Pimenov 2019-04-12 21:50:40 +03:00 • committed by Tatiana Yan
parent 861bc09eeb
commit 939e41450a
17 changed files with 141 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
search/search_quality/assessment_tool/context.cpp
View file

@ -117,7 +117,7 @@ void Context::ApplyEdits()
}
// ContextList -------------------------------------------------------------------------------------
ContextList::ContextList(OnUpdate onResultsUpdate, OnUpdate onNonFoundResultsUpdate,
ContextList::ContextList(OnResultsUpdate onResultsUpdate, OnResultsUpdate onNonFoundResultsUpdate,
OnSampleUpdate onSampleUpdate)
: m_onResultsUpdate(onResultsUpdate)
, m_onNonFoundResultsUpdate(onNonFoundResultsUpdate)
@ -138,12 +138,12 @@ void ContextList::Resize(size_t size)
for (size_t i = oldSize; i < size; ++i)
{
m_contexts.emplace_back(
[this, i](Edits::Update const & update) {
[this, i](ResultsEdits::Update const & update) {
OnContextUpdated(i);
if (m_onResultsUpdate)
m_onResultsUpdate(i, update);
},
[this, i](Edits::Update const & update) {
[this, i](ResultsEdits::Update const & update) {
OnContextUpdated(i);
if (m_onNonFoundResultsUpdate)
m_onNonFoundResultsUpdate(i, update);

16
search/search_quality/assessment_tool/context.hpp
View file

@ -26,8 +26,8 @@ struct Context
Completed
};
Context(Edits::OnUpdate onFoundResultsUpdate, Edits::OnUpdate onNonFoundResultsUpdate,
SampleEdits::OnUpdate onSampleUpdate)
Context(ResultsEdits::OnUpdate onFoundResultsUpdate,
ResultsEdits::OnUpdate onNonFoundResultsUpdate, SampleEdits::OnUpdate onSampleUpdate)
: m_foundResultsEdits(onFoundResultsUpdate)
, m_nonFoundResultsEdits(onNonFoundResultsUpdate)
, m_sampleEdits(onSampleUpdate)
@ -68,13 +68,13 @@ struct Context
search::Sample m_sample;
search::Results m_foundResults;
Edits m_foundResultsEdits;
ResultsEdits m_foundResultsEdits;
std::vector<size_t> m_goldenMatching;
std::vector<size_t> m_actualMatching;
std::vector<search::Sample::Result> m_nonFoundResults;
Edits m_nonFoundResultsEdits;
ResultsEdits m_nonFoundResultsEdits;
SampleEdits m_sampleEdits;
@ -114,10 +114,10 @@ public:
ContextList const * m_contexts = nullptr;
};
using OnUpdate = std::function<void(size_t index, Edits::Update const & update)>;
using OnResultsUpdate = std::function<void(size_t index, ResultsEdits::Update const & update)>;
using OnSampleUpdate = std::function<void(size_t index)>;
ContextList(OnUpdate onResultsUpdate, OnUpdate onNonFoundResultsUpdate,
ContextList(OnResultsUpdate onResultsUpdate, OnResultsUpdate onNonFoundResultsUpdate,
OnSampleUpdate onSampleUpdate);
void Resize(size_t size);
@ -141,7 +141,7 @@ private:
std::vector<bool> m_hasChanges;
size_t m_numChanges = 0;
OnUpdate m_onResultsUpdate;
OnUpdate m_onNonFoundResultsUpdate;
OnResultsUpdate m_onResultsUpdate;
OnResultsUpdate m_onNonFoundResultsUpdate;
OnSampleUpdate m_onSampleUpdate;
};

69
search/search_quality/assessment_tool/edits.cpp
View file

@ -6,7 +6,8 @@ using namespace std;
namespace
{
void UpdateNumEdits(Edits::Entry const & entry, Edits::Relevance const & r, size_t & numEdits)
void UpdateNumEdits(ResultsEdits::Entry const & entry, ResultsEdits::Relevance const & r,
size_t & numEdits)
{
if (entry.m_currRelevance != entry.m_origRelevance && r == entry.m_origRelevance)
{
@ -18,31 +19,51 @@ void UpdateNumEdits(Edits::Entry const & entry, Edits::Relevance const & r, size
}
} // namespace
// Edits::Editor -----------------------------------------------------------------------------------
Edits::Editor::Editor(Edits & parent, size_t index)
: m_parent(parent), m_index(index)
// SampleEdits -------------------------------------------------------------------------------------
void SampleEdits::Reset(bool origUseless)
{
m_origUseless = origUseless;
m_currUseless = origUseless;
}
void SampleEdits::FlipUsefulness()
{
m_currUseless ^= true;
if (m_onUpdate)
m_onUpdate();
}
void SampleEdits::Apply()
{
m_origUseless = m_currUseless;
if (m_onUpdate)
m_onUpdate();
}
// ResultsEdits::Editor ----------------------------------------------------------------------------
ResultsEdits::Editor::Editor(ResultsEdits & parent, size_t index) : m_parent(parent), m_index(index)
{
}
bool Edits::Editor::Set(Relevance relevance)
bool ResultsEdits::Editor::Set(Relevance relevance)
{
return m_parent.SetRelevance(m_index, relevance);
}
boost::optional<Edits::Relevance> const & Edits::Editor::Get() const
boost::optional<ResultsEdits::Relevance> const & ResultsEdits::Editor::Get() const
{
return m_parent.Get(m_index).m_currRelevance;
}
bool Edits::Editor::HasChanges() const { return m_parent.HasChanges(m_index); }
bool ResultsEdits::Editor::HasChanges() const { return m_parent.HasChanges(m_index); }
Edits::Entry::Type Edits::Editor::GetType() const
ResultsEdits::Entry::Type ResultsEdits::Editor::GetType() const
{
return m_parent.Get(m_index).m_type;
}
// Edits -------------------------------------------------------------------------------------------
void Edits::Apply()
// ResultsEdits ------------------------------------------------------------------------------------
void ResultsEdits::Apply()
{
WithObserver(Update::MakeAll(), [this]() {
for (auto & entry : m_entries)
@ -54,7 +75,7 @@ void Edits::Apply()
});
}
void Edits::Reset(vector<boost::optional<Edits::Relevance>> const & relevances)
void ResultsEdits::Reset(vector<boost::optional<ResultsEdits::Relevance>> const & relevances)
{
WithObserver(Update::MakeAll(), [this, &relevances]() {
m_entries.resize(relevances.size());
@ -70,7 +91,7 @@ void Edits::Reset(vector<boost::optional<Edits::Relevance>> const & relevances)
});
}
bool Edits::SetRelevance(size_t index, Relevance relevance)
bool ResultsEdits::SetRelevance(size_t index, Relevance relevance)
{
return WithObserver(Update::MakeSingle(index), [this, index, relevance]() {
CHECK_LESS(index, m_entries.size(), ());
@ -84,7 +105,7 @@ bool Edits::SetRelevance(size_t index, Relevance relevance)
});
}
void Edits::SetAllRelevances(Relevance relevance)
void ResultsEdits::SetAllRelevances(Relevance relevance)
{
WithObserver(Update::MakeAll(), [this, relevance]() {
for (auto & entry : m_entries)
@ -95,7 +116,7 @@ void Edits::SetAllRelevances(Relevance relevance)
});
}
void Edits::Add(Relevance relevance)
void ResultsEdits::Add(Relevance relevance)
{
auto const index = m_entries.size();
WithObserver(Update::MakeAdd(index), [&]() {
@ -104,7 +125,7 @@ void Edits::Add(Relevance relevance)
});
}
void Edits::Delete(size_t index)
void ResultsEdits::Delete(size_t index)
{
return WithObserver(Update::MakeDelete(index), [this, index]() {
CHECK_LESS(index, m_entries.size(), ());
@ -120,7 +141,7 @@ void Edits::Delete(size_t index)
});
}
void Edits::Resurrect(size_t index)
void ResultsEdits::Resurrect(size_t index)
{
return WithObserver(Update::MakeResurrect(index), [this, index]() {
CHECK_LESS(index, m_entries.size(), ());
@ -137,33 +158,33 @@ void Edits::Resurrect(size_t index)
});
}
Edits::Entry & Edits::GetEntry(size_t index)
ResultsEdits::Entry & ResultsEdits::GetEntry(size_t index)
{
CHECK_LESS(index, m_entries.size(), ());
return m_entries[index];
}
Edits::Entry const & Edits::GetEntry(size_t index) const
ResultsEdits::Entry const & ResultsEdits::GetEntry(size_t index) const
{
CHECK_LESS(index, m_entries.size(), ());
return m_entries[index];
}
vector<boost::optional<Edits::Relevance>> Edits::GetRelevances() const
vector<boost::optional<ResultsEdits::Relevance>> ResultsEdits::GetRelevances() const
{
vector<boost::optional<Edits::Relevance>> relevances(m_entries.size());
vector<boost::optional<ResultsEdits::Relevance>> relevances(m_entries.size());
for (size_t i = 0; i < m_entries.size(); ++i)
relevances[i] = m_entries[i].m_currRelevance;
return relevances;
}
Edits::Entry const & Edits::Get(size_t index) const
ResultsEdits::Entry const & ResultsEdits::Get(size_t index) const
{
CHECK_LESS(index, m_entries.size(), ());
return m_entries[index];
}
void Edits::Clear()
void ResultsEdits::Clear()
{
WithObserver(Update::MakeAll(), [this]() {
m_entries.clear();
@ -171,9 +192,9 @@ void Edits::Clear()
});
}
bool Edits::HasChanges() const { return m_numEdits != 0; }
bool ResultsEdits::HasChanges() const { return m_numEdits != 0; }
bool Edits::HasChanges(size_t index) const
bool ResultsEdits::HasChanges(size_t index) const
{
CHECK_LESS(index, m_entries.size(), ());
auto const & entry = m_entries[index];

28
search/search_quality/assessment_tool/edits.hpp
View file

@ -18,23 +18,10 @@ struct SampleEdits
SampleEdits(OnUpdate onUpdate) : m_onUpdate(onUpdate) {}
void Reset(bool origUseless)
{
m_origUseless = origUseless;
m_currUseless = origUseless;
}
void FlipUsefulness()
{
m_currUseless ^= true;
if (m_onUpdate)
m_onUpdate();
}
void Apply() { m_origUseless = m_currUseless; }
void Reset(bool origUseless);
void FlipUsefulness();
void Apply();
bool HasChanges() const { return m_origUseless != m_currUseless; }
void Clear() {}
bool m_origUseless = false;
@ -43,8 +30,7 @@ struct SampleEdits
OnUpdate m_onUpdate;
};
// todo(@m) Rename to ResultsEdits?
class Edits
class ResultsEdits
{
public:
using Relevance = search::Sample::Result::Relevance;
@ -100,7 +86,7 @@ public:
class Editor
{
public:
Editor(Edits & parent, size_t index);
Editor(ResultsEdits & parent, size_t index);
// Sets relevance to |relevance|. Returns true iff |relevance|
// differs from the original one.
@ -110,11 +96,11 @@ public:
Entry::Type GetType() const;
private:
Edits & m_parent;
ResultsEdits & m_parent;
size_t m_index = 0;
};
explicit Edits(OnUpdate onUpdate) : m_onUpdate(onUpdate) {}
explicit ResultsEdits(OnUpdate onUpdate) : m_onUpdate(onUpdate) {}
void Apply();
void Reset(std::vector<boost::optional<Relevance>> const & relevances);

37
search/search_quality/assessment_tool/main_model.cpp
View file

@ -31,10 +31,10 @@ MainModel::MainModel(Framework & framework)
, m_dataSource(m_framework.GetDataSource())
, m_loader(m_dataSource)
, m_contexts(
[this](size_t sampleIndex, Edits::Update const & update) {
[this](size_t sampleIndex, ResultsEdits::Update const & update) {
OnUpdate(View::ResultType::Found, sampleIndex, update);
},
[this](size_t sampleIndex, Edits::Update const & update) {
[this](size_t sampleIndex, ResultsEdits::Update const & update) {
OnUpdate(View::ResultType::NonFound, sampleIndex, update);
},
[this](size_t sampleIndex) { OnSampleUpdate(sampleIndex); })
@ -220,12 +220,12 @@ void MainModel::OnShowPositionClicked()
void MainModel::OnMarkAllAsRelevantClicked()
{
OnChangeAllRelevancesClicked(Edits::Relevance::Relevant);
OnChangeAllRelevancesClicked(ResultsEdits::Relevance::Relevant);
}
void MainModel::OnMarkAllAsIrrelevantClicked()
{
OnChangeAllRelevancesClicked(Edits::Relevance::Irrelevant);
OnChangeAllRelevancesClicked(ResultsEdits::Relevance::Irrelevant);
}
bool MainModel::HasChanges() { return m_contexts.HasChanges(); }
@ -237,7 +237,7 @@ bool MainModel::AlreadyInSamples(FeatureID const & id)
CHECK_LESS(static_cast<size_t>(m_selectedSample), m_contexts.Size(), ());
bool found = false;
ForAnyMatchingEntry(m_contexts[m_selectedSample], id, [&](Edits & edits, size_t index) {
ForAnyMatchingEntry(m_contexts[m_selectedSample], id, [&](ResultsEdits & edits, size_t index) {
auto const & entry = edits.GetEntry(index);
if (!entry.m_deleted)
found = true;
@ -254,7 +254,7 @@ void MainModel::AddNonFoundResult(FeatureID const & id)
auto & context = m_contexts[m_selectedSample];
bool resurrected = false;
ForAnyMatchingEntry(context, id, [&](Edits & edits, size_t index) {
ForAnyMatchingEntry(context, id, [&](ResultsEdits & edits, size_t index) {
auto const & entry = edits.GetEntry(index);
CHECK(entry.m_deleted, ());
edits.Resurrect(index);
@ -289,9 +289,10 @@ void MainModel::InitiateForegroundSearch(size_t index)
m_view->OnSearchStarted();
}
void MainModel::OnUpdate(View::ResultType type, size_t sampleIndex, Edits::Update const & update)
void MainModel::OnUpdate(View::ResultType type, size_t sampleIndex,
ResultsEdits::Update const & update)
{
using Type = Edits::Update::Type;
using Type = ResultsEdits::Update::Type;
CHECK_GREATER_OR_EQUAL(sampleIndex, 0, ());
CHECK_LESS(static_cast<size_t>(sampleIndex), m_contexts.Size(), ());
@ -303,7 +304,8 @@ void MainModel::OnUpdate(View::ResultType type, size_t sampleIndex, Edits::Updat
CHECK_EQUAL(type, View::ResultType::NonFound, ());
m_view->ShowNonFoundResults(context.m_nonFoundResults,
context.m_nonFoundResultsEdits.GetEntries());
m_view->SetEdits(m_selectedSample, context.m_foundResultsEdits, context.m_nonFoundResultsEdits);
m_view->SetResultsEdits(m_selectedSample, context.m_foundResultsEdits,
context.m_nonFoundResultsEdits);
}
m_view->OnResultChanged(sampleIndex, type, update);
@ -343,16 +345,19 @@ void MainModel::UpdateViewOnResults(search::Results const & results)
m_view->ShowNonFoundResults(context.m_nonFoundResults,
context.m_nonFoundResultsEdits.GetEntries());
m_view->ShowMarks(context);
m_view->OnResultChanged(m_selectedSample, View::ResultType::Found, Edits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::NonFound, Edits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::Found,
ResultsEdits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::NonFound,
ResultsEdits::Update::MakeAll());
m_view->OnSampleChanged(m_selectedSample, context.IsUseless(), context.HasChanges());
m_view->OnSamplesChanged(m_contexts.HasChanges());
m_view->SetEdits(m_selectedSample, context.m_foundResultsEdits, context.m_nonFoundResultsEdits);
m_view->SetResultsEdits(m_selectedSample, context.m_foundResultsEdits,
context.m_nonFoundResultsEdits);
m_view->OnSearchCompleted();
}
void MainModel::OnChangeAllRelevancesClicked(Edits::Relevance relevance)
void MainModel::OnChangeAllRelevancesClicked(ResultsEdits::Relevance relevance)
{
CHECK_GREATER_OR_EQUAL(m_selectedSample, 0, ());
CHECK_LESS(static_cast<size_t>(m_selectedSample), m_contexts.Size(), ());
@ -361,8 +366,10 @@ void MainModel::OnChangeAllRelevancesClicked(Edits::Relevance relevance)
context.m_foundResultsEdits.SetAllRelevances(relevance);
context.m_nonFoundResultsEdits.SetAllRelevances(relevance);
m_view->OnResultChanged(m_selectedSample, View::ResultType::Found, Edits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::NonFound, Edits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::Found,
ResultsEdits::Update::MakeAll());
m_view->OnResultChanged(m_selectedSample, View::ResultType::NonFound,
ResultsEdits::Update::MakeAll());
m_view->OnSampleChanged(m_selectedSample, context.IsUseless(), context.HasChanges());
m_view->OnSamplesChanged(m_contexts.HasChanges());
}

4
search/search_quality/assessment_tool/main_model.hpp
View file

@ -54,13 +54,13 @@ private:
void InitiateForegroundSearch(size_t index);
void OnUpdate(View::ResultType type, size_t sampleIndex, Edits::Update const & update);
void OnUpdate(View::ResultType type, size_t sampleIndex, ResultsEdits::Update const & update);
void OnSampleUpdate(size_t sampleIndex);
void UpdateViewOnResults(search::Results const & results);
void ShowMarks(Context const & context);
void OnChangeAllRelevancesClicked(Edits::Relevance relevance);
void OnChangeAllRelevancesClicked(ResultsEdits::Relevance relevance);
template <typename Fn>
void ForAnyMatchingEntry(Context & context, FeatureID const & id, Fn && fn);

16
search/search_quality/assessment_tool/main_view.cpp
View file

@ -120,8 +120,8 @@ void MainView::ShowSample(size_t sampleIndex, search::Sample const & sample,
m_sampleView->SetContents(sample, position);
m_sampleView->show();
OnResultChanged(sampleIndex, ResultType::Found, Edits::Update::MakeAll());
OnResultChanged(sampleIndex, ResultType::NonFound, Edits::Update::MakeAll());
OnResultChanged(sampleIndex, ResultType::Found, ResultsEdits::Update::MakeAll());
OnResultChanged(sampleIndex, ResultType::NonFound, ResultsEdits::Update::MakeAll());
OnSampleChanged(sampleIndex, isUseless, hasEdits);
}
@ -131,7 +131,7 @@ void MainView::AddFoundResults(search::Results::ConstIter begin, search::Results
}
void MainView::ShowNonFoundResults(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries)
std::vector<ResultsEdits::Entry> const & entries)
{
m_sampleView->ShowNonFoundResults(results, entries);
}
@ -151,7 +151,7 @@ void MainView::ShowFoundResultsMarks(search::Results::ConstIter begin,
}
void MainView::ShowNonFoundResultsMarks(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries)
std::vector<ResultsEdits::Entry> const & entries)
{
m_sampleView->ShowNonFoundResultsMarks(results, entries);
}
@ -177,7 +177,8 @@ void MainView::MoveViewportToRect(m2::RectD const & rect)
m_framework.ShowRect(rect, -1 /* maxScale */, false /* animation */);
}
void MainView::OnResultChanged(size_t sampleIndex, ResultType type, Edits::Update const & update)
void MainView::OnResultChanged(size_t sampleIndex, ResultType type,
ResultsEdits::Update const & update)
{
m_samplesView->OnUpdate(sampleIndex);
@ -207,10 +208,11 @@ void MainView::OnSamplesChanged(bool hasEdits)
m_saveAs->setEnabled(hasEdits);
}
void MainView::SetEdits(size_t sampleIndex, Edits & foundResultsEdits, Edits & nonFoundResultsEdits)
void MainView::SetResultsEdits(size_t sampleIndex, ResultsEdits & foundResultsEdits,
ResultsEdits & nonFoundResultsEdits)
{
CHECK(m_samplesView->IsSelected(sampleIndex), ());
m_sampleView->SetEdits(foundResultsEdits, nonFoundResultsEdits);
m_sampleView->SetResultsEdits(foundResultsEdits, nonFoundResultsEdits);
}
void MainView::ShowError(std::string const & msg)

11
search/search_quality/assessment_tool/main_view.hpp
View file

@ -38,22 +38,23 @@ public:
void AddFoundResults(search::Results::ConstIter begin, search::Results::ConstIter end) override;
void ShowNonFoundResults(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries) override;
std::vector<ResultsEdits::Entry> const & entries) override;
void ShowMarks(Context const & context) override;
void ShowFoundResultsMarks(search::Results::ConstIter begin,
search::Results::ConstIter end) override;
void ShowNonFoundResultsMarks(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries) override;
std::vector<ResultsEdits::Entry> const & entries) override;
void ClearSearchResultMarks() override;
void MoveViewportToResult(search::Result const & result) override;
void MoveViewportToResult(search::Sample::Result const & result) override;
void MoveViewportToRect(m2::RectD const & rect) override;
void OnResultChanged(size_t sampleIndex, ResultType type, Edits::Update const & update) override;
void SetEdits(size_t sampleIndex, Edits & foundResultsEdits,
Edits & nonFoundResultsEdits) override;
void OnResultChanged(size_t sampleIndex, ResultType type,
ResultsEdits::Update const & update) override;
void SetResultsEdits(size_t sampleIndex, ResultsEdits & foundResultsResultsEdits,
ResultsEdits & nonFoundResultsResultsEdits) override;
void OnSampleChanged(size_t sampleIndex, bool isUseless, bool hasEdits) override;
void OnSamplesChanged(bool hasEdits) override;

6
search/search_quality/assessment_tool/result_view.cpp
View file

@ -72,9 +72,9 @@ ResultView::ResultView(search::Sample::Result const & result, QWidget & parent)
{
}
void ResultView::SetEditor(Edits::Editor && editor)
void ResultView::SetEditor(ResultsEdits::Editor && editor)
{
m_editor = make_unique<Edits::Editor>(std::move(editor));
m_editor = make_unique<ResultsEdits::Editor>(std::move(editor));
UpdateRelevanceRadioButtons();
@ -89,7 +89,7 @@ void ResultView::Update()
return;
}
if (m_editor->GetType() == Edits::Entry::Type::Created)
if (m_editor->GetType() == ResultsEdits::Entry::Type::Created)
{
setStyleSheet("#result {background: rgba(173, 223, 173, 50%)}");
}

4
search/search_quality/assessment_tool/result_view.hpp
View file

@ -24,7 +24,7 @@ public:
ResultView(search::Result const & result, QWidget & parent);
ResultView(search::Sample::Result const & result, QWidget & parent);
void SetEditor(Edits::Editor && editor);
void SetEditor(ResultsEdits::Editor && editor);
void Update();
@ -49,5 +49,5 @@ private:
QRadioButton * m_relevant = nullptr;
QRadioButton * m_vital = nullptr;
std::unique_ptr<Edits::Editor> m_editor;
std::unique_ptr<ResultsEdits::Editor> m_editor;
};

14
search/search_quality/assessment_tool/results_view.cpp
View file

@ -31,7 +31,7 @@ void ResultsView::Add(search::Result const & result)
m_hasResultsWithPoints = true;
}
void ResultsView::Add(search::Sample::Result const & result, Edits::Entry const & entry)
void ResultsView::Add(search::Sample::Result const & result, ResultsEdits::Entry const & entry)
{
AddImpl(result, entry.m_deleted /* hidden */);
}
@ -48,36 +48,36 @@ ResultView const & ResultsView::Get(size_t i) const
return *m_results[i];
}
void ResultsView::Update(Edits::Update const & update)
void ResultsView::Update(ResultsEdits::Update const & update)
{
switch (update.m_type)
{
case Edits::Update::Type::Single:
case ResultsEdits::Update::Type::Single:
{
CHECK_LESS(update.m_index, m_results.size(), ());
m_results[update.m_index]->Update();
break;
}
case Edits::Update::Type::All:
case ResultsEdits::Update::Type::All:
{
for (auto * result : m_results)
result->Update();
break;
}
case Edits::Update::Type::Add:
case ResultsEdits::Update::Type::Add:
{
CHECK_LESS(update.m_index, m_results.size(), ());
m_results[update.m_index]->Update();
break;
}
case Edits::Update::Type::Delete:
case ResultsEdits::Update::Type::Delete:
{
auto const index = update.m_index;
CHECK_LESS(index, Size(), ());
item(static_cast<int>(index))->setHidden(true);
break;
}
case Edits::Update::Type::Resurrect:
case ResultsEdits::Update::Type::Resurrect:
auto const index = update.m_index;
CHECK_LESS(index, Size(), ());
item(static_cast<int>(index))->setHidden(false);

4
search/search_quality/assessment_tool/results_view.hpp
View file

@ -23,11 +23,11 @@ public:
explicit ResultsView(QWidget & parent);
void Add(search::Result const & result);
void Add(search::Sample::Result const & result, Edits::Entry const & entry);
void Add(search::Sample::Result const & result, ResultsEdits::Entry const & entry);
ResultView & Get(size_t i);
ResultView const & Get(size_t i) const;
void Update(Edits::Update const & update);
void Update(ResultsEdits::Update const & update);
size_t Size() const { return m_results.size(); }
bool HasResultsWithPoints() const { return m_hasResultsWithPoints; }

15
search/search_quality/assessment_tool/sample_view.cpp
View file

@ -249,7 +249,7 @@ void SampleView::AddFoundResults(search::Results::ConstIter begin, search::Resul
}
void SampleView::ShowNonFoundResults(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries)
std::vector<ResultsEdits::Entry> const & entries)
{
CHECK_EQUAL(results.size(), entries.size(), ());
@ -273,7 +273,7 @@ void SampleView::ShowFoundResultsMarks(search::Results::ConstIter begin, search:
}
void SampleView::ShowNonFoundResultsMarks(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries)
std::vector<ResultsEdits::Entry> const & entries)
{
CHECK_EQUAL(results.size(), entries.size(), ());
@ -306,10 +306,11 @@ void SampleView::ClearAllResults()
ClearSearchResultMarks();
}
void SampleView::SetEdits(Edits & resultsEdits, Edits & nonFoundResultsEdits)
void SampleView::SetResultsEdits(ResultsEdits & resultsResultsEdits,
ResultsEdits & nonFoundResultsEdits)
{
SetEdits(*m_foundResults, resultsEdits);
SetEdits(*m_nonFoundResults, nonFoundResultsEdits);
SetResultsEdits(*m_foundResults, resultsResultsEdits);
SetResultsEdits(*m_nonFoundResults, nonFoundResultsEdits);
m_nonFoundResultsEdits = &nonFoundResultsEdits;
}
@ -359,12 +360,12 @@ void SampleView::OnLocationChanged(Qt::DockWidgetArea area)
layout()->setContentsMargins(m_defaultMargins);
}
void SampleView::SetEdits(ResultsView & results, Edits & edits)
void SampleView::SetResultsEdits(ResultsView & results, ResultsEdits & edits)
{
size_t const numRelevances = edits.GetRelevances().size();
CHECK_EQUAL(results.Size(), numRelevances, ());
for (size_t i = 0; i < numRelevances; ++i)
results.Get(i).SetEditor(Edits::Editor(edits, i));
results.Get(i).SetEditor(ResultsEdits::Editor(edits, i));
}
void SampleView::OnRemoveNonFoundResult(int row) { m_nonFoundResultsEdits->Delete(row); }

11
search/search_quality/assessment_tool/sample_view.hpp
View file

@ -35,14 +35,15 @@ public:
void AddFoundResults(search::Results::ConstIter begin, search::Results::ConstIter end);
void ShowNonFoundResults(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries);
std::vector<ResultsEdits::Entry> const & entries);
void ShowFoundResultsMarks(search::Results::ConstIter begin, search::Results::ConstIter end);
void ShowNonFoundResultsMarks(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries);
std::vector<ResultsEdits::Entry> const & entries);
void ClearSearchResultMarks();
void SetEdits(Edits & resultsEdits, Edits & nonFoundResultsEdits);
void SetResultsEdits(ResultsEdits & resultsResultsEdits,
ResultsEdits & nonFoundResultsResultsEdits);
void OnUselessnessChanged(bool isUseless);
@ -61,7 +62,7 @@ signals:
private:
void ClearAllResults();
void SetEdits(ResultsView & results, Edits & edits);
void SetResultsEdits(ResultsView & results, ResultsEdits & edits);
void OnRemoveNonFoundResult(int row);
void ShowUserPosition(m2::PointD const & position);
@ -91,7 +92,7 @@ private:
ResultsView * m_nonFoundResults = nullptr;
QWidget * m_nonFoundResultsBox = nullptr;
Edits * m_nonFoundResultsEdits = nullptr;
ResultsEdits * m_nonFoundResultsEdits = nullptr;
QMargins m_rightAreaMargins;
QMargins m_defaultMargins;

4
search/search_quality/assessment_tool/search_request_runner.cpp
View file

@ -90,7 +90,7 @@ void SearchRequestRunner::RunRequest(size_t index, bool background, size_t times
search::SearchParams params;
sample.FillSearchParams(params);
params.m_onResults = [=](search::Results const & results) {
vector<boost::optional<Edits::Relevance>> relevances;
vector<boost::optional<ResultsEdits::Relevance>> relevances;
vector<size_t> goldenMatching;
vector<size_t> actualMatching;
@ -145,7 +145,7 @@ void SearchRequestRunner::RunRequest(size_t index, bool background, size_t times
context.m_actualMatching = actualMatching;
{
vector<boost::optional<Edits::Relevance>> relevances;
vector<boost::optional<ResultsEdits::Relevance>> relevances;
auto & nonFound = context.m_nonFoundResults;
CHECK(nonFound.empty(), ());

11
search/search_quality/assessment_tool/view.hpp
View file

@ -14,7 +14,7 @@
#include <boost/optional.hpp>
class Edits;
class ResultsEdits;
class Model;
class View
@ -40,13 +40,13 @@ public:
virtual void AddFoundResults(search::Results::ConstIter begin,
search::Results::ConstIter end) = 0;
virtual void ShowNonFoundResults(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries) = 0;
std::vector<ResultsEdits::Entry> const & entries) = 0;
virtual void ShowMarks(Context const & context) = 0;
virtual void ShowFoundResultsMarks(search::Results::ConstIter begin,
search::Results::ConstIter end) = 0;
virtual void ShowNonFoundResultsMarks(std::vector<search::Sample::Result> const & results,
std::vector<Edits::Entry> const & entries) = 0;
std::vector<ResultsEdits::Entry> const & entries) = 0;
virtual void ClearSearchResultMarks() = 0;
virtual void MoveViewportToResult(search::Result const & result) = 0;
@ -54,8 +54,9 @@ public:
virtual void MoveViewportToRect(m2::RectD const & rect) = 0;
virtual void OnResultChanged(size_t sampleIndex, ResultType type,
Edits::Update const & update) = 0;
virtual void SetEdits(size_t index, Edits & foundResultsEdits, Edits & nonFoundResultsEdits) = 0;
ResultsEdits::Update const & update) = 0;
virtual void SetResultsEdits(size_t index, ResultsEdits & foundResultsEdits,
ResultsEdits & nonFoundResultsEdits) = 0;
virtual void OnSampleChanged(size_t sampleIndex, bool isUseless, bool hasEdits) = 0;
virtual void OnSamplesChanged(bool hasEdits) = 0;

4
search/search_quality/sample.hpp
View file

@ -79,7 +79,9 @@ struct Sample
// A useless sample is usually a result of the user exploring
// the search engine without a clear search intent or a sample
// that cannot be assessed properly using only the data it contains.
// that cannot be assessed properly using only the data available
// to the engine (for example, related queries may help a lot but
// are not expected to be available).
bool m_useless = false;
};