1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include "queryvisitor.h"
namespace search::query {
/**
* By typedefing a (complete) set of subclasses to the query nodes in
* a traits class, you can get the CustomTypeVisitor to visit those
* types instead of their base classes.
*
* The traits class must define the following types:
* And, AndNot, Equiv, NumberTerm, Near, ONear, Or,
* Phrase, PrefixTerm, RangeTerm, Rank, StringTerm, SubstringTerm,
* SuffixTerm, WeakAnd, WeightedSetTerm, DotProduct, RegExpTerm
*
* See customtypevisitor_test.cpp for an example.
*
* Please note that your CustomTypeVisitor<T> subclass should NOT
* implement any of the regular QueryVisitor member functions, as this
* would interfere with the routing.
*/
template <class NodeTypes>
class CustomTypeVisitor : public QueryVisitor {
public:
virtual ~CustomTypeVisitor() {}
virtual void visit(typename NodeTypes::And &) = 0;
virtual void visit(typename NodeTypes::AndNot &) = 0;
virtual void visit(typename NodeTypes::Equiv &) = 0;
virtual void visit(typename NodeTypes::NumberTerm &) = 0;
virtual void visit(typename NodeTypes::LocationTerm &) = 0;
virtual void visit(typename NodeTypes::Near &) = 0;
virtual void visit(typename NodeTypes::ONear &) = 0;
virtual void visit(typename NodeTypes::Or &) = 0;
virtual void visit(typename NodeTypes::Phrase &) = 0;
virtual void visit(typename NodeTypes::SameElement &) = 0;
virtual void visit(typename NodeTypes::PrefixTerm &) = 0;
virtual void visit(typename NodeTypes::RangeTerm &) = 0;
virtual void visit(typename NodeTypes::Rank &) = 0;
virtual void visit(typename NodeTypes::StringTerm &) = 0;
virtual void visit(typename NodeTypes::SubstringTerm &) = 0;
virtual void visit(typename NodeTypes::SuffixTerm &) = 0;
virtual void visit(typename NodeTypes::WeakAnd &) = 0;
virtual void visit(typename NodeTypes::WeightedSetTerm &) = 0;
virtual void visit(typename NodeTypes::DotProduct &) = 0;
virtual void visit(typename NodeTypes::WandTerm &) = 0;
virtual void visit(typename NodeTypes::PredicateQuery &) = 0;
virtual void visit(typename NodeTypes::RegExpTerm &) = 0;
virtual void visit(typename NodeTypes::NearestNeighborTerm &) = 0;
virtual void visit(typename NodeTypes::TrueQueryNode &) = 0;
virtual void visit(typename NodeTypes::FalseQueryNode &) = 0;
virtual void visit(typename NodeTypes::FuzzyTerm &) = 0;
private:
// Route QueryVisit requests to the correct custom type.
using TAnd = typename NodeTypes::And;
using TAndNot = typename NodeTypes::AndNot;
using TEquiv = typename NodeTypes::Equiv;
using TNumberTerm = typename NodeTypes::NumberTerm;
using TLocTrm = typename NodeTypes::LocationTerm;
using TNear = typename NodeTypes::Near;
using TONear = typename NodeTypes::ONear;
using TOr = typename NodeTypes::Or;
using TPhrase = typename NodeTypes::Phrase;
using TSameElement = typename NodeTypes::SameElement;
using TPrefixTerm = typename NodeTypes::PrefixTerm;
using TRangeTerm = typename NodeTypes::RangeTerm;
using TRank = typename NodeTypes::Rank;
using TStringTerm = typename NodeTypes::StringTerm;
using TSubstrTr = typename NodeTypes::SubstringTerm;
using TSuffixTerm = typename NodeTypes::SuffixTerm;
using TWeakAnd = typename NodeTypes::WeakAnd;
using TWeightedSetTerm = typename NodeTypes::WeightedSetTerm;
using TDotProduct = typename NodeTypes::DotProduct;
using TWandTerm = typename NodeTypes::WandTerm;
using TPredicateQuery = typename NodeTypes::PredicateQuery;
using TRegExpTerm = typename NodeTypes::RegExpTerm;
using TNearestNeighborTerm = typename NodeTypes::NearestNeighborTerm;
using TTrueQueryNode = typename NodeTypes::TrueQueryNode;
using TFalseQueryNode = typename NodeTypes::FalseQueryNode;
using TFuzzyTerm = typename NodeTypes::FuzzyTerm;
void visit(And &n) override { visit(static_cast<TAnd&>(n)); }
void visit(AndNot &n) override { visit(static_cast<TAndNot&>(n)); }
void visit(Equiv &n) override { visit(static_cast<TEquiv&>(n)); }
void visit(NumberTerm &n) override { visit(static_cast<TNumberTerm&>(n)); }
void visit(LocationTerm &n) override { visit(static_cast<TLocTrm&>(n)); }
void visit(Near &n) override { visit(static_cast<TNear&>(n)); }
void visit(ONear &n) override { visit(static_cast<TONear&>(n)); }
void visit(Or &n) override { visit(static_cast<TOr&>(n)); }
void visit(Phrase &n) override { visit(static_cast<TPhrase&>(n)); }
void visit(SameElement &n) override { visit(static_cast<TSameElement &>(n)); }
void visit(PrefixTerm &n) override { visit(static_cast<TPrefixTerm&>(n)); }
void visit(RangeTerm &n) override { visit(static_cast<TRangeTerm&>(n)); }
void visit(Rank &n) override { visit(static_cast<TRank&>(n)); }
void visit(StringTerm &n) override { visit(static_cast<TStringTerm&>(n)); }
void visit(SubstringTerm &n) override { visit(static_cast<TSubstrTr&>(n)); }
void visit(SuffixTerm &n) override { visit(static_cast<TSuffixTerm&>(n)); }
void visit(WeakAnd &n) override { visit(static_cast<TWeakAnd&>(n)); }
void visit(WeightedSetTerm &n) override { visit(static_cast<TWeightedSetTerm&>(n)); }
void visit(DotProduct &n) override { visit(static_cast<TDotProduct&>(n)); }
void visit(WandTerm &n) override { visit(static_cast<TWandTerm&>(n)); }
void visit(PredicateQuery &n) override { visit(static_cast<TPredicateQuery&>(n)); }
void visit(RegExpTerm &n) override { visit(static_cast<TRegExpTerm&>(n)); }
void visit(NearestNeighborTerm &n) override { visit(static_cast<TNearestNeighborTerm&>(n)); }
void visit(TrueQueryNode &n) override { visit(static_cast<TTrueQueryNode&>(n)); }
void visit(FalseQueryNode &n) override { visit(static_cast<TFalseQueryNode&>(n)); }
void visit(FuzzyTerm &n) override { visit(static_cast<TFuzzyTerm &>(n)); }
};
}
|
