Thanks to visit codestin.com
Credit goes to github.com

Skip to content

ParsedJsonMapValue stub out MapValue #901

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 6, 2024
Merged

ParsedJsonMapValue stub out MapValue #901

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
147 changes: 147 additions & 0 deletions common/values/parsed_json_map_value.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,13 +14,160 @@

#include "common/values/parsed_json_map_value.h"

#include <cstddef>
#include <memory>
#include <string>
#include <utility>

#include "google/protobuf/struct.pb.h"
#include "absl/base/nullability.h"
#include "absl/base/optimization.h"
#include "absl/log/absl_check.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/str_cat.h"
#include "common/json.h"
#include "common/memory.h"
#include "common/value.h"
#include "internal/status_macros.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/text_format.h"

namespace cel {

ParsedJsonMapValue::ParsedJsonMapValue()
: ParsedJsonMapValue(common_internal::WrapEternal(
&google::protobuf::Struct::default_instance())) {}

std::string ParsedJsonMapValue::DebugString() const {
if (ABSL_PREDICT_FALSE(value_ == nullptr)) {
return "";
}
if (const auto* generated_message =
google::protobuf::DynamicCastMessage<google::protobuf::Struct>(&*value_);
generated_message != nullptr) {
return absl::StrCat(*generated_message);
}
const auto& dynamic_message =
google::protobuf::DownCastMessage<google::protobuf::Message>(*value_);
std::string result;
google::protobuf::TextFormat::PrintToString(dynamic_message, &result);
return result;
}

absl::Status ParsedJsonMapValue::SerializeTo(AnyToJsonConverter& converter,
absl::Cord& value) const {
return absl::UnimplementedError("SerializeTo is not yet implemented");
}

absl::StatusOr<Json> ParsedJsonMapValue::ConvertToJson(
AnyToJsonConverter& converter) const {
return absl::UnimplementedError("ConvertToJson is not yet implemented");
}

absl::StatusOr<JsonObject> ParsedJsonMapValue::ConvertToJsonObject(
AnyToJsonConverter& converter) const {
return absl::UnimplementedError("ConvertToJsonObject is not yet implemented");
}

absl::Status ParsedJsonMapValue::Equal(ValueManager& value_manager,
const Value& other,
Value& result) const {
return absl::UnimplementedError("Equal is not yet implemented");
}

absl::StatusOr<Value> ParsedJsonMapValue::Equal(ValueManager& value_manager,
const Value& other) const {
Value result;
CEL_RETURN_IF_ERROR(Equal(value_manager, other, result));
return result;
}

bool ParsedJsonMapValue::IsZeroValue() const { return IsEmpty(); }

bool ParsedJsonMapValue::IsEmpty() const { return Size() == 0; }

size_t ParsedJsonMapValue::Size() const {
ABSL_DCHECK(*this);
if (ABSL_PREDICT_FALSE(value_ == nullptr)) {
return 0;
}
if (const auto* generated_message =
google::protobuf::DynamicCastMessage<google::protobuf::Struct>(&*value_);
generated_message != nullptr) {
return static_cast<size_t>(generated_message->fields().size());
}
const auto& dynamic_message =
google::protobuf::DownCastMessage<google::protobuf::Message>(*value_);
const auto* descriptor = dynamic_message.GetDescriptor();
const auto* fields_field = descriptor->FindFieldByNumber(1);
const auto* reflection = dynamic_message.GetReflection();
return static_cast<size_t>(
reflection->FieldSize(dynamic_message, fields_field));
}

absl::Status ParsedJsonMapValue::Get(ValueManager& value_manager,
const Value& key, Value& result) const {
return absl::UnimplementedError("Get is not yet implemented");
}

absl::StatusOr<Value> ParsedJsonMapValue::Get(ValueManager& value_manager,
const Value& key) const {
Value result;
CEL_RETURN_IF_ERROR(Get(value_manager, key, result));
return result;
}

absl::StatusOr<bool> ParsedJsonMapValue::Find(ValueManager& value_manager,
const Value& key,
Value& result) const {
return absl::UnimplementedError("Find is not yet implemented");
}

absl::StatusOr<std::pair<Value, bool>> ParsedJsonMapValue::Find(
ValueManager& value_manager, const Value& key) const {
Value result;
CEL_ASSIGN_OR_RETURN(auto found, Find(value_manager, key, result));
if (found) {
return std::pair{std::move(result), found};
}
return std::pair{NullValue(), found};
}

absl::Status ParsedJsonMapValue::Has(ValueManager& value_manager,
const Value& key, Value& result) const {
return absl::UnimplementedError("Has is not yet implemented");
}

absl::StatusOr<Value> ParsedJsonMapValue::Has(ValueManager& value_manager,
const Value& key) const {
Value result;
CEL_RETURN_IF_ERROR(Has(value_manager, key, result));
return result;
}

absl::Status ParsedJsonMapValue::ListKeys(ValueManager& value_manager,
ListValue& result) const {
return absl::UnimplementedError("ListKeys is not yet implemented");
}

absl::StatusOr<ListValue> ParsedJsonMapValue::ListKeys(
ValueManager& value_manager) const {
ListValue result;
CEL_RETURN_IF_ERROR(ListKeys(value_manager, result));
return result;
}

absl::Status ParsedJsonMapValue::ForEach(ValueManager& value_manager,
ForEachCallback callback) const {
return absl::UnimplementedError("ForEach is not yet implemented");
}

absl::StatusOr<absl::Nonnull<std::unique_ptr<ValueIterator>>>
ParsedJsonMapValue::NewIterator(ValueManager& value_manager) const {
return absl::UnimplementedError("NewIterator is not yet implemented");
}

} // namespace cel
59 changes: 59 additions & 0 deletions common/values/parsed_json_map_value.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,24 +18,36 @@
#ifndef THIRD_PARTY_CEL_CPP_COMMON_VALUES_PARSED_JSON_MAP_VALUE_H_
#define THIRD_PARTY_CEL_CPP_COMMON_VALUES_PARSED_JSON_MAP_VALUE_H_

#include <cstddef>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/any.pb.h"
#include "google/protobuf/struct.pb.h"
#include "absl/base/nullability.h"
#include "absl/log/absl_check.h"
#include "absl/meta/type_traits.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "common/json.h"
#include "common/memory.h"
#include "common/type.h"
#include "common/value_kind.h"
#include "common/values/map_value_interface.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"

namespace cel {

class Value;
class ValueManager;
class ListValue;
class ValueIterator;

// ParsedJsonMapValue is a MapValue backed by the google.protobuf.Struct
// well known message type.
Expand Down Expand Up @@ -66,6 +78,53 @@ class ParsedJsonMapValue final {

static MapType GetRuntimeType() { return JsonMapType(); }

std::string DebugString() const;

absl::Status SerializeTo(AnyToJsonConverter& converter,
absl::Cord& value) const;

absl::StatusOr<Json> ConvertToJson(AnyToJsonConverter& converter) const;

absl::StatusOr<JsonObject> ConvertToJsonObject(
AnyToJsonConverter& converter) const;

absl::Status Equal(ValueManager& value_manager, const Value& other,
Value& result) const;
absl::StatusOr<Value> Equal(ValueManager& value_manager,
const Value& other) const;

bool IsZeroValue() const;

bool IsEmpty() const;

size_t Size() const;

absl::Status Get(ValueManager& value_manager, const Value& key,
Value& result) const;
absl::StatusOr<Value> Get(ValueManager& value_manager,
const Value& key) const;

absl::StatusOr<bool> Find(ValueManager& value_manager, const Value& key,
Value& result) const;
absl::StatusOr<std::pair<Value, bool>> Find(ValueManager& value_manager,
const Value& key) const;

absl::Status Has(ValueManager& value_manager, const Value& key,
Value& result) const;
absl::StatusOr<Value> Has(ValueManager& value_manager,
const Value& key) const;

absl::Status ListKeys(ValueManager& value_manager, ListValue& result) const;
absl::StatusOr<ListValue> ListKeys(ValueManager& value_manager) const;

using ForEachCallback = typename MapValueInterface::ForEachCallback;

absl::Status ForEach(ValueManager& value_manager,
ForEachCallback callback) const;

absl::StatusOr<absl::Nonnull<std::unique_ptr<ValueIterator>>> NewIterator(
ValueManager& value_manager) const;

// Returns `true` if `ParsedJsonMapValue` is in a valid state. Currently only
// moves place `ParsedJsonMapValue` in an invalid state.
explicit operator bool() const { return static_cast<bool>(value_); }
Expand Down
Loading