ATLAS Offline Software
Loading...
Searching...
No Matches
StringUtilsTemplates.h
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4#ifndef CXXUTILS_STRINGUTILSTEMPLATES_H
5#define CXXUTILS_STRINGUTILSTEMPLATES_H
6
7#include <string>
8#include <string_view>
9#include <vector>
10#include <concepts>
12#include <stdexcept>
13#include <type_traits>
14#include <span>
15#include <cstring>
16
17namespace CxxUtils {
18
19 template <typename T>
20 concept Numeric = std::integral<T> || std::floating_point<T>;
21
22 template <Numeric dType, bool silenceEmpty = true>
23 void convertToNumber(std::string_view str, dType& number) {
25 if constexpr(silenceEmpty){
26 if (str.empty()) {
27 number = 0;
28 return;
29 }
30 }
31 auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), number);
32
33 if (ec != std::errc{}) {
34 throw std::runtime_error("CxxUtils::convertToNumber() - Invalid numeric string: " + std::string(str));
35 }
36 }
37
38 // A generic tokenizer that returns views
39 template <typename T = std::string, typename X = std::string_view>
40 std::vector<T> tokenize(std::string_view str, X delimiters) {
41 std::vector<T> tokens;
42 size_t lastPos = str.find_first_not_of(delimiters, 0);
43 size_t pos = str.find_first_of(delimiters, lastPos);
44
45 while (lastPos != std::string_view::npos) {
46 std::string_view token = str.substr(lastPos, pos - lastPos);
47
48 if constexpr (std::is_same_v<T, std::string_view>) {
49 tokens.push_back(token);
50 } else if constexpr (std::is_same_v<T, std::string>) {
51 tokens.emplace_back(token);
52 } else {
53 // This handles the int/double cases via your existing convertToNumber
54 T value;
55 convertToNumber(token, value);
56 tokens.push_back(value);
57 }
58
59 lastPos = str.find_first_not_of(delimiters, pos);
60 pos = str.find_first_of(delimiters, lastPos);
61 }
62 return tokens;
63 }
64
65
66 namespace detail{
67
83 template<typename T>
84 constexpr size_t get_arg_size(const T& arg) noexcept {
85 using DecayT = std::decay_t<T>;
86 if constexpr (std::is_same_v<DecayT, char>) {
87 return 1;
88 }
89 else if constexpr (std::is_array_v<std::remove_reference_t<T>>) {
90 using CharType = std::remove_cv_t<std::remove_extent_t<std::remove_reference_t<T>>>;
91 if constexpr (std::is_same_v<CharType, char>) {
92 return sizeof(std::remove_reference_t<T>) - 1;
93 } else {
94 return std::string_view(arg, sizeof(std::remove_reference_t<T>) / sizeof(CharType) - 1).size();
95 }
96 }
97 // 1. Handle types with a static stringSize() trait (e.g., Guid)
98 else if constexpr (requires { DecayT::stringSize(); }) {
99 return DecayT::stringSize();
100 }
101 // 2. Handle types with a member stringSize() method
102 else if constexpr (requires { arg.stringSize(); }) {
103 return arg.stringSize();
104 }
105 else {
106 return std::string_view(arg).size();
107 }
108 }
109
110
127 template<typename... Args>
128 constexpr void append_to(char*& p, Args&&... args) {
129 [[maybe_unused]] auto write_arg = [&p](auto&& arg) {
130 using T = std::decay_t<decltype(arg)>;
131 using RawT = std::remove_reference_t<decltype(arg)>;
132
133 if constexpr (std::is_same_v<T, char>) {
134 *p++ = arg;
135 }
136 else if constexpr (std::is_array_v<RawT>) {
137 using CharType = std::remove_cv_t<std::remove_extent_t<RawT>>;
138 if constexpr (std::is_same_v<CharType, char>) {
139 constexpr size_t N = sizeof(RawT) - 1;
140 std::memcpy(p, arg, N);
141 p += N;
142 } else {
143 std::string_view sv(arg, sizeof(RawT) / sizeof(CharType) - 1);
144 if (!sv.empty()) { //sv.data can be null when empty and trigger UB with memcopy
145 std::memcpy(p, sv.data(), sv.size());
146 p += sv.size();
147 }
148 }
149 }
150 // Serialize types with static stringSize() directly into the span buffer
151 else if constexpr (requires { T::stringSize(); }) {
152 constexpr size_t N = T::stringSize();
153 arg.toString(std::span<char, N>(p, N));
154 p += N;
155 }
156 // Serialize types with member stringSize() directly into the span buffer
157 else if constexpr (requires { arg.stringSize(); }) {
158 const size_t N = arg.stringSize();
159 arg.toString(std::span<char>(p, N));
160 p += N;
161 }
162 else {
163 std::string_view sv = arg;
164 if (!sv.empty()) { //sv.data can be null when empty and trigger UB with memcopy
165 std::memcpy(p, sv.data(), sv.size());
166 p += sv.size();
167 }
168 }
169 };
170 (write_arg(std::forward<Args>(args)), ...);
171 }
172 };
202 template<typename... Args>
203 constexpr std::string strcat(Args&&... args) {
204 static_assert(sizeof...(Args) > 0, "strcat() requires at least one argument.");
205 const size_t total_size = ( ... + detail::get_arg_size(args));
206
207 std::string res;
208 res.resize_and_overwrite(total_size, [&](char* buf, size_t) {
209 char* p = buf;
210 detail::append_to(p, std::forward<Args>(args)...);
211 return static_cast<size_t>(p - buf);
212 });
213 return res;
214 }
215}
216
217#endif
std::pair< std::vector< unsigned int >, bool > res
#define X(x)
Definition SiHitPlots.h:102
constexpr size_t get_arg_size(const T &arg) noexcept
Computes the exact character length of a given argument at compile time or runtime.
constexpr void append_to(char *&p, Args &&... args)
Variadic helper that writes and serializes multiple arguments directly into a raw target character bu...
std::string_view trimWhiteSpaces(std::string_view str) noexcept
Removes all trailing and starting whitespaces from a string.
constexpr std::string strcat(Args &&... args)
std::vector< std::string > tokenize(std::string_view the_str, std::string_view delimiters)
Splits the string into smaller substrings.
void convertToNumber(std::string_view str, dType &number)
std::string number(const double &d, const std::string &s)
Definition utils.cxx:186