1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef MAPLE_UTIL_INCLUDE_UTILS_H
17 #define MAPLE_UTIL_INCLUDE_UTILS_H
18 #include <type_traits>
19 #include <limits>
20 #include <vector>
21 #include "mpl_logging.h"
22
23 namespace maple {
24 namespace utils {
25 // Operations on char
IsDigit(char c)26 constexpr bool IsDigit(char c)
27 {
28 return (c >= '0' && c <= '9');
29 }
30
IsLower(char c)31 constexpr bool IsLower(char c)
32 {
33 return (c >= 'a' && c <= 'z');
34 }
35
IsUpper(char c)36 constexpr bool IsUpper(char c)
37 {
38 return (c >= 'A' && c <= 'Z');
39 }
40
IsAlpha(char c)41 constexpr bool IsAlpha(char c)
42 {
43 return (IsLower(c) || IsUpper(c));
44 }
45
IsAlnum(char c)46 constexpr bool IsAlnum(char c)
47 {
48 return (IsAlpha(c) || IsDigit(c));
49 }
50
51 namespace __ToDigitImpl {
52 template <uint8_t Scale, typename T>
53 struct ToDigitImpl {
54 };
55
56 constexpr uint8_t kOctalNum = 8;
57 constexpr uint8_t kDecimalNum = 10;
58 constexpr uint8_t kHexadecimalNum = 16;
59
60 template <typename T>
61 struct ToDigitImpl<kDecimalNum, T> {
DoItmaple::utils::__ToDigitImpl::ToDigitImpl62 static T DoIt(char c)
63 {
64 if (utils::IsDigit(c)) {
65 return c - '0';
66 }
67 return std::numeric_limits<T>::max();
68 }
69 };
70
71 template <typename T>
72 struct ToDigitImpl<kOctalNum, T> {
DoItmaple::utils::__ToDigitImpl::ToDigitImpl73 static T DoIt(char c)
74 {
75 if (c >= '0' && c < '8') {
76 return c - '0';
77 }
78 return std::numeric_limits<T>::max();
79 }
80 };
81
82 template <typename T>
83 struct ToDigitImpl<kHexadecimalNum, T> {
DoItmaple::utils::__ToDigitImpl::ToDigitImpl84 static T DoIt(char c)
85 {
86 if (utils::IsDigit(c)) {
87 return c - '0';
88 }
89 if (c >= 'a' && c <= 'f') {
90 return c - 'a' + kDecimalNum;
91 }
92 if (c >= 'A' && c <= 'F') {
93 return c - 'A' + kDecimalNum;
94 }
95 return std::numeric_limits<T>::max();
96 }
97 };
98 } // namespace __ToDigitImpl
99
100 template <uint8_t Scale = __ToDigitImpl::kDecimalNum, typename T = uint8_t>
ToDigit(char c)101 constexpr T ToDigit(char c)
102 {
103 return __ToDigitImpl::ToDigitImpl<Scale, T>::DoIt(c);
104 }
105
106 // Operations on pointer
107 template <typename T>
ToRef(T *ptr)108 inline T &ToRef(T *ptr)
109 {
110 CHECK_NULL_FATAL(ptr);
111 return *ptr;
112 }
113
114 template <typename T, typename = decltype(&T::get)>
ToRef(T &ptr)115 inline typename T::element_type &ToRef(T &ptr)
116 {
117 return ToRef(ptr.get());
118 }
119
120 template <size_t pos, typename = std::enable_if_t<pos<32>> struct bit_field {
121 enum { value = 1U << pos };
122 };
123
124 template <size_t pos>
125 constexpr uint32_t bit_field_v = bit_field<pos>::value;
126
127 template <size_t pos, typename = std::enable_if_t<pos<64>> struct lbit_field {
128 enum { value = 1ULL << pos };
129 };
130
131 template <size_t pos>
132 constexpr uint64_t lbit_field_v = bit_field<pos>::value;
133
134 template <typename T>
135 bool Contains(const std::vector<T> &container, const T &data)
136 {
137 return (std::find(std::begin(container), std::end(container), data) != container.end());
138 }
139
140 } // namespace utils
141 } // namespace maple
142 #endif // MAPLE_UTIL_INCLUDE_UTILS_H
143