src/core/lib/security/authorization/mock_cel/cel_value.h

   1 // Copyright 2020 gRPC authors.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
  16 #define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
  17
  18 // CelValue is a holder, capable of storing all kinds of data
  19 // supported by CEL.
  20 // CelValue defines explicitly typed/named getters/setters.
  21 // When storing pointers to objects, CelValue does not accept ownership
  22 // to them and does not control their lifecycle. Instead objects are expected
  23 // to be either external to expression evaluation, and controlled beyond the
  24 // scope or to be allocated and associated with some allocation/ownership
  25 // controller (Arena).
  26 // Usage examples:
  27 // (a) For primitive types:
  28 //    CelValue value = CelValue::CreateInt64(1);
  29 // (b) For string:
  30 //    std::string* msg("test");
  31 //    CelValue value = CelValue::CreateString(msg);
  32
  33 #include <grpc/support/port_platform.h>
  34
  35 #include "absl/strings/string_view.h"
  36
  37 namespace grpc_core {
  38 namespace mock_cel {
  39
  40 // Break cyclic depdendencies for container types.
  41 class CelMap {
  42  public:
  43   CelMap() = default;
  44 };
  45
  46 // This is a temporary stub implementation of CEL APIs.
  47 // Once gRPC imports the CEL library, this class will be removed.
  48 class CelValue {
  49  public:
  50   // Default constructor.
  51   // Creates CelValue with null data type.
  52   CelValue() : CelValue(nullptr) {}
  53
  54   // We will use factory methods instead of public constructors
  55   // The reason for this is the high risk of implicit type conversions
  56   // between bool/int/pointer types.
  57   // We rely on copy elision to avoid extra copying.
  58   static CelValue CreateNull() { return CelValue(nullptr); }
  59
  60   static CelValue CreateInt64(int64_t value) { return CreateNull(); }
  61
  62   static CelValue CreateUint64(uint64_t value) { return CreateNull(); }
  63
  64   static CelValue CreateStringView(absl::string_view value) {
  65     return CreateNull();
  66   }
  67
  68   static CelValue CreateString(const std::string* str) { return CreateNull(); }
  69
  70   static CelValue CreateMap(const CelMap* value) { return CreateNull(); }
  71
  72  private:
  73   // Constructs CelValue wrapping value supplied as argument.
  74   // Value type T should be supported by specification of ValueHolder.
  75   template <class T>
  76   explicit CelValue(T value) {}
  77 };
  78
  79 // CelMap implementation that uses STL map container as backing storage.
  80 class ContainerBackedMapImpl : public CelMap {
  81  public:
  82   ContainerBackedMapImpl() = default;
  83
  84   static std::unique_ptr<CelMap> Create(
  85       absl::Span<std::pair<CelValue, CelValue>> key_values) {
  86     return absl::make_unique<ContainerBackedMapImpl>();
  87   }
  88 };
  89
  90 }  // namespace mock_cel
  91 }  // namespace grpc_core
  92
  93 #endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H