Coverage Report

Created: 2026-07-11 06:47

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
2.90M
  static bool trivially_destructible(const U& obj) {
89
2.90M
    static_assert(!std::is_void_v<U>, "T must not be void");
90
2.90M
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
2.90M
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
2.90M
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
2.90M
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
2.90M
    if constexpr (always_trivially_destructible<U>()) {
96
1.25M
      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.64M
                             U>::value) {
101
1.64M
      return ArenaTraits<U>::trivially_destructible(obj);
102
1.64M
    } else {
103
0
      return false;
104
0
    }
105
2.90M
  }
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
97
  static bool trivially_destructible(const U& obj) {
89
97
    static_assert(!std::is_void_v<U>, "T must not be void");
90
97
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
97
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
97
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
97
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
97
    if constexpr (always_trivially_destructible<U>()) {
96
97
      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
97
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::BoolValue>(cel::BoolValue const&)
Line
Count
Source
88
103k
  static bool trivially_destructible(const U& obj) {
89
103k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
103k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
103k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
103k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
103k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
103k
    if constexpr (always_trivially_destructible<U>()) {
96
103k
      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
103k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::IntValue>(cel::IntValue const&)
Line
Count
Source
88
1.03M
  static bool trivially_destructible(const U& obj) {
89
1.03M
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.03M
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.03M
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.03M
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.03M
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1.03M
    if constexpr (always_trivially_destructible<U>()) {
96
1.03M
      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.03M
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::UintValue>(cel::UintValue const&)
Line
Count
Source
88
17.1k
  static bool trivially_destructible(const U& obj) {
89
17.1k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
17.1k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
17.1k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
17.1k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
17.1k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
17.1k
    if constexpr (always_trivially_destructible<U>()) {
96
17.1k
      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
17.1k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::DoubleValue>(cel::DoubleValue const&)
Line
Count
Source
88
83.7k
  static bool trivially_destructible(const U& obj) {
89
83.7k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
83.7k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
83.7k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
83.7k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
83.7k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
83.7k
    if constexpr (always_trivially_destructible<U>()) {
96
83.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
83.7k
  }
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
8.06k
  static bool trivially_destructible(const U& obj) {
89
8.06k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
8.06k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
8.06k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
8.06k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
8.06k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
8.06k
    if constexpr (always_trivially_destructible<U>()) {
96
8.06k
      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
8.06k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyListValue>(cel::common_internal::LegacyListValue const&)
Line
Count
Source
88
1.80k
  static bool trivially_destructible(const U& obj) {
89
1.80k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.80k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.80k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.80k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.80k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1.80k
    if constexpr (always_trivially_destructible<U>()) {
96
1.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
1.80k
  }
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
3.01k
  static bool trivially_destructible(const U& obj) {
89
3.01k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
3.01k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
3.01k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
3.01k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
3.01k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
3.01k
    if constexpr (always_trivially_destructible<U>()) {
96
3.01k
      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.01k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyMapValue>(cel::common_internal::LegacyMapValue const&)
Line
Count
Source
88
9
  static bool trivially_destructible(const U& obj) {
89
9
    static_assert(!std::is_void_v<U>, "T must not be void");
90
9
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
9
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
9
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
9
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
9
    if constexpr (always_trivially_destructible<U>()) {
96
9
      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
9
  }
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
1.10k
  static bool trivially_destructible(const U& obj) {
89
1.10k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.10k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.10k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.10k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.10k
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
1.10k
    if constexpr (always_trivially_destructible<U>()) {
96
1.10k
      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.10k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::common_internal::LegacyStructValue>(cel::common_internal::LegacyStructValue const&)
Line
Count
Source
88
12
  static bool trivially_destructible(const U& obj) {
89
12
    static_assert(!std::is_void_v<U>, "T must not be void");
90
12
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
12
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
12
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
12
    static_assert(!std::is_array_v<U>, "T must not be an array");
94
95
12
    if constexpr (always_trivially_destructible<U>()) {
96
12
      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
12
  }
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
46.5k
  static bool trivially_destructible(const U& obj) {
89
46.5k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
46.5k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
46.5k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
46.5k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
46.5k
    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
46.5k
                             U>::value) {
101
46.5k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
46.5k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::StringValue>(cel::StringValue const&)
Line
Count
Source
88
4.64k
  static bool trivially_destructible(const U& obj) {
89
4.64k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
4.64k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
4.64k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
4.64k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
4.64k
    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
4.64k
                             U>::value) {
101
4.64k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
4.64k
  }
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
289k
  static bool trivially_destructible(const U& obj) {
89
289k
    static_assert(!std::is_void_v<U>, "T must not be void");
90
289k
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
289k
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
289k
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
289k
    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
289k
                             U>::value) {
101
289k
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
289k
  }
bool cel::ArenaTraits<void>::trivially_destructible<cel::Value>(cel::Value const&)
Line
Count
Source
88
1.30M
  static bool trivially_destructible(const U& obj) {
89
1.30M
    static_assert(!std::is_void_v<U>, "T must not be void");
90
1.30M
    static_assert(!std::is_reference_v<U>, "T must not be a reference");
91
1.30M
    static_assert(!std::is_volatile_v<U>, "T must not be volatile qualified");
92
1.30M
    static_assert(!std::is_const_v<U>, "T must not be const qualified");
93
1.30M
    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.30M
                             U>::value) {
101
1.30M
      return ArenaTraits<U>::trivially_destructible(obj);
102
    } else {
103
      return false;
104
    }
105
1.30M
  }
106
};
107
108
}  // namespace cel
109
110
#endif  // THIRD_PARTY_CEL_CPP_COMMON_ARENA_H_