Skip to content

Commit 4b413aa

Browse files
ironageironage
authored
Use an enum class instead of int constants (#6968)
* prefer a strongly typed enum class to int constants * fix MSVC warning * fix a warning
1 parent 2d639a7 commit 4b413aa

File tree

5 files changed

+297
-197
lines changed

5 files changed

+297
-197
lines changed

‎src/realm/parser/driver.cpp‎

Lines changed: 113 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -72,21 +72,6 @@ const char* expression_cmp_type_to_str(util::Optional<ExpressionComparisonType>
7272
return "";
7373
}
7474

75-
76-
static std::map<int, std::string> opstr = {
77-
{CompareNode::EQUAL, "="},
78-
{CompareNode::NOT_EQUAL, "!="},
79-
{CompareNode::GREATER, ">"},
80-
{CompareNode::LESS, "<"},
81-
{CompareNode::GREATER_EQUAL, ">="},
82-
{CompareNode::LESS_EQUAL, "<="},
83-
{CompareNode::BEGINSWITH, "beginswith"},
84-
{CompareNode::ENDSWITH, "endswith"},
85-
{CompareNode::CONTAINS, "contains"},
86-
{CompareNode::LIKE, "like"},
87-
{CompareNode::IN, "in"},
88-
};
89-
9075
std::string print_pretty_objlink(const ObjLink& link, const Group* g)
9176
{
9277
REALM_ASSERT(g);
@@ -311,6 +296,37 @@ namespace realm {
311296

312297
namespace query_parser {
313298

299+
std::string_view string_for_op(CompareType op)
300+
{
301+
switch (op) {
302+
case CompareType::EQUAL:
303+
return "=";
304+
case CompareType::NOT_EQUAL:
305+
return "!=";
306+
case CompareType::GREATER:
307+
return ">";
308+
case CompareType::LESS:
309+
return "<";
310+
case CompareType::GREATER_EQUAL:
311+
return ">=";
312+
case CompareType::LESS_EQUAL:
313+
return "<=";
314+
case CompareType::BEGINSWITH:
315+
return "beginswith";
316+
case CompareType::ENDSWITH:
317+
return "endswith";
318+
case CompareType::CONTAINS:
319+
return "contains";
320+
case CompareType::LIKE:
321+
return "like";
322+
case CompareType::IN:
323+
return "in";
324+
case CompareType::TEXT:
325+
return "text";
326+
}
327+
return ""; // appease MSVC warnings
328+
}
329+
314330
NoArguments ParserDriver::s_default_args;
315331
query_parser::KeyPathMapping ParserDriver::s_default_mapping;
316332

@@ -348,7 +364,7 @@ Query AndNode::visit(ParserDriver* drv)
348364
return q;
349365
}
350366

351-
static void verify_only_string_types(DataType type, const std::string& op_string)
367+
static void verify_only_string_types(DataType type, std::string_view op_string)
352368
{
353369
if (type != type_String && type != type_Binary && type != type_Mixed) {
354370
throw InvalidQueryError(util::format(
@@ -502,7 +518,7 @@ Query EqualityNode::visit(ParserDriver* drv)
502518
}
503519
}
504520

505-
if (op == CompareNode::IN) {
521+
if (op == CompareType::IN) {
506522
Subexpr* r = right.get();
507523
if (!r->has_multiple_values()) {
508524
throw InvalidQueryArgError("The keypath following 'IN' must contain a list. Found '" +
@@ -523,11 +539,11 @@ Query EqualityNode::visit(ParserDriver* drv)
523539
for (auto val : *link_values) {
524540
values.emplace_back(val.is_null() ? ObjKey() : val.get<ObjKey>());
525541
}
526-
if (op == CompareNode::EQUAL) {
542+
if (op == CompareType::EQUAL) {
527543
return drv->m_base_table->where().links_to(link_column->link_map().get_first_column_key(),
528544
values);
529545
}
530-
else if (op == CompareNode::NOT_EQUAL) {
546+
else if (op == CompareType::NOT_EQUAL) {
531547
return drv->m_base_table->where().not_links_to(link_column->link_map().get_first_column_key(),
532548
values);
533549
}
@@ -541,11 +557,13 @@ Query EqualityNode::visit(ParserDriver* drv)
541557
auto col_key = prop->column_key();
542558
if (val.is_null()) {
543559
switch (op) {
544-
case CompareNode::EQUAL:
545-
case CompareNode::IN:
560+
case CompareType::EQUAL:
561+
case CompareType::IN:
546562
return drv->m_base_table->where().equal(col_key, realm::null());
547-
case CompareNode::NOT_EQUAL:
563+
case CompareType::NOT_EQUAL:
548564
return drv->m_base_table->where().not_equal(col_key, realm::null());
565+
default:
566+
break;
549567
}
550568
}
551569
switch (left->get_type()) {
@@ -578,22 +596,26 @@ Query EqualityNode::visit(ParserDriver* drv)
578596
}
579597
if (case_sensitive) {
580598
switch (op) {
581-
case CompareNode::EQUAL:
582-
case CompareNode::IN:
599+
case CompareType::EQUAL:
600+
case CompareType::IN:
583601
return Query(std::unique_ptr<Expression>(new Compare<Equal>(std::move(left), std::move(right))));
584-
case CompareNode::NOT_EQUAL:
602+
case CompareType::NOT_EQUAL:
585603
return Query(std::unique_ptr<Expression>(new Compare<NotEqual>(std::move(left), std::move(right))));
604+
default:
605+
break;
586606
}
587607
}
588608
else {
589-
verify_only_string_types(right_type, opstr[op] + "[c]");
609+
verify_only_string_types(right_type, util::format("%1%2", string_for_op(op), "[c]"));
590610
switch (op) {
591-
case CompareNode::EQUAL:
592-
case CompareNode::IN:
611+
case CompareType::EQUAL:
612+
case CompareType::IN:
593613
return Query(std::unique_ptr<Expression>(new Compare<EqualIns>(std::move(left), std::move(right))));
594-
case CompareNode::NOT_EQUAL:
614+
case CompareType::NOT_EQUAL:
595615
return Query(
596616
std::unique_ptr<Expression>(new Compare<NotEqualIns>(std::move(left), std::move(right))));
617+
default:
618+
break;
597619
}
598620
}
599621
return {};
@@ -615,8 +637,8 @@ Query BetweenNode::visit(ParserDriver* drv)
615637

616638
auto& min(limits->elements.at(0));
617639
auto& max(limits->elements.at(1));
618-
RelationalNode cmp1(prop, CompareNode::GREATER_EQUAL, min);
619-
RelationalNode cmp2(prop, CompareNode::LESS_EQUAL, max);
640+
RelationalNode cmp1(prop, CompareType::GREATER_EQUAL, min);
641+
RelationalNode cmp2(prop, CompareType::LESS_EQUAL, max);
620642

621643
Query q(drv->m_base_table);
622644
q.and_query(cmp1.visit(drv));
@@ -638,7 +660,7 @@ Query RelationalNode::visit(ParserDriver* drv)
638660
if (left_type == type_Link || left_type == type_TypeOfValue) {
639661
throw InvalidQueryError(util::format(
640662
"Unsupported operator %1 in query. Only equal (==) and not equal (!=) are supported for this type.",
641-
opstr[op]));
663+
string_for_op(op)));
642664
}
643665

644666
if (!(left_type_is_null || right_type_is_null) && (!left_type.is_valid() || !right_type.is_valid() ||
@@ -685,14 +707,16 @@ Query RelationalNode::visit(ParserDriver* drv)
685707
}
686708
}
687709
switch (op) {
688-
case CompareNode::GREATER:
710+
case CompareType::GREATER:
689711
return Query(std::unique_ptr<Expression>(new Compare<Greater>(std::move(left), std::move(right))));
690-
case CompareNode::LESS:
712+
case CompareType::LESS:
691713
return Query(std::unique_ptr<Expression>(new Compare<Less>(std::move(left), std::move(right))));
692-
case CompareNode::GREATER_EQUAL:
714+
case CompareType::GREATER_EQUAL:
693715
return Query(std::unique_ptr<Expression>(new Compare<GreaterEqual>(std::move(left), std::move(right))));
694-
case CompareNode::LESS_EQUAL:
716+
case CompareType::LESS_EQUAL:
695717
return Query(std::unique_ptr<Expression>(new Compare<LessEqual>(std::move(left), std::move(right))));
718+
default:
719+
break;
696720
}
697721
return {};
698722
}
@@ -705,7 +729,7 @@ Query StringOpsNode::visit(ParserDriver* drv)
705729
auto right_type = right->get_type();
706730
const ObjPropertyBase* prop = dynamic_cast<const ObjPropertyBase*>(left.get());
707731

708-
verify_only_string_types(right_type, opstr[op]);
732+
verify_only_string_types(right_type, string_for_op(op));
709733

710734
if (prop && !prop->links_exist() && right->has_single_value() &&
711735
(left_type == right_type || left_type == type_Mixed)) {
@@ -714,64 +738,98 @@ Query StringOpsNode::visit(ParserDriver* drv)
714738
StringData val = right->get_mixed().get_string();
715739

716740
switch (op) {
717-
case CompareNode::BEGINSWITH:
741+
case CompareType::BEGINSWITH:
718742
return drv->m_base_table->where().begins_with(col_key, val, case_sensitive);
719-
case CompareNode::ENDSWITH:
743+
case CompareType::ENDSWITH:
720744
return drv->m_base_table->where().ends_with(col_key, val, case_sensitive);
721-
case CompareNode::CONTAINS:
745+
case CompareType::CONTAINS:
722746
return drv->m_base_table->where().contains(col_key, val, case_sensitive);
723-
case CompareNode::LIKE:
747+
case CompareType::LIKE:
724748
return drv->m_base_table->where().like(col_key, val, case_sensitive);
725-
case CompareNode::TEXT:
749+
case CompareType::TEXT:
726750
return drv->m_base_table->where().fulltext(col_key, val);
751+
case CompareType::IN:
752+
case CompareType::EQUAL:
753+
case CompareType::NOT_EQUAL:
754+
case CompareType::GREATER:
755+
case CompareType::LESS:
756+
case CompareType::GREATER_EQUAL:
757+
case CompareType::LESS_EQUAL:
758+
break;
727759
}
728760
}
729761
else if (right_type == type_Binary) {
730762
BinaryData val = right->get_mixed().get_binary();
731763

732764
switch (op) {
733-
case CompareNode::BEGINSWITH:
765+
case CompareType::BEGINSWITH:
734766
return drv->m_base_table->where().begins_with(col_key, val, case_sensitive);
735-
case CompareNode::ENDSWITH:
767+
case CompareType::ENDSWITH:
736768
return drv->m_base_table->where().ends_with(col_key, val, case_sensitive);
737-
case CompareNode::CONTAINS:
769+
case CompareType::CONTAINS:
738770
return drv->m_base_table->where().contains(col_key, val, case_sensitive);
739-
case CompareNode::LIKE:
771+
case CompareType::LIKE:
740772
return drv->m_base_table->where().like(col_key, val, case_sensitive);
773+
case CompareType::TEXT:
774+
case CompareType::IN:
775+
case CompareType::EQUAL:
776+
case CompareType::NOT_EQUAL:
777+
case CompareType::GREATER:
778+
case CompareType::LESS:
779+
case CompareType::GREATER_EQUAL:
780+
case CompareType::LESS_EQUAL:
781+
break;
741782
}
742783
}
743784
}
744785

745786
if (case_sensitive) {
746787
switch (op) {
747-
case CompareNode::BEGINSWITH:
788+
case CompareType::BEGINSWITH:
748789
return Query(std::unique_ptr<Expression>(new Compare<BeginsWith>(std::move(right), std::move(left))));
749-
case CompareNode::ENDSWITH:
790+
case CompareType::ENDSWITH:
750791
return Query(std::unique_ptr<Expression>(new Compare<EndsWith>(std::move(right), std::move(left))));
751-
case CompareNode::CONTAINS:
792+
case CompareType::CONTAINS:
752793
return Query(std::unique_ptr<Expression>(new Compare<Contains>(std::move(right), std::move(left))));
753-
case CompareNode::LIKE:
794+
case CompareType::LIKE:
754795
return Query(std::unique_ptr<Expression>(new Compare<Like>(std::move(right), std::move(left))));
755-
case CompareNode::TEXT: {
796+
case CompareType::TEXT: {
756797
StringData val = right->get_mixed().get_string();
757798
auto string_prop = dynamic_cast<Columns<StringData>*>(left.get());
758799
return string_prop->fulltext(val);
759800
}
801+
case CompareType::IN:
802+
case CompareType::EQUAL:
803+
case CompareType::NOT_EQUAL:
804+
case CompareType::GREATER:
805+
case CompareType::LESS:
806+
case CompareType::GREATER_EQUAL:
807+
case CompareType::LESS_EQUAL:
808+
break;
760809
}
761810
}
762811
else {
763812
switch (op) {
764-
case CompareNode::BEGINSWITH:
813+
case CompareType::BEGINSWITH:
765814
return Query(
766815
std::unique_ptr<Expression>(new Compare<BeginsWithIns>(std::move(right), std::move(left))));
767-
case CompareNode::ENDSWITH:
816+
case CompareType::ENDSWITH:
768817
return Query(
769818
std::unique_ptr<Expression>(new Compare<EndsWithIns>(std::move(right), std::move(left))));
770-
case CompareNode::CONTAINS:
819+
case CompareType::CONTAINS:
771820
return Query(
772821
std::unique_ptr<Expression>(new Compare<ContainsIns>(std::move(right), std::move(left))));
773-
case CompareNode::LIKE:
822+
case CompareType::LIKE:
774823
return Query(std::unique_ptr<Expression>(new Compare<LikeIns>(std::move(right), std::move(left))));
824+
case CompareType::IN:
825+
case CompareType::EQUAL:
826+
case CompareType::NOT_EQUAL:
827+
case CompareType::GREATER:
828+
case CompareType::LESS:
829+
case CompareType::GREATER_EQUAL:
830+
case CompareType::LESS_EQUAL:
831+
case CompareType::TEXT:
832+
break;
775833
}
776834
}
777835
return {};

0 commit comments

Comments
 (0)