Coverage Report

Created: 2025-06-16 21:51

/root/doris/be/src/common/cast_set.h
Line
Count
Source (jump to first uncovered line)
1
2
// Licensed to the Apache Software Foundation (ASF) under one
3
// or more contributor license agreements.  See the NOTICE file
4
// distributed with this work for additional information
5
// regarding copyright ownership.  The ASF licenses this file
6
// to you under the Apache License, Version 2.0 (the
7
// "License"); you may not use this file except in compliance
8
// with the License.  You may obtain a copy of the License at
9
//
10
//   http://www.apache.org/licenses/LICENSE-2.0
11
//
12
// Unless required by applicable law or agreed to in writing,
13
// software distributed under the License is distributed on an
14
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15
// KIND, either express or implied.  See the License for the
16
// specific language governing permissions and limitations
17
// under the License.
18
19
#pragma once
20
21
#include <limits>
22
#include <type_traits>
23
24
#include "common/exception.h"
25
#include "common/status.h"
26
27
namespace doris {
28
29
template <typename T, typename U>
30
117M
void check_cast_value(U b) {
31
117M
    if constexpr (std::is_unsigned_v<U>) {
32
117M
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
117M
    } else if constexpr (std::is_unsigned_v<T>) {
39
22.8k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
0
                                   std::numeric_limits<T>::max());
44
0
        }
45
22.8k
    } else {
46
9.00k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
0
                                   std::numeric_limits<T>::max());
51
0
        }
52
9.00k
    }
53
117M
}
_ZN5doris16check_cast_valueIimEEvT0_
Line
Count
Source
30
7.73k
void check_cast_value(U b) {
31
7.73k
    if constexpr (std::is_unsigned_v<U>) {
32
7.73k
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
7.73k
    } else if constexpr (std::is_unsigned_v<T>) {
39
7.73k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
7.73k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
7.73k
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
7.73k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
7.73k
                                   std::numeric_limits<T>::max());
44
7.73k
        }
45
7.73k
    } else {
46
7.73k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
7.73k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
7.73k
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
7.73k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
7.73k
                                   std::numeric_limits<T>::max());
51
7.73k
        }
52
7.73k
    }
53
7.73k
}
_ZN5doris16check_cast_valueIilEEvT0_
Line
Count
Source
30
8.72k
void check_cast_value(U b) {
31
8.72k
    if constexpr (std::is_unsigned_v<U>) {
32
8.72k
        if (b > std::numeric_limits<T>::max()) {
33
8.72k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
8.72k
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
8.72k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
8.72k
                                   std::numeric_limits<T>::max());
37
8.72k
        }
38
8.72k
    } else if constexpr (std::is_unsigned_v<T>) {
39
8.72k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
8.72k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
8.72k
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
8.72k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
8.72k
                                   std::numeric_limits<T>::max());
44
8.72k
        }
45
8.72k
    } else {
46
8.72k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
0
                                   std::numeric_limits<T>::max());
51
0
        }
52
8.72k
    }
53
8.72k
}
_ZN5doris16check_cast_valueItiEEvT0_
Line
Count
Source
30
18.2k
void check_cast_value(U b) {
31
18.2k
    if constexpr (std::is_unsigned_v<U>) {
32
18.2k
        if (b > std::numeric_limits<T>::max()) {
33
18.2k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
18.2k
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
18.2k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
18.2k
                                   std::numeric_limits<T>::max());
37
18.2k
        }
38
18.2k
    } else if constexpr (std::is_unsigned_v<T>) {
39
18.2k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
0
                                   std::numeric_limits<T>::max());
44
0
        }
45
18.2k
    } else {
46
18.2k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
18.2k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
18.2k
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
18.2k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
18.2k
                                   std::numeric_limits<T>::max());
51
18.2k
        }
52
18.2k
    }
53
18.2k
}
_ZN5doris16check_cast_valueIjmEEvT0_
Line
Count
Source
30
947k
void check_cast_value(U b) {
31
947k
    if constexpr (std::is_unsigned_v<U>) {
32
947k
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
947k
    } else if constexpr (std::is_unsigned_v<T>) {
39
947k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
947k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
947k
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
947k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
947k
                                   std::numeric_limits<T>::max());
44
947k
        }
45
947k
    } else {
46
947k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
947k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
947k
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
947k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
947k
                                   std::numeric_limits<T>::max());
51
947k
        }
52
947k
    }
53
947k
}
_ZN5doris16check_cast_valueIlmEEvT0_
Line
Count
Source
30
116M
void check_cast_value(U b) {
31
116M
    if constexpr (std::is_unsigned_v<U>) {
32
116M
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
116M
    } else if constexpr (std::is_unsigned_v<T>) {
39
116M
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
116M
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
116M
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
116M
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
116M
                                   std::numeric_limits<T>::max());
44
116M
        }
45
116M
    } else {
46
116M
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
116M
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
116M
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
116M
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
116M
                                   std::numeric_limits<T>::max());
51
116M
        }
52
116M
    }
53
116M
}
_ZN5doris16check_cast_valueIjlEEvT0_
Line
Count
Source
30
1.04k
void check_cast_value(U b) {
31
1.04k
    if constexpr (std::is_unsigned_v<U>) {
32
1.04k
        if (b > std::numeric_limits<T>::max()) {
33
1.04k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
1.04k
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
1.04k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
1.04k
                                   std::numeric_limits<T>::max());
37
1.04k
        }
38
1.04k
    } else if constexpr (std::is_unsigned_v<T>) {
39
1.04k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
0
                                   std::numeric_limits<T>::max());
44
0
        }
45
1.04k
    } else {
46
1.04k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
1.04k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
1.04k
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
1.04k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
1.04k
                                   std::numeric_limits<T>::max());
51
1.04k
        }
52
1.04k
    }
53
1.04k
}
_ZN5doris16check_cast_valueIiiEEvT0_
Line
Count
Source
30
167
void check_cast_value(U b) {
31
167
    if constexpr (std::is_unsigned_v<U>) {
32
167
        if (b > std::numeric_limits<T>::max()) {
33
167
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
167
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
167
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
167
                                   std::numeric_limits<T>::max());
37
167
        }
38
167
    } else if constexpr (std::is_unsigned_v<T>) {
39
167
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
167
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
167
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
167
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
167
                                   std::numeric_limits<T>::max());
44
167
        }
45
167
    } else {
46
167
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
0
                                   std::numeric_limits<T>::max());
51
0
        }
52
167
    }
53
167
}
Unexecuted instantiation: _ZN5doris16check_cast_valueIliEEvT0_
Unexecuted instantiation: _ZN5doris16check_cast_valueIllEEvT0_
Unexecuted instantiation: _ZN5doris16check_cast_valueIlnEEvT0_
_ZN5doris16check_cast_valueIjjEEvT0_
Line
Count
Source
30
21
void check_cast_value(U b) {
31
21
    if constexpr (std::is_unsigned_v<U>) {
32
21
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
21
    } else if constexpr (std::is_unsigned_v<T>) {
39
21
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
21
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
21
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
21
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
21
                                   std::numeric_limits<T>::max());
44
21
        }
45
21
    } else {
46
21
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
21
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
21
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
21
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
21
                                   std::numeric_limits<T>::max());
51
21
        }
52
21
    }
53
21
}
_ZN5doris16check_cast_valueImjEEvT0_
Line
Count
Source
30
42
void check_cast_value(U b) {
31
42
    if constexpr (std::is_unsigned_v<U>) {
32
42
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
42
    } else if constexpr (std::is_unsigned_v<T>) {
39
42
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
42
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
42
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
42
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
42
                                   std::numeric_limits<T>::max());
44
42
        }
45
42
    } else {
46
42
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
42
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
42
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
42
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
42
                                   std::numeric_limits<T>::max());
51
42
        }
52
42
    }
53
42
}
_ZN5doris16check_cast_valueImnEEvT0_
Line
Count
Source
30
3.60k
void check_cast_value(U b) {
31
3.60k
    if constexpr (std::is_unsigned_v<U>) {
32
3.60k
        if (b > std::numeric_limits<T>::max()) {
33
3.60k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
3.60k
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
3.60k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
3.60k
                                   std::numeric_limits<T>::max());
37
3.60k
        }
38
3.60k
    } else if constexpr (std::is_unsigned_v<T>) {
39
3.60k
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
0
                                   std::numeric_limits<T>::max());
44
0
        }
45
3.60k
    } else {
46
3.60k
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
3.60k
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
3.60k
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
3.60k
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
3.60k
                                   std::numeric_limits<T>::max());
51
3.60k
        }
52
3.60k
    }
53
3.60k
}
_ZN5doris16check_cast_valueIsiEEvT0_
Line
Count
Source
30
117
void check_cast_value(U b) {
31
117
    if constexpr (std::is_unsigned_v<U>) {
32
117
        if (b > std::numeric_limits<T>::max()) {
33
117
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
117
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
117
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
117
                                   std::numeric_limits<T>::max());
37
117
        }
38
117
    } else if constexpr (std::is_unsigned_v<T>) {
39
117
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
117
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
117
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
117
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
117
                                   std::numeric_limits<T>::max());
44
117
        }
45
117
    } else {
46
117
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
0
                                   std::numeric_limits<T>::max());
51
0
        }
52
117
    }
53
117
}
_ZN5doris16check_cast_valueIijEEvT0_
Line
Count
Source
30
24
void check_cast_value(U b) {
31
24
    if constexpr (std::is_unsigned_v<U>) {
32
24
        if (b > std::numeric_limits<T>::max()) {
33
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
34
0
                                   "value {} cast  to type {} out of range [{},{}]", b,
35
0
                                   typeid(T).name(), std::numeric_limits<T>::min(),
36
0
                                   std::numeric_limits<T>::max());
37
0
        }
38
24
    } else if constexpr (std::is_unsigned_v<T>) {
39
24
        if (b < 0 || b > std::numeric_limits<T>::max()) {
40
24
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
41
24
                                   "value {} cast  to type {} out of range [{},{}]", b,
42
24
                                   typeid(T).name(), std::numeric_limits<T>::min(),
43
24
                                   std::numeric_limits<T>::max());
44
24
        }
45
24
    } else {
46
24
        if (b < std::numeric_limits<T>::min() || b > std::numeric_limits<T>::max()) {
47
24
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
48
24
                                   "value {} cast  to type {} out of range [{},{}]", b,
49
24
                                   typeid(T).name(), std::numeric_limits<T>::min(),
50
24
                                   std::numeric_limits<T>::max());
51
24
        }
52
24
    }
53
24
}
Unexecuted instantiation: _ZN5doris16check_cast_valueIhsEEvT0_
Unexecuted instantiation: _ZN5doris16check_cast_valueIhlEEvT0_
54
55
template <typename T, typename U, bool need_check_value = true>
56
    requires std::is_integral_v<T> && std::is_integral_v<U>
57
0
void cast_set(T& a, U b) {
58
0
    if constexpr (need_check_value) {
59
0
        check_cast_value<T>(b);
60
0
    }
61
0
    a = static_cast<T>(b);
62
0
}
Unexecuted instantiation: _ZN5doris8cast_setIilLb1EEEvRT_T0_
Unexecuted instantiation: _ZN5doris8cast_setIjmLb1EEEvRT_T0_
Unexecuted instantiation: _ZN5doris8cast_setIimLb1EEEvRT_T0_
63
64
template <typename T, typename U>
65
    requires std::is_floating_point_v<T> and std::is_integral_v<U>
66
void cast_set(T& a, U b) {
67
    a = static_cast<T>(b);
68
}
69
70
template <typename T, typename U, bool need_check_value = true>
71
    requires std::is_integral_v<T> && std::is_integral_v<U>
72
117M
T cast_set(U b) {
73
117M
    if constexpr (need_check_value) {
74
117M
        check_cast_value<T>(b);
75
117M
    }
76
117M
    return static_cast<T>(b);
77
117M
}
_ZN5doris8cast_setIciLb0EEET_T0_
Line
Count
Source
72
2.25k
T cast_set(U b) {
73
2.25k
    if constexpr (need_check_value) {
74
2.25k
        check_cast_value<T>(b);
75
2.25k
    }
76
2.25k
    return static_cast<T>(b);
77
2.25k
}
_ZN5doris8cast_setIimLb1EEET_T0_
Line
Count
Source
72
7.73k
T cast_set(U b) {
73
7.73k
    if constexpr (need_check_value) {
74
7.73k
        check_cast_value<T>(b);
75
7.73k
    }
76
7.73k
    return static_cast<T>(b);
77
7.73k
}
_ZN5doris8cast_setIilLb1EEET_T0_
Line
Count
Source
72
8.72k
T cast_set(U b) {
73
8.72k
    if constexpr (need_check_value) {
74
8.72k
        check_cast_value<T>(b);
75
8.72k
    }
76
8.72k
    return static_cast<T>(b);
77
8.72k
}
_ZN5doris8cast_setItiLb1EEET_T0_
Line
Count
Source
72
18.2k
T cast_set(U b) {
73
18.2k
    if constexpr (need_check_value) {
74
18.2k
        check_cast_value<T>(b);
75
18.2k
    }
76
18.2k
    return static_cast<T>(b);
77
18.2k
}
_ZN5doris8cast_setIimLb0EEET_T0_
Line
Count
Source
72
1.86k
T cast_set(U b) {
73
1.86k
    if constexpr (need_check_value) {
74
1.86k
        check_cast_value<T>(b);
75
1.86k
    }
76
1.86k
    return static_cast<T>(b);
77
1.86k
}
_ZN5doris8cast_setIjmLb1EEET_T0_
Line
Count
Source
72
947k
T cast_set(U b) {
73
947k
    if constexpr (need_check_value) {
74
947k
        check_cast_value<T>(b);
75
947k
    }
76
947k
    return static_cast<T>(b);
77
947k
}
_ZN5doris8cast_setIhjLb0EEET_T0_
Line
Count
Source
72
8
T cast_set(U b) {
73
8
    if constexpr (need_check_value) {
74
8
        check_cast_value<T>(b);
75
8
    }
76
8
    return static_cast<T>(b);
77
8
}
_ZN5doris8cast_setIlmLb1EEET_T0_
Line
Count
Source
72
116M
T cast_set(U b) {
73
116M
    if constexpr (need_check_value) {
74
116M
        check_cast_value<T>(b);
75
116M
    }
76
116M
    return static_cast<T>(b);
77
116M
}
_ZN5doris8cast_setIjlLb1EEET_T0_
Line
Count
Source
72
1.04k
T cast_set(U b) {
73
1.04k
    if constexpr (need_check_value) {
74
1.04k
        check_cast_value<T>(b);
75
1.04k
    }
76
1.04k
    return static_cast<T>(b);
77
1.04k
}
_ZN5doris8cast_setIsiLb0EEET_T0_
Line
Count
Source
72
1.01k
T cast_set(U b) {
73
1.01k
    if constexpr (need_check_value) {
74
1.01k
        check_cast_value<T>(b);
75
1.01k
    }
76
1.01k
    return static_cast<T>(b);
77
1.01k
}
_ZN5doris8cast_setIiiLb1EEET_T0_
Line
Count
Source
72
167
T cast_set(U b) {
73
167
    if constexpr (need_check_value) {
74
167
        check_cast_value<T>(b);
75
167
    }
76
167
    return static_cast<T>(b);
77
167
}
_ZN5doris8cast_setIaiLb0EEET_T0_
Line
Count
Source
72
1.07k
T cast_set(U b) {
73
1.07k
    if constexpr (need_check_value) {
74
1.07k
        check_cast_value<T>(b);
75
1.07k
    }
76
1.07k
    return static_cast<T>(b);
77
1.07k
}
Unexecuted instantiation: _ZN5doris8cast_setIliLb1EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setIllLb1EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setIlnLb1EEET_T0_
_ZN5doris8cast_setIilLb0EEET_T0_
Line
Count
Source
72
294
T cast_set(U b) {
73
294
    if constexpr (need_check_value) {
74
294
        check_cast_value<T>(b);
75
294
    }
76
294
    return static_cast<T>(b);
77
294
}
_ZN5doris8cast_setIjjLb1EEET_T0_
Line
Count
Source
72
21
T cast_set(U b) {
73
21
    if constexpr (need_check_value) {
74
21
        check_cast_value<T>(b);
75
21
    }
76
21
    return static_cast<T>(b);
77
21
}
_ZN5doris8cast_setIjmLb0EEET_T0_
Line
Count
Source
72
2
T cast_set(U b) {
73
2
    if constexpr (need_check_value) {
74
2
        check_cast_value<T>(b);
75
2
    }
76
2
    return static_cast<T>(b);
77
2
}
_ZN5doris8cast_setImjLb1EEET_T0_
Line
Count
Source
72
42
T cast_set(U b) {
73
42
    if constexpr (need_check_value) {
74
42
        check_cast_value<T>(b);
75
42
    }
76
42
    return static_cast<T>(b);
77
42
}
_ZN5doris8cast_setImnLb1EEET_T0_
Line
Count
Source
72
3.60k
T cast_set(U b) {
73
3.60k
    if constexpr (need_check_value) {
74
3.60k
        check_cast_value<T>(b);
75
3.60k
    }
76
3.60k
    return static_cast<T>(b);
77
3.60k
}
_ZN5doris8cast_setIsiLb1EEET_T0_
Line
Count
Source
72
117
T cast_set(U b) {
73
117
    if constexpr (need_check_value) {
74
117
        check_cast_value<T>(b);
75
117
    }
76
117
    return static_cast<T>(b);
77
117
}
Unexecuted instantiation: _ZN5doris8cast_setIiiLb0EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setIliLb0EEET_T0_
_ZN5doris8cast_setIllLb0EEET_T0_
Line
Count
Source
72
25
T cast_set(U b) {
73
25
    if constexpr (need_check_value) {
74
25
        check_cast_value<T>(b);
75
25
    }
76
25
    return static_cast<T>(b);
77
25
}
Unexecuted instantiation: _ZN5doris8cast_setIniLb0EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setInlLb0EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setIsmLb0EEET_T0_
_ZN5doris8cast_setIijLb1EEET_T0_
Line
Count
Source
72
24
T cast_set(U b) {
73
24
    if constexpr (need_check_value) {
74
24
        check_cast_value<T>(b);
75
24
    }
76
24
    return static_cast<T>(b);
77
24
}
Unexecuted instantiation: _ZN5doris8cast_setIhsLb1EEET_T0_
Unexecuted instantiation: _ZN5doris8cast_setIhlLb1EEET_T0_
_ZN5doris8cast_setIahLb0EEET_T0_
Line
Count
Source
72
99
T cast_set(U b) {
73
99
    if constexpr (need_check_value) {
74
99
        check_cast_value<T>(b);
75
99
    }
76
99
    return static_cast<T>(b);
77
99
}
_ZN5doris8cast_setIijLb0EEET_T0_
Line
Count
Source
72
12
T cast_set(U b) {
73
12
    if constexpr (need_check_value) {
74
12
        check_cast_value<T>(b);
75
12
    }
76
12
    return static_cast<T>(b);
77
12
}
_ZN5doris8cast_setIatLb0EEET_T0_
Line
Count
Source
72
4
T cast_set(U b) {
73
4
    if constexpr (need_check_value) {
74
4
        check_cast_value<T>(b);
75
4
    }
76
4
    return static_cast<T>(b);
77
4
}
Unexecuted instantiation: _ZN5doris8cast_setImmLb0EEET_T0_
_ZN5doris8cast_setIjjLb0EEET_T0_
Line
Count
Source
72
8
T cast_set(U b) {
73
8
    if constexpr (need_check_value) {
74
8
        check_cast_value<T>(b);
75
8
    }
76
8
    return static_cast<T>(b);
77
8
}
Unexecuted instantiation: _ZN5doris8cast_setItmLb0EEET_T0_
78
79
template <typename T, typename U>
80
    requires std::is_floating_point_v<T> and std::is_integral_v<U>
81
0
T cast_set(U b) {
82
0
    return static_cast<T>(b);
83
0
}
84
85
} // namespace doris