/proc/self/cwd/common/values/value_variant.cc

Source
// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "common/values/value_variant.h"

#include <cstddef>
#include <cstring>
#include <memory>
#include <utility>

#include "absl/base/optimization.h"
#include "absl/log/absl_check.h"
#include "common/values/bytes_value.h"
#include "common/values/error_value.h"
#include "common/values/string_value.h"
#include "common/values/unknown_value.h"
#include "common/values/values.h"

namespace cel::common_internal {

void ValueVariant::SlowCopyConstruct(const ValueVariant& other) noexcept {
  ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);

  switch (index_) {
    case ValueIndex::kBytes:
      ::new (static_cast<void*>(&raw_[0])) BytesValue(*other.At<BytesValue>());
      break;
    case ValueIndex::kString:
      ::new (static_cast<void*>(&raw_[0]))
          StringValue(*other.At<StringValue>());
      break;
    case ValueIndex::kError:
      ::new (static_cast<void*>(&raw_[0])) ErrorValue(*other.At<ErrorValue>());
      break;
    case ValueIndex::kUnknown:
      ::new (static_cast<void*>(&raw_[0]))
          UnknownValue(*other.At<UnknownValue>());
      break;
    default:
      ABSL_UNREACHABLE();
  }
}

void ValueVariant::SlowMoveConstruct(ValueVariant& other) noexcept {
  ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);

  switch (index_) {
    case ValueIndex::kBytes:
      ::new (static_cast<void*>(&raw_[0]))
          BytesValue(std::move(*other.At<BytesValue>()));
      break;
    case ValueIndex::kString:
      ::new (static_cast<void*>(&raw_[0]))
          StringValue(std::move(*other.At<StringValue>()));
      break;
    case ValueIndex::kError:
      ::new (static_cast<void*>(&raw_[0]))
          ErrorValue(std::move(*other.At<ErrorValue>()));
      break;
    case ValueIndex::kUnknown:
      ::new (static_cast<void*>(&raw_[0]))
          UnknownValue(std::move(*other.At<UnknownValue>()));
      break;
    default:
      ABSL_UNREACHABLE();
  }
}

void ValueVariant::SlowDestruct() noexcept {
  ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);

  switch (index_) {
    case ValueIndex::kBytes:
      At<BytesValue>()->~BytesValue();
      break;
    case ValueIndex::kString:
      At<StringValue>()->~StringValue();
      break;
    case ValueIndex::kError:
      At<ErrorValue>()->~ErrorValue();
      break;
    case ValueIndex::kUnknown:
      At<UnknownValue>()->~UnknownValue();
      break;
    default:
      ABSL_UNREACHABLE();
  }
}

void ValueVariant::SlowCopyAssign(const ValueVariant& other, bool trivial,
                                  bool other_trivial) noexcept {
  ABSL_DCHECK(!trivial || !other_trivial);

  if (trivial) {
    switch (other.index_) {
      case ValueIndex::kBytes:
        ::new (static_cast<void*>(&raw_[0]))
            BytesValue(*other.At<BytesValue>());
        break;
      case ValueIndex::kString:
        ::new (static_cast<void*>(&raw_[0]))
            StringValue(*other.At<StringValue>());
        break;
      case ValueIndex::kError:
        ::new (static_cast<void*>(&raw_[0]))
            ErrorValue(*other.At<ErrorValue>());
        break;
      case ValueIndex::kUnknown:
        ::new (static_cast<void*>(&raw_[0]))
            UnknownValue(*other.At<UnknownValue>());
        break;
      default:
        ABSL_UNREACHABLE();
    }
    index_ = other.index_;
    kind_ = other.kind_;
    flags_ = other.flags_;
  } else if (other_trivial) {
    switch (index_) {
      case ValueIndex::kBytes:
        At<BytesValue>()->~BytesValue();
        break;
      case ValueIndex::kString:
        At<StringValue>()->~StringValue();
        break;
      case ValueIndex::kError:
        At<ErrorValue>()->~ErrorValue();
        break;
      case ValueIndex::kUnknown:
        At<UnknownValue>()->~UnknownValue();
        break;
      default:
        ABSL_UNREACHABLE();
    }
    FastCopyAssign(other);
  } else {
    switch (index_) {
      case ValueIndex::kBytes:
        switch (other.index_) {
          case ValueIndex::kBytes:
            *At<BytesValue>() = *other.At<BytesValue>();
            break;
          case ValueIndex::kString:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(*other.At<StringValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(*other.At<ErrorValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(*other.At<UnknownValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kString:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(*other.At<BytesValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            *At<StringValue>() = *other.At<StringValue>();
            break;
          case ValueIndex::kError:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(*other.At<ErrorValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(*other.At<UnknownValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kError:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(*other.At<BytesValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(*other.At<StringValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            *At<ErrorValue>() = *other.At<ErrorValue>();
            break;
          case ValueIndex::kUnknown:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(*other.At<UnknownValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kUnknown:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(*other.At<BytesValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(*other.At<StringValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(*other.At<ErrorValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(*other.At<UnknownValue>());
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      default:
        ABSL_UNREACHABLE();
    }
    flags_ = other.flags_;
  }
}

void ValueVariant::SlowMoveAssign(ValueVariant& other, bool trivial,
                                  bool other_trivial) noexcept {
  ABSL_DCHECK(!trivial || !other_trivial);

  if (trivial) {
    switch (other.index_) {
      case ValueIndex::kBytes:
        ::new (static_cast<void*>(&raw_[0]))
            BytesValue(std::move(*other.At<BytesValue>()));
        break;
      case ValueIndex::kString:
        ::new (static_cast<void*>(&raw_[0]))
            StringValue(std::move(*other.At<StringValue>()));
        break;
      case ValueIndex::kError:
        ::new (static_cast<void*>(&raw_[0]))
            ErrorValue(std::move(*other.At<ErrorValue>()));
        break;
      case ValueIndex::kUnknown:
        ::new (static_cast<void*>(&raw_[0]))
            UnknownValue(std::move(*other.At<UnknownValue>()));
        break;
      default:
        ABSL_UNREACHABLE();
    }
    index_ = other.index_;
    kind_ = other.kind_;
    flags_ = other.flags_;
  } else if (other_trivial) {
    switch (index_) {
      case ValueIndex::kBytes:
        At<BytesValue>()->~BytesValue();
        break;
      case ValueIndex::kString:
        At<StringValue>()->~StringValue();
        break;
      case ValueIndex::kError:
        At<ErrorValue>()->~ErrorValue();
        break;
      case ValueIndex::kUnknown:
        At<UnknownValue>()->~UnknownValue();
        break;
      default:
        ABSL_UNREACHABLE();
    }
    FastMoveAssign(other);
  } else {
    switch (index_) {
      case ValueIndex::kBytes:
        switch (other.index_) {
          case ValueIndex::kBytes:
            *At<BytesValue>() = std::move(*other.At<BytesValue>());
            break;
          case ValueIndex::kString:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(std::move(*other.At<StringValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(std::move(*other.At<ErrorValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            At<BytesValue>()->~BytesValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(std::move(*other.At<UnknownValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kString:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(std::move(*other.At<BytesValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            *At<StringValue>() = std::move(*other.At<StringValue>());
            break;
          case ValueIndex::kError:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(std::move(*other.At<ErrorValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            At<StringValue>()->~StringValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(std::move(*other.At<UnknownValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kError:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(std::move(*other.At<BytesValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(std::move(*other.At<StringValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            *At<ErrorValue>() = std::move(*other.At<ErrorValue>());
            break;
          case ValueIndex::kUnknown:
            At<ErrorValue>()->~ErrorValue();
            ::new (static_cast<void*>(&raw_[0]))
                UnknownValue(std::move(*other.At<UnknownValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      case ValueIndex::kUnknown:
        switch (other.index_) {
          case ValueIndex::kBytes:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                BytesValue(std::move(*other.At<BytesValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kString:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                StringValue(std::move(*other.At<StringValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kError:
            At<UnknownValue>()->~UnknownValue();
            ::new (static_cast<void*>(&raw_[0]))
                ErrorValue(std::move(*other.At<ErrorValue>()));
            index_ = other.index_;
            kind_ = other.kind_;
            break;
          case ValueIndex::kUnknown:
            *At<UnknownValue>() = std::move(*other.At<UnknownValue>());
            break;
          default:
            ABSL_UNREACHABLE();
        }
        break;
      default:
        ABSL_UNREACHABLE();
    }
    flags_ = other.flags_;
  }
}

void ValueVariant::SlowSwap(ValueVariant& lhs, ValueVariant& rhs,
                            bool lhs_trivial, bool rhs_trivial) noexcept {
  using std::swap;
  ABSL_DCHECK(!lhs_trivial || !rhs_trivial);

  if (lhs_trivial) {
    alignas(ValueVariant) std::byte tmp[sizeof(ValueVariant)];
    // This is acceptable. We know that both are trivially copyable at runtime.
    // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
    std::memcpy(tmp, std::addressof(lhs), sizeof(ValueVariant));
    switch (rhs.index_) {
      case ValueIndex::kBytes:
        ::new (static_cast<void*>(&lhs.raw_[0]))
            BytesValue(*rhs.At<BytesValue>());
        rhs.At<BytesValue>()->~BytesValue();
        break;
      case ValueIndex::kString:
        ::new (static_cast<void*>(&lhs.raw_[0]))
            StringValue(*rhs.At<StringValue>());
        rhs.At<StringValue>()->~StringValue();
        break;
      case ValueIndex::kError:
        ::new (static_cast<void*>(&lhs.raw_[0]))
            ErrorValue(*rhs.At<ErrorValue>());
        rhs.At<ErrorValue>()->~ErrorValue();
        break;
      case ValueIndex::kUnknown:
        ::new (static_cast<void*>(&lhs.raw_[0]))
            UnknownValue(*rhs.At<UnknownValue>());
        rhs.At<UnknownValue>()->~UnknownValue();
        break;
      default:
        ABSL_UNREACHABLE();
    }
    lhs.index_ = rhs.index_;
    lhs.kind_ = rhs.kind_;
    lhs.flags_ = rhs.flags_;
    // This is acceptable. We know that both are trivially copyable at runtime.
    // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
    std::memcpy(std::addressof(rhs), tmp, sizeof(ValueVariant));
  } else if (rhs_trivial) {
    alignas(ValueVariant) std::byte tmp[sizeof(ValueVariant)];
    // This is acceptable. We know that both are trivially copyable at runtime.
    // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
    std::memcpy(tmp, std::addressof(rhs), sizeof(ValueVariant));
    switch (lhs.index_) {
      case ValueIndex::kBytes:
        ::new (static_cast<void*>(&rhs.raw_[0]))
            BytesValue(*lhs.At<BytesValue>());
        lhs.At<BytesValue>()->~BytesValue();
        break;
      case ValueIndex::kString:
        ::new (static_cast<void*>(&rhs.raw_[0]))
            StringValue(*lhs.At<StringValue>());
        lhs.At<StringValue>()->~StringValue();
        break;
      case ValueIndex::kError:
        ::new (static_cast<void*>(&rhs.raw_[0]))
            ErrorValue(*lhs.At<ErrorValue>());
        lhs.At<ErrorValue>()->~ErrorValue();
        break;
      case ValueIndex::kUnknown:
        ::new (static_cast<void*>(&rhs.raw_[0]))
            UnknownValue(*lhs.At<UnknownValue>());
        lhs.At<UnknownValue>()->~UnknownValue();
        break;
      default:
        ABSL_UNREACHABLE();
    }
    rhs.index_ = lhs.index_;
    rhs.kind_ = lhs.kind_;
    rhs.flags_ = lhs.flags_;
    // This is acceptable. We know that both are trivially copyable at runtime.
    // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
    std::memcpy(std::addressof(lhs), tmp, sizeof(ValueVariant));
  } else {
    ValueVariant tmp = std::move(lhs);
    lhs = std::move(rhs);
    rhs = std::move(tmp);
  }
}

}  // namespace cel::common_internal

Coverage Report

Created: 2026-07-16 06:29

Line	Count	Source
1		// Copyright 2025 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		#include "common/values/value_variant.h"
16
17		#include <cstddef>
18		#include <cstring>
19		#include <memory>
20		#include <utility>
21
22		#include "absl/base/optimization.h"
23		#include "absl/log/absl_check.h"
24		#include "common/values/bytes_value.h"
25		#include "common/values/error_value.h"
26		#include "common/values/string_value.h"
27		#include "common/values/unknown_value.h"
28		#include "common/values/values.h"
29
30		namespace cel::common_internal {
31
32	8.24M	void ValueVariant::SlowCopyConstruct(const ValueVariant& other) noexcept {
33	8.24M	ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);
34
35	8.24M	switch (index_) {
36	175k	case ValueIndex::kBytes:
37	175k	::new (static_cast<void>(&raw_[0])) BytesValue(other.At<BytesValue>());
38	175k	break;
39	65.0k	case ValueIndex::kString:
40	65.0k	::new (static_cast<void*>(&raw_[0]))
41	65.0k	StringValue(*other.At<StringValue>());
42	65.0k	break;
43	8.00M	case ValueIndex::kError:
44	8.00M	::new (static_cast<void>(&raw_[0])) ErrorValue(other.At<ErrorValue>());
45	8.00M	break;
46	0	case ValueIndex::kUnknown:
47	0	::new (static_cast<void*>(&raw_[0]))
48	0	UnknownValue(*other.At<UnknownValue>());
49	0	break;
50	0	default:
51	0	ABSL_UNREACHABLE();
52	8.24M	}
53	8.24M	}
54
55	20.0M	void ValueVariant::SlowMoveConstruct(ValueVariant& other) noexcept {
56	20.0M	ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);
57
58	20.0M	switch (index_) {
59	364k	case ValueIndex::kBytes:
60	364k	::new (static_cast<void*>(&raw_[0]))
61	364k	BytesValue(std::move(*other.At<BytesValue>()));
62	364k	break;
63	49.4k	case ValueIndex::kString:
64	49.4k	::new (static_cast<void*>(&raw_[0]))
65	49.4k	StringValue(std::move(*other.At<StringValue>()));
66	49.4k	break;
67	19.5M	case ValueIndex::kError:
68	19.5M	::new (static_cast<void*>(&raw_[0]))
69	19.5M	ErrorValue(std::move(*other.At<ErrorValue>()));
70	19.5M	break;
71	0	case ValueIndex::kUnknown:
72	0	::new (static_cast<void*>(&raw_[0]))
73	0	UnknownValue(std::move(*other.At<UnknownValue>()));
74	0	break;
75	0	default:
76	0	ABSL_UNREACHABLE();
77	20.0M	}
78	20.0M	}
79
80	37.1M	void ValueVariant::SlowDestruct() noexcept {
81	37.1M	ABSL_DCHECK((flags_ & ValueFlags::kNonTrivial) == ValueFlags::kNonTrivial);
82
83	37.1M	switch (index_) {
84	556k	case ValueIndex::kBytes:
85	556k	At<BytesValue>()->~BytesValue();
86	556k	break;
87	115k	case ValueIndex::kString:
88	115k	At<StringValue>()->~StringValue();
89	115k	break;
90	36.4M	case ValueIndex::kError:
91	36.4M	At<ErrorValue>()->~ErrorValue();
92	36.4M	break;
93	0	case ValueIndex::kUnknown:
94	0	At<UnknownValue>()->~UnknownValue();
95	0	break;
96	0	default:
97	0	ABSL_UNREACHABLE();
98	37.1M	}
99	37.1M	}
100
101		void ValueVariant::SlowCopyAssign(const ValueVariant& other, bool trivial,
102	1.36M	bool other_trivial) noexcept {
103	1.36M	ABSL_DCHECK(!trivial \|\| !other_trivial);
104
105	1.36M	if (trivial) {
106	1.36M	switch (other.index_) {
107	6.61k	case ValueIndex::kBytes:
108	6.61k	::new (static_cast<void*>(&raw_[0]))
109	6.61k	BytesValue(*other.At<BytesValue>());
110	6.61k	break;
111	1.50k	case ValueIndex::kString:
112	1.50k	::new (static_cast<void*>(&raw_[0]))
113	1.50k	StringValue(*other.At<StringValue>());
114	1.50k	break;
115	1.36M	case ValueIndex::kError:
116	1.36M	::new (static_cast<void*>(&raw_[0]))
117	1.36M	ErrorValue(*other.At<ErrorValue>());
118	1.36M	break;
119	0	case ValueIndex::kUnknown:
120	0	::new (static_cast<void*>(&raw_[0]))
121	0	UnknownValue(*other.At<UnknownValue>());
122	0	break;
123	0	default:
124	0	ABSL_UNREACHABLE();
125	1.36M	}
126	1.36M	index_ = other.index_;
127	1.36M	kind_ = other.kind_;
128	1.36M	flags_ = other.flags_;
129	1.36M	} else if (other_trivial) {
130	0	switch (index_) {
131	0	case ValueIndex::kBytes:
132	0	At<BytesValue>()->~BytesValue();
133	0	break;
134	0	case ValueIndex::kString:
135	0	At<StringValue>()->~StringValue();
136	0	break;
137	0	case ValueIndex::kError:
138	0	At<ErrorValue>()->~ErrorValue();
139	0	break;
140	0	case ValueIndex::kUnknown:
141	0	At<UnknownValue>()->~UnknownValue();
142	0	break;
143	0	default:
144	0	ABSL_UNREACHABLE();
145	0	}
146	0	FastCopyAssign(other);
147	0	} else {
148	0	switch (index_) {
149	0	case ValueIndex::kBytes:
150	0	switch (other.index_) {
151	0	case ValueIndex::kBytes:
152	0	At<BytesValue>() = other.At<BytesValue>();
153	0	break;
154	0	case ValueIndex::kString:
155	0	At<BytesValue>()->~BytesValue();
156	0	::new (static_cast<void*>(&raw_[0]))
157	0	StringValue(*other.At<StringValue>());
158	0	index_ = other.index_;
159	0	kind_ = other.kind_;
160	0	break;
161	0	case ValueIndex::kError:
162	0	At<BytesValue>()->~BytesValue();
163	0	::new (static_cast<void*>(&raw_[0]))
164	0	ErrorValue(*other.At<ErrorValue>());
165	0	index_ = other.index_;
166	0	kind_ = other.kind_;
167	0	break;
168	0	case ValueIndex::kUnknown:
169	0	At<BytesValue>()->~BytesValue();
170	0	::new (static_cast<void*>(&raw_[0]))
171	0	UnknownValue(*other.At<UnknownValue>());
172	0	index_ = other.index_;
173	0	kind_ = other.kind_;
174	0	break;
175	0	default:
176	0	ABSL_UNREACHABLE();
177	0	}
178	0	break;
179	0	case ValueIndex::kString:
180	0	switch (other.index_) {
181	0	case ValueIndex::kBytes:
182	0	At<StringValue>()->~StringValue();
183	0	::new (static_cast<void*>(&raw_[0]))
184	0	BytesValue(*other.At<BytesValue>());
185	0	index_ = other.index_;
186	0	kind_ = other.kind_;
187	0	break;
188	0	case ValueIndex::kString:
189	0	At<StringValue>() = other.At<StringValue>();
190	0	break;
191	0	case ValueIndex::kError:
192	0	At<StringValue>()->~StringValue();
193	0	::new (static_cast<void*>(&raw_[0]))
194	0	ErrorValue(*other.At<ErrorValue>());
195	0	index_ = other.index_;
196	0	kind_ = other.kind_;
197	0	break;
198	0	case ValueIndex::kUnknown:
199	0	At<StringValue>()->~StringValue();
200	0	::new (static_cast<void*>(&raw_[0]))
201	0	UnknownValue(*other.At<UnknownValue>());
202	0	index_ = other.index_;
203	0	kind_ = other.kind_;
204	0	break;
205	0	default:
206	0	ABSL_UNREACHABLE();
207	0	}
208	0	break;
209	0	case ValueIndex::kError:
210	0	switch (other.index_) {
211	0	case ValueIndex::kBytes:
212	0	At<ErrorValue>()->~ErrorValue();
213	0	::new (static_cast<void*>(&raw_[0]))
214	0	BytesValue(*other.At<BytesValue>());
215	0	index_ = other.index_;
216	0	kind_ = other.kind_;
217	0	break;
218	0	case ValueIndex::kString:
219	0	At<ErrorValue>()->~ErrorValue();
220	0	::new (static_cast<void*>(&raw_[0]))
221	0	StringValue(*other.At<StringValue>());
222	0	index_ = other.index_;
223	0	kind_ = other.kind_;
224	0	break;
225	0	case ValueIndex::kError:
226	0	At<ErrorValue>() = other.At<ErrorValue>();
227	0	break;
228	0	case ValueIndex::kUnknown:
229	0	At<ErrorValue>()->~ErrorValue();
230	0	::new (static_cast<void*>(&raw_[0]))
231	0	UnknownValue(*other.At<UnknownValue>());
232	0	index_ = other.index_;
233	0	kind_ = other.kind_;
234	0	break;
235	0	default:
236	0	ABSL_UNREACHABLE();
237	0	}
238	0	break;
239	0	case ValueIndex::kUnknown:
240	0	switch (other.index_) {
241	0	case ValueIndex::kBytes:
242	0	At<UnknownValue>()->~UnknownValue();
243	0	::new (static_cast<void*>(&raw_[0]))
244	0	BytesValue(*other.At<BytesValue>());
245	0	index_ = other.index_;
246	0	kind_ = other.kind_;
247	0	break;
248	0	case ValueIndex::kString:
249	0	At<UnknownValue>()->~UnknownValue();
250	0	::new (static_cast<void*>(&raw_[0]))
251	0	StringValue(*other.At<StringValue>());
252	0	index_ = other.index_;
253	0	kind_ = other.kind_;
254	0	break;
255	0	case ValueIndex::kError:
256	0	At<UnknownValue>()->~UnknownValue();
257	0	::new (static_cast<void*>(&raw_[0]))
258	0	ErrorValue(*other.At<ErrorValue>());
259	0	index_ = other.index_;
260	0	kind_ = other.kind_;
261	0	break;
262	0	case ValueIndex::kUnknown:
263	0	At<UnknownValue>()->~UnknownValue();
264	0	::new (static_cast<void*>(&raw_[0]))
265	0	UnknownValue(*other.At<UnknownValue>());
266	0	index_ = other.index_;
267	0	kind_ = other.kind_;
268	0	break;
269	0	default:
270	0	ABSL_UNREACHABLE();
271	0	}
272	0	break;
273	0	default:
274	0	ABSL_UNREACHABLE();
275	0	}
276	0	flags_ = other.flags_;
277	0	}
278	1.36M	}
279
280		void ValueVariant::SlowMoveAssign(ValueVariant& other, bool trivial,
281	10.8M	bool other_trivial) noexcept {
282	10.8M	ABSL_DCHECK(!trivial \|\| !other_trivial);
283
284	10.8M	if (trivial) {
285	2.55M	switch (other.index_) {
286	216	case ValueIndex::kBytes:
287	216	::new (static_cast<void*>(&raw_[0]))
288	216	BytesValue(std::move(*other.At<BytesValue>()));
289	216	break;
290	1.33k	case ValueIndex::kString:
291	1.33k	::new (static_cast<void*>(&raw_[0]))
292	1.33k	StringValue(std::move(*other.At<StringValue>()));
293	1.33k	break;
294	2.54M	case ValueIndex::kError:
295	2.54M	::new (static_cast<void*>(&raw_[0]))
296	2.54M	ErrorValue(std::move(*other.At<ErrorValue>()));
297	2.54M	break;
298	0	case ValueIndex::kUnknown:
299	0	::new (static_cast<void*>(&raw_[0]))
300	0	UnknownValue(std::move(*other.At<UnknownValue>()));
301	0	break;
302	0	default:
303	0	ABSL_UNREACHABLE();
304	2.55M	}
305	2.55M	index_ = other.index_;
306	2.55M	kind_ = other.kind_;
307	2.55M	flags_ = other.flags_;
308	8.32M	} else if (other_trivial) {
309	73.4k	switch (index_) {
310	61.2k	case ValueIndex::kBytes:
311	61.2k	At<BytesValue>()->~BytesValue();
312	61.2k	break;
313	8.87k	case ValueIndex::kString:
314	8.87k	At<StringValue>()->~StringValue();
315	8.87k	break;
316	3.31k	case ValueIndex::kError:
317	3.31k	At<ErrorValue>()->~ErrorValue();
318	3.31k	break;
319	0	case ValueIndex::kUnknown:
320	0	At<UnknownValue>()->~UnknownValue();
321	0	break;
322	0	default:
323	0	ABSL_UNREACHABLE();
324	73.4k	}
325	73.4k	FastMoveAssign(other);
326	8.25M	} else {
327	8.25M	switch (index_) {
328	83.2k	case ValueIndex::kBytes:
329	83.2k	switch (other.index_) {
330	76.7k	case ValueIndex::kBytes:
331	76.7k	At<BytesValue>() = std::move(other.At<BytesValue>());
332	76.7k	break;
333	1.15k	case ValueIndex::kString:
334	1.15k	At<BytesValue>()->~BytesValue();
335	1.15k	::new (static_cast<void*>(&raw_[0]))
336	1.15k	StringValue(std::move(*other.At<StringValue>()));
337	1.15k	index_ = other.index_;
338	1.15k	kind_ = other.kind_;
339	1.15k	break;
340	5.35k	case ValueIndex::kError:
341	5.35k	At<BytesValue>()->~BytesValue();
342	5.35k	::new (static_cast<void*>(&raw_[0]))
343	5.35k	ErrorValue(std::move(*other.At<ErrorValue>()));
344	5.35k	index_ = other.index_;
345	5.35k	kind_ = other.kind_;
346	5.35k	break;
347	0	case ValueIndex::kUnknown:
348	0	At<BytesValue>()->~BytesValue();
349	0	::new (static_cast<void*>(&raw_[0]))
350	0	UnknownValue(std::move(*other.At<UnknownValue>()));
351	0	index_ = other.index_;
352	0	kind_ = other.kind_;
353	0	break;
354	0	default:
355	0	ABSL_UNREACHABLE();
356	83.2k	}
357	83.2k	break;
358	83.2k	case ValueIndex::kString:
359	40.8k	switch (other.index_) {
360	0	case ValueIndex::kBytes:
361	0	At<StringValue>()->~StringValue();
362	0	::new (static_cast<void*>(&raw_[0]))
363	0	BytesValue(std::move(*other.At<BytesValue>()));
364	0	index_ = other.index_;
365	0	kind_ = other.kind_;
366	0	break;
367	1.02k	case ValueIndex::kString:
368	1.02k	At<StringValue>() = std::move(other.At<StringValue>());
369	1.02k	break;
370	39.7k	case ValueIndex::kError:
371	39.7k	At<StringValue>()->~StringValue();
372	39.7k	::new (static_cast<void*>(&raw_[0]))
373	39.7k	ErrorValue(std::move(*other.At<ErrorValue>()));
374	39.7k	index_ = other.index_;
375	39.7k	kind_ = other.kind_;
376	39.7k	break;
377	0	case ValueIndex::kUnknown:
378	0	At<StringValue>()->~StringValue();
379	0	::new (static_cast<void*>(&raw_[0]))
380	0	UnknownValue(std::move(*other.At<UnknownValue>()));
381	0	index_ = other.index_;
382	0	kind_ = other.kind_;
383	0	break;
384	0	default:
385	0	ABSL_UNREACHABLE();
386	40.8k	}
387	40.8k	break;
388	8.13M	case ValueIndex::kError:
389	8.13M	switch (other.index_) {
390	0	case ValueIndex::kBytes:
391	0	At<ErrorValue>()->~ErrorValue();
392	0	::new (static_cast<void*>(&raw_[0]))
393	0	BytesValue(std::move(*other.At<BytesValue>()));
394	0	index_ = other.index_;
395	0	kind_ = other.kind_;
396	0	break;
397	0	case ValueIndex::kString:
398	0	At<ErrorValue>()->~ErrorValue();
399	0	::new (static_cast<void*>(&raw_[0]))
400	0	StringValue(std::move(*other.At<StringValue>()));
401	0	index_ = other.index_;
402	0	kind_ = other.kind_;
403	0	break;
404	8.13M	case ValueIndex::kError:
405	8.13M	At<ErrorValue>() = std::move(other.At<ErrorValue>());
406	8.13M	break;
407	0	case ValueIndex::kUnknown:
408	0	At<ErrorValue>()->~ErrorValue();
409	0	::new (static_cast<void*>(&raw_[0]))
410	0	UnknownValue(std::move(*other.At<UnknownValue>()));
411	0	index_ = other.index_;
412	0	kind_ = other.kind_;
413	0	break;
414	0	default:
415	0	ABSL_UNREACHABLE();
416	8.13M	}
417	8.13M	break;
418	8.13M	case ValueIndex::kUnknown:
419	0	switch (other.index_) {
420	0	case ValueIndex::kBytes:
421	0	At<UnknownValue>()->~UnknownValue();
422	0	::new (static_cast<void*>(&raw_[0]))
423	0	BytesValue(std::move(*other.At<BytesValue>()));
424	0	index_ = other.index_;
425	0	kind_ = other.kind_;
426	0	break;
427	0	case ValueIndex::kString:
428	0	At<UnknownValue>()->~UnknownValue();
429	0	::new (static_cast<void*>(&raw_[0]))
430	0	StringValue(std::move(*other.At<StringValue>()));
431	0	index_ = other.index_;
432	0	kind_ = other.kind_;
433	0	break;
434	0	case ValueIndex::kError:
435	0	At<UnknownValue>()->~UnknownValue();
436	0	::new (static_cast<void*>(&raw_[0]))
437	0	ErrorValue(std::move(*other.At<ErrorValue>()));
438	0	index_ = other.index_;
439	0	kind_ = other.kind_;
440	0	break;
441	0	case ValueIndex::kUnknown:
442	0	At<UnknownValue>() = std::move(other.At<UnknownValue>());
443	0	break;
444	0	default:
445	0	ABSL_UNREACHABLE();
446	0	}
447	0	break;
448	0	default:
449	0	ABSL_UNREACHABLE();
450	8.25M	}
451	8.25M	flags_ = other.flags_;
452	8.25M	}
453	10.8M	}
454
455		void ValueVariant::SlowSwap(ValueVariant& lhs, ValueVariant& rhs,
456	106k	bool lhs_trivial, bool rhs_trivial) noexcept {
457	106k	using std::swap;
458	106k	ABSL_DCHECK(!lhs_trivial \|\| !rhs_trivial);
459
460	106k	if (lhs_trivial) {
461	106k	alignas(ValueVariant) std::byte tmp[sizeof(ValueVariant)];
462		// This is acceptable. We know that both are trivially copyable at runtime.
463		// NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
464	106k	std::memcpy(tmp, std::addressof(lhs), sizeof(ValueVariant));
465	106k	switch (rhs.index_) {
466	0	case ValueIndex::kBytes:
467	0	::new (static_cast<void*>(&lhs.raw_[0]))
468	0	BytesValue(*rhs.At<BytesValue>());
469	0	rhs.At<BytesValue>()->~BytesValue();
470	0	break;
471	0	case ValueIndex::kString:
472	0	::new (static_cast<void*>(&lhs.raw_[0]))
473	0	StringValue(*rhs.At<StringValue>());
474	0	rhs.At<StringValue>()->~StringValue();
475	0	break;
476	106k	case ValueIndex::kError:
477	106k	::new (static_cast<void*>(&lhs.raw_[0]))
478	106k	ErrorValue(*rhs.At<ErrorValue>());
479	106k	rhs.At<ErrorValue>()->~ErrorValue();
480	106k	break;
481	0	case ValueIndex::kUnknown:
482	0	::new (static_cast<void*>(&lhs.raw_[0]))
483	0	UnknownValue(*rhs.At<UnknownValue>());
484	0	rhs.At<UnknownValue>()->~UnknownValue();
485	0	break;
486	0	default:
487	0	ABSL_UNREACHABLE();
488	106k	}
489	106k	lhs.index_ = rhs.index_;
490	106k	lhs.kind_ = rhs.kind_;
491	106k	lhs.flags_ = rhs.flags_;
492		// This is acceptable. We know that both are trivially copyable at runtime.
493		// NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
494	106k	std::memcpy(std::addressof(rhs), tmp, sizeof(ValueVariant));
495	106k	} else if (rhs_trivial) {
496	0	alignas(ValueVariant) std::byte tmp[sizeof(ValueVariant)];
497		// This is acceptable. We know that both are trivially copyable at runtime.
498		// NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
499	0	std::memcpy(tmp, std::addressof(rhs), sizeof(ValueVariant));
500	0	switch (lhs.index_) {
501	0	case ValueIndex::kBytes:
502	0	::new (static_cast<void*>(&rhs.raw_[0]))
503	0	BytesValue(*lhs.At<BytesValue>());
504	0	lhs.At<BytesValue>()->~BytesValue();
505	0	break;
506	0	case ValueIndex::kString:
507	0	::new (static_cast<void*>(&rhs.raw_[0]))
508	0	StringValue(*lhs.At<StringValue>());
509	0	lhs.At<StringValue>()->~StringValue();
510	0	break;
511	0	case ValueIndex::kError:
512	0	::new (static_cast<void*>(&rhs.raw_[0]))
513	0	ErrorValue(*lhs.At<ErrorValue>());
514	0	lhs.At<ErrorValue>()->~ErrorValue();
515	0	break;
516	0	case ValueIndex::kUnknown:
517	0	::new (static_cast<void*>(&rhs.raw_[0]))
518	0	UnknownValue(*lhs.At<UnknownValue>());
519	0	lhs.At<UnknownValue>()->~UnknownValue();
520	0	break;
521	0	default:
522	0	ABSL_UNREACHABLE();
523	0	}
524	0	rhs.index_ = lhs.index_;
525	0	rhs.kind_ = lhs.kind_;
526	0	rhs.flags_ = lhs.flags_;
527		// This is acceptable. We know that both are trivially copyable at runtime.
528		// NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
529	0	std::memcpy(std::addressof(lhs), tmp, sizeof(ValueVariant));
530	0	} else {
531	0	ValueVariant tmp = std::move(lhs);
532	0	lhs = std::move(rhs);
533	0	rhs = std::move(tmp);
534	0	}
535	106k	}
536
537		} // namespace cel::common_internal