Skip to content

Commit f9b959f

Browse files
wu-huiwu-hui
committed
[realppl 4] Array, debug, field and logical expressions
1 parent 961d492 commit f9b959f

File tree

13 files changed

+2989
-23
lines changed

13 files changed

+2989
-23
lines changed

‎Firestore/Example/Firestore.xcodeproj/project.pbxproj‎

Lines changed: 59 additions & 3 deletions
Large diffs are not rendered by default.

‎Firestore/core/src/core/expressions_eval.cc‎

Lines changed: 770 additions & 5 deletions
Large diffs are not rendered by default.

‎Firestore/core/src/core/expressions_eval.h‎

Lines changed: 266 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -288,6 +288,272 @@ class CoreMod : public EvaluableExpr {
288288
std::unique_ptr<api::FunctionExpr> expr_;
289289
};
290290

291+
// --- Array Expressions ---
292+
293+
class CoreArrayReverse : public EvaluableExpr {
294+
public:
295+
explicit CoreArrayReverse(const api::FunctionExpr& expr)
296+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
297+
}
298+
EvaluateResult Evaluate(
299+
const api::EvaluateContext& context,
300+
const model::PipelineInputOutput& document) const override;
301+
302+
private:
303+
std::unique_ptr<api::FunctionExpr> expr_;
304+
};
305+
306+
class CoreArrayContains : public EvaluableExpr {
307+
public:
308+
explicit CoreArrayContains(const api::FunctionExpr& expr)
309+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
310+
}
311+
EvaluateResult Evaluate(
312+
const api::EvaluateContext& context,
313+
const model::PipelineInputOutput& document) const override;
314+
315+
private:
316+
std::unique_ptr<api::FunctionExpr> expr_;
317+
};
318+
319+
class CoreArrayContainsAll : public EvaluableExpr {
320+
public:
321+
explicit CoreArrayContainsAll(const api::FunctionExpr& expr)
322+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
323+
}
324+
EvaluateResult Evaluate(
325+
const api::EvaluateContext& context,
326+
const model::PipelineInputOutput& document) const override;
327+
328+
private:
329+
std::unique_ptr<api::FunctionExpr> expr_;
330+
};
331+
332+
class CoreArrayContainsAny : public EvaluableExpr {
333+
public:
334+
explicit CoreArrayContainsAny(const api::FunctionExpr& expr)
335+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
336+
}
337+
EvaluateResult Evaluate(
338+
const api::EvaluateContext& context,
339+
const model::PipelineInputOutput& document) const override;
340+
341+
private:
342+
std::unique_ptr<api::FunctionExpr> expr_;
343+
};
344+
345+
class CoreArrayLength : public EvaluableExpr {
346+
public:
347+
explicit CoreArrayLength(const api::FunctionExpr& expr)
348+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
349+
}
350+
EvaluateResult Evaluate(
351+
const api::EvaluateContext& context,
352+
const model::PipelineInputOutput& document) const override;
353+
354+
private:
355+
std::unique_ptr<api::FunctionExpr> expr_;
356+
};
357+
358+
// --- Logical Expressions ---
359+
360+
class CoreAnd : public EvaluableExpr {
361+
public:
362+
explicit CoreAnd(const api::FunctionExpr& expr)
363+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
364+
}
365+
EvaluateResult Evaluate(
366+
const api::EvaluateContext& context,
367+
const model::PipelineInputOutput& document) const override;
368+
369+
private:
370+
std::unique_ptr<api::FunctionExpr> expr_;
371+
};
372+
373+
class CoreOr : public EvaluableExpr {
374+
public:
375+
explicit CoreOr(const api::FunctionExpr& expr)
376+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
377+
}
378+
EvaluateResult Evaluate(
379+
const api::EvaluateContext& context,
380+
const model::PipelineInputOutput& document) const override;
381+
382+
private:
383+
std::unique_ptr<api::FunctionExpr> expr_;
384+
};
385+
386+
class CoreXor : public EvaluableExpr {
387+
public:
388+
explicit CoreXor(const api::FunctionExpr& expr)
389+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
390+
}
391+
EvaluateResult Evaluate(
392+
const api::EvaluateContext& context,
393+
const model::PipelineInputOutput& document) const override;
394+
395+
private:
396+
std::unique_ptr<api::FunctionExpr> expr_;
397+
};
398+
399+
class CoreCond : public EvaluableExpr {
400+
public:
401+
explicit CoreCond(const api::FunctionExpr& expr)
402+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
403+
}
404+
EvaluateResult Evaluate(
405+
const api::EvaluateContext& context,
406+
const model::PipelineInputOutput& document) const override;
407+
408+
private:
409+
std::unique_ptr<api::FunctionExpr> expr_;
410+
};
411+
412+
class CoreEqAny : public EvaluableExpr {
413+
public:
414+
explicit CoreEqAny(const api::FunctionExpr& expr)
415+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
416+
}
417+
EvaluateResult Evaluate(
418+
const api::EvaluateContext& context,
419+
const model::PipelineInputOutput& document) const override;
420+
421+
private:
422+
std::unique_ptr<api::FunctionExpr> expr_;
423+
};
424+
425+
class CoreNotEqAny : public EvaluableExpr {
426+
public:
427+
explicit CoreNotEqAny(const api::FunctionExpr& expr)
428+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
429+
}
430+
EvaluateResult Evaluate(
431+
const api::EvaluateContext& context,
432+
const model::PipelineInputOutput& document) const override;
433+
434+
private:
435+
std::unique_ptr<api::FunctionExpr> expr_;
436+
};
437+
438+
class CoreIsNan : public EvaluableExpr {
439+
public:
440+
explicit CoreIsNan(const api::FunctionExpr& expr)
441+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
442+
}
443+
EvaluateResult Evaluate(
444+
const api::EvaluateContext& context,
445+
const model::PipelineInputOutput& document) const override;
446+
447+
private:
448+
std::unique_ptr<api::FunctionExpr> expr_;
449+
};
450+
451+
class CoreIsNotNan : public EvaluableExpr {
452+
public:
453+
explicit CoreIsNotNan(const api::FunctionExpr& expr)
454+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
455+
}
456+
EvaluateResult Evaluate(
457+
const api::EvaluateContext& context,
458+
const model::PipelineInputOutput& document) const override;
459+
460+
private:
461+
std::unique_ptr<api::FunctionExpr> expr_;
462+
};
463+
464+
class CoreIsNull : public EvaluableExpr {
465+
public:
466+
explicit CoreIsNull(const api::FunctionExpr& expr)
467+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
468+
}
469+
EvaluateResult Evaluate(
470+
const api::EvaluateContext& context,
471+
const model::PipelineInputOutput& document) const override;
472+
473+
private:
474+
std::unique_ptr<api::FunctionExpr> expr_;
475+
};
476+
477+
class CoreIsNotNull : public EvaluableExpr {
478+
public:
479+
explicit CoreIsNotNull(const api::FunctionExpr& expr)
480+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
481+
}
482+
EvaluateResult Evaluate(
483+
const api::EvaluateContext& context,
484+
const model::PipelineInputOutput& document) const override;
485+
486+
private:
487+
std::unique_ptr<api::FunctionExpr> expr_;
488+
};
489+
490+
class CoreIsError : public EvaluableExpr {
491+
public:
492+
explicit CoreIsError(const api::FunctionExpr& expr)
493+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
494+
}
495+
EvaluateResult Evaluate(
496+
const api::EvaluateContext& context,
497+
const model::PipelineInputOutput& document) const override;
498+
499+
private:
500+
std::unique_ptr<api::FunctionExpr> expr_;
501+
};
502+
503+
class CoreLogicalMaximum : public EvaluableExpr {
504+
public:
505+
explicit CoreLogicalMaximum(const api::FunctionExpr& expr)
506+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
507+
}
508+
EvaluateResult Evaluate(
509+
const api::EvaluateContext& context,
510+
const model::PipelineInputOutput& document) const override;
511+
512+
private:
513+
std::unique_ptr<api::FunctionExpr> expr_;
514+
};
515+
516+
class CoreLogicalMinimum : public EvaluableExpr {
517+
public:
518+
explicit CoreLogicalMinimum(const api::FunctionExpr& expr)
519+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
520+
}
521+
EvaluateResult Evaluate(
522+
const api::EvaluateContext& context,
523+
const model::PipelineInputOutput& document) const override;
524+
525+
private:
526+
std::unique_ptr<api::FunctionExpr> expr_;
527+
};
528+
529+
// --- Debugging Expressions ---
530+
531+
class CoreExists : public EvaluableExpr {
532+
public:
533+
explicit CoreExists(const api::FunctionExpr& expr)
534+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
535+
}
536+
EvaluateResult Evaluate(
537+
const api::EvaluateContext& context,
538+
const model::PipelineInputOutput& document) const override;
539+
540+
private:
541+
std::unique_ptr<api::FunctionExpr> expr_;
542+
};
543+
544+
class CoreNot : public EvaluableExpr {
545+
public:
546+
explicit CoreNot(const api::FunctionExpr& expr)
547+
: expr_(std::make_unique<api::FunctionExpr>(expr)) {
548+
}
549+
EvaluateResult Evaluate(
550+
const api::EvaluateContext& context,
551+
const model::PipelineInputOutput& document) const override;
552+
553+
private:
554+
std::unique_ptr<api::FunctionExpr> expr_;
555+
};
556+
291557
/**
292558
* Converts a high-level expression representation into an evaluable one.
293559
*/

‎Firestore/core/src/model/value_util.cc‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -955,6 +955,20 @@ Message<google_firestore_v1_Value> RefValue(
955955
return result;
956956
}
957957

958+
Message<google_firestore_v1_Value> ArrayValue(
959+
std::vector<Message<google_firestore_v1_Value>> values) {
960+
google_firestore_v1_Value result;
961+
result.which_value_type = google_firestore_v1_Value_array_value_tag;
962+
963+
SetRepeatedField(&result.array_value.values, &result.array_value.values_count,
964+
values.begin(), values.end(),
965+
[](Message<google_firestore_v1_Value>& value) {
966+
return *value.release();
967+
});
968+
969+
return nanopb::MakeMessage(result);
970+
}
971+
958972
Message<google_firestore_v1_Value> DeepClone(
959973
const google_firestore_v1_Value& source) {
960974
Message<google_firestore_v1_Value> target{source};

‎Firestore/core/src/model/value_util.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -248,6 +248,14 @@ google_firestore_v1_Value MinMap();
248248
nanopb::Message<google_firestore_v1_Value> RefValue(
249249
const DatabaseId& database_id, const DocumentKey& document_key);
250250

251+
/**
252+
* Returns a Protobuf array value representing the given values.
253+
*
254+
* This function owns the passed in vector and might move the values out.
255+
*/
256+
nanopb::Message<google_firestore_v1_Value> ArrayValue(
257+
std::vector<nanopb::Message<google_firestore_v1_Value>> values);
258+
251259
/** Creates a copy of the contents of the Value proto. */
252260
nanopb::Message<google_firestore_v1_Value> DeepClone(
253261
const google_firestore_v1_Value& source);

‎Firestore/core/test/unit/core/expressions/arithmetic_test.cc‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,15 +14,14 @@
1414
* limitations under the License.
1515
*/
1616

17-
#include "Firestore/core/src/core/expressions_eval.h"
18-
1917
#include <initializer_list>
2018
#include <limits>
2119
#include <memory>
2220
#include <string>
2321
#include <utility>
2422
#include <vector>
2523

24+
#include "Firestore/core/src/core/expressions_eval.h"
2625
#include "Firestore/core/test/unit/testutil/expression_test_util.h"
2726
#include "Firestore/core/test/unit/testutil/testutil.h"
2827
#include "gmock/gmock.h"

0 commit comments

Comments
 (0)