A lot Quicker than std::string, fmt::format, std::to_chars, std::time and extra?

By Admin

October 6, 2022

0

1

✨⚡️ xeerx C++ Format Library ⚡️✨

An excellent quick c++ library for managing and formatting strings with the power to transform from/to any sort

♻️ Cross-Platform – examined by Google Take a look at.
⚡️ Velocity – sooner than std::string, std::time, std::to_chars, {fmt}, .., examined by Google Benchmark.
🍃 Gentle – minimal traces of code, fast compiling, examined by GCC 12.
✨ optimization – improved conduct to scale back Reminiscence Allocation, examined by Valgrind.
🌟 Skill – works with a whole lot of knowledge varieties any char numbers time bool ..and so forth.

🔹🔹 you’ll discover take a look at, gtest and benchmark for every little thing in: checks/🔹🔹

Index

The library comprises:

xeerx::string quickest string class.
xeerx::to_chars, chars_to quickest numbers-strings conversion capabilities.
xeerx::time, xeerx::stime quickest time lessons.
xeerx::format quickest formatting perform.
xeerx::exception to throw an exception with details about it.

Utilization

#embrace "core.h"

utilizing namespace xeerx;

String

How It Works

To grasp how strings work, let’s examine the next examples:

// [1]
xeerx::string s1 ("Howdy World");

// [2]
xeerx::string s2 ("Howdy");
s2 += "World";

// [3]
xeerx::string s3 ("chars:");
for(int i = 0; i < 100; i++) s3 += 'C';

Rationalization of examples

### First Instance
On this case the category will simply pointing to the worth, like std::string_view
so there isn’t any copies, identical to regular const char*
Second Instance

1- pointing to the worth Howdy

2- copy Howdy to the stack buffer

3- copy World to the top of stack buffer to be HelloWorld
Third Instance

1- pointing to the worth chars:

2- copy chars: to the stack buffer

now we have to append C x100 instances, and our stack buffer dimension is 64

and the present dimension of the buffer is 6 (chars: is 6 characters)

so the stack can maintain extra 64 - 6 = 58 characters

3- copy C 58 instances to the top of stack buffer

now the stack buffer is full and we have to append extra 42 characters

so allocate an sufficient area within the heap reminiscence known as heap buffer

4- allocate an area within the heap reminiscence

5- copy contents of stack buffer to the heap buffer

6- append the remaining 42 characters to the top of the heap buffer

Typedefs

Kind	Definition
xeerx::string	xeerx::basic_string<`char`>
xeerx::wstring	xeerx::basic_string<`wchar_t`>
xeerx::u16string	xeerx::basic_string<`char16_t`>
xeerx::u32string	xeerx::basic_string<`char32_t`>

### Specialization Varieties

// prototype
template<typename Kind, class Alloc = std::allocator<Kind>, xeerx::size_t L_Capacity = X_BUFF_SIZE>
xeerx::basic_string<Kind, Alloc, L_Capacity>

// instance: basic_string for 'char' with native buffer capability 256
typedef xeerx::basic_string<char, std::allocator<char>, 256> string_256;

There are two sorts of characters allowed, char and wchar_t.

However you should utilize any sort of character as a result of the category takes tamplate parameter to know what sort of character to make use of,

BUT I am undecided about something besides char and wchar_t so you need to attempt to take a look at it your self.

Macros

Identify	Worth	Definition
`X_BUFF_SIZE`	64UL	default dimension of the native buffer

Exceptions

Exception	Definition
`std::length_error`	when the scale of the string >= `xeex::size_t_max`
`std::out_of_range`	when the index of the string > `dimension()`

Template Parameters

Parameter	Definition
Kind	character sort
Alloc	Allocator sort used to allocate inner storage

Member Varieties

Kind	Definition
chars	`xeerx::char_traits<Kind>`
value_type	`Kind`
size_type	_traits::size_type `xeerx::size_t`
reference	_traits::reference `Kind&`
const_reference	_traits::const_reference `const Kind&`
pointer	_traits::pointer `Kind*`
const_pointer	_traits::const_pointer `const Kind*`
iterator	_traits::iterator `Kind*`
const_iterator	_traits::const_iterator `const Kind*`

Member Capabilities

constructor’s | destructor

🔹 Examples 🔹

// empty  constructor
string s0;                          // 👉 ""
// assign constructor utilizing array of characters
string s1("Howdy");                 // 👉 "Howdy"
// assign constructor utilizing single character 
string s2('C');                     // 👉 "C"
// assign constructor utilizing vary (iterators)
string s3(s1.cbegin(), s1.cend());  // 👉 "Howdy"
// assign constructor utilizing bool
string s4(true);                    // 👉 "true"
// assign constructor utilizing integer (see convert perform for extra particulars)
string s5(123);                     // 👉 "123"
// assign constructor utilizing float   (see convert perform for extra particulars)
string s6(0.14);                    // 👉 "0.14"
// copy constructor
string s7(s1);                      // 👉 "Howdy"
// transfer constructor
string s8(std::transfer(s1));           // 👉 "Howdy"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	0.976 ns	689897792	⚡️ 1.0	empty constructor
🔸 std::string	0.978 ns	704357784
🔹 xeerx::string	1.30 ns	531657012	⚡️ 2.2	copy constructor
🔸 std::string	2.93 ns	238350514
🔹 xeerx::string	1.30 ns	532291700	⚡️ 4.7	transfer constructor
🔸 std::string	6.15 ns	110840133
🔹 xeerx::string	1.30 ns	473253168	⚡️ 1.7	array constructor
🔸 std::string	2.26 ns	356990635
🔹 xeerx::string	1.41 ns	427177908	⚡️ 8.0	single char constructor
🔸 std::string	11.3 ns	62462721
🔹 xeerx::string	2.45 ns	292649634	⚡️ 1.6	vary constructor
🔸 std::string	3.93 ns	186850707
🔹 xeerx::string	1.97 ns	344396141	⚡️ —	bool constructor
🔸 std::string	— ns	———
🔹 xeerx::string	3.02 ns	234255879	⚡️ 2.0	lengthy int constructor
🔸 std::string	6.31 ns	109529125
🔹 xeerx::string	8.13 ns	84837465	⚡️ 2.8	brief int constructor
🔸 std::string	22.9 ns	30325927
🔹 xeerx::string	2.60 ns	267951182	⚡️ 75.3	lengthy float constructor
🔸 std::string	196 ns	3535237
🔹 xeerx::string	3.26 ns	214303767	⚡️ 61.0	brief float constructor
🔸 std::string	199 ns	3511556

🌟 std::to_string cannot convert bool to string.

Copy | Transfer | Swap

🔹 Examples 🔹

string s("Howdy World");

string s1; s1.copy(s);              // 👉 "Howdy World"
string s2; s2.transfer(std::transfer(s));   // 👉 "Howdy World"
string s3; s3.swap(s);              // 👉 "Howdy World"

🔸 Benchmark 🔸

no benchmark want on this part, you’ll be able to see constructor part to search out copy and transfer benchmark, as about swap is simply std::swap.

Assign

🔹 Examples 🔹

string s;
string s1("One other String");

// assign utilizing array of characters
s.assign("Howdy");                  // 👉 "Howdy"
// assign utilizing single character 
s.assign('C');                      // 👉 "C"
// assign utilizing vary (iterators)
s.assign(s1.cbegin(), s1.cend());   // 👉 "One other String"
// assign utilizing bool
s.assign(true);                     // 👉 "true"
// assign utilizing integer (see convert perform for extra particulars)
s.assign(123);                      // 👉 "123"
// assign utilizing float   (see convert perform for extra particulars)
s.assign(0.14);                     // 👉 "0.14"
// assign utilizing one other string
s.assign(s1);                       // 👉 "One other String"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	1.34 ns	531380206	⚡️ 2.2	assign utilizing string
🔸 std::string	2.93 ns	238106163
🔹 xeerx::string	1.31 ns	528827390	⚡️ 6.7	assign utilizing array
🔸 std::string	8.81 ns	78799728
🔹 xeerx::string	1.31 ns	534289066	⚡️ 8.6	assign utilizing single char
🔸 std::string	11.3 ns	61128346
🔹 xeerx::string	2.28 ns	306184756	⚡️ 4.3	assign utilizing vary
🔸 std::string	9.90 ns	69530909
🔹 xeerx::string	1.95 ns	357179984	⚡️ —	assign utilizing bool
🔸 std::string	— ns	———
🔹 xeerx::string	9.09 ns	75920717	⚡️ 2.0	assign utilizing lengthy int
🔸 std::string	18.7 ns	37284998
🔹 xeerx::string	3.54 ns	169905048	⚡️ 1.0	assign utilizing brief int
🔸 std::string	3.91 ns	195297191
🔹 xeerx::string	3.59 ns	195349150	⚡️ 56.5	assign utilizing lengthy float
🔸 std::string	203 ns	3436025
🔹 xeerx::string	2.61 ns	268187597	⚡️ 76.6	assign utilizing brief float
🔸 std::string	200 ns	3430881

🌟 std::to_string cannot convert bool to string.

Convert

This perform utilizing xeerx::to_chars to transform

So for extra info see the conversion part

🔹 Examples 🔹

// integer
string s1; s1.convert(123);                     // 👉 "123"
// integer base
string s2; s2.convert(123, 16);                 // 👉 "7b"
// signal
string s3; s3.convert(123, 16, '+');            // 👉 "+7b"
// letter case
string s4; s4.convert(123, 16, '+', tail, 1);   // 👉 "+7B"

// float
string s5; s5.convert(3.987);                   // 👉 "3.98"
// float precision
string s6; s6.convert(3.987, 3);                // 👉 "3.987"
// float trailing zeros
string s7; s7.convert(1.09800, 5, '+', 1);      // 👉 "+1.09800"
string s8; s8.convert(1.09800, 5, '+', 0);      // 👉 "+1.098"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	2.49 ns	280885493	⚡️ —	convert utilizing bool
🔸 std::string	— ns	———
🔹 xeerx::string	9.13 ns	75557257	⚡️ 5.6	convert utilizing lengthy int
🔸 std::string	52.0 ns	13533688
🔹 xeerx::string	4.40 ns	163482392	⚡️ 3.3	convert utilizing brief int
🔸 std::string	14.8 ns	46670954
🔹 xeerx::string	3.62 ns	195510099	⚡️ 57.4	convert utilizing lengthy float
🔸 std::string	208 ns	3371255
🔹 xeerx::string	2.93 ns	238643277	⚡️ 69.9	convert utilizing brief float
🔸 std::string	205 ns	3402302

🌟 std::to_string cannot convert bool to string.

Append

🔹 Examples 🔹

string s;
string s1("One other String");

// append utilizing array of characters
s.append("Howdy");                  // 👉 "Howdy"
// append utilizing single character 
s.append('C');                      // 👉 "...C"
// append utilizing vary (iterators)
s.append(s1.cbegin(), s1.cend());   // 👉 "...One other String"
// append utilizing bool
s.append(true);                     // 👉 "...true"
// append utilizing integer (see convert perform for extra particulars)
s.append(123);                      // 👉 "...123"
// append utilizing float   (see convert perform for extra particulars)
s.append(0.14);                     // 👉 "...0.14"
// append utilizing one other string
s.append(s1);                       // 👉 "...One other String"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	45.0 ns	16190001	⚡️ 2.2	append utilizing string
🔸 std::string	103 ns	6637803
🔹 xeerx::string	38.2 ns	18203461	⚡️ 2.5	append utilizing array
🔸 std::string	96.0 ns	7101166
🔹 xeerx::string	21.0 ns	32952515	⚡️ 2.2	append utilizing single char
🔸 std::string	46.8 ns	14844033
🔹 xeerx::string	44.0 ns	15887083	⚡️ 2.7	append utilizing vary
🔸 std::string	122 ns	5548724
🔹 xeerx::string	20.9 ns	34528601	⚡️ —	append utilizing bool
🔸 std::string	— ns	———
🔹 xeerx::string	116 ns	5953486	⚡️ 2.6	append utilizing lengthy int
🔸 std::string	307 ns	2270919
🔹 xeerx::string	75.4 ns	9182231	⚡️ 1.0	append utilizing brief int
🔸 std::string	80.4 ns	8533531
🔹 xeerx::string	68.6 ns	9908682	⚡️ 33.1	append utilizing lengthy float
🔸 std::string	2253 ns	308565
🔹 xeerx::string	30.3 ns	22941116	⚡️ 74.4	append utilizing brief float
🔸 std::string	2242 ns	314610

🌟 std::to_string cannot convert bool to string.

Insert

🔹 Examples 🔹

Yow will discover the take a look at script in /checks/insert-string.cpp to verify it your self.

string s("15 : ");

// insert utilizing single character 
s.insert(0, '0');                   // 👉 "015 : "
// insert utilizing array of characters
s.insert(2, "234");                 // 👉 "012345 : "
// insert utilizing one other string
s.insert(s.dimension(), s);              // 👉 "012345 : 012345 : "
// insert utilizing vary (iterators)
string s1("Iterator");
s.insert(s.dimension(), s1.cbegin(), s1.cend()); // 👉 "012345 : 012345 : Iterator"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	90.9 ns	7302295	⚡️ 1.5	insert utilizing string
🔸 std::string	143 ns	4852644
🔹 xeerx::string	92.3 ns	7438356	⚡️ 1.3	insert utilizing array
🔸 std::string	124 ns	5604204
🔹 xeerx::string	59.6 ns	11534530	⚡️ 1.4	insert utilizing single char
🔸 std::string	83.2 ns	8121425
🔹 xeerx::string	44.0 ns	7648863	⚡️ —	insert utilizing vary
🔸 std::string	— ns	———

🌟 there isn’t any perform to insert utilizing vary in std::string.

Fill

🔹 Examples 🔹

string s;

// string just isn't initialized but, so append `C` * 10 instances
s.fill('C', 0, 10);                // 👉 "CCCCCCCCCC"
// string is initialized, so change vary(0,9) with `M`
s.fill('M', 0, 10);                // 👉 "MMMMMMMMMM"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	13.9 ns	49118574	⚡️ 2.6	fill utilizing character
🔸 std::string	37.0 ns	18117575

🌟 there isn’t any perform to fill in std::string, so i used change in benchmark.

Substitute

🔹 Examples 🔹

// size of "AB" = 2, size of vary to interchange is (6-4) = 2
// so change "45" with "AB"
string s1("0123456789"); 
s1.change("AB", 4, 6);             // 👉 "0123AB6789"

// size of "A" = 1, size of vary to interchange is (6-4) = 2
// so change "4" with "A"
// and transfer "6789" to backward by one.
// in one other phrase, change "45" with "A"
string s2("0123456789"); 
s2.change("A", 4, 6);              // 👉 "0123A6789"

// size of "HelloWorld" = 10, size of vary to interchange is (6-4) = 2
// so transfer "6789" to ahead by (10 - 2) = 8.
// and change "45        " with "HelloWorld"
// in one other phrase, change "45" with "HelloWorld"
string s3("0123456789"); 
s3.change("HelloWorld", 4, 6);     // 👉 "0123HelloWorld6789"

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	35.5 ns	19680601	⚡️ 1.3	change utilizing array
🔸 std::string	46.5 ns	15060716

Erase

🔹 Examples 🔹
```
string s("0123456789"); s.erase(4, 2);  // 👉 "01236789"
```
🔸 Benchmark 🔸

Benchmark Time Iterations Velocity Kind

🔹 xeerx::string 9.36 ns 74738109 ⚡️ 2.2 erase a part of string

🔸 std::string 21.2 ns 32678576
Clear

🔹 Examples 🔹
```
string s("0123456789"); s.clear();     // 👉 ""
```
🔸 Benchmark 🔸

Benchmark Time Iterations Velocity Kind

🔹 xeerx::string 1.30 ns 536039461 ⚡️ 12.6 clear string contents

🔸 std::string 16.4 ns 40010757
Resize

🔹 Examples 🔹
```
string s("0123456789"); s.resize(5);    // 👉 "01234"
```
🔸 Benchmark 🔸

Benchmark Time Iterations Velocity Kind

🔹 xeerx::string 2.86 ns 267733338 ⚡️ 6.3 resize string dimension

🔸 std::string 18.2 ns 36673351
Reserve

🔹 Examples 🔹
```
string s; s.reserve(100);               // 👉 heap capability now could be 100
```
🔸 Benchmark 🔸

Benchmark Time Iterations Velocity Kind

🔹 xeerx::string 16.1 ns 44328723 ⚡️ 2.1 reserve area within the heap

🔸 std::string 35.3 ns 19861444

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	9.36 ns	74738109	⚡️ 2.2	erase a part of string
🔸 std::string	21.2 ns	32678576

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	1.30 ns	536039461	⚡️ 12.6	clear string contents
🔸 std::string	16.4 ns	40010757

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	2.86 ns	267733338	⚡️ 6.3	resize string dimension
🔸 std::string	18.2 ns	36673351

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	16.1 ns	44328723	⚡️ 2.1	reserve area within the heap
🔸 std::string	35.3 ns	19861444

Evaluate

🔹 Examples 🔹

string s("Howdy");  

s.evaluate("Howdy");                     // 👉 0
s.evaluate("whats up");                     // 👉 -32
s.evaluate("Blah" );                     // 👉 6

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	1.63 ns	425109330	⚡️ 1.2	evaluate two strings
🔸 std::string	1.97 ns	354517169

Discover

🔹 Examples 🔹

string s("12 13 12 14"); 

// discover utilizing array
s.discover("12", 0);                        // 👉 0
s.discover("12", 2);                        // 👉 6

// discover utilizing character
s.discover('3' , 0);                        // 👉 4

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::string	1.30 ns	519393604	⚡️ 12.8	discover utilizing array
🔸 std::string	16.7 ns	41623313
🔹 xeerx::string	1.30 ns	532126470	⚡️ 12.7	discover utilizing character
🔸 std::string	16.6 ns	41633714

Letter Case Management

🔹 Examples 🔹

string s("whats up World s S 123"); 

// all to higher case
s.higher();                        // 👉 "HELLO WORLD S S 123"
// all to decrease case
s.decrease();                        // 👉 "whats up world s s 123"
// make all phrases begin with higher case character
s.wupper();                       // 👉 "Howdy World s S 123"

Entry Capabilities

🔹 Learn-Solely 🔹

string.cdata();        // Buffer of characters
string.cbegin();       // Start iterator
string.cend();         // Finish   iterator
string.dimension();         // Measurement of buffer
string.max_size();     // Most dimension that may be accommodated
string.capability();     // Capability of buffer
string.empty();        // Examine if dimension == 0
string.cat(N);         // Get character at place

🔹 Learn-Write 🔹

string.knowledge();        // Buffer of characters
string.start();       // Start iterator
string.finish();         // Finish   iterator
string.at(N);         // Get character at place

🔸 Benchmark 🔸

no benchmark want on this part, all of this capabilities simply return to the non-public variables.

Operatores

🔹 copy-move 🔹

string A("Howdy"), B;
B = A;            // copy
B = std::transfer(B); // transfer

🔹 assign 🔹

string S;
S = "Howdy";
S = 123;
S = ...; // identical as assign()

🔹 append 🔹

string S;
S += "Howdy";
S += 123;
S += ...; // identical as append()

🔹 append plus 🔹[The Power Of The Append]

string A("-> "), S;
S += A + false + " 123" + 456 + ' ' + 3.14; // 👉 "-> false 123456 3.14"
// [NOTE] A will likely be additionally "-> false 123456 3.14"
// as a result of the information append to A primary, than to S
// so you need to use a brief string within the first argument

// What if i wish to add S1 and S2 to S3 with out change S1 and S2 ?
string S1("Howdy"), S2("World"), S3;
S3 = S1; S3 += S2;     // like this
S3 += string(S1) + S2; // or   this

🔹 evaluate 🔹

string S1("Howdy"), S2("World");
bool is_same = (S1 == S2);

🔹 at 🔹

string S1("Howdy");
S1[0] = 'h';

🔹 stream 🔹

string S1("Howdy");
std::cout << S1 << std::endl;

🔸 Benchmark 🔸

no benchmark want on this part, operators do identical of it is perform, for instance += name append, ..and so forth.

Conversions

convert numbers to characters array

🔹 Examples 🔹

char c[11] = "N:xxxxxxxx";          // will be wchar_t or sort of characters

// handbook size (overload with 'final' as a parameter)
to_chars(c, c + sizeof(c), -10);    // c 👉 "-10" 

// auto size   (overload with 'final' as a template parameter)
to_chars(c,-10);                    // c 👉 "-10" 

// [integer base] you should utilize any base between 2 and 36
to_chars(c,-123, 36);               // c 👉 "-3f"
to_chars(c,-123, 16);               // c 👉 "-7b"
to_chars(c,-123, 10);               // c 👉 "-123"
to_chars(c,-123,  8);               // c 👉 "-173" 
to_chars(c,-123,  2);               // c 👉 "-1111011"

// [sign]
to_chars(c, 1, 10, '+');            // c 👉 "+1"
to_chars(c,-1, 10, '+');            // c 👉 "-1"

to_chars(c, 1, 10, '-');            // c 👉  "1"
to_chars(c,-1, 10, '-');            // c 👉 "-1"

to_chars(c, 1, 10, ' ');            // c 👉 " 1"
to_chars(c,-1, 10, ' ');            // c 👉 "-1"

// [terminate array]
to_chars(c, 1, 10, '+', 1);         // c 👉 "+1"
to_chars(c, 1, 10, '+', 0);         // c 👉 "+1xxxxxxxx"

// [floating precision]
float f = -1.09800;
to_chars(c,f);                      // c 👉 "-1.09" 
to_chars(c,f,  1);                  // c 👉 "-1.0" 
to_chars(c,f,  2);                  // c 👉 "-1.09" 
to_chars(c,f,  3);                  // c 👉 "-1.098" 
to_chars(c,f,  4);                  // c 👉 "-1.0980" 

// [trailing zeros]
to_chars(c,f,  5, '+', 1, 0);       // c 👉 "-1.098" 
to_chars(c,f,  5, '+', 1, 1);       // c 👉 "-1.09800"

// [trailing zeros]
to_chars(c,f,  5, '+', 1, 0);       // c 👉 "-1.098" 
to_chars(c,f,  5, '+', 1, 1);       // c 👉 "-1.09800"

// [letter case]
to_chars(c,-123, 36, '+', 1, 1, 1); // c 👉 "-3F"
to_chars(c,-123, 36, '+', 1, 1, 0); // c 👉 "-3f"

// [length] if you recognize the size of the integer half, so put it in final argument
to_chars(c,-123, 36, '+', 1, 1, 3); // c 👉 "-3F"

// [return | exception]
// 🟩 if successed return to final written place 
// 🟥 if failed    return to xeerx::size_t_max
// 🟧 if X_DEBUG macro is outlined, when failed will throw an exceptionx

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::to_chars	0.333 ns	1000000000	⚡️243.8	lengthy float
🔸 std::to_chars	81.2 ns	8665522
🔹 xeerx::to_chars	0.327 ns	1000000000	⚡️177.6	brief float
🔸 std::to_chars	58.1 ns	12034705
🔹 xeerx::to_chars	0.327 ns	1000000000	⚡️ 3.9	lengthy int
🔸 std::to_chars	1.30 ns	531564683
🔹 xeerx::to_chars	0.326 ns	1000000000	⚡️ 2.0	brief int
🔸 std::to_chars	0.652 ns	1000000000

convert characters array to numbers

🔹 Examples 🔹

chars_to<int>("-123");   // 👉 -123

// [integer base] you should utilize any base between 2 and 36
chars_to<int>("-3F",       36);     // 👉 -123
chars_to<int>("-7B",       16);     // 👉 -123
chars_to<int>("-123",      10);     // 👉 -123
chars_to<int>("-173",       8);     // 👉 -123
chars_to<int>("-1111011",   2);     // 👉 -123

// [floating precision]
chars_to<double>("-1.0098765");     // 👉 -1.00
chars_to<double>("-1.0098765",  1); // 👉 -1.0
chars_to<double>("-1.0098765",  2); // 👉 -1.00
chars_to<double>("-1.0098765",  3); // 👉 -1.009
chars_to<double>("-1.0098765",  4); // 👉 -1.0098
chars_to<double>("-1.0098765",  5); // 👉 -1.00986
chars_to<double>("-1.0098765",  6); // 👉 -1.009865

// [return | exception]
// 🟩 if successed return to transformed worth
// 🟥 if failed    return to std::numeric_limits::max<N>()
// 🟧 if X_DEBUG macro is outlined, when failed will throw an exceptionx

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::chars_to	0.327 ns	1000000000	⚡️ 88.6	lengthy float
🔸 std::from_chars	29.0 ns	24078935
🔹 xeerx::chars_to	0.327 ns	1000000000	⚡️ 1.6	brief float
🔸 std::from_chars	0.545 ns	1000000000
🔹 xeerx::chars_to	0.327 ns	1000000000	⚡️ 4.0	lengthy int
🔸 std::from_chars	1.31 ns	533874680
🔹 xeerx::chars_to	0.328 ns	1000000000	⚡️ 1.9	brief int
🔸 std::from_chars	0.652 ns	1000000000

Time

models

all models utilizing std::chrono

second;
milliseconds;
microseconds;
nanoseconds;

timestamp

timestamp<unit>();           // auto
timestamp<unit>(1664697587); // handbook

// members
val; // timestamp worth
fac; // issue (second = 1, mirosecond = 1000, ...)

essential time class

// auto
time<second>      t; // timestamp 👉 1664697587          , fac 👉 1
time<millisecond> t; // timestamp 👉 1664697587405       , fac 👉 1000
time<microsecond> t; // timestamp 👉 1664697587405492    , fac 👉 1000000
time<nanosecond>  t; // timestamp 👉 1664697587405492704 , fac 👉 1000000000

// handbook
time<second>   t(1664697587); // timestamp -> 1664697587 , fac -> 1

// specification characters sort
time<unit, char_type> t;    // char_type by default is `char`

// for string format use it
stime<unit, char_type> t;  
// this can containts identical members of regular `time` class
// along with the string members

numerical members

t.unit;        // xeerx::timestamp object
t.unit.val;    // timestamp of unit : 👉 1664697587405492704
t.unit.fac;    // issue    of unit : 👉 1000000000
t.12 months;        // 👉 2022
t.month;       // 👉 10
t.week;        // 👉 1
t.weekday;     // 👉 2
t.day;         // 👉 2
t.yday;        // 👉 275
t.hour;        // 👉 7
t.Hour;        // 👉 7
t.minute;      // 👉 59
t.second;      // 👉 47
t.millisecond; // 👉 405
t.microsecond; // 👉 492
t.nanosecond;  // 👉 704

string members

to get time members in string format you need to utilizing stimg as a substitute of time.

t.num;          // xeerx::time object, use it to entry the numerical members

t.syear;        // 👉 "2022" 
t.smonth;       // 👉 "10" 
t.sweek;        // 👉 "01" 
t.sweekday;     // 👉 "02" 
t.sday;         // 👉 "02" 

t.shour;        // 👉 "07"
t.sHour;        // 👉 "07"
t.sminute;      // 👉 "59"
t.ssecond;      // 👉 "47"

t.smillisecond; // 👉 "405"
t.smicrosecond; // 👉 "492"
t.snanosecond ; // 👉 "704"

t.m;            // 👉 "AM"

// names
t.nweekday;     // 👉 "Solar"
t.Nweekday;     // 👉 "Sunday"

t.nmonth;       // 👉 "Oct"
t.Nmonth;       // 👉 "October"

convert between time and stime

// stime -> time
time<nanosecond>  t  = stime<nanosecond>;       // ERROR
time<nanosecond>  t  = stime<nanosecond>().num; // OK

// time  -> stime
stime<nanosecond> st = time<nanosecond>;        // OK

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity
🔹 xeerx::time	13.2 ns	51969561	⚡️ 200.7
🔹 xeerx::stime	29.4 ns	24039762	⚡️ 90.1
🔸 local_time	2430 ns	293162
🔸 to_time_t	2844 ns	234573
🔸 asctime	2847 ns	250791

Formatting

Sample

prototype

// prototype
// N -> What number of sections are there on this sample [for optimization]
// C -> Kind of character
fpattern<N, C = char> ("...");

arguments

// sequence argument
fpattern<1>("{}");

// numbered argument
fpattern<1>("{I}");

// mixture of sequence and numbered argument
fpattern<4>("{1} {} {0} {}");
// [1] -> second "{1}"  - (no impact on the final argument id)
// [2] -> first  "{}"   (final argument id is 0, and will likely be 1)
// [3] -> first  "{0}"  - (no impact on the final argument id)
// [4] -> second "{}"   (final argument id is 1, and will likely be 2)

// management arguments
fpattern<1>("{:}" || "{I:}");  // wrtie ':' to handle the argument

// management integer base | float precision
fpattern<1>("{:N}" || "{I:N}");
// for integer, 'N' will be any quantity between 2 and 36 (default is 10)
// for float  , 'N' will be any quantity between 1 and 36 (default is  2)

// management letter case (With out specifying case, will probably be left as is)
// [NOTE] letter case contoller works solely on integer's 
//        when base numerical base > 10
fpattern<1>("{:NC}" || "{I:NC}");  // for all capital
fpattern<1>("{:Nc}" || "{I:Nc}");  // for all small

// management signal (see conversion part to know extra about signal's)
fpattern<1>("{:SN}" || "{I:SN}");

// the ultimate sample
fpattern<1>("{:SNC}" || "{I:SNC}");
//  precision (Not Vital)
// C -> letter case      (Not Vital)
//  -> finish of part   (Vital)

/* ------------ Exceptions ------------ */
// std::invalid_argument("dangerous syntax")
// [-] you need to write a number of specifier at the very least after the controller `:`
// [-] you need to write the start '{' and the top '}' of the part 
//     with out any-unknown character between it
//     the recognized characters is "I:SNC"

// std::out_of_range("invalid argument id")
// [-] 'I' can't be bigger than the template parameter 'N'

padding

// prototype
fpattern<1>("{.AFV.}");

// {. -> start of padding part       (Vital)
// A  -> padding align  ['<', '>', '^'] (Not Vital) (default is left '<')
// F  -> padding fill   [any char]      (Vital)
// V  -> padding worth  [any numbers]   (Vital)
// .} -> finish   of padding part       (Vital)

// dynamic padding (with argument's and textual content inside it)
fpattern<4>("{.^ 15IP:{}.},{.^ 15PORT:{}.}");
// IF IP is "127.0.0.1" && PORT is 443, so the end result will likely be prefer it:
// --> "IP:127.0.0.1   ,PORT:443       "

// regular padding (with out something inside it)
fpattern<2>("{.*5.} IP:{}");
// --> "***** IP:127.0.0.1"

Examples

xeerx::format<N> returns to xeerx::basic_string<char>

xeerx::format<C, N> returns to xeerx::basic_string<C>

// sequence arguments   👉 "Howdy World"
format<2>("{} {}", "Howdy", "World");

// numbered arguments   👉 "World Howdy, Howdy World"
format<4>("{1} {0}, {0} {1}", "Howdy", "World");

// character            👉 "C, C"
format<2>("{}, {}", 'C', 'c'); 

// bool                 👉 "true, false"
format<2>("{}, {}", true, false);                   

// integer              👉 "123"
format<1>("{}", 123);

// integer base         👉 "d:123, x:7b, o:173, b:1111011, 36:3f"
format<5>("d:{0:10}, x:{0:16}, o:{0:8}, b:{0:2}, 36:{0:36}", 123);  

// letter case          👉 "Capital:3F, Small:3f"
format<2>("Capital:{0:36C}, Small:{0:36c}", 123);

// float                👉 "3.14"
format<1>("{}", 3.14);

// float precision      👉 "3.01, 3.014, 3.0143"
format<3>("{0:2}, {0:3}, {0:4}", 3.014321);

// signal                 👉 "+:[+1, 1,  1], -:[-1, -1, -1]"
format<6>("+:[{0:+10}, {0:-10}, {0: 10}], -:[{1:+10}, {1:-10}, {1: 10}]",  1, -1); 

// multi varieties          👉 "string, C, true, -123, 3.14"
format<5>("{}, {}, {}, {}, {}", "string", 'C', true, -123, 3.14);

padding examples

// empty padding        👉 "**********, true"
format<2>("{.*10.}, {}", true);

// left   aligned       👉 "******true"
format<2>("{.<*10{}.}", true);

// proper  aligned       👉 "true******"
format<2>("{.>*10{}.}", true);

// middle aligned       👉 "***true***"
format<2>("{.^*10{}.}", true);

// one other instance      👉 "[IP:127.0.0.1    ] [PORT:443        ]"
format<4>("[{.> 15IP:{}.}] [{.> 15PORT:{}.}]", "127.0.0.1", 443);

🔸 Benchmark 🔸

Benchmark	Time	Iterations	Velocity	Kind
🔹 xeerx::format	3.70 ns	186586391	⚡️ 52.9	left padding
🔸 fmt::format	196 ns	3545286
🔹 xeerx::format	3.70 ns	189126228	⚡️ 54.3	proper padding
🔸 fmt::format	201 ns	3464272
🔹 xeerx::format	3.70 ns	188942568	⚡️ 57.0	middle padding
🔸 fmt::format	211 ns	3304297
🔹 xeerx::format	2.69 ns	258969920	⚡️ 9.9	one string
🔸 fmt::format	26.7 ns	26305344
🔹 xeerx::format	16.5 ns	42150231	⚡️ 4.0	two strings
🔸 fmt::format	66.7 ns	10376705
🔹 xeerx::format	77.8 ns	8581737	⚡️ 2.2	loads strings
🔸 fmt::format	174 ns	4061439
🔹 xeerx::format	2.69 ns	259762850	⚡️ 14.3	signle character
🔸 fmt::format	38.6 ns	18119202
🔹 xeerx::format	10.8 ns	64446743	⚡️ 5.3	bool
🔸 fmt::format	57.6 ns	11925818
🔹 xeerx::format	2.02 ns	346543561	⚡️ 10.0	brief int
🔸 fmt::format	20.1 ns	34644407
🔹 xeerx::format	3.02 ns	231357308	⚡️ 17.4	lengthy int
🔸 fmt::format	52.4 ns	13166775
🔹 xeerx::format	2.69 ns	252905827	⚡️ 29.4	float
🔸 fmt::format	78.6 ns	9923260

Optimization with `constexpr fpattern`

will probably be sooner by close to 30% in lengthy and sophisticated patterns

constexpr fpattern<N> pat("...");
// then you'll be able to cross it to format perform like:
format<N>(pat, ...);

Exceptions

0. void take a look at()
1. {
2.      x_throw(exceptions::out_of_range);
3. }

// output:
// xeerx::exception::out_of_range
// [FILE] /path/to/file.ext [LINE] 2 [FUNC] take a look at

```cpp
0. void take a look at()
1. {    int pos = 21, dimension = 20;
2.      x_throws(exceptions::out_of_range, format<2>("pos:{} >= dimension:{}", pos, dimension));
3. }

// output:
// xeerx::exception::out_of_range
// [FILE] /path/to/file.ext [LINE] 2 [FUNC] take a look at : pos:21 >= dimension:20
```

Benchmark Information

compiler: GCC 12
c++ model: 20
operator system: Ubuntu 22.04.1 LTS
processor: Intel® Core™ i7-6500U CPU @ 2.50GHz × 4
flags: -Ofast

Supply Code

yow will discover the supply code on Github

as a result of the supply code is huge and has loads script’s

so i can not put it right here.

This Submit Was Printed In Model 0.0.1

Updates

..

Hope I made one thing helpful

This model continues to be a beta model and I’ve not completed absolutely creating the library

So I want to know your opinion about this

Are there issues ?
Is there something that may be developed or added?
Did I do something flawed?

Thanks.

Previous articleZen 4 Is AMD’s Shiny New CPU Structure However Devs Are Already Trying To Zen 5

A lot Quicker than std::string, fmt::format, std::to_chars, std::time and extra?

✨⚡️ xeerx C++ Format Library ⚡️✨

Index

The library comprises:

Utilization

String

How It Works

Rationalization of examples

Second Instance

Third Instance

Typedefs

Macros

Exceptions

Template Parameters

Member Varieties

Member Capabilities

constructor’s | destructor

🔹 Examples 🔹

🔸 Benchmark 🔸

Copy | Transfer | Swap

🔹 Examples 🔹

🔸 Benchmark 🔸

Assign

🔹 Examples 🔹

🔸 Benchmark 🔸

Convert

🔹 Examples 🔹

🔸 Benchmark 🔸

Append

🔹 Examples 🔹

🔸 Benchmark 🔸

Insert

🔹 Examples 🔹

🔸 Benchmark 🔸

Fill

🔹 Examples 🔹

🔸 Benchmark 🔸

Substitute

🔹 Examples 🔹

🔸 Benchmark 🔸

Erase

🔹 Examples 🔹

🔸 Benchmark 🔸

Clear

🔹 Examples 🔹

🔸 Benchmark 🔸

Resize

🔹 Examples 🔹

🔸 Benchmark 🔸

Reserve

🔹 Examples 🔹

🔸 Benchmark 🔸

Evaluate

🔹 Examples 🔹

🔸 Benchmark 🔸

Discover

🔹 Examples 🔹

🔸 Benchmark 🔸

Letter Case Management

🔹 Examples 🔹

Entry Capabilities

🔹 Learn-Solely 🔹

🔹 Learn-Write 🔹

🔸 Benchmark 🔸

Operatores

🔹 copy-move 🔹

🔹 assign 🔹

🔹 append 🔹

🔹 append plus 🔹[The Power Of The Append]

🔹 evaluate 🔹

🔹 at 🔹

🔹 stream 🔹

🔸 Benchmark 🔸

Conversions

convert numbers to characters array

🔹 Examples 🔹

🔸 Benchmark 🔸

convert characters array to numbers

🔹 Examples 🔹

🔸 Benchmark 🔸

Optimization with `constexpr fpattern`