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 <memory>
  36
  37 #include "absl/memory/memory.h"
  38 #include "absl/strings/string_view.h"
  39 #include "absl/types/span.h"
  40
  41 namespace grpc_core {
  42 namespace mock_cel {
  43
  44 // Break cyclic depdendencies for container types.
  45 class CelMap {
  46  public:
  47   CelMap() = default;
  48 };
  49
  50 // This is a temporary stub implementation of CEL APIs.
  51 // Once gRPC imports the CEL library, this class will be removed.
  52 class CelValue {
  53  public:
  54   // Default constructor.
  55   // Creates CelValue with null data type.
  56   CelValue() : CelValue(nullptr) {}
  57
  58   // We will use factory methods instead of public constructors
  59   // The reason for this is the high risk of implicit type conversions
  60   // between bool/int/pointer types.
  61   // We rely on copy elision to avoid extra copying.
  62   static CelValue CreateNull() { return CelValue(nullptr); }
  63
  64   static CelValue CreateInt64(int64_t /*value*/) { return CreateNull(); }
  65
  66   static CelValue CreateUint64(uint64_t /*value*/) { return CreateNull(); }
  67
  68   static CelValue CreateStringView(absl::string_view /*value*/) {
  69     return CreateNull();
  70   }
  71
  72   static CelValue CreateString(const std::string* /*str*/) {
  73     return CreateNull();
  74   }
  75
  76   static CelValue CreateMap(const CelMap* /*value*/) { return CreateNull(); }
  77
  78  private:
  79   // Constructs CelValue wrapping value supplied as argument.
  80   // Value type T should be supported by specification of ValueHolder.
  81   template <class T>
  82   explicit CelValue(T /*value*/) {}
  83 };
  84
  85 // CelMap implementation that uses STL map container as backing storage.
  86 class ContainerBackedMapImpl : public CelMap {
  87  public:
  88   ContainerBackedMapImpl() = default;
  89
  90   static std::unique_ptr<CelMap> Create(
  91       absl::Span<std::pair<CelValue, CelValue>> /*key_values*/) {
  92     return absl::make_unique<ContainerBackedMapImpl>();
  93   }
  94 };
  95
  96 }  // namespace mock_cel
  97 }  // namespace grpc_core
  98
  99 #endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H