Coverage Report

Created: 2026-05-27 07:00

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/proc/self/cwd/common/arena.h
Line
Count
Source
1
// Copyright 2024 Google LLC
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
//     https://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 THIRD_PARTY_CEL_CPP_COMMON_ARENA_H_
16
#define THIRD_PARTY_CEL_CPP_COMMON_ARENA_H_
17
18
#include <type_traits>
19
#include <utility>
20
21
#include "absl/base/nullability.h"
22
#include "google/protobuf/arena.h"
23
24
namespace cel {
25
26
template <typename T = void>
27
struct ArenaTraits;
28
29
namespace common_internal {
30
31
template <typename T>
32
struct AssertArenaType : std::false_type {
33
  static_assert(!std::is_void_v<T>, "T must not be void");
34
  static_assert(!std::is_reference_v<T>, "T must not be a reference");
35
  static_assert(!std::is_volatile_v<T>, "T must not be volatile qualified");
36
  static_assert(!std::is_const_v<T>, "T must not be const qualified");
37
  static_assert(!std::is_array_v<T>, "T must not be an array");
38
};
39
40
template <typename, typename = void>
41
struct ArenaTraitsConstructible {
42
  using type = std::false_type;
43
};
44
45
template <typename T>
46
struct ArenaTraitsConstructible<
47
    T, std::void_t<decltype(ArenaTraits<T>::constructible)>> {
48
  using type = typename ArenaTraits<T>::constructible;
49
};
50
51
template <typename T>
52
std::enable_if_t<google::protobuf::Arena::is_arena_constructable<T>::value,
53
                 google::protobuf::Arena* absl_nullable>
54
GetArena(const T* absl_nullable ptr) {
55
  return ptr != nullptr ? ptr->GetArena() : nullptr;
56
}
57
58
template <typename T>
59
std::enable_if_t<!google::protobuf::Arena::is_arena_constructable<T>::value,
60
                 google::protobuf::Arena* absl_nullable>
61
GetArena([[maybe_unused]] const T* absl_nullable ptr) {
62
  return nullptr;
63
}
64
65
template <typename, typename = void>
66
struct HasArenaTraitsTriviallyDestructible : std::false_type {};
67
68
template <typename T>
69
struct HasArenaTraitsTriviallyDestructible<
70
    T, std::void_t<decltype(ArenaTraits<T>::trivially_destructible(
71
           std::declval<const T&>()))>> : std::true_type {};
72
73
}  // namespace common_internal
74
75
template <>
76
struct ArenaTraits<void> {
77
  template <typename U>
78
  using constructible = std::disjunction<
79
      typename common_internal::AssertArenaType<U>::type,
80
      typename common_internal::ArenaTraitsConstructible<U>::type>;
81
82
  template <typename U>
83
  using always_trivially_destructible =
84
      std::disjunction<typename common_internal::AssertArenaType<U>::type,
85
                       std::is_trivially_destructible<U>>;
86
87
  template <typename U>
88
232k
  static bool trivially_destructible(const U& obj) {
89
232k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
232k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
232k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
232k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
232k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
232k
    if constexpr (always_trivially_destructible<U>()) {
96
100k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
131k
                             U>::value) {
101
131k
      return ArenaTraits<U>::trivially_destructible(obj);
102
131k
    } else {
103
0
      return false;
104
0
    }
105
232k
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<std::__1::monostate>(std::__1::monostate const&)
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ParsedMessageValue>(cel::ParsedMessageValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::NullValue>(cel::NullValue const&)
Line
Count
Source
88
105
  static bool trivially_destructible(const U& obj) {
89
105
    static_assert(!std::is_void_v<U>, "T must not be void");
90
105
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
105
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
105
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
105
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
105
    if constexpr (always_trivially_destructible<U>()) {
96
105
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
105
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::BoolValue>(cel::BoolValue const&)
Line
Count
Source
88
3.80k
  static bool trivially_destructible(const U& obj) {
89
3.80k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
3.80k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
3.80k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
3.80k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
3.80k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
3.80k
    if constexpr (always_trivially_destructible<U>()) {
96
3.80k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
3.80k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::IntValue>(cel::IntValue const&)
Line
Count
Source
88
82.7k
  static bool trivially_destructible(const U& obj) {
89
82.7k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
82.7k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
82.7k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
82.7k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
82.7k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
82.7k
    if constexpr (always_trivially_destructible<U>()) {
96
82.7k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
82.7k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::UintValue>(cel::UintValue const&)
Line
Count
Source
88
2.83k
  static bool trivially_destructible(const U& obj) {
89
2.83k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
2.83k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
2.83k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
2.83k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
2.83k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
2.83k
    if constexpr (always_trivially_destructible<U>()) {
96
2.83k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
2.83k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::DoubleValue>(cel::DoubleValue const&)
Line
Count
Source
88
6.47k
  static bool trivially_destructible(const U& obj) {
89
6.47k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
6.47k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
6.47k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
6.47k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
6.47k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
6.47k
    if constexpr (always_trivially_destructible<U>()) {
96
6.47k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
6.47k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::DurationValue>(cel::DurationValue const&)
Line
Count
Source
88
1
  static bool trivially_destructible(const U& obj) {
89
1
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1
    if constexpr (always_trivially_destructible<U>()) {
96
1
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::TimestampValue>(cel::TimestampValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::TypeValue>(cel::TypeValue const&)
Line
Count
Source
88
1.91k
  static bool trivially_destructible(const U& obj) {
89
1.91k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.91k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.91k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.91k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.91k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1.91k
    if constexpr (always_trivially_destructible<U>()) {
96
1.91k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1.91k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyListValue>(cel::common_internal::LegacyListValue const&)
Line
Count
Source
88
154
  static bool trivially_destructible(const U& obj) {
89
154
    static_assert(!std::is_void_v<U>, "T must not be void");
90
154
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
154
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
154
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
154
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
154
    if constexpr (always_trivially_destructible<U>()) {
96
154
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
154
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ParsedJsonListValue>(cel::ParsedJsonListValue const&)
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ParsedRepeatedFieldValue>(cel::ParsedRepeatedFieldValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::CustomListValue>(cel::CustomListValue const&)
Line
Count
Source
88
2.14k
  static bool trivially_destructible(const U& obj) {
89
2.14k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
2.14k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
2.14k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
2.14k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
2.14k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
2.14k
    if constexpr (always_trivially_destructible<U>()) {
96
2.14k
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
2.14k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyMapValue>(cel::common_internal::LegacyMapValue const&)
Line
Count
Source
88
1
  static bool trivially_destructible(const U& obj) {
89
1
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1
    if constexpr (always_trivially_destructible<U>()) {
96
1
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ParsedJsonMapValue>(cel::ParsedJsonMapValue const&)
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ParsedMapFieldValue>(cel::ParsedMapFieldValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::CustomMapValue>(cel::CustomMapValue const&)
Line
Count
Source
88
527
  static bool trivially_destructible(const U& obj) {
89
527
    static_assert(!std::is_void_v<U>, "T must not be void");
90
527
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
527
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
527
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
527
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
527
    if constexpr (always_trivially_destructible<U>()) {
96
527
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
527
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyStructValue>(cel::common_internal::LegacyStructValue const&)
Line
Count
Source
88
1
  static bool trivially_destructible(const U& obj) {
89
1
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1
    if constexpr (always_trivially_destructible<U>()) {
96
1
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
                             U>::value) {
101
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::CustomStructValue>(cel::CustomStructValue const&)
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::OpaqueValue>(cel::OpaqueValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::BytesValue>(cel::BytesValue const&)
Line
Count
Source
88
2.68k
  static bool trivially_destructible(const U& obj) {
89
2.68k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
2.68k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
2.68k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
2.68k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
2.68k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
    if constexpr (always_trivially_destructible<U>()) {
96
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
2.68k
                             U>::value) {
101
2.68k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
2.68k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::StringValue>(cel::StringValue const&)
Line
Count
Source
88
1.55k
  static bool trivially_destructible(const U& obj) {
89
1.55k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.55k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.55k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.55k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.55k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
    if constexpr (always_trivially_destructible<U>()) {
96
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
1.55k
                             U>::value) {
101
1.55k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1.55k
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::ErrorValue>(cel::ErrorValue const&)
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::UnknownValue>(cel::UnknownValue const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::ByteString>(cel::common_internal::ByteString const&)
Line
Count
Source
88
22.7k
  static bool trivially_destructible(const U& obj) {
89
22.7k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
22.7k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
22.7k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
22.7k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
22.7k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
    if constexpr (always_trivially_destructible<U>()) {
96
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
22.7k
                             U>::value) {
101
22.7k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
22.7k
  }
Unexecuted instantiation: bool cel::ArenaTraits<void>::trivially_destructible<cel::Value*>(cel::Value* const&)
bool cel::ArenaTraits<void>::trivially_destructible<cel::Value>(cel::Value const&)
Line
Count
Source
88
104k
  static bool trivially_destructible(const U& obj) {
89
104k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
104k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
104k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
104k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
104k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
    if constexpr (always_trivially_destructible<U>()) {
96
      return true;
97
    } else if constexpr (google::protobuf::Arena::is_destructor_skippable<U>::value) {
98
      return obj.GetArena() != nullptr;
99
    } else if constexpr (common_internal::HasArenaTraitsTriviallyDestructible<
100
104k
                             U>::value) {
101
104k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
104k
  }
106
};
107
108
}  // namespace cel
109
110
#endif  // THIRD_PARTY_CEL_CPP_COMMON_ARENA_H_